Merge pull request #6628 from thaJeztah/swarm_enums

cli/command/service: use enum-consts defined in API

Author: thaJeztah

cli/command/service/opts.go

@@ -286,11 +286,11 @@ func defaultRestartPolicy() *swarm.RestartPolicy {
 func defaultRestartCondition() swarm.RestartPolicyCondition {
 	switch defaults.Service.Task.Restart.Condition {
 	case api.RestartOnNone:
-		return "none"
+		return swarm.RestartPolicyConditionNone
 	case api.RestartOnFailure:
-		return "on-failure"
+		return swarm.RestartPolicyConditionOnFailure
 	case api.RestartOnAny:
-		return "any"
+		return swarm.RestartPolicyConditionAny
 	default:
 		return ""
 	}
@@ -299,9 +299,9 @@ func defaultRestartCondition() swarm.RestartPolicyCondition {
 func defaultOrder(order api.UpdateConfig_UpdateOrder) string {
 	switch order {
 	case api.UpdateConfig_STOP_FIRST:
-		return "stop-first"
+		return swarm.UpdateOrderStopFirst
 	case api.UpdateConfig_START_FIRST:
-		return "start-first"
+		return swarm.UpdateOrderStartFirst
 	default:
 		return ""
 	}

cli/command/service/opts_test.go

@@ -249,17 +249,17 @@ func TestToServiceUpdateRollback(t *testing.T) {
 			Parallelism:     23,
 			Delay:           34 * time.Second,
 			Monitor:         54321 * time.Nanosecond,
-			FailureAction:   "pause",
+			FailureAction:   swarm.UpdateFailureActionPause,
 			MaxFailureRatio: 0.6,
-			Order:           "stop-first",
+			Order:           swarm.UpdateOrderStopFirst,
 		},
 		RollbackConfig: &swarm.UpdateConfig{
 			Parallelism:     12,
 			Delay:           23 * time.Second,
 			Monitor:         12345 * time.Nanosecond,
-			FailureAction:   "continue",
+			FailureAction:   swarm.UpdateFailureActionContinue,
 			MaxFailureRatio: 0.5,
-			Order:           "start-first",
+			Order:           swarm.UpdateOrderStartFirst,
 		},
 	}
 
@@ -269,34 +269,34 @@ func TestToServiceUpdateRollback(t *testing.T) {
 	flags.Set("update-parallelism", "23")
 	flags.Set("update-delay", "34s")
 	flags.Set("update-monitor", "54321ns")
-	flags.Set("update-failure-action", "pause")
+	flags.Set("update-failure-action", swarm.UpdateFailureActionPause)
 	flags.Set("update-max-failure-ratio", "0.6")
-	flags.Set("update-order", "stop-first")
+	flags.Set("update-order", swarm.UpdateOrderStopFirst)
 
 	flags.Set("rollback-parallelism", "12")
 	flags.Set("rollback-delay", "23s")
 	flags.Set("rollback-monitor", "12345ns")
-	flags.Set("rollback-failure-action", "continue")
+	flags.Set("rollback-failure-action", swarm.UpdateFailureActionContinue)
 	flags.Set("rollback-max-failure-ratio", "0.5")
-	flags.Set("rollback-order", "start-first")
+	flags.Set("rollback-order", swarm.UpdateOrderStartFirst)
 
 	o := newServiceOptions()
 	o.mode = "replicated"
 	o.update = updateOptions{
 		parallelism:     23,
 		delay:           34 * time.Second,
 		monitor:         54321 * time.Nanosecond,
-		onFailure:       "pause",
+		onFailure:       swarm.UpdateFailureActionPause,
 		maxFailureRatio: 0.6,
-		order:           "stop-first",
+		order:           swarm.UpdateOrderStopFirst,
 	}
 	o.rollback = updateOptions{
 		parallelism:     12,
 		delay:           23 * time.Second,
 		monitor:         12345 * time.Nanosecond,
-		onFailure:       "continue",
+		onFailure:       swarm.UpdateFailureActionContinue,
 		maxFailureRatio: 0.5,
-		order:           "start-first",
+		order:           swarm.UpdateOrderStartFirst,
 	}
 
 	service, err := o.ToService(context.Background(), &fakeClient{}, flags)
@@ -307,13 +307,13 @@ func TestToServiceUpdateRollback(t *testing.T) {
 
 func TestToServiceUpdateRollbackOrder(t *testing.T) {
 	flags := newCreateCommand(nil).Flags()
-	flags.Set("update-order", "start-first")
-	flags.Set("rollback-order", "start-first")
+	flags.Set("update-order", swarm.UpdateOrderStartFirst)
+	flags.Set("rollback-order", swarm.UpdateOrderStartFirst)
 
 	o := newServiceOptions()
 	o.mode = "replicated"
-	o.update = updateOptions{order: "start-first"}
-	o.rollback = updateOptions{order: "start-first"}
+	o.update = updateOptions{order: swarm.UpdateOrderStartFirst}
+	o.rollback = updateOptions{order: swarm.UpdateOrderStartFirst}
 
 	service, err := o.ToService(context.Background(), &fakeClient{}, flags)
 	assert.NilError(t, err)