From 438f952128690df9ea68f46a02218d308239a115 Mon Sep 17 00:00:00 2001 From: stefanprodan Date: Tue, 9 Jul 2019 15:22:56 +0300 Subject: [PATCH] Implement status conditions Add Promoted status condition with the following reasons: Initialized, Progressing, Succeeded, Failed Usage: `kubectl wait canary/app --for=condition=promoted` Fix: #184 --- pkg/apis/flagger/v1alpha3/status.go | 68 +++++++++++++++++++ pkg/apis/flagger/v1alpha3/types.go | 31 --------- .../flagger/v1alpha3/zz_generated.deepcopy.go | 25 +++++++ pkg/canary/deployer_test.go | 8 +-- pkg/canary/status.go | 66 +++++++++++++++++- pkg/controller/scheduler.go | 44 ++++++------ pkg/controller/scheduler_test.go | 18 ++--- pkg/controller/webhook_test.go | 4 +- pkg/metrics/recorder.go | 4 +- 9 files changed, 197 insertions(+), 71 deletions(-) create mode 100644 pkg/apis/flagger/v1alpha3/status.go diff --git a/pkg/apis/flagger/v1alpha3/status.go b/pkg/apis/flagger/v1alpha3/status.go new file mode 100644 index 00000000..d28a860c --- /dev/null +++ b/pkg/apis/flagger/v1alpha3/status.go @@ -0,0 +1,68 @@ +package v1alpha3 + +import ( + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// CanaryConditionType is the type of a CanaryCondition +type CanaryConditionType string + +const ( + // PromotedType refers to the result of the last canary analysis + PromotedType CanaryConditionType = "Promoted" +) + +// CanaryCondition is a status condition for a Canary +type CanaryCondition struct { + // Type of this condition + Type CanaryConditionType `json:"type"` + + // Status of this condition + Status corev1.ConditionStatus `json:"status"` + + // LastUpdateTime of this condition + LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"` + + // LastTransitionTime of this condition + LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"` + + // Reason for the current status of this condition + Reason string `json:"reason,omitempty"` + + // Message associated with this condition + Message string `json:"message,omitempty"` +} + +// CanaryPhase is a label for the condition of a canary at the current time +type CanaryPhase string + +const ( + // CanaryPhaseInitialized means the primary deployment, hpa and ClusterIP services + // have been created along with the service mesh or ingress objects + CanaryPhaseInitialized CanaryPhase = "Initialized" + // CanaryPhaseProgressing means the canary analysis is underway + CanaryPhaseProgressing CanaryPhase = "Progressing" + // CanaryPhaseSucceeded means the canary analysis has been successful + // and the canary deployment has been promoted + CanaryPhaseSucceeded CanaryPhase = "Succeeded" + // CanaryPhaseFailed means the canary analysis failed + // and the canary deployment has been scaled to zero + CanaryPhaseFailed CanaryPhase = "Failed" +) + +// CanaryStatus is used for state persistence (read-only) +type CanaryStatus struct { + Phase CanaryPhase `json:"phase"` + FailedChecks int `json:"failedChecks"` + CanaryWeight int `json:"canaryWeight"` + Iterations int `json:"iterations"` + // +optional + TrackedConfigs *map[string]string `json:"trackedConfigs,omitempty"` + // +optional + LastAppliedSpec string `json:"lastAppliedSpec,omitempty"` + // +optional + LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"` + // +optional + Conditions []CanaryCondition `json:"conditions,omitempty"` +} diff --git a/pkg/apis/flagger/v1alpha3/types.go b/pkg/apis/flagger/v1alpha3/types.go index d127a23b..1f995e02 100755 --- a/pkg/apis/flagger/v1alpha3/types.go +++ b/pkg/apis/flagger/v1alpha3/types.go @@ -85,37 +85,6 @@ type CanaryList struct { Items []Canary `json:"items"` } -// CanaryPhase is a label for the condition of a canary at the current time -type CanaryPhase string - -const ( - // CanaryInitialized means the primary deployment, hpa and ClusterIP services - // have been created along with the Istio virtual service - CanaryInitialized CanaryPhase = "Initialized" - // CanaryProgressing means the canary analysis is underway - CanaryProgressing CanaryPhase = "Progressing" - // CanarySucceeded means the canary analysis has been successful - // and the canary deployment has been promoted - CanarySucceeded CanaryPhase = "Succeeded" - // CanaryFailed means the canary analysis failed - // and the canary deployment has been scaled to zero - CanaryFailed CanaryPhase = "Failed" -) - -// CanaryStatus is used for state persistence (read-only) -type CanaryStatus struct { - Phase CanaryPhase `json:"phase"` - FailedChecks int `json:"failedChecks"` - CanaryWeight int `json:"canaryWeight"` - Iterations int `json:"iterations"` - // +optional - TrackedConfigs *map[string]string `json:"trackedConfigs,omitempty"` - // +optional - LastAppliedSpec string `json:"lastAppliedSpec,omitempty"` - // +optional - LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"` -} - // CanaryService is used to create ClusterIP services // and Istio Virtual Service type CanaryService struct { diff --git a/pkg/apis/flagger/v1alpha3/zz_generated.deepcopy.go b/pkg/apis/flagger/v1alpha3/zz_generated.deepcopy.go index f1210e8c..79e7d71d 100644 --- a/pkg/apis/flagger/v1alpha3/zz_generated.deepcopy.go +++ b/pkg/apis/flagger/v1alpha3/zz_generated.deepcopy.go @@ -89,6 +89,24 @@ func (in *CanaryAnalysis) DeepCopy() *CanaryAnalysis { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CanaryCondition) DeepCopyInto(out *CanaryCondition) { + *out = *in + in.LastUpdateTime.DeepCopyInto(&out.LastUpdateTime) + in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CanaryCondition. +func (in *CanaryCondition) DeepCopy() *CanaryCondition { + if in == nil { + return nil + } + out := new(CanaryCondition) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *CanaryList) DeepCopyInto(out *CanaryList) { *out = *in @@ -250,6 +268,13 @@ func (in *CanaryStatus) DeepCopyInto(out *CanaryStatus) { } } in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]CanaryCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } return } diff --git a/pkg/canary/deployer_test.go b/pkg/canary/deployer_test.go index 7a0d1c9b..ec545aa9 100644 --- a/pkg/canary/deployer_test.go +++ b/pkg/canary/deployer_test.go @@ -229,7 +229,7 @@ func TestCanaryDeployer_SetState(t *testing.T) { t.Fatal(err.Error()) } - err = mocks.deployer.SetStatusPhase(mocks.canary, v1alpha3.CanaryProgressing) + err = mocks.deployer.SetStatusPhase(mocks.canary, v1alpha3.CanaryPhaseProgressing) if err != nil { t.Fatal(err.Error()) } @@ -239,8 +239,8 @@ func TestCanaryDeployer_SetState(t *testing.T) { t.Fatal(err.Error()) } - if res.Status.Phase != v1alpha3.CanaryProgressing { - t.Errorf("Got %v wanted %v", res.Status.Phase, v1alpha3.CanaryProgressing) + if res.Status.Phase != v1alpha3.CanaryPhaseProgressing { + t.Errorf("Got %v wanted %v", res.Status.Phase, v1alpha3.CanaryPhaseProgressing) } } @@ -252,7 +252,7 @@ func TestCanaryDeployer_SyncStatus(t *testing.T) { } status := v1alpha3.CanaryStatus{ - Phase: v1alpha3.CanaryProgressing, + Phase: v1alpha3.CanaryPhaseProgressing, FailedChecks: 2, } err = mocks.deployer.SyncStatus(mocks.canary, status) diff --git a/pkg/canary/status.go b/pkg/canary/status.go index 7c2cb317..163b0bee 100644 --- a/pkg/canary/status.go +++ b/pkg/canary/status.go @@ -5,6 +5,7 @@ import ( "github.com/mitchellh/hashstructure" flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) @@ -38,6 +39,10 @@ func (c *Deployer) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatu cdCopy.Status.LastTransitionTime = metav1.Now() cdCopy.Status.TrackedConfigs = configs + if ok, conditions := c.makeStatusConditions(cd.Status, status.Phase); ok { + cdCopy.Status.Conditions = conditions + } + cd, err = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy) if err != nil { return fmt.Errorf("canary %s.%s status update error %v", cdCopy.Name, cdCopy.Namespace, err) @@ -90,14 +95,73 @@ func (c *Deployer) SetStatusPhase(cd *flaggerv1.Canary, phase flaggerv1.CanaryPh cdCopy.Status.Phase = phase cdCopy.Status.LastTransitionTime = metav1.Now() - if phase != flaggerv1.CanaryProgressing { + if phase != flaggerv1.CanaryPhaseProgressing { cdCopy.Status.CanaryWeight = 0 cdCopy.Status.Iterations = 0 } + if ok, conditions := c.makeStatusConditions(cdCopy.Status, phase); ok { + cdCopy.Status.Conditions = conditions + } + cd, err := c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy) if err != nil { return fmt.Errorf("canary %s.%s status update error %v", cdCopy.Name, cdCopy.Namespace, err) } return nil } + +// GetStatusCondition returns a condition based on type +func (c *Deployer) getStatusCondition(status flaggerv1.CanaryStatus, conditionType flaggerv1.CanaryConditionType) *flaggerv1.CanaryCondition { + for i := range status.Conditions { + c := status.Conditions[i] + if c.Type == conditionType { + return &c + } + } + return nil +} + +// MakeStatusCondition updates the canary status conditions based on canary phase +func (c *Deployer) makeStatusConditions(canaryStatus flaggerv1.CanaryStatus, + phase flaggerv1.CanaryPhase) (bool, []flaggerv1.CanaryCondition) { + currentCondition := c.getStatusCondition(canaryStatus, flaggerv1.PromotedType) + + message := "New deployment detected, starting initialization." + status := corev1.ConditionUnknown + switch phase { + case flaggerv1.CanaryPhaseProgressing: + status = corev1.ConditionUnknown + message = "New revision detected, starting canary analysis." + case flaggerv1.CanaryPhaseInitialized: + status = corev1.ConditionTrue + message = "New deployment detected, initialization completed." + case flaggerv1.CanaryPhaseSucceeded: + status = corev1.ConditionTrue + message = "Canary analysis completed successfully, promotion finished." + case flaggerv1.CanaryPhaseFailed: + status = corev1.ConditionFalse + message = "Canary analysis failed, deployment scaled to zero." + } + + newCondition := &flaggerv1.CanaryCondition{ + Type: flaggerv1.PromotedType, + Status: status, + LastUpdateTime: metav1.Now(), + LastTransitionTime: metav1.Now(), + Message: message, + Reason: string(phase), + } + + if currentCondition != nil && + currentCondition.Status == newCondition.Status && + currentCondition.Reason == newCondition.Reason { + return false, nil + } + + if currentCondition != nil && currentCondition.Status == newCondition.Status { + newCondition.LastTransitionTime = currentCondition.LastTransitionTime + } + + return true, []flaggerv1.CanaryCondition{*newCondition} +} diff --git a/pkg/controller/scheduler.go b/pkg/controller/scheduler.go index 5ed080ad..10cbca22 100644 --- a/pkg/controller/scheduler.go +++ b/pkg/controller/scheduler.go @@ -178,7 +178,7 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh // reset status status := flaggerv1.CanaryStatus{ - Phase: flaggerv1.CanaryProgressing, + Phase: flaggerv1.CanaryPhaseProgressing, CanaryWeight: 0, FailedChecks: 0, Iterations: 0, @@ -210,7 +210,7 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh } // check if the number of failed checks reached the threshold - if cd.Status.Phase == flaggerv1.CanaryProgressing && + if cd.Status.Phase == flaggerv1.CanaryPhaseProgressing && (!retriable || cd.Status.FailedChecks >= cd.Spec.CanaryAnalysis.Threshold) { if cd.Status.FailedChecks >= cd.Spec.CanaryAnalysis.Threshold { @@ -246,13 +246,13 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh } // mark canary as failed - if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryFailed, CanaryWeight: 0}); err != nil { + if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseFailed, CanaryWeight: 0}); err != nil { c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Errorf("%v", err) return } - c.recorder.SetStatus(cd, flaggerv1.CanaryFailed) - c.runPostRolloutHooks(cd, flaggerv1.CanaryFailed) + c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseFailed) + c.runPostRolloutHooks(cd, flaggerv1.CanaryPhaseFailed) return } @@ -331,12 +331,12 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh } // update status phase - if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanarySucceeded); err != nil { + if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhaseSucceeded); err != nil { c.recordEventWarningf(cd, "%v", err) return } - c.recorder.SetStatus(cd, flaggerv1.CanarySucceeded) - c.runPostRolloutHooks(cd, flaggerv1.CanarySucceeded) + c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseSucceeded) + c.runPostRolloutHooks(cd, flaggerv1.CanaryPhaseSucceeded) c.sendNotification(cd, "Canary analysis completed successfully, promotion finished.", false, false) return @@ -398,12 +398,12 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh } // update status phase - if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanarySucceeded); err != nil { + if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhaseSucceeded); err != nil { c.recordEventWarningf(cd, "%v", err) return } - c.recorder.SetStatus(cd, flaggerv1.CanarySucceeded) - c.runPostRolloutHooks(cd, flaggerv1.CanarySucceeded) + c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseSucceeded) + c.runPostRolloutHooks(cd, flaggerv1.CanaryPhaseSucceeded) c.sendNotification(cd, "Canary analysis completed successfully, promotion finished.", false, false) } @@ -438,13 +438,13 @@ func (c *Controller) shouldSkipAnalysis(cd *flaggerv1.Canary, meshRouter router. } // update status phase - if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanarySucceeded); err != nil { + if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhaseSucceeded); err != nil { c.recordEventWarningf(cd, "%v", err) return false } // notify - c.recorder.SetStatus(cd, flaggerv1.CanarySucceeded) + c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseSucceeded) c.recordEventInfof(cd, "Promotion completed! Canary analysis was skipped for %s.%s", cd.Spec.TargetRef.Name, cd.Namespace) c.sendNotification(cd, "Canary analysis was skipped, promotion finished.", @@ -454,7 +454,7 @@ func (c *Controller) shouldSkipAnalysis(cd *flaggerv1.Canary, meshRouter router. } func (c *Controller) shouldAdvance(cd *flaggerv1.Canary) (bool, error) { - if cd.Status.LastAppliedSpec == "" || cd.Status.Phase == flaggerv1.CanaryProgressing { + if cd.Status.LastAppliedSpec == "" || cd.Status.Phase == flaggerv1.CanaryPhaseProgressing { return true, nil } @@ -477,16 +477,16 @@ func (c *Controller) shouldAdvance(cd *flaggerv1.Canary) (bool, error) { func (c *Controller) checkCanaryStatus(cd *flaggerv1.Canary, shouldAdvance bool) bool { c.recorder.SetStatus(cd, cd.Status.Phase) - if cd.Status.Phase == flaggerv1.CanaryProgressing { + if cd.Status.Phase == flaggerv1.CanaryPhaseProgressing { return true } if cd.Status.Phase == "" { - if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryInitialized}); err != nil { + if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseInitialized}); err != nil { c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Errorf("%v", err) return false } - c.recorder.SetStatus(cd, flaggerv1.CanaryInitialized) + c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseInitialized) c.recordEventInfof(cd, "Initialization done! %s.%s", cd.Name, cd.Namespace) c.sendNotification(cd, "New deployment detected, initialization completed.", true, false) @@ -501,18 +501,18 @@ func (c *Controller) checkCanaryStatus(cd *flaggerv1.Canary, shouldAdvance bool) c.recordEventErrorf(cd, "%v", err) return false } - if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryProgressing}); err != nil { + if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseProgressing}); err != nil { c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Errorf("%v", err) return false } - c.recorder.SetStatus(cd, flaggerv1.CanaryProgressing) + c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseProgressing) return false } return false } func (c *Controller) hasCanaryRevisionChanged(cd *flaggerv1.Canary) bool { - if cd.Status.Phase == flaggerv1.CanaryProgressing { + if cd.Status.Phase == flaggerv1.CanaryPhaseProgressing { if diff, _ := c.deployer.HasDeploymentChanged(cd); diff { return true } @@ -526,7 +526,7 @@ func (c *Controller) hasCanaryRevisionChanged(cd *flaggerv1.Canary) bool { func (c *Controller) runPreRolloutHooks(canary *flaggerv1.Canary) bool { for _, webhook := range canary.Spec.CanaryAnalysis.Webhooks { if webhook.Type == flaggerv1.PreRolloutHook { - err := CallWebhook(canary.Name, canary.Namespace, flaggerv1.CanaryProgressing, webhook) + err := CallWebhook(canary.Name, canary.Namespace, flaggerv1.CanaryPhaseProgressing, webhook) if err != nil { c.recordEventWarningf(canary, "Halt %s.%s advancement pre-rollout check %s failed %v", canary.Name, canary.Namespace, webhook.Name, err) @@ -558,7 +558,7 @@ func (c *Controller) analyseCanary(r *flaggerv1.Canary) bool { // run external checks for _, webhook := range r.Spec.CanaryAnalysis.Webhooks { if webhook.Type == "" || webhook.Type == flaggerv1.RolloutHook { - err := CallWebhook(r.Name, r.Namespace, flaggerv1.CanaryProgressing, webhook) + err := CallWebhook(r.Name, r.Namespace, flaggerv1.CanaryPhaseProgressing, webhook) if err != nil { c.recordEventWarningf(r, "Halt %s.%s advancement external check %s failed %v", r.Name, r.Namespace, webhook.Name, err) diff --git a/pkg/controller/scheduler_test.go b/pkg/controller/scheduler_test.go index 32ba819d..bd88e8e4 100644 --- a/pkg/controller/scheduler_test.go +++ b/pkg/controller/scheduler_test.go @@ -47,7 +47,7 @@ func TestScheduler_Rollback(t *testing.T) { mocks.ctrl.advanceCanary("podinfo", "default", true) // update failed checks to max - err := mocks.deployer.SyncStatus(mocks.canary, v1alpha3.CanaryStatus{Phase: v1alpha3.CanaryProgressing, FailedChecks: 11}) + err := mocks.deployer.SyncStatus(mocks.canary, v1alpha3.CanaryStatus{Phase: v1alpha3.CanaryPhaseProgressing, FailedChecks: 11}) if err != nil { t.Fatal(err.Error()) } @@ -60,8 +60,8 @@ func TestScheduler_Rollback(t *testing.T) { t.Fatal(err.Error()) } - if c.Status.Phase != v1alpha3.CanaryFailed { - t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanaryFailed) + if c.Status.Phase != v1alpha3.CanaryPhaseFailed { + t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanaryPhaseFailed) } } @@ -101,8 +101,8 @@ func TestScheduler_SkipAnalysis(t *testing.T) { t.Errorf("Got skip analysis %v wanted %v", c.Spec.SkipAnalysis, true) } - if c.Status.Phase != v1alpha3.CanarySucceeded { - t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanarySucceeded) + if c.Status.Phase != v1alpha3.CanaryPhaseSucceeded { + t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanaryPhaseSucceeded) } } @@ -255,8 +255,8 @@ func TestScheduler_Promotion(t *testing.T) { t.Fatal(err.Error()) } - if c.Status.Phase != v1alpha3.CanarySucceeded { - t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanarySucceeded) + if c.Status.Phase != v1alpha3.CanaryPhaseSucceeded { + t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanaryPhaseSucceeded) } } @@ -326,8 +326,8 @@ func TestScheduler_ABTesting(t *testing.T) { t.Fatal(err.Error()) } - if c.Status.Phase != v1alpha3.CanarySucceeded { - t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanarySucceeded) + if c.Status.Phase != v1alpha3.CanaryPhaseSucceeded { + t.Errorf("Got canary state %v wanted %v", c.Status.Phase, v1alpha3.CanaryPhaseSucceeded) } } diff --git a/pkg/controller/webhook_test.go b/pkg/controller/webhook_test.go index 528dc516..669a95c9 100644 --- a/pkg/controller/webhook_test.go +++ b/pkg/controller/webhook_test.go @@ -19,7 +19,7 @@ func TestCallWebhook(t *testing.T) { Metadata: &map[string]string{"key1": "val1"}, } - err := CallWebhook("podinfo", "default", flaggerv1.CanaryProgressing, hook) + err := CallWebhook("podinfo", "default", flaggerv1.CanaryPhaseProgressing, hook) if err != nil { t.Fatal(err.Error()) } @@ -35,7 +35,7 @@ func TestCallWebhook_StatusCode(t *testing.T) { URL: ts.URL, } - err := CallWebhook("podinfo", "default", flaggerv1.CanaryProgressing, hook) + err := CallWebhook("podinfo", "default", flaggerv1.CanaryPhaseProgressing, hook) if err == nil { t.Errorf("Got no error wanted %v", http.StatusInternalServerError) } diff --git a/pkg/metrics/recorder.go b/pkg/metrics/recorder.go index 6b8d50ed..d798bc65 100644 --- a/pkg/metrics/recorder.go +++ b/pkg/metrics/recorder.go @@ -87,9 +87,9 @@ func (cr *Recorder) SetTotal(namespace string, total int) { func (cr *Recorder) SetStatus(cd *flaggerv1.Canary, phase flaggerv1.CanaryPhase) { status := 1 switch phase { - case flaggerv1.CanaryProgressing: + case flaggerv1.CanaryPhaseProgressing: status = 0 - case flaggerv1.CanaryFailed: + case flaggerv1.CanaryPhaseFailed: status = 2 default: status = 1