func (a *Automator) reschedule(j *jobs.Job) error {
j.ScheduledAt = j.ScheduledAt.Add(automationCycle)
if _, err := a.cfg.Jobs.PutJobIgnoringDuplicates(j.Instance, *j); err != nil {
return errors.Wrap(err, "rescheduling check automated service job") // abnormal
}
return nil
}
func (r *Releaser) Handle(job *jobs.Job, updater jobs.JobUpdater) (err error) {
spec := job.Params.(jobs.ReleaseJobParams)
releaseType := "unknown"
defer func(begin time.Time) {
r.metrics.ReleaseDuration.With(
"release_type", releaseType,
"release_kind", fmt.Sprint(spec.Kind),
"success", fmt.Sprint(err == nil),
).Observe(time.Since(begin).Seconds())
}(time.Now())
inst, err := r.instancer.Get(job.Instance)
if err != nil {
return err
}
inst.Logger = log.NewContext(inst.Logger).With("job", job.ID)
updateJob := func(format string, args ...interface{}) {
status := fmt.Sprintf(format, args...)
job.Status = status
job.Log = append(job.Log, status)
updater.UpdateJob(*job)
}
exclude := flux.ServiceIDSet{}
exclude.Add(spec.Excludes)
locked, err := lockedServices(inst)
if err != nil {
return err
}
exclude.Add(locked)
updateJob("Calculating release actions.")
switch {
case spec.ServiceSpec == flux.ServiceSpecAll && spec.ImageSpec == flux.ImageSpecLatest:
releaseType = "release_all_to_latest"
return r.releaseImages(releaseType, "Release latest images to all services", inst, spec.Kind, allServicesExcept(exclude), allLatestImages, updateJob)
case spec.ServiceSpec == flux.ServiceSpecAll && spec.ImageSpec == flux.ImageSpecNone:
releaseType = "release_all_without_update"
return r.releaseWithoutUpdate(releaseType, "Apply latest config to all services", inst, spec.Kind, allServicesExcept(exclude), updateJob)
case spec.ServiceSpec == flux.ServiceSpecAll:
releaseType = "release_all_for_image"
imageID := flux.ParseImageID(string(spec.ImageSpec))
return r.releaseImages(releaseType, fmt.Sprintf("Release %s to all services", imageID), inst, spec.Kind, allServicesExcept(exclude), exactlyTheseImages([]flux.ImageID{imageID}), updateJob)
case spec.ImageSpec == flux.ImageSpecLatest:
releaseType = "release_one_to_latest"
serviceID, err := flux.ParseServiceID(string(spec.ServiceSpec))
if err != nil {
return errors.Wrapf(err, "parsing service ID from spec %s", spec.ServiceSpec)
}
services := flux.ServiceIDs([]flux.ServiceID{serviceID}).Without(exclude)
return r.releaseImages(releaseType, fmt.Sprintf("Release latest images to %s", serviceID), inst, spec.Kind, exactlyTheseServices(services), allLatestImages, updateJob)
case spec.ImageSpec == flux.ImageSpecNone:
releaseType = "release_one_without_update"
serviceID, err := flux.ParseServiceID(string(spec.ServiceSpec))
if err != nil {
return errors.Wrapf(err, "parsing service ID from spec %s", spec.ServiceSpec)
}
services := flux.ServiceIDs([]flux.ServiceID{serviceID}).Without(exclude)
return r.releaseWithoutUpdate(releaseType, fmt.Sprintf("Apply latest config to %s", serviceID), inst, spec.Kind, exactlyTheseServices(services), updateJob)
default:
releaseType = "release_one"
serviceID, err := flux.ParseServiceID(string(spec.ServiceSpec))
if err != nil {
return errors.Wrapf(err, "parsing service ID from spec %s", spec.ServiceSpec)
}
services := flux.ServiceIDs([]flux.ServiceID{serviceID}).Without(exclude)
imageID := flux.ParseImageID(string(spec.ImageSpec))
return r.releaseImages(releaseType, fmt.Sprintf("Release %s to %s", imageID, serviceID), inst, spec.Kind, exactlyTheseServices(services), exactlyTheseImages([]flux.ImageID{imageID}), updateJob)
}
}