diff --git a/internal/apis/certmanager/types_certificate.go b/internal/apis/certmanager/types_certificate.go index 5c7aed2e2..8336ee437 100644 --- a/internal/apis/certmanager/types_certificate.go +++ b/internal/apis/certmanager/types_certificate.go @@ -169,6 +169,11 @@ type CertificateSpec struct { // +optional RenewBeforePercentage *int32 + // `renewal` allows configuration of how your certificate is renewed. If the policy mentioned is + // `RenewBefore` then the controller respects `renewBefore` and `renewBeforePercentage`. + // +optional + Renewal *CertificateRenewal + // Requested DNS subject alternative names. DNSNames []string @@ -490,6 +495,34 @@ const ( Modern2023PKCS12Profile PKCS12Profile = "Modern2023" ) +type CertificateRenewal struct { + // `policy` must be one of `Disabled`, `RenewBefore`. + Policy CertificateRenewalPolicy + + // `windows` mentions the behavior of when the renewal must happen. + Windows []CertificateRenewalWindows +} + +type CertificateRenewalPolicy string + +const ( + RenewBefore CertificateRenewalPolicy = "RenewBefore" + Disabled CertificateRenewalPolicy = "Disabled" +) + +// CertificateRenewalWindows is the definition for renewal windows +type CertificateRenewalWindows struct { + // `timezone` is IANA compliant timezone. + Timezone string + + // `windowDuration` is how long the cron definition is active for. + // Value must be in units accepted by Go time.ParseDuration https://golang.org/pkg/time/#ParseDuration. + WindowDuration *metav1.Duration + + // `cron` is a cron compliant string to allow when the renewal should be allowed. + Cron string +} + // CertificateStatus defines the observed state of Certificate type CertificateStatus struct { // List of status conditions to indicate the status of certificates. diff --git a/internal/apis/certmanager/v1/zz_generated.conversion.go b/internal/apis/certmanager/v1/zz_generated.conversion.go index 8e7938ea3..0406b318e 100644 --- a/internal/apis/certmanager/v1/zz_generated.conversion.go +++ b/internal/apis/certmanager/v1/zz_generated.conversion.go @@ -114,6 +114,26 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddGeneratedConversionFunc((*certmanagerv1.CertificateRenewal)(nil), (*certmanager.CertificateRenewal)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_CertificateRenewal_To_certmanager_CertificateRenewal(a.(*certmanagerv1.CertificateRenewal), b.(*certmanager.CertificateRenewal), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*certmanager.CertificateRenewal)(nil), (*certmanagerv1.CertificateRenewal)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_certmanager_CertificateRenewal_To_v1_CertificateRenewal(a.(*certmanager.CertificateRenewal), b.(*certmanagerv1.CertificateRenewal), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*certmanagerv1.CertificateRenewalWindows)(nil), (*certmanager.CertificateRenewalWindows)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_CertificateRenewalWindows_To_certmanager_CertificateRenewalWindows(a.(*certmanagerv1.CertificateRenewalWindows), b.(*certmanager.CertificateRenewalWindows), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*certmanager.CertificateRenewalWindows)(nil), (*certmanagerv1.CertificateRenewalWindows)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_certmanager_CertificateRenewalWindows_To_v1_CertificateRenewalWindows(a.(*certmanager.CertificateRenewalWindows), b.(*certmanagerv1.CertificateRenewalWindows), scope) + }); err != nil { + return err + } if err := s.AddGeneratedConversionFunc((*certmanagerv1.CertificateRequest)(nil), (*certmanager.CertificateRequest)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_v1_CertificateRequest_To_certmanager_CertificateRequest(a.(*certmanagerv1.CertificateRequest), b.(*certmanager.CertificateRequest), scope) }); err != nil { @@ -667,6 +687,52 @@ func Convert_certmanager_CertificatePrivateKey_To_v1_CertificatePrivateKey(in *c return autoConvert_certmanager_CertificatePrivateKey_To_v1_CertificatePrivateKey(in, out, s) } +func autoConvert_v1_CertificateRenewal_To_certmanager_CertificateRenewal(in *certmanagerv1.CertificateRenewal, out *certmanager.CertificateRenewal, s conversion.Scope) error { + out.Policy = certmanager.CertificateRenewalPolicy(in.Policy) + out.Windows = *(*[]certmanager.CertificateRenewalWindows)(unsafe.Pointer(&in.Windows)) + return nil +} + +// Convert_v1_CertificateRenewal_To_certmanager_CertificateRenewal is an autogenerated conversion function. +func Convert_v1_CertificateRenewal_To_certmanager_CertificateRenewal(in *certmanagerv1.CertificateRenewal, out *certmanager.CertificateRenewal, s conversion.Scope) error { + return autoConvert_v1_CertificateRenewal_To_certmanager_CertificateRenewal(in, out, s) +} + +func autoConvert_certmanager_CertificateRenewal_To_v1_CertificateRenewal(in *certmanager.CertificateRenewal, out *certmanagerv1.CertificateRenewal, s conversion.Scope) error { + out.Policy = certmanagerv1.CertificateRenewalPolicy(in.Policy) + out.Windows = *(*[]certmanagerv1.CertificateRenewalWindows)(unsafe.Pointer(&in.Windows)) + return nil +} + +// Convert_certmanager_CertificateRenewal_To_v1_CertificateRenewal is an autogenerated conversion function. +func Convert_certmanager_CertificateRenewal_To_v1_CertificateRenewal(in *certmanager.CertificateRenewal, out *certmanagerv1.CertificateRenewal, s conversion.Scope) error { + return autoConvert_certmanager_CertificateRenewal_To_v1_CertificateRenewal(in, out, s) +} + +func autoConvert_v1_CertificateRenewalWindows_To_certmanager_CertificateRenewalWindows(in *certmanagerv1.CertificateRenewalWindows, out *certmanager.CertificateRenewalWindows, s conversion.Scope) error { + out.Timezone = in.Timezone + out.WindowDuration = (*metav1.Duration)(unsafe.Pointer(in.WindowDuration)) + out.Cron = in.Cron + return nil +} + +// Convert_v1_CertificateRenewalWindows_To_certmanager_CertificateRenewalWindows is an autogenerated conversion function. +func Convert_v1_CertificateRenewalWindows_To_certmanager_CertificateRenewalWindows(in *certmanagerv1.CertificateRenewalWindows, out *certmanager.CertificateRenewalWindows, s conversion.Scope) error { + return autoConvert_v1_CertificateRenewalWindows_To_certmanager_CertificateRenewalWindows(in, out, s) +} + +func autoConvert_certmanager_CertificateRenewalWindows_To_v1_CertificateRenewalWindows(in *certmanager.CertificateRenewalWindows, out *certmanagerv1.CertificateRenewalWindows, s conversion.Scope) error { + out.Timezone = in.Timezone + out.WindowDuration = (*metav1.Duration)(unsafe.Pointer(in.WindowDuration)) + out.Cron = in.Cron + return nil +} + +// Convert_certmanager_CertificateRenewalWindows_To_v1_CertificateRenewalWindows is an autogenerated conversion function. +func Convert_certmanager_CertificateRenewalWindows_To_v1_CertificateRenewalWindows(in *certmanager.CertificateRenewalWindows, out *certmanagerv1.CertificateRenewalWindows, s conversion.Scope) error { + return autoConvert_certmanager_CertificateRenewalWindows_To_v1_CertificateRenewalWindows(in, out, s) +} + func autoConvert_v1_CertificateRequest_To_certmanager_CertificateRequest(in *certmanagerv1.CertificateRequest, out *certmanager.CertificateRequest, s conversion.Scope) error { out.ObjectMeta = in.ObjectMeta if err := Convert_v1_CertificateRequestSpec_To_certmanager_CertificateRequestSpec(&in.Spec, &out.Spec, s); err != nil { @@ -864,6 +930,7 @@ func autoConvert_v1_CertificateSpec_To_certmanager_CertificateSpec(in *certmanag out.Duration = (*metav1.Duration)(unsafe.Pointer(in.Duration)) out.RenewBefore = (*metav1.Duration)(unsafe.Pointer(in.RenewBefore)) out.RenewBeforePercentage = (*int32)(unsafe.Pointer(in.RenewBeforePercentage)) + out.Renewal = (*certmanager.CertificateRenewal)(unsafe.Pointer(in.Renewal)) out.DNSNames = *(*[]string)(unsafe.Pointer(&in.DNSNames)) out.IPAddresses = *(*[]string)(unsafe.Pointer(&in.IPAddresses)) out.URIs = *(*[]string)(unsafe.Pointer(&in.URIs)) @@ -906,6 +973,7 @@ func autoConvert_certmanager_CertificateSpec_To_v1_CertificateSpec(in *certmanag out.Duration = (*metav1.Duration)(unsafe.Pointer(in.Duration)) out.RenewBefore = (*metav1.Duration)(unsafe.Pointer(in.RenewBefore)) out.RenewBeforePercentage = (*int32)(unsafe.Pointer(in.RenewBeforePercentage)) + out.Renewal = (*certmanagerv1.CertificateRenewal)(unsafe.Pointer(in.Renewal)) out.DNSNames = *(*[]string)(unsafe.Pointer(&in.DNSNames)) out.IPAddresses = *(*[]string)(unsafe.Pointer(&in.IPAddresses)) out.URIs = *(*[]string)(unsafe.Pointer(&in.URIs)) diff --git a/internal/apis/certmanager/validation/certificate.go b/internal/apis/certmanager/validation/certificate.go index de109d223..8a0b9f4f6 100644 --- a/internal/apis/certmanager/validation/certificate.go +++ b/internal/apis/certmanager/validation/certificate.go @@ -37,6 +37,7 @@ import ( "github.com/cert-manager/cert-manager/internal/webhook/feature" "github.com/cert-manager/cert-manager/pkg/api/util" cmapi "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1" + utilpkg "github.com/cert-manager/cert-manager/pkg/util" utilfeature "github.com/cert-manager/cert-manager/pkg/util/feature" "github.com/cert-manager/cert-manager/pkg/util/pki" ) @@ -72,7 +73,7 @@ func ValidateCertificateSpec(crt *internalcmapi.CertificateSpec, fldPath *field. el = append(el, validateIssuerRef(crt.IssuerRef, fldPath)...) - var commonName = crt.CommonName + commonName := crt.CommonName if crt.LiteralSubject != "" { if !utilfeature.DefaultFeatureGate.Enabled(feature.LiteralCertificateSubject) { el = append(el, field.Forbidden(fldPath.Child("literalSubject"), "Feature gate LiteralCertificateSubject must be enabled on both webhook and controller to use the alpha `literalSubject` field")) @@ -231,6 +232,10 @@ func ValidateCertificateSpec(crt *internalcmapi.CertificateSpec, fldPath *field. el = append(el, validateKeystores(crt, fldPath)...) } + if crt.Renewal != nil { + el = append(el, validateCertificateRenewal(crt, fldPath)...) + } + return el } @@ -445,3 +450,43 @@ func validateKeystores(crt *internalcmapi.CertificateSpec, fldPath *field.Path) return el } + +func validateCertificateRenewal(crt *internalcmapi.CertificateSpec, fldPath *field.Path) field.ErrorList { + var el field.ErrorList + switch crt.Renewal.Policy { + case internalcmapi.RenewBefore: + case internalcmapi.Disabled: + if len(crt.Renewal.Windows) > 0 { + el = append(el, field.Forbidden(fldPath.Child("renewal", "windows"), "windows cannot be set when `renewal.policy` is set to Disabled")) + } + return el + default: + el = append(el, field.NotSupported(fldPath.Child("renewal", "policy"), crt.Renewal.Policy, []string{string(internalcmapi.Disabled), string(internalcmapi.RenewBefore)})) + } + + if crt.Renewal.Windows != nil { + for i, window := range crt.Renewal.Windows { + el = append(el, validateCertificateRenewalWindows(window, fldPath.Child("renewal", "windows").Index(i))...) + } + } + + return el +} + +func validateCertificateRenewalWindows(window internalcmapi.CertificateRenewalWindows, fldPath *field.Path) field.ErrorList { + var el field.ErrorList + + if window.WindowDuration == nil { + el = append(el, field.Required(fldPath.Child("windowDuration"), "windowDuration must be specified and should be greater than 0")) + } + + if _, err := time.LoadLocation(window.Timezone); err != nil && window.Timezone != "" { + el = append(el, field.Invalid(fldPath.Child("timezone"), window.Timezone, "invalid value for timezone. timezone must be IANA compliant")) + } + + if _, err := utilpkg.CronParse(window.Cron, window.Timezone); err != nil { + el = append(el, field.Invalid(fldPath.Child("cron"), window.Cron, fmt.Sprintf("invalid cron syntax: %s. cron needs to follow: cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow", err.Error()))) + } + + return el +} diff --git a/internal/apis/certmanager/zz_generated.deepcopy.go b/internal/apis/certmanager/zz_generated.deepcopy.go index d64f9cd5e..87ac6cbeb 100644 --- a/internal/apis/certmanager/zz_generated.deepcopy.go +++ b/internal/apis/certmanager/zz_generated.deepcopy.go @@ -198,6 +198,50 @@ func (in *CertificatePrivateKey) DeepCopy() *CertificatePrivateKey { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CertificateRenewal) DeepCopyInto(out *CertificateRenewal) { + *out = *in + if in.Windows != nil { + in, out := &in.Windows, &out.Windows + *out = make([]CertificateRenewalWindows, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateRenewal. +func (in *CertificateRenewal) DeepCopy() *CertificateRenewal { + if in == nil { + return nil + } + out := new(CertificateRenewal) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CertificateRenewalWindows) DeepCopyInto(out *CertificateRenewalWindows) { + *out = *in + if in.WindowDuration != nil { + in, out := &in.WindowDuration, &out.WindowDuration + *out = new(v1.Duration) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateRenewalWindows. +func (in *CertificateRenewalWindows) DeepCopy() *CertificateRenewalWindows { + if in == nil { + return nil + } + out := new(CertificateRenewalWindows) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *CertificateRequest) DeepCopyInto(out *CertificateRequest) { *out = *in @@ -421,6 +465,11 @@ func (in *CertificateSpec) DeepCopyInto(out *CertificateSpec) { *out = new(int32) **out = **in } + if in.Renewal != nil { + in, out := &in.Renewal, &out.Renewal + *out = new(CertificateRenewal) + (*in).DeepCopyInto(*out) + } if in.DNSNames != nil { in, out := &in.DNSNames, &out.DNSNames *out = make([]string, len(*in)) diff --git a/internal/controller/certificates/policies/checks.go b/internal/controller/certificates/policies/checks.go index 02d6fa980..83afaccf7 100644 --- a/internal/controller/certificates/policies/checks.go +++ b/internal/controller/certificates/policies/checks.go @@ -270,7 +270,15 @@ func CurrentCertificateNearingExpiry(c clock.Clock) Func { notBefore := metav1.NewTime(x509Cert.NotBefore) notAfter := metav1.NewTime(x509Cert.NotAfter) crt := input.Certificate - renewalTime := pki.RenewalTime(notBefore.Time, notAfter.Time, crt.Spec.RenewBefore, crt.Spec.RenewBeforePercentage) + + reason := Renewing + message := fmt.Sprintf("Renewing certificate as renewal was scheduled at %s", input.Certificate.Status.RenewalTime) + + renewalTime, err := pki.RenewalTime(notBefore.Time, notAfter.Time, crt.Spec.RenewBefore, crt.Spec.RenewBeforePercentage, crt.Spec.Renewal) + if err != nil { + reason = WindowError + message = err.Error() + } renewIn := renewalTime.Time.Sub(c.Now()) if renewIn > 0 { @@ -278,7 +286,7 @@ func CurrentCertificateNearingExpiry(c clock.Clock) Func { return "", "", false } - return Renewing, fmt.Sprintf("Renewing certificate as renewal was scheduled at %s", input.Certificate.Status.RenewalTime), true + return reason, message, true } } @@ -308,8 +316,10 @@ func formatIssuerRef(name, kind, group string) string { return fmt.Sprintf("%s.%s/%s", kind, group, name) } -const defaultIssuerKind = "Issuer" -const defaultIssuerGroup = "cert-manager.io" +const ( + defaultIssuerKind = "Issuer" + defaultIssuerGroup = "cert-manager.io" +) func issuerKindsEqual(l, r string) bool { if l == "" { diff --git a/internal/controller/certificates/policies/constants.go b/internal/controller/certificates/policies/constants.go index ba320fdc9..d6493d2cd 100644 --- a/internal/controller/certificates/policies/constants.go +++ b/internal/controller/certificates/policies/constants.go @@ -53,6 +53,9 @@ const ( // Expired is a policy violation reason for a scenario where Certificate has // expired. Expired string = "Expired" + // WindowError is a policy violation for a scenario where a time couldn't be + // found due to a cron misconfiguration or validation. + WindowError string = "WindowError" // SecretTemplateMismatch is a policy violation whereby the Certificate's // SecretTemplate is not reflected on the target Secret, either by having // extra, missing, or wrong Annotations or Labels. diff --git a/internal/cron/constantdelay.go b/internal/cron/constantdelay.go new file mode 100644 index 000000000..b359ce17b --- /dev/null +++ b/internal/cron/constantdelay.go @@ -0,0 +1,35 @@ +// +skip_license_check + +/* +This file contains portions of code directly taken from the 'robfig/cron' project. +A copy of the license for this code can be found in the file named LICENSE in +this directory. +*/ + +package cron + +import "time" + +// ConstantDelaySchedule represents a simple recurring duty cycle, e.g. "Every 5 minutes". +// It does not support jobs more frequent than once a second. +type ConstantDelaySchedule struct { + Delay time.Duration +} + +// Every returns a crontab Schedule that activates once every duration. +// Delays of less than a second are not supported (will round up to 1 second). +// Any fields less than a Second are truncated. +func Every(duration time.Duration) ConstantDelaySchedule { + if duration < time.Second { + duration = time.Second + } + return ConstantDelaySchedule{ + Delay: duration - time.Duration(duration.Nanoseconds())%time.Second, + } +} + +// Next returns the next time this should be run. +// This rounds so that the next activation time will be on the second. +func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time { + return t.Add(schedule.Delay - time.Duration(t.Nanosecond())*time.Nanosecond) +} diff --git a/internal/cron/cron.go b/internal/cron/cron.go new file mode 100644 index 000000000..2f6f372b4 --- /dev/null +++ b/internal/cron/cron.go @@ -0,0 +1,353 @@ +// +skip_license_check + +/* +This file contains portions of code directly taken from the 'robfig/cron' project. +A copy of the license for this code can be found in the file named LICENSE in +this directory. +*/ + +package cron + +import ( + "context" + "sort" + "sync" + "time" +) + +// Cron keeps track of any number of entries, invoking the associated func as +// specified by the schedule. It may be started, stopped, and the entries may +// be inspected while running. +type Cron struct { + entries []*Entry + stop chan struct{} + add chan *Entry + remove chan EntryID + snapshot chan chan []Entry + running bool + logger Logger + runningMu sync.Mutex + location *time.Location + parser Parser + nextID EntryID + jobWaiter sync.WaitGroup +} + +// Job is an interface for submitted cron jobs. +type Job interface { + Run() +} + +// Schedule describes a job's duty cycle. +type Schedule interface { + // Next returns the next activation time, later than the given time. + // Next is invoked initially, and then each time the job is run. + Next(time.Time) time.Time +} + +// EntryID identifies an entry within a Cron instance +type EntryID int + +// Entry consists of a schedule and the func to execute on that schedule. +type Entry struct { + // ID is the cron-assigned ID of this entry, which may be used to look up a + // snapshot or remove it. + ID EntryID + + // Schedule on which this job should be run. + Schedule Schedule + + // Next time the job will run, or the zero time if Cron has not been + // started or this entry's schedule is unsatisfiable + Next time.Time + + // Prev is the last time this job was run, or the zero time if never. + Prev time.Time + + // WrappedJob is the thing to run when the Schedule is activated. + WrappedJob Job + + // Job is the thing that was submitted to cron. + // It is kept around so that user code that needs to get at the job later, + // e.g. via Entries() can do so. + Job Job +} + +// Valid returns true if this is not the zero entry. +func (e Entry) Valid() bool { return e.ID != 0 } + +// byTime is a wrapper for sorting the entry array by time +// (with zero time at the end). +type byTime []*Entry + +func (s byTime) Len() int { return len(s) } +func (s byTime) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s byTime) Less(i, j int) bool { + // Two zero times should return false. + // Otherwise, zero is "greater" than any other time. + // (To sort it at the end of the list.) + if s[i].Next.IsZero() { + return false + } + if s[j].Next.IsZero() { + return true + } + return s[i].Next.Before(s[j].Next) +} + +// New returns a new Cron job runner, modified by the given options. +// +// Available Settings +// +// Time Zone +// Description: The time zone in which schedules are interpreted +// Default: time.Local +// +// Parser +// Description: Parser converts cron spec strings into cron.Schedules. +// Default: Accepts this spec: https://en.wikipedia.org/wiki/Cron +// +// Chain +// Description: Wrap submitted jobs to customize behavior. +// Default: A chain that recovers panics and logs them to stderr. +// +// See "cron.With*" to modify the default behavior. +func New(opts ...Option) *Cron { + c := &Cron{ + entries: nil, + add: make(chan *Entry), + stop: make(chan struct{}), + snapshot: make(chan chan []Entry), + remove: make(chan EntryID), + running: false, + runningMu: sync.Mutex{}, + logger: DefaultLogger, + location: time.Local, //nolint: gosmopolitan // This is just a default + parser: standardParser, + } + for _, opt := range opts { + opt(c) + } + return c +} + +// FuncJob is a wrapper that turns a func() into a cron.Job +type FuncJob func() + +func (f FuncJob) Run() { f() } + +// AddFunc adds a func to the Cron to be run on the given schedule. +// The spec is parsed using the time zone of this Cron instance as the default. +// An opaque ID is returned that can be used to later remove it. +func (c *Cron) AddFunc(spec string, cmd func()) (EntryID, error) { + return c.AddJob(spec, FuncJob(cmd)) +} + +// AddJob adds a Job to the Cron to be run on the given schedule. +// The spec is parsed using the time zone of this Cron instance as the default. +// An opaque ID is returned that can be used to later remove it. +func (c *Cron) AddJob(spec string, cmd Job) (EntryID, error) { + schedule, err := c.parser.Parse(spec) + if err != nil { + return 0, err + } + return c.Schedule(schedule, cmd), nil +} + +// Schedule adds a Job to the Cron to be run on the given schedule. +// The job is wrapped with the configured Chain. +func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID { + c.runningMu.Lock() + defer c.runningMu.Unlock() + c.nextID++ + entry := &Entry{ + ID: c.nextID, + Schedule: schedule, + Job: cmd, + } + if !c.running { + c.entries = append(c.entries, entry) + } else { + c.add <- entry + } + return entry.ID +} + +// Entries returns a snapshot of the cron entries. +func (c *Cron) Entries() []Entry { + c.runningMu.Lock() + defer c.runningMu.Unlock() + if c.running { + replyChan := make(chan []Entry, 1) + c.snapshot <- replyChan + return <-replyChan + } + return c.entrySnapshot() +} + +// Location gets the time zone location +func (c *Cron) Location() *time.Location { + return c.location +} + +// Entry returns a snapshot of the given entry, or nil if it couldn't be found. +func (c *Cron) Entry(id EntryID) Entry { + for _, entry := range c.Entries() { + if id == entry.ID { + return entry + } + } + return Entry{} +} + +// Remove an entry from being run in the future. +func (c *Cron) Remove(id EntryID) { + c.runningMu.Lock() + defer c.runningMu.Unlock() + if c.running { + c.remove <- id + } else { + c.removeEntry(id) + } +} + +// Start the cron scheduler in its own goroutine, or no-op if already started. +func (c *Cron) Start() { + c.runningMu.Lock() + defer c.runningMu.Unlock() + if c.running { + return + } + c.running = true + go c.run() +} + +// Run the cron scheduler, or no-op if already running. +func (c *Cron) Run() { + c.runningMu.Lock() + if c.running { + c.runningMu.Unlock() + return + } + c.running = true + c.runningMu.Unlock() + c.run() +} + +// run the scheduler.. this is private just due to the need to synchronize +// access to the 'running' state variable. +func (c *Cron) run() { + c.logger.Info("start") + + // Figure out the next activation times for each entry. + now := c.now() + for _, entry := range c.entries { + entry.Next = entry.Schedule.Next(now) + c.logger.Info("schedule", "now", now, "entry", entry.ID, "next", entry.Next) + } + + for { + // Determine the next entry to run. + sort.Sort(byTime(c.entries)) + + var timer *time.Timer + if len(c.entries) == 0 || c.entries[0].Next.IsZero() { + // If there are no entries yet, just sleep - it still handles new entries + // and stop requests. + timer = time.NewTimer(100000 * time.Hour) + } else { + timer = time.NewTimer(c.entries[0].Next.Sub(now)) + } + + for { + select { + case now = <-timer.C: + now = now.In(c.location) + c.logger.Info("wake", "now", now) + + // Run every entry whose next time was less than now + for _, e := range c.entries { + if e.Next.After(now) || e.Next.IsZero() { + break + } + c.startJob(e.WrappedJob) + e.Prev = e.Next + e.Next = e.Schedule.Next(now) + c.logger.Info("run", "now", now, "entry", e.ID, "next", e.Next) + } + + case newEntry := <-c.add: + timer.Stop() + now = c.now() + newEntry.Next = newEntry.Schedule.Next(now) + c.entries = append(c.entries, newEntry) + c.logger.Info("added", "now", now, "entry", newEntry.ID, "next", newEntry.Next) + + case replyChan := <-c.snapshot: + replyChan <- c.entrySnapshot() + continue + + case <-c.stop: + timer.Stop() + c.logger.Info("stop") + return + + case id := <-c.remove: + timer.Stop() + now = c.now() + c.removeEntry(id) + c.logger.Info("removed", "entry", id) + } + + break + } + } +} + +// startJob runs the given job in a new goroutine. +func (c *Cron) startJob(j Job) { + c.jobWaiter.Go(func() { + j.Run() + }) +} + +// now returns current time in c location +func (c *Cron) now() time.Time { + return time.Now().In(c.location) +} + +// Stop stops the cron scheduler if it is running; otherwise it does nothing. +// A context is returned so the caller can wait for running jobs to complete. +func (c *Cron) Stop() context.Context { + c.runningMu.Lock() + defer c.runningMu.Unlock() + if c.running { + c.stop <- struct{}{} + c.running = false + } + ctx, cancel := context.WithCancel(context.Background()) + go func() { + c.jobWaiter.Wait() + cancel() + }() + return ctx +} + +// entrySnapshot returns a copy of the current cron entry list. +func (c *Cron) entrySnapshot() []Entry { + var entries = make([]Entry, len(c.entries)) + for i, e := range c.entries { + entries[i] = *e + } + return entries +} + +func (c *Cron) removeEntry(id EntryID) { + var entries []*Entry + for _, e := range c.entries { + if e.ID != id { + entries = append(entries, e) + } + } + c.entries = entries +} diff --git a/internal/cron/logger.go b/internal/cron/logger.go new file mode 100644 index 000000000..565067f4d --- /dev/null +++ b/internal/cron/logger.go @@ -0,0 +1,94 @@ +// +skip_license_check + +/* +This file contains portions of code directly taken from the 'robfig/cron' project. +A copy of the license for this code can be found in the file named LICENSE in +this directory. +*/ + +package cron + +import ( + "io" + "log" + "os" + "strings" + "time" +) + +// DefaultLogger is used by Cron if none is specified. +var DefaultLogger Logger = PrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags)) + +// DiscardLogger can be used by callers to discard all log messages. +var DiscardLogger Logger = PrintfLogger(log.New(io.Discard, "", 0)) + +// Logger is the interface used in this package for logging, so that any backend +// can be plugged in. It is a subset of the github.com/go-logr/logr interface. +type Logger interface { + // Info logs routine messages about cron's operation. + Info(msg string, keysAndValues ...any) + // Error logs an error condition. + Error(err error, msg string, keysAndValues ...any) +} + +// PrintfLogger wraps a Printf-based logger (such as the standard library "log") +// into an implementation of the Logger interface which logs errors only. +func PrintfLogger(l interface{ Printf(string, ...any) }) Logger { + return printfLogger{l, false} +} + +// VerbosePrintfLogger wraps a Printf-based logger (such as the standard library +// "log") into an implementation of the Logger interface which logs everything. +func VerbosePrintfLogger(l interface{ Printf(string, ...any) }) Logger { + return printfLogger{l, true} +} + +type printfLogger struct { + logger interface{ Printf(string, ...any) } + logInfo bool +} + +func (pl printfLogger) Info(msg string, keysAndValues ...any) { + if pl.logInfo { + keysAndValues = formatTimes(keysAndValues) + pl.logger.Printf( + formatString(len(keysAndValues)), + append([]any{msg}, keysAndValues...)...) + } +} + +func (pl printfLogger) Error(err error, msg string, keysAndValues ...any) { + keysAndValues = formatTimes(keysAndValues) + pl.logger.Printf( + formatString(len(keysAndValues)+2), + append([]any{msg, "error", err}, keysAndValues...)...) +} + +// formatString returns a logfmt-like format string for the number of +// key/values. +func formatString(numKeysAndValues int) string { + var sb strings.Builder + sb.WriteString("%s") + if numKeysAndValues > 0 { + sb.WriteString(", ") + } + for i := range numKeysAndValues / 2 { + if i > 0 { + sb.WriteString(", ") + } + sb.WriteString("%v=%v") + } + return sb.String() +} + +// formatTimes formats any time.Time values as RFC3339. +func formatTimes(keysAndValues []any) []any { + var formattedArgs []any + for _, arg := range keysAndValues { + if t, ok := arg.(time.Time); ok { + arg = t.Format(time.RFC3339) + } + formattedArgs = append(formattedArgs, arg) + } + return formattedArgs +} diff --git a/internal/cron/option.go b/internal/cron/option.go new file mode 100644 index 000000000..56739c499 --- /dev/null +++ b/internal/cron/option.go @@ -0,0 +1,45 @@ +// +skip_license_check + +/* +This file contains portions of code directly taken from the 'robfig/cron' project. +A copy of the license for this code can be found in the file named LICENSE in +this directory. +*/ + +package cron + +import ( + "time" +) + +// Option represents a modification to the default behavior of a Cron. +type Option func(*Cron) + +// WithLocation overrides the timezone of the cron instance. +func WithLocation(loc *time.Location) Option { + return func(c *Cron) { + c.location = loc + } +} + +// WithSeconds overrides the parser used for interpreting job schedules to +// include a seconds field as the first one. +func WithSeconds() Option { + return WithParser(NewParser( + Second | Minute | Hour | Dom | Month | Dow | Descriptor, + )) +} + +// WithParser overrides the parser used for interpreting job schedules. +func WithParser(p Parser) Option { + return func(c *Cron) { + c.parser = p + } +} + +// WithLogger uses the provided logger. +func WithLogger(logger Logger) Option { + return func(c *Cron) { + c.logger = logger + } +} diff --git a/internal/cron/parser.go b/internal/cron/parser.go new file mode 100644 index 000000000..ee05d3a22 --- /dev/null +++ b/internal/cron/parser.go @@ -0,0 +1,444 @@ +// +skip_license_check + +/* +This file contains portions of code directly taken from the 'robfig/cron' project. +A copy of the license for this code can be found in the file named LICENSE in +this directory. +*/ + +package cron + +import ( + "fmt" + "math" + "strconv" + "strings" + "time" +) + +// Configuration options for creating a parser. Most options specify which +// fields should be included, while others enable features. If a field is not +// included the parser will assume a default value. These options do not change +// the order fields are parse in. +type ParseOption int + +const ( + Second ParseOption = 1 << iota // Seconds field, default 0 + SecondOptional // Optional seconds field, default 0 + Minute // Minutes field, default 0 + Hour // Hours field, default 0 + Dom // Day of month field, default * + Month // Month field, default * + Dow // Day of week field, default * + DowOptional // Optional day of week field, default * + Descriptor // Allow descriptors such as @monthly, @weekly, etc. +) + +var places = []ParseOption{ + Second, + Minute, + Hour, + Dom, + Month, + Dow, +} + +var defaults = []string{ + "0", + "0", + "0", + "*", + "*", + "*", +} + +// A custom Parser that can be configured. +type Parser struct { + options ParseOption +} + +// NewParser creates a Parser with custom options. +// +// It panics if more than one Optional is given, since it would be impossible to +// correctly infer which optional is provided or missing in general. +// +// Examples +// +// // Standard parser without descriptors +// specParser := NewParser(Minute | Hour | Dom | Month | Dow) +// sched, err := specParser.Parse("0 0 15 */3 *") +// +// // Same as above, just excludes time fields +// subsParser := NewParser(Dom | Month | Dow) +// sched, err := specParser.Parse("15 */3 *") +// +// // Same as above, just makes Dow optional +// subsParser := NewParser(Dom | Month | DowOptional) +// sched, err := specParser.Parse("15 */3") +func NewParser(options ParseOption) Parser { + optionals := 0 + if options&DowOptional > 0 { + optionals++ + } + if options&SecondOptional > 0 { + optionals++ + } + if optionals > 1 { + panic("multiple optionals may not be configured") + } + return Parser{options} +} + +// Parse returns a new crontab schedule representing the given spec. +// It returns a descriptive error if the spec is not valid. +// It accepts crontab specs and features configured by NewParser. +func (p Parser) Parse(spec string) (Schedule, error) { + if len(spec) == 0 { + return nil, fmt.Errorf("empty spec string") + } + + // Extract timezone if present + //nolint: gosmopolitan // this makes sense as it also handles other locations below + var loc = time.Local + if strings.HasPrefix(spec, "TZ=") || strings.HasPrefix(spec, "CRON_TZ=") { + var err error + i := strings.Index(spec, " ") + eq := strings.Index(spec, "=") + if loc, err = time.LoadLocation(spec[eq+1 : i]); err != nil { + return nil, fmt.Errorf("provided bad location %s: %v", spec[eq+1:i], err) + } + spec = strings.TrimSpace(spec[i:]) + } + + // Handle named schedules (descriptors), if configured + if strings.HasPrefix(spec, "@") { + if p.options&Descriptor == 0 { + return nil, fmt.Errorf("parser does not accept descriptors: %v", spec) + } + return parseDescriptor(spec, loc) + } + + // Split on whitespace. + fields := strings.Fields(spec) + + // Validate & fill in any omitted or optional fields + var err error + fields, err = normalizeFields(fields, p.options) + if err != nil { + return nil, err + } + + field := func(field string, r bounds) uint64 { + if err != nil { + return 0 + } + var bits uint64 + bits, err = getField(field, r) + return bits + } + + var ( + second = field(fields[0], seconds) + minute = field(fields[1], minutes) + hour = field(fields[2], hours) + dayofmonth = field(fields[3], dom) + month = field(fields[4], months) + dayofweek = field(fields[5], dow) + ) + if err != nil { + return nil, err + } + + return &SpecSchedule{ + Second: second, + Minute: minute, + Hour: hour, + Dom: dayofmonth, + Month: month, + Dow: dayofweek, + Location: loc, + }, nil +} + +// normalizeFields takes a subset set of the time fields and returns the full set +// with defaults (zeroes) populated for unset fields. +// +// As part of performing this function, it also validates that the provided +// fields are compatible with the configured options. +func normalizeFields(fields []string, options ParseOption) ([]string, error) { + // Validate optionals & add their field to options + optionals := 0 + if options&SecondOptional > 0 { + options |= Second + optionals++ + } + if options&DowOptional > 0 { + options |= Dow + optionals++ + } + if optionals > 1 { + return nil, fmt.Errorf("multiple optionals may not be configured") + } + + // Figure out how many fields we need + maxField := 0 + for _, place := range places { + if options&place > 0 { + maxField++ + } + } + minField := maxField - optionals + + // Validate number of fields + if count := len(fields); count < minField || count > maxField { + if minField == maxField { + return nil, fmt.Errorf("expected exactly %d fields, found %d: %s", minField, count, fields) + } + return nil, fmt.Errorf("expected %d to %d fields, found %d: %s", minField, maxField, count, fields) + } + + // Populate the optional field if not provided + if minField < maxField && len(fields) == minField { + switch { + case options&DowOptional > 0: + fields = append(fields, defaults[5]) // TODO: improve access to default + case options&SecondOptional > 0: + fields = append([]string{defaults[0]}, fields...) + default: + return nil, fmt.Errorf("unknown optional field") + } + } + + // Populate all fields not part of options with their defaults + n := 0 + expandedFields := make([]string, len(places)) + copy(expandedFields, defaults) + for i, place := range places { + if options&place > 0 { + expandedFields[i] = fields[n] + n++ + } + } + return expandedFields, nil +} + +var standardParser = NewParser( + Minute | Hour | Dom | Month | Dow | Descriptor, +) + +// ParseStandard returns a new crontab schedule representing the given +// standardSpec (https://en.wikipedia.org/wiki/Cron). It requires 5 entries +// representing: minute, hour, day of month, month and day of week, in that +// order. It returns a descriptive error if the spec is not valid. +// +// It accepts +// - Standard crontab specs, e.g. "* * * * ?" +// - Descriptors, e.g. "@midnight", "@every 1h30m" +func ParseStandard(standardSpec string) (Schedule, error) { + return standardParser.Parse(standardSpec) +} + +// getField returns an Int with the bits set representing all of the times that +// the field represents or error parsing field value. A "field" is a comma-separated +// list of "ranges". +func getField(field string, r bounds) (uint64, error) { + var bits uint64 + ranges := strings.FieldsFunc(field, func(r rune) bool { return r == ',' }) + for _, expr := range ranges { + bit, err := getRange(expr, r) + if err != nil { + return bits, err + } + bits |= bit + } + return bits, nil +} + +// getRange returns the bits indicated by the given expression: +// +// number | number "-" number [ "/" number ] +// +// or error parsing range. +func getRange(expr string, r bounds) (uint64, error) { + var ( + start, end, step uint + rangeAndStep = strings.Split(expr, "/") + lowAndHigh = strings.Split(rangeAndStep[0], "-") + singleDigit = len(lowAndHigh) == 1 + err error + ) + + var extra uint64 + if lowAndHigh[0] == "*" || lowAndHigh[0] == "?" { + start = r.min + end = r.max + extra = starBit + } else { + start, err = parseIntOrName(lowAndHigh[0], r.names) + if err != nil { + return 0, err + } + switch len(lowAndHigh) { + case 1: + end = start + case 2: + end, err = parseIntOrName(lowAndHigh[1], r.names) + if err != nil { + return 0, err + } + default: + return 0, fmt.Errorf("too many hyphens: %s", expr) + } + } + + switch len(rangeAndStep) { + case 1: + step = 1 + case 2: + step, err = mustParseInt(rangeAndStep[1]) + if err != nil { + return 0, err + } + + // Special handling: "N/step" means "N-max/step". + if singleDigit { + end = r.max + } + if step > 1 { + extra = 0 + } + default: + return 0, fmt.Errorf("too many slashes: %s", expr) + } + + if start < r.min { + return 0, fmt.Errorf("beginning of range (%d) below minimum (%d): %s", start, r.min, expr) + } + if end > r.max { + return 0, fmt.Errorf("end of range (%d) above maximum (%d): %s", end, r.max, expr) + } + if start > end { + return 0, fmt.Errorf("beginning of range (%d) beyond end of range (%d): %s", start, end, expr) + } + if step == 0 { + return 0, fmt.Errorf("step of range should be a positive number: %s", expr) + } + + return getBits(start, end, step) | extra, nil +} + +// parseIntOrName returns the (possibly-named) integer contained in expr. +func parseIntOrName(expr string, names map[string]uint) (uint, error) { + if names != nil { + if namedInt, ok := names[strings.ToLower(expr)]; ok { + return namedInt, nil + } + } + return mustParseInt(expr) +} + +// mustParseInt parses the given expression as an int or returns an error. +func mustParseInt(expr string) (uint, error) { + num, err := strconv.Atoi(expr) + if err != nil { + return 0, fmt.Errorf("failed to parse int from %s: %s", expr, err) + } + if num < 0 { + return 0, fmt.Errorf("negative number (%d) not allowed: %s", num, expr) + } + + return uint(num), nil +} + +// getBits sets all bits in the range [min, max], modulo the given step size. +func getBits(minSize, maxSize, step uint) uint64 { + var bits uint64 + + // If step is 1, use shifts. + if step == 1 { + return ^(math.MaxUint64 << (maxSize + 1)) & (math.MaxUint64 << minSize) + } + + // Else, use a simple loop. + for i := minSize; i <= maxSize; i += step { + bits |= 1 << i + } + return bits +} + +// all returns all bits within the given bounds. (plus the star bit) +func all(r bounds) uint64 { + return getBits(r.min, r.max, 1) | starBit +} + +// parseDescriptor returns a predefined schedule for the expression, or error if none matches. +func parseDescriptor(descriptor string, loc *time.Location) (Schedule, error) { + switch descriptor { + case "@yearly", "@annually": + return &SpecSchedule{ + Second: 1 << seconds.min, + Minute: 1 << minutes.min, + Hour: 1 << hours.min, + Dom: 1 << dom.min, + Month: 1 << months.min, + Dow: all(dow), + Location: loc, + }, nil + + case "@monthly": + return &SpecSchedule{ + Second: 1 << seconds.min, + Minute: 1 << minutes.min, + Hour: 1 << hours.min, + Dom: 1 << dom.min, + Month: all(months), + Dow: all(dow), + Location: loc, + }, nil + + case "@weekly": + return &SpecSchedule{ + Second: 1 << seconds.min, + Minute: 1 << minutes.min, + Hour: 1 << hours.min, + Dom: all(dom), + Month: all(months), + Dow: 1 << dow.min, + Location: loc, + }, nil + + case "@daily", "@midnight": + return &SpecSchedule{ + Second: 1 << seconds.min, + Minute: 1 << minutes.min, + Hour: 1 << hours.min, + Dom: all(dom), + Month: all(months), + Dow: all(dow), + Location: loc, + }, nil + + case "@hourly": + return &SpecSchedule{ + Second: 1 << seconds.min, + Minute: 1 << minutes.min, + Hour: all(hours), + Dom: all(dom), + Month: all(months), + Dow: all(dow), + Location: loc, + }, nil + + } + + const every = "@every " + if strings.HasPrefix(descriptor, every) { + duration, err := time.ParseDuration(descriptor[len(every):]) + if err != nil { + return nil, fmt.Errorf("failed to parse duration %s: %s", descriptor, err) + } + return Every(duration), nil + } + + return nil, fmt.Errorf("unrecognized descriptor: %s", descriptor) +} diff --git a/internal/cron/spec.go b/internal/cron/spec.go new file mode 100644 index 000000000..00a355c04 --- /dev/null +++ b/internal/cron/spec.go @@ -0,0 +1,204 @@ +// +skip_license_check + +/* +This file contains portions of code directly taken from the 'robfig/cron' project. +A copy of the license for this code can be found in the file named LICENSE in +this directory. +*/ + +package cron + +import "time" + +// SpecSchedule specifies a duty cycle (to the second granularity), based on a +// traditional crontab specification. It is computed initially and stored as bit sets. +type SpecSchedule struct { + Second, Minute, Hour, Dom, Month, Dow uint64 + + // Override location for this schedule. + Location *time.Location +} + +// bounds provides a range of acceptable values (plus a map of name to value). +type bounds struct { + min, max uint + names map[string]uint +} + +// The bounds for each field. +var ( + seconds = bounds{0, 59, nil} + minutes = bounds{0, 59, nil} + hours = bounds{0, 23, nil} + dom = bounds{1, 31, nil} + months = bounds{1, 12, map[string]uint{ + "jan": 1, + "feb": 2, + "mar": 3, + "apr": 4, + "may": 5, + "jun": 6, + "jul": 7, + "aug": 8, + "sep": 9, + "oct": 10, + "nov": 11, + "dec": 12, + }} + dow = bounds{0, 6, map[string]uint{ + "sun": 0, + "mon": 1, + "tue": 2, + "wed": 3, + "thu": 4, + "fri": 5, + "sat": 6, + }} +) + +const ( + // Set the top bit if a star was included in the expression. + starBit = 1 << 63 +) + +// Next returns the next time this schedule is activated, greater than the given +// time. If no time can be found to satisfy the schedule, return the zero time. +func (s *SpecSchedule) Next(t time.Time) time.Time { + // General approach + // + // For Month, Day, Hour, Minute, Second: + // Check if the time value matches. If yes, continue to the next field. + // If the field doesn't match the schedule, then increment the field until it matches. + // While incrementing the field, a wrap-around brings it back to the beginning + // of the field list (since it is necessary to re-verify previous field + // values) + + // Convert the given time into the schedule's timezone, if one is specified. + // Save the original timezone so we can convert back after we find a time. + // Note that schedules without a time zone specified (time.Local) are treated + // as local to the time provided. + origLocation := t.Location() + loc := s.Location + //nolint: gosmopolitan // this makes sense as it also handles other locations below + if loc == time.Local { + loc = t.Location() + } + //nolint:gosmopolitan + if s.Location != time.Local { + t = t.In(s.Location) + } + + // Start at the earliest possible time (the upcoming second). + t = t.Add(1*time.Second - time.Duration(t.Nanosecond())*time.Nanosecond) + + // This flag indicates whether a field has been incremented. + added := false + + // If no time is found within five years, return zero. + yearLimit := t.Year() + 5 + +WRAP: + if t.Year() > yearLimit { + return time.Time{} + } + + // Find the first applicable month. + // If it's this month, then do nothing. + //nolint:gosec + for 1< 12 { + t = t.Add(time.Duration(24-t.Hour()) * time.Hour) + } else { + t = t.Add(time.Duration(-t.Hour()) * time.Hour) + } + } + + if t.Day() == 1 { + goto WRAP + } + } + + //nolint:gosec + for 1< 0 + //nolint:gosec + dowMatch = 1< 0 + ) + if s.Dom&starBit > 0 || s.Dow&starBit > 0 { + return domMatch && dowMatch + } + return domMatch || dowMatch +} diff --git a/internal/generated/openapi/zz_generated.openapi.go b/internal/generated/openapi/zz_generated.openapi.go index 37ffccbb1..274ac4a34 100644 --- a/internal/generated/openapi/zz_generated.openapi.go +++ b/internal/generated/openapi/zz_generated.openapi.go @@ -81,6 +81,8 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateKeystores": schema_pkg_apis_certmanager_v1_CertificateKeystores(ref), "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateList": schema_pkg_apis_certmanager_v1_CertificateList(ref), "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificatePrivateKey": schema_pkg_apis_certmanager_v1_CertificatePrivateKey(ref), + "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRenewal": schema_pkg_apis_certmanager_v1_CertificateRenewal(ref), + "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRenewalWindows": schema_pkg_apis_certmanager_v1_CertificateRenewalWindows(ref), "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRequest": schema_pkg_apis_certmanager_v1_CertificateRequest(ref), "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRequestCondition": schema_pkg_apis_certmanager_v1_CertificateRequestCondition(ref), "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRequestList": schema_pkg_apis_certmanager_v1_CertificateRequestList(ref), @@ -2854,6 +2856,82 @@ func schema_pkg_apis_certmanager_v1_CertificatePrivateKey(ref common.ReferenceCa } } +func schema_pkg_apis_certmanager_v1_CertificateRenewal(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "policy": { + SchemaProps: spec.SchemaProps{ + Description: "`policy` must be one of `Disabled`, `RenewBefore`.", + Type: []string{"string"}, + Format: "", + }, + }, + "windows": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "atomic", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "`windows` mentions the behavior of when the renewal must happen.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRenewalWindows"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRenewalWindows"}, + } +} + +func schema_pkg_apis_certmanager_v1_CertificateRenewalWindows(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "CertificateRenewalWindows is the definition for renewal windows", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "timezone": { + SchemaProps: spec.SchemaProps{ + Description: "`timezone` is IANA compliant timezone. For example America/Denver. If this field is not set, timezone is treated as UTC.", + Type: []string{"string"}, + Format: "", + }, + }, + "windowDuration": { + SchemaProps: spec.SchemaProps{ + Description: "`windowDuration` is how long the cron definition is active for. Value must be in units accepted by Go time.ParseDuration https://golang.org/pkg/time/#ParseDuration.", + Ref: ref(metav1.Duration{}.OpenAPIModelName()), + }, + }, + "cron": { + SchemaProps: spec.SchemaProps{ + Description: "`cron` is a cron compliant string to allow when the renewal should be allowed. Format is as shown below: * * * * * | | | | | | | | | day of the week (0–6) (Sunday to Saturday; | | | month (1–12) 7 is also Sunday on some systems) | | day of the month (1–31) | hour (0–23) minute (0–59)", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"windowDuration", "cron"}, + }, + }, + Dependencies: []string{ + metav1.Duration{}.OpenAPIModelName()}, + } +} + func schema_pkg_apis_certmanager_v1_CertificateRequest(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -3275,6 +3353,12 @@ func schema_pkg_apis_certmanager_v1_CertificateSpec(ref common.ReferenceCallback Format: "int32", }, }, + "renewal": { + SchemaProps: spec.SchemaProps{ + Description: "`renewal` allows configuration of how your certificate is renewed. If the policy mentioned is `RenewBefore` then the controller respects `renewBefore` and `renewBeforePercentage`.", + Ref: ref("github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRenewal"), + }, + }, "dnsNames": { VendorExtensible: spec.VendorExtensible{ Extensions: spec.Extensions{ @@ -3485,7 +3569,7 @@ func schema_pkg_apis_certmanager_v1_CertificateSpec(ref common.ReferenceCallback }, }, Dependencies: []string{ - "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateAdditionalOutputFormat", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateKeystores", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificatePrivateKey", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateSecretTemplate", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.NameConstraints", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.OtherName", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.X509Subject", "github.com/cert-manager/cert-manager/pkg/apis/meta/v1.IssuerReference", metav1.Duration{}.OpenAPIModelName()}, + "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateAdditionalOutputFormat", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateKeystores", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificatePrivateKey", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateRenewal", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.CertificateSecretTemplate", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.NameConstraints", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.OtherName", "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1.X509Subject", "github.com/cert-manager/cert-manager/pkg/apis/meta/v1.IssuerReference", metav1.Duration{}.OpenAPIModelName()}, } } @@ -4786,7 +4870,7 @@ func schema_pkg_apis_meta_v1_IssuerReference(ref common.ReferenceCallback) commo return common.OpenAPIDefinition{ Schema: spec.Schema{ SchemaProps: spec.SchemaProps{ - Description: "IssuerReference is a reference to a certificate issuer object with a given name, kind and group.", + Description: "ObjectReference is a reference to an object with a given name, kind and group.\n\nDeprecated: Use IssuerReference instead.", Type: []string{"object"}, Properties: map[string]spec.Schema{ "name": { diff --git a/pkg/apis/certmanager/v1/types_certificate.go b/pkg/apis/certmanager/v1/types_certificate.go index 80e641520..6863b2a9c 100644 --- a/pkg/apis/certmanager/v1/types_certificate.go +++ b/pkg/apis/certmanager/v1/types_certificate.go @@ -206,6 +206,11 @@ type CertificateSpec struct { // +optional RenewBeforePercentage *int32 `json:"renewBeforePercentage,omitempty"` + // `renewal` allows configuration of how your certificate is renewed. If the policy mentioned is + // `RenewBefore` then the controller respects `renewBefore` and `renewBeforePercentage`. + // +optional + Renewal *CertificateRenewal `json:"renewal,omitempty"` + // Requested DNS subject alternative names. // +optional // +listType=atomic @@ -583,6 +588,52 @@ const ( Modern2023PKCS12Profile PKCS12Profile = "Modern2023" ) +type CertificateRenewal struct { + // `policy` must be one of `Disabled`, `RenewBefore`. + // +kubebuilder:validation:Enum=RenewBefore;Disabled + Policy CertificateRenewalPolicy `json:"policy,omitempty"` + + // `windows` mentions the behavior of when the renewal must happen. + // +listType=atomic + // +optional + Windows []CertificateRenewalWindows `json:"windows,omitempty"` +} + +type CertificateRenewalPolicy string + +const ( + CertificateRenewalPolicyRenewBefore CertificateRenewalPolicy = "RenewBefore" + CertificateRenewalPolicyDisabled CertificateRenewalPolicy = "Disabled" +) + +// CertificateRenewalWindows is the definition for renewal windows +type CertificateRenewalWindows struct { + // `timezone` is IANA compliant timezone. For example America/Denver. + // If this field is not set, timezone is treated as UTC. + // +kubebuilder:validation:MinLength=1 + // +optional + Timezone string `json:"timezone,omitempty"` + + // `windowDuration` is how long the cron definition is active for. + // Value must be in units accepted by Go time.ParseDuration https://golang.org/pkg/time/#ParseDuration. + // +kubebuilder:validation:Type=string + // +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(s|m|h))+$" + // +required + WindowDuration *metav1.Duration `json:"windowDuration,omitempty"` + + // `cron` is a cron compliant string to allow when the renewal should be allowed. Format is as shown below: + // * * * * * + // | | | | | + // | | | | day of the week (0–6) (Sunday to Saturday; + // | | | month (1–12) 7 is also Sunday on some systems) + // | | day of the month (1–31) + // | hour (0–23) + // minute (0–59) + // +kubebuilder:validation:MinLength=1 + // +required + Cron string `json:"cron,omitempty"` +} + // CertificateStatus defines the observed state of Certificate type CertificateStatus struct { // List of status conditions to indicate the status of certificates. diff --git a/pkg/apis/certmanager/v1/zz_generated.deepcopy.go b/pkg/apis/certmanager/v1/zz_generated.deepcopy.go index e889ecf1a..306ccce0f 100644 --- a/pkg/apis/certmanager/v1/zz_generated.deepcopy.go +++ b/pkg/apis/certmanager/v1/zz_generated.deepcopy.go @@ -198,6 +198,50 @@ func (in *CertificatePrivateKey) DeepCopy() *CertificatePrivateKey { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CertificateRenewal) DeepCopyInto(out *CertificateRenewal) { + *out = *in + if in.Windows != nil { + in, out := &in.Windows, &out.Windows + *out = make([]CertificateRenewalWindows, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateRenewal. +func (in *CertificateRenewal) DeepCopy() *CertificateRenewal { + if in == nil { + return nil + } + out := new(CertificateRenewal) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CertificateRenewalWindows) DeepCopyInto(out *CertificateRenewalWindows) { + *out = *in + if in.WindowDuration != nil { + in, out := &in.WindowDuration, &out.WindowDuration + *out = new(metav1.Duration) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateRenewalWindows. +func (in *CertificateRenewalWindows) DeepCopy() *CertificateRenewalWindows { + if in == nil { + return nil + } + out := new(CertificateRenewalWindows) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *CertificateRequest) DeepCopyInto(out *CertificateRequest) { *out = *in @@ -421,6 +465,11 @@ func (in *CertificateSpec) DeepCopyInto(out *CertificateSpec) { *out = new(int32) **out = **in } + if in.Renewal != nil { + in, out := &in.Renewal, &out.Renewal + *out = new(CertificateRenewal) + (*in).DeepCopyInto(*out) + } if in.DNSNames != nil { in, out := &in.DNSNames, &out.DNSNames *out = make([]string, len(*in)) diff --git a/pkg/client/applyconfigurations/certmanager/v1/certificaterenewal.go b/pkg/client/applyconfigurations/certmanager/v1/certificaterenewal.go new file mode 100644 index 000000000..e52d91039 --- /dev/null +++ b/pkg/client/applyconfigurations/certmanager/v1/certificaterenewal.go @@ -0,0 +1,59 @@ +/* +Copyright The cert-manager Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + certmanagerv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1" +) + +// CertificateRenewalApplyConfiguration represents a declarative configuration of the CertificateRenewal type for use +// with apply. +type CertificateRenewalApplyConfiguration struct { + // `policy` must be one of `Disabled`, `RenewBefore`. + Policy *certmanagerv1.CertificateRenewalPolicy `json:"policy,omitempty"` + // `windows` mentions the behavior of when the renewal must happen. + Windows []CertificateRenewalWindowsApplyConfiguration `json:"windows,omitempty"` +} + +// CertificateRenewalApplyConfiguration constructs a declarative configuration of the CertificateRenewal type for use with +// apply. +func CertificateRenewal() *CertificateRenewalApplyConfiguration { + return &CertificateRenewalApplyConfiguration{} +} + +// WithPolicy sets the Policy field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Policy field is set to the value of the last call. +func (b *CertificateRenewalApplyConfiguration) WithPolicy(value certmanagerv1.CertificateRenewalPolicy) *CertificateRenewalApplyConfiguration { + b.Policy = &value + return b +} + +// WithWindows adds the given value to the Windows field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Windows field. +func (b *CertificateRenewalApplyConfiguration) WithWindows(values ...*CertificateRenewalWindowsApplyConfiguration) *CertificateRenewalApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithWindows") + } + b.Windows = append(b.Windows, *values[i]) + } + return b +} diff --git a/pkg/client/applyconfigurations/certmanager/v1/certificaterenewalwindows.go b/pkg/client/applyconfigurations/certmanager/v1/certificaterenewalwindows.go new file mode 100644 index 000000000..b4b8dc509 --- /dev/null +++ b/pkg/client/applyconfigurations/certmanager/v1/certificaterenewalwindows.go @@ -0,0 +1,75 @@ +/* +Copyright The cert-manager Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// CertificateRenewalWindowsApplyConfiguration represents a declarative configuration of the CertificateRenewalWindows type for use +// with apply. +// +// CertificateRenewalWindows is the definition for renewal windows +type CertificateRenewalWindowsApplyConfiguration struct { + // `timezone` is IANA compliant timezone. For example America/Denver. + // If this field is not set, timezone is treated as UTC. + Timezone *string `json:"timezone,omitempty"` + // `windowDuration` is how long the cron definition is active for. + // Value must be in units accepted by Go time.ParseDuration https://golang.org/pkg/time/#ParseDuration. + WindowDuration *metav1.Duration `json:"windowDuration,omitempty"` + // `cron` is a cron compliant string to allow when the renewal should be allowed. Format is as shown below: + // * * * * * + // | | | | | + // | | | | day of the week (0–6) (Sunday to Saturday; + // | | | month (1–12) 7 is also Sunday on some systems) + // | | day of the month (1–31) + // | hour (0–23) + // minute (0–59) + Cron *string `json:"cron,omitempty"` +} + +// CertificateRenewalWindowsApplyConfiguration constructs a declarative configuration of the CertificateRenewalWindows type for use with +// apply. +func CertificateRenewalWindows() *CertificateRenewalWindowsApplyConfiguration { + return &CertificateRenewalWindowsApplyConfiguration{} +} + +// WithTimezone sets the Timezone field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Timezone field is set to the value of the last call. +func (b *CertificateRenewalWindowsApplyConfiguration) WithTimezone(value string) *CertificateRenewalWindowsApplyConfiguration { + b.Timezone = &value + return b +} + +// WithWindowDuration sets the WindowDuration field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the WindowDuration field is set to the value of the last call. +func (b *CertificateRenewalWindowsApplyConfiguration) WithWindowDuration(value metav1.Duration) *CertificateRenewalWindowsApplyConfiguration { + b.WindowDuration = &value + return b +} + +// WithCron sets the Cron field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Cron field is set to the value of the last call. +func (b *CertificateRenewalWindowsApplyConfiguration) WithCron(value string) *CertificateRenewalWindowsApplyConfiguration { + b.Cron = &value + return b +} diff --git a/pkg/client/applyconfigurations/certmanager/v1/certificatespec.go b/pkg/client/applyconfigurations/certmanager/v1/certificatespec.go index 47adfb4e9..1e9c58e8a 100644 --- a/pkg/client/applyconfigurations/certmanager/v1/certificatespec.go +++ b/pkg/client/applyconfigurations/certmanager/v1/certificatespec.go @@ -101,6 +101,9 @@ type CertificateSpecApplyConfiguration struct { // minutes. // Cannot be set if the `renewBefore` field is set. RenewBeforePercentage *int32 `json:"renewBeforePercentage,omitempty"` + // `renewal` allows configuration of how your certificate is renewed. If the policy mentioned is + // `RenewBefore` then the controller respects `renewBefore` and `renewBeforePercentage`. + Renewal *CertificateRenewalApplyConfiguration `json:"renewal,omitempty"` // Requested DNS subject alternative names. DNSNames []string `json:"dnsNames,omitempty"` // Requested IP address subject alternative names. @@ -237,6 +240,14 @@ func (b *CertificateSpecApplyConfiguration) WithRenewBeforePercentage(value int3 return b } +// WithRenewal sets the Renewal field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Renewal field is set to the value of the last call. +func (b *CertificateSpecApplyConfiguration) WithRenewal(value *CertificateRenewalApplyConfiguration) *CertificateSpecApplyConfiguration { + b.Renewal = value + return b +} + // WithDNSNames adds the given value to the DNSNames field in the declarative configuration // and returns the receiver, so that objects can be build by chaining "With" function invocations. // If called multiple times, values provided by each call will be appended to the DNSNames field. diff --git a/pkg/client/applyconfigurations/internal/internal.go b/pkg/client/applyconfigurations/internal/internal.go index cac0cadc5..d76c344c7 100644 --- a/pkg/client/applyconfigurations/internal/internal.go +++ b/pkg/client/applyconfigurations/internal/internal.go @@ -1224,6 +1224,30 @@ var schemaYAML = typed.YAMLObject(`types: - name: size type: scalar: numeric +- name: com.github.cert-manager.cert-manager.pkg.apis.certmanager.v1.CertificateRenewal + map: + fields: + - name: policy + type: + scalar: string + - name: windows + type: + list: + elementType: + namedType: com.github.cert-manager.cert-manager.pkg.apis.certmanager.v1.CertificateRenewalWindows + elementRelationship: atomic +- name: com.github.cert-manager.cert-manager.pkg.apis.certmanager.v1.CertificateRenewalWindows + map: + fields: + - name: cron + type: + scalar: string + - name: timezone + type: + scalar: string + - name: windowDuration + type: + namedType: Duration.v1.meta.apis.pkg.apimachinery.k8s.io - name: com.github.cert-manager.cert-manager.pkg.apis.certmanager.v1.CertificateRequest map: fields: @@ -1407,6 +1431,9 @@ var schemaYAML = typed.YAMLObject(`types: - name: renewBeforePercentage type: scalar: numeric + - name: renewal + type: + namedType: com.github.cert-manager.cert-manager.pkg.apis.certmanager.v1.CertificateRenewal - name: revisionHistoryLimit type: scalar: numeric diff --git a/pkg/client/applyconfigurations/utils.go b/pkg/client/applyconfigurations/utils.go index 0729e915a..c38f34103 100644 --- a/pkg/client/applyconfigurations/utils.go +++ b/pkg/client/applyconfigurations/utils.go @@ -124,6 +124,10 @@ func ForKind(kind schema.GroupVersionKind) interface{} { return &applyconfigurationscertmanagerv1.CertificateKeystoresApplyConfiguration{} case certmanagerv1.SchemeGroupVersion.WithKind("CertificatePrivateKey"): return &applyconfigurationscertmanagerv1.CertificatePrivateKeyApplyConfiguration{} + case certmanagerv1.SchemeGroupVersion.WithKind("CertificateRenewal"): + return &applyconfigurationscertmanagerv1.CertificateRenewalApplyConfiguration{} + case certmanagerv1.SchemeGroupVersion.WithKind("CertificateRenewalWindows"): + return &applyconfigurationscertmanagerv1.CertificateRenewalWindowsApplyConfiguration{} case certmanagerv1.SchemeGroupVersion.WithKind("CertificateRequest"): return &applyconfigurationscertmanagerv1.CertificateRequestApplyConfiguration{} case certmanagerv1.SchemeGroupVersion.WithKind("CertificateRequestCondition"): diff --git a/pkg/controller/certificates/readiness/readiness_controller.go b/pkg/controller/certificates/readiness/readiness_controller.go index a5e7ac798..fc4f11576 100644 --- a/pkg/controller/certificates/readiness/readiness_controller.go +++ b/pkg/controller/certificates/readiness/readiness_controller.go @@ -25,8 +25,10 @@ import ( apiequality "k8s.io/apimachinery/pkg/api/equality" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/tools/cache" + "k8s.io/client-go/tools/record" "k8s.io/client-go/util/workqueue" internalcertificates "github.com/cert-manager/cert-manager/internal/controller/certificates" @@ -60,6 +62,7 @@ type controller struct { certificateRequestLister cmlisters.CertificateRequestLister secretLister internalinformers.SecretLister client cmclient.Interface + recorder record.EventRecorder gatherer *policies.Gatherer // policyEvaluator builds Ready condition of a Certificate based on policy evaluation policyEvaluator policyEvaluatorFunc @@ -101,26 +104,17 @@ func NewController( } // When a CertificateRequest resource changes, enqueue the Certificate resource that owns it. - if _, err := certificateRequestInformer.Informer().AddEventHandler( - controllerpkg.BlockingEventHandler( - certificates.EnqueueCertificatesForResourceUsingPredicates[*cmapi.CertificateRequest]( - log, queue, certificateInformer.Lister(), - predicate.ResourceOwnerOf, - ), - ), - ); err != nil { + if _, err := certificateRequestInformer.Informer().AddEventHandler(controllerpkg.BlockingEventHandler( + certificates.EnqueueCertificatesForResourceUsingPredicates(log, queue, certificateInformer.Lister(), labels.Everything(), predicate.ResourceOwnerOf), + )); err != nil { return nil, nil, nil, fmt.Errorf("error setting up event handler: %v", err) } // When a Secret resource changes, enqueue any Certificate resources that name it as spec.secretName. - if _, err := secretsInformer.Informer().AddEventHandler( - controllerpkg.BlockingEventHandler( - // Trigger reconciles on changes to the Secret named `spec.secretName` - certificates.EnqueueCertificatesForResourceUsingPredicates( - log, queue, certificateInformer.Lister(), - predicate.ExtractResourceName[*corev1.Secret](predicate.CertificateSecretName), - ), - ), - ); err != nil { + if _, err := secretsInformer.Informer().AddEventHandler(controllerpkg.BlockingEventHandler( + // Trigger reconciles on changes to the Secret named `spec.secretName` + certificates.EnqueueCertificatesForResourceUsingPredicates(log, queue, certificateInformer.Lister(), labels.Everything(), + predicate.ExtractResourceName(predicate.CertificateSecretName)), + )); err != nil { return nil, nil, nil, fmt.Errorf("error setting up event handler: %v", err) } @@ -138,6 +132,7 @@ func NewController( certificateRequestLister: certificateRequestInformer.Lister(), secretLister: secretsInformer.Lister(), client: ctx.CMClient, + recorder: ctx.Recorder, gatherer: &policies.Gatherer{ CertificateRequestLister: certificateRequestInformer.Lister(), SecretLister: secretsInformer.Lister(), @@ -189,7 +184,15 @@ func (c *controller) ProcessItem(ctx context.Context, key types.NamespacedName) notBefore := metav1.NewTime(x509cert.NotBefore) notAfter := metav1.NewTime(x509cert.NotAfter) - renewalTime := c.renewalTimeCalculator(x509cert.NotBefore, x509cert.NotAfter, crt.Spec.RenewBefore, crt.Spec.RenewBeforePercentage) + renewalTime, err := c.renewalTimeCalculator(x509cert.NotBefore, x509cert.NotAfter, crt.Spec.RenewBefore, crt.Spec.RenewBeforePercentage, crt.Spec.Renewal) + + if err != nil { + reason := policies.WindowError + message := fmt.Sprintf("Could not calculate renewal time: %v", err) + apiutil.SetCertificateCondition(crt, crt.Generation, cmapi.CertificateConditionReady, cmmeta.ConditionFalse, reason, message) + + c.recorder.Event(crt, corev1.EventTypeWarning, reason, message) + } // update Certificate's Status crt.Status.NotBefore = ¬Before diff --git a/pkg/controller/certificates/trigger/trigger_controller.go b/pkg/controller/certificates/trigger/trigger_controller.go index 5ffd2800d..1a6659c85 100644 --- a/pkg/controller/certificates/trigger/trigger_controller.go +++ b/pkg/controller/certificates/trigger/trigger_controller.go @@ -26,6 +26,7 @@ import ( corev1 "k8s.io/api/core/v1" k8sErrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/tools/cache" "k8s.io/client-go/tools/record" @@ -106,26 +107,17 @@ func NewController( } // When a CertificateRequest resource changes, enqueue the Certificate resource that owns it. - if _, err := certificateRequestInformer.Informer().AddEventHandler( - controllerpkg.BlockingEventHandler( - certificates.EnqueueCertificatesForResourceUsingPredicates[*cmapi.CertificateRequest]( - log, queue, certificateInformer.Lister(), - predicate.ResourceOwnerOf, - ), - ), - ); err != nil { + if _, err := certificateRequestInformer.Informer().AddEventHandler(controllerpkg.BlockingEventHandler( + certificates.EnqueueCertificatesForResourceUsingPredicates(log, queue, certificateInformer.Lister(), labels.Everything(), predicate.ResourceOwnerOf), + )); err != nil { return nil, nil, nil, fmt.Errorf("error setting up event handler: %v", err) } // When a Secret resource changes, enqueue any Certificate resources that name it as spec.secretName. - if _, err := secretsInformer.Informer().AddEventHandler( - controllerpkg.BlockingEventHandler( - // Trigger reconciles on changes to the Secret named `spec.secretName` - certificates.EnqueueCertificatesForResourceUsingPredicates( - log, queue, certificateInformer.Lister(), - predicate.ExtractResourceName[*corev1.Secret](predicate.CertificateSecretName), - ), - ), - ); err != nil { + if _, err := secretsInformer.Informer().AddEventHandler(controllerpkg.BlockingEventHandler( + // Trigger reconciles on changes to the Secret named `spec.secretName` + certificates.EnqueueCertificatesForResourceUsingPredicates(log, queue, certificateInformer.Lister(), labels.Everything(), + predicate.ExtractResourceName(predicate.CertificateSecretName)), + )); err != nil { return nil, nil, nil, fmt.Errorf("error setting up event handler: %v", err) } @@ -223,8 +215,13 @@ func (c *controller) ProcessItem(ctx context.Context, key types.NamespacedName) } reason, message, reissue := c.shouldReissue(input) + if reason == policies.WindowError { + c.recorder.Event(crt, corev1.EventTypeWarning, reason, fmt.Sprintf("Renewing certificate without satisfying renewal windows due to %s", message)) + message = fmt.Sprintf("Renewing certificate without satisfying renewal windows at: %s", crt.Status.RenewalTime) + reason = policies.Renewing + } + if !reissue { - // no re-issuance required, return early return nil } diff --git a/pkg/util/pki/renewaltime.go b/pkg/util/pki/renewaltime.go index 6e558abca..1a8281021 100644 --- a/pkg/util/pki/renewaltime.go +++ b/pkg/util/pki/renewaltime.go @@ -17,13 +17,17 @@ limitations under the License. package pki import ( + "fmt" "time" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + apiv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1" + "github.com/cert-manager/cert-manager/pkg/util" ) // RenewalTimeFunc is a custom function type for calculating renewal time of a certificate. -type RenewalTimeFunc func(time.Time, time.Time, *metav1.Duration, *int32) *metav1.Time +type RenewalTimeFunc func(time.Time, time.Time, *metav1.Duration, *int32, *apiv1.CertificateRenewal) (*metav1.Time, error) // RenewalTime calculates renewal time for a certificate. // If renewBefore is non-nil and less than the certificate's lifetime, renewal @@ -32,14 +36,14 @@ type RenewalTimeFunc func(time.Time, time.Time, *metav1.Duration, *int32) *metav // will be the computed period before expiry based on the renewBeforePercentage // value and certificate lifetime. // Default renewal time is 2/3 through certificate's lifetime. -func RenewalTime(notBefore, notAfter time.Time, renewBefore *metav1.Duration, renewBeforePercentage *int32) *metav1.Time { - // 1. Calculate how long before expiry a cert should be renewed +func RenewalTime(notBefore, notAfter time.Time, renewBefore *metav1.Duration, renewBeforePercentage *int32, renewalSpec *apiv1.CertificateRenewal) (*metav1.Time, error) { + // 1. Start calculation of desired renewal time based on renewBefore and renewBeforePercentage. + // 1.1: Calculate how long before expiry a cert should be renewed actualDuration := notAfter.Sub(notBefore) - actualRenewBefore := RenewBefore(actualDuration, renewBefore, renewBeforePercentage) - - // 2. Calculate when a cert should be renewed + actualRenewBefore := desiredRenewalTime(actualDuration, renewBefore, renewBeforePercentage) + // 1.2: Calculate when a cert should be renewed // Truncate the renewal time to nearest second. This is important // because the renewal time also gets stored on Certificate's status // where it is truncated to the nearest second. We use the renewal time @@ -51,17 +55,33 @@ func RenewalTime(notBefore, notAfter time.Time, renewBefore *metav1.Duration, re // causing Certificates to not be automatically renewed. See // https://github.com/cert-manager/cert-manager/pull/4399. rt := metav1.NewTime(notAfter.Add(-1 * actualRenewBefore).Truncate(time.Second)) - return &rt + + // 2. If there is no renewal spec then just return the desired renewal time calculated above. + if renewalSpec == nil { + return &rt, nil + } + + switch renewalSpec.Policy { + case apiv1.CertificateRenewalPolicyDisabled: + return nil, nil + case apiv1.CertificateRenewalPolicyRenewBefore: + return applyRenewBeforeWithWindows(notAfter, notBefore, rt.Time, renewalSpec.Windows) + default: + return nil, fmt.Errorf("unsupported renewal policy: %s", renewalSpec.Policy) + } } -// RenewBefore calculates how far before expiry a certificate should be renewed. +// desiredRenewalTime calculates how far before expiry a certificate should be renewed. // If renewBefore is non-nil and less than the certificate's lifetime, renewal // time will be the computed renewBefore period before expiry. // If renewBeforePercentage is non-nil and in the range (0,100), renewal time // will be the computed period before expiry based on the renewBeforePercentage // and actualDuration values. // Default is 2/3 through certificate's lifetime. -func RenewBefore(actualDuration time.Duration, renewBefore *metav1.Duration, renewBeforePercentage *int32) time.Duration { + +// Note that this function used to be called RenewBefore and was an exported function which would expose the renewal time. +// Currently, this function calculates the desired renewal time and feeds into the renewal windows logic called above. +func desiredRenewalTime(actualDuration time.Duration, renewBefore *metav1.Duration, renewBeforePercentage *int32) time.Duration { // If spec.renewBefore or spec.renewBeforePercentage was set (and is // valid) respect that. We don't want to prevent users from renewing // longer lived certs more frequently. @@ -74,3 +94,171 @@ func RenewBefore(actualDuration time.Duration, renewBefore *metav1.Duration, ren // Otherwise, default to renewing 2/3 through certificate's lifetime. return actualDuration / 3 } + +// applyRenewBeforeWithWindows calculates effective renewal time with windows in it. We want the logic to be as follows: +// Take in the desiredRenewalTime from the function above and look forward and backward to find a desirable time which satisfies +// the cron window along with the cronSeconds duration. If we find a time that is before the renewalTime we return that first. +func applyRenewBeforeWithWindows(notAfter, notBefore, desiredRenewalTime time.Time, windows []apiv1.CertificateRenewalWindows) (*metav1.Time, error) { + var ( + bestBefore *time.Time + bestAfter *time.Time + ) + + if len(windows) == 0 { + return &metav1.Time{Time: desiredRenewalTime}, nil + } + + for _, w := range windows { + loc := time.UTC + if w.Timezone != "" { + if tz, err := time.LoadLocation(w.Timezone); err == nil { + loc = tz + } else { + // This shouldn't get triggered as we validate timezones in the validation webhook. + return nil, fmt.Errorf("error parsing timezone in window %s", err.Error()) + } + } + + cronSched, err := util.CronParse(w.Cron, loc.String()) + if err != nil { + return nil, fmt.Errorf("error parsing cron in window %s", err.Error()) + } + + if w.WindowDuration == nil || w.WindowDuration.Duration <= 0 { + return nil, fmt.Errorf("windowDuration must be a positive duration in window %v", w) + } + + // Any renewal logic should only start after notBefore and before notAfter. Bounds are [notBefore - dur, notAfter + dur) + searchMin := notBefore.Add(-w.WindowDuration.Duration) + searchMax := notAfter.Add(w.WindowDuration.Duration) + + bestBefore = findBeforeDesired(cronSched, searchMin, searchMax, desiredRenewalTime, bestBefore, w.WindowDuration.Duration) + bestAfter = findAfterDesired(cronSched, searchMin, searchMax, desiredRenewalTime, bestAfter, w.WindowDuration.Duration) + } + + if bestBefore != nil { + return &metav1.Time{Time: *bestBefore}, nil + } + + if bestAfter != nil { + return &metav1.Time{Time: *bestAfter}, nil + } + + return &metav1.Time{Time: desiredRenewalTime}, fmt.Errorf("cannot find a time with the given windows between %s and %s for: %s", notBefore, notAfter, desiredRenewalTime) +} + +// bsFindEarliestWindowBeforeDesired performs a binary search over time to find +// the latest cron window start S such that: +// +// minTime <= S < maxTime +// +// where S is a time produced by sched.Next(..). +func bsFindLatestWindowBeforeDesired(sched util.CronSchedule, minTime, maxTime time.Time) *time.Time { + if !minTime.Before(maxTime) { + return nil + } + + // If the first instance that matches the cron is after the max bound then we don't have a earliest window before desired renewal. + if sched.Next(minTime.Add(-time.Second)).After(maxTime) { + return nil + } + + low := minTime + high := maxTime + + // We binary search on the time range [low, high), maintaining the invariant: + // + // There exists at least one cron start S such that: + // low <= S <= maxTime + // + // and S is produced by sched.Next(..). + for high.Sub(low) > time.Second { + mid := low.Add(high.Sub(low) / 2) + next := sched.Next(mid) + + if next.After(maxTime) { + high = mid + } else { + low = mid + } + } + + last := sched.Next(low.Add(-time.Second)) + if last.After(maxTime) { + return nil + } + + return &last +} + +// findBeforeDesired returns a time that matches the cron schedule before the desiredRenewalTime. This function makes use of a binary search +// algorithm, with the bounds defined by searchMin and searchMax (desiredRenewalTime if it's before searchMax), to find a time which matches the cron schedule. +// if the desiredRenewalTime is in [lastStart, lastStart+duration) we just return that else we return lastStart+duration. +func findBeforeDesired(cronSched util.CronSchedule, searchMin, searchMax, desiredRenewalTime time.Time, bestBefore *time.Time, duration time.Duration) *time.Time { + if desiredRenewalTime.Before(searchMin) { + return nil + } + var beforeMax time.Time + if desiredRenewalTime.Before(searchMax) { + beforeMax = desiredRenewalTime + } else { + beforeMax = searchMax + } + lastStart := bsFindLatestWindowBeforeDesired(cronSched, searchMin, beforeMax) + if lastStart != nil { + end := lastStart.Add(duration) + + var candidateBefore time.Time + if !desiredRenewalTime.Before(*lastStart) && desiredRenewalTime.Before(end) { + candidateBefore = desiredRenewalTime + } else { + candidateBefore = end + } + + // This is done to ensure that any candidateBefore is not before the desired renewal time. + if !candidateBefore.Before(desiredRenewalTime) { + if bestBefore == nil || candidateBefore.After(*bestBefore) { + c := candidateBefore + bestBefore = &c + } + } + } + + return bestBefore +} + +// findAfterDesired returns the first instance of time that matches the cronSched after the desiredRenewalTime. +func findAfterDesired(cronSched util.CronSchedule, searchMin, searchMax, desiredRenewalTime time.Time, bestAfter *time.Time, duration time.Duration) *time.Time { + var afterMin time.Time + if desiredRenewalTime.After(searchMin) { + afterMin = desiredRenewalTime + } else { + afterMin = searchMin + } + start := cronSched.Next(afterMin.Add(-time.Second)) + if start.After(searchMax) { + return nil + } + + end := start.Add(duration) + + var candidateAfter time.Time + switch { + case !desiredRenewalTime.Before(start) && desiredRenewalTime.Before(end): + candidateAfter = desiredRenewalTime + case desiredRenewalTime.Before(start): + candidateAfter = start + default: + candidateAfter = time.Time{} + } + + // This check ensures that candidateAfter is never before the desiredRenewalTime + if !candidateAfter.IsZero() && !candidateAfter.Before(desiredRenewalTime) { + if bestAfter == nil || candidateAfter.Before(*bestAfter) { + c := candidateAfter + bestAfter = &c + } + } + + return bestAfter +} diff --git a/pkg/util/util.go b/pkg/util/util.go index 7893e43b9..9161c62b9 100644 --- a/pkg/util/util.go +++ b/pkg/util/util.go @@ -24,10 +24,18 @@ import ( "net/url" "slices" "strings" + "time" + "github.com/cert-manager/cert-manager/internal/cron" cmapi "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1" ) +// CronSchedule defines the minimal schedule behavior exposed by this package, +// decoupling callers from the internal cron implementation. +type CronSchedule interface { + Next(time.Time) time.Time +} + // genericEqualUnsorted reports whether two slices are identical up to reordering // using a comparison function. // If the lengths are different, genericEqualUnsorted returns false. Otherwise, the @@ -136,3 +144,19 @@ func SplitWithEscapeCSV(in string) ([]string, error) { return records[0], nil } + +// CronParse parses the given cron syntax to return a cron schedule interface. It also takes in an optional timezone which would parse the +// cron schedule in that timezone. timeZone must be an IANA compliant time zone (e.g. America/Denver). +func CronParse(origCronString, timeZone string) (CronSchedule, error) { + cronString := origCronString + if timeZone != "" { + cronString = fmt.Sprintf("CRON_TZ=%s %s", timeZone, origCronString) + } + s, err := cron. + NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor). + Parse(cronString) + if err == nil { + return s, nil + } + return nil, fmt.Errorf("failed to parse cron spec '%s': %w", origCronString, err) +}