Merge branch 'main' into main-restart-canary-steps

Samze · web-flow · commit 701812c45f1d · 2025-03-12T14:55:36.000-06:00
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
@@ -34,7 +34,6 @@ jobs:
         uses: actions/setup-go@v5
         with:
           go-version-file: go.mod
-          check-latest: true
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v6
         with:
@@ -52,6 +51,5 @@ jobs:
       uses: actions/setup-go@v5
       with:
         go-version-file: go.mod
-        check-latest: true
     - name: Run go fmt
       run: make format && git diff --exit-code
diff --git a/.github/workflows/release-build-sign-upload.yml b/.github/workflows/release-build-sign-upload.yml
@@ -424,7 +424,7 @@ jobs:
     - name: Update Homebrew
       run: |
         brew tap pivotalsoftware/gon
-        brew update --preinstall
+        brew update
         cat "$(brew --repository)/Library/Taps/pivotalsoftware/homebrew-gon/gon.rb" > .github/brew-formulae
 
     - name: Configure Homebrew cache
diff --git a/.github/workflows/release-update-repos.yml b/.github/workflows/release-update-repos.yml
@@ -383,11 +383,12 @@ jobs:
       env:
         DEBIAN_FRONTEND: noninteractive
       run: >
-        sudo apt update &&
-        sudo apt install --yes --no-install-recommends
+        sudo apt update
+        && sudo apt install --yes --no-install-recommends
         gnupg
         createrepo-c
-        awscli
+        python3-pip
+        && pip3 install awscli
 
     - name: Setup aws to upload installers to CLAW S3 bucket
       uses: aws-actions/configure-aws-credentials@v4
diff --git a/.github/workflows/tests-integration-reusable.yml b/.github/workflows/tests-integration-reusable.yml
@@ -70,7 +70,6 @@ jobs:
       uses: actions/setup-go@v5
       with:
         go-version-file: go.mod
-        check-latest: true
 
     - name: Install Tools
       env:
@@ -144,6 +143,7 @@ jobs:
           "include_apps": true,
           "include_backend_compatibility": false,
           "include_container_networking": true,
+          "include_deployments": true,
           "include_detect": true,
           "include_docker": true,
           "include_cnb": true,
diff --git a/.github/workflows/tests-integration.yml b/.github/workflows/tests-integration.yml
@@ -110,7 +110,6 @@ jobs:
         if: ${{ inputs.run_unit_tests || inputs.run_unit_tests == '' }}
         with:
           go-version-file: go.mod
-          check-latest: true
       - name: Run Units
         if: ${{ inputs.run_unit_tests || inputs.run_unit_tests == '' }}
         run: make units
diff --git a/.github/workflows/tests-unit.yml b/.github/workflows/tests-unit.yml
@@ -54,7 +54,6 @@ jobs:
       uses: actions/setup-go@v5
       with:
         go-version-file: go.mod
-        check-latest: true
         cache: true
 
     - name: Install Windows Build Dependencies
diff --git a/actor/v7pushaction/create_deployment_for_push_plan.go b/actor/v7pushaction/create_deployment_for_push_plan.go
@@ -19,7 +19,7 @@ func (actor Actor) CreateDeploymentForApplication(pushPlan PushPlan, eventStream
 	}
 
 	if len(pushPlan.InstanceSteps) > 0 {
-		dep.Options.CanaryDeploymentOptions = resources.CanaryDeploymentOptions{Steps: []resources.CanaryStep{}}
+		dep.Options.CanaryDeploymentOptions = &resources.CanaryDeploymentOptions{Steps: []resources.CanaryStep{}}
 		for _, w := range pushPlan.InstanceSteps {
 			dep.Options.CanaryDeploymentOptions.Steps = append(dep.Options.CanaryDeploymentOptions.Steps, resources.CanaryStep{InstanceWeight: w})
 		}
diff --git a/actor/v7pushaction/create_deployment_for_push_plan_test.go b/actor/v7pushaction/create_deployment_for_push_plan_test.go
@@ -175,7 +175,7 @@ var _ = Describe("CreateDeploymentForApplication()", func() {
 				Expect(dep).To(Equal(resources.Deployment{
 					Strategy: "canary",
 					Options: resources.DeploymentOpts{
-						CanaryDeploymentOptions: resources.CanaryDeploymentOptions{
+						CanaryDeploymentOptions: &resources.CanaryDeploymentOptions{
 							Steps: []resources.CanaryStep{
 								{InstanceWeight: 1},
 								{InstanceWeight: 2},
diff --git a/api/cloudcontroller/ccv3/deployment_test.go b/api/cloudcontroller/ccv3/deployment_test.go
@@ -251,7 +251,7 @@ var _ = Describe("Deployment", func() {
 			dep.Strategy = constant.DeploymentStrategyCanary
 			dep.RevisionGUID = revisionGUID
 			dep.Relationships = resources.Relationships{constant.RelationshipTypeApplication: resources.Relationship{GUID: "some-app-guid"}}
-			dep.Options.CanaryDeploymentOptions = resources.CanaryDeploymentOptions{Steps: []resources.CanaryStep{{InstanceWeight: 1}, {InstanceWeight: 2}}}
+			dep.Options.CanaryDeploymentOptions = &resources.CanaryDeploymentOptions{Steps: []resources.CanaryStep{{InstanceWeight: 1}, {InstanceWeight: 2}}}
 			deploymentGUID, warnings, executeErr = client.CreateApplicationDeployment(dep)
 		})
 
diff --git a/api/cloudcontroller/ccv3/process_instance.go b/api/cloudcontroller/ccv3/process_instance.go
@@ -38,6 +38,8 @@ type ProcessInstance struct {
 	LogRate uint64
 	// State is the state of the instance.
 	State constant.ProcessInstanceState
+	// Routeable is the readiness state of the instance, can be true, false or null.
+	Routable *bool
 	// Type is the process type for the instance.
 	Type string
 	// Uptime is the duration that the instance has been running.
@@ -54,6 +56,7 @@ func (instance *ProcessInstance) UnmarshalJSON(data []byte) error {
 		MemQuota         uint64 `json:"mem_quota"`
 		LogRateLimit     int64  `json:"log_rate_limit"`
 		State            string `json:"state"`
+		Routable         *bool  `json:"routable"`
 		Type             string `json:"type"`
 		Uptime           int64  `json:"uptime"`
 		Usage            struct {
@@ -80,6 +83,7 @@ func (instance *ProcessInstance) UnmarshalJSON(data []byte) error {
 	instance.LogRateLimit = inputInstance.LogRateLimit
 	instance.LogRate = inputInstance.Usage.LogRate
 	instance.State = constant.ProcessInstanceState(inputInstance.State)
+	instance.Routable = inputInstance.Routable
 	instance.Type = inputInstance.Type
 	instance.Uptime, err = time.ParseDuration(fmt.Sprintf("%ds", inputInstance.Uptime))
 	if err != nil {
diff --git a/api/cloudcontroller/cloud_controller_connection_test.go b/api/cloudcontroller/cloud_controller_connection_test.go
@@ -301,9 +301,14 @@ var _ = Describe("Cloud Controller Connection", func() {
 
 						var response Response
 						err = connection.Make(request, &response)
-						Expect(err).To(MatchError(ccerror.SSLValidationHostnameError{
-							Message: "x509: certificate is valid for example.com, not loopback.cli.fun",
-						}))
+						Expect(err).To(
+							SatisfyAny(
+								MatchError(ccerror.SSLValidationHostnameError{
+									Message: "x509: certificate is valid for example.com, *.example.com, not loopback.cli.fun",
+								}),
+								MatchError(ccerror.SSLValidationHostnameError{
+									Message: "x509: certificate is valid for example.com, not loopback.cli.fun",
+								})))
 					})
 				})
 			})
diff --git a/api/plugin/plugin_connection_test.go b/api/plugin/plugin_connection_test.go
@@ -200,9 +200,14 @@ var _ = Describe("Plugin Connection", func() {
 
 						var response Response
 						err = connection.Make(request, &response, nil)
-						Expect(err).To(MatchError(pluginerror.SSLValidationHostnameError{
-							Message: "x509: certificate is valid for example.com, not loopback.cli.fun",
-						}))
+						Expect(err).To(
+							SatisfyAny(
+								MatchError(pluginerror.SSLValidationHostnameError{
+									Message: "x509: certificate is valid for example.com, *.example.com, not loopback.cli.fun",
+								}),
+								MatchError(pluginerror.SSLValidationHostnameError{
+									Message: "x509: certificate is valid for example.com, not loopback.cli.fun",
+								})))
 					})
 				})
 			})
diff --git a/command/v7/create_route_command.go b/command/v7/create_route_command.go
@@ -68,18 +68,17 @@ func (cmd CreateRouteCommand) Execute(args []string) error {
 			"Organization": orgName,
 		})
 
-	err = cmd.validateAPIVersionForPerRouteOptions()
-	if err != nil {
-		return err
-	}
-
-	routeOptions, wrongOptSpec := resources.CreateRouteOptions(cmd.Options)
-	if wrongOptSpec != nil {
-		return actionerror.RouteOptionError{
-			Name:       *wrongOptSpec,
-			DomainName: domain,
-			Path:       pathName,
-			Host:       hostname,
+	var routeOptions map[string]*string
+	if len(cmd.Options) > 0 && cmd.validateAPIVersionForPerRouteOptions() == nil {
+		var wrongOptSpec *string
+		routeOptions, wrongOptSpec = resources.CreateRouteOptions(cmd.Options)
+		if wrongOptSpec != nil {
+			return actionerror.RouteOptionError{
+				Name:       *wrongOptSpec,
+				DomainName: domain,
+				Path:       pathName,
+				Host:       hostname,
+			}
 		}
 	}
 	route, warnings, err := cmd.Actor.CreateRoute(spaceGUID, domain, hostname, pathName, port, routeOptions)
diff --git a/command/v7/create_route_command_test.go b/command/v7/create_route_command_test.go
@@ -164,15 +164,15 @@ var _ = Describe("create-route Command", func() {
 			})
 		})
 
-		When("creating the route fails when the CC API version is too old for route options", func() {
+		When("creating the route does not fail when the CC API version is too old for route options", func() {
 			BeforeEach(func() {
 				cCAPIOldVersion = strconv.Itoa(1)
 				fakeConfig.APIVersionReturns(cCAPIOldVersion)
 			})
 
-			It("does not create a route and gives error message", func() {
-				Expect(executeErr).To(HaveOccurred())
-				Expect(fakeActor.CreateRouteCallCount()).To(Equal(0))
+			It("does create a route and gives a warning message", func() {
+				Expect(executeErr).NotTo(HaveOccurred())
+				Expect(fakeActor.CreateRouteCallCount()).To(Equal(1))
 				Expect(testUI.Err).To(Say("Your CC API"))
 				Expect(testUI.Err).To(Say("does not support per-route options"))
 			})
@@ -205,13 +205,24 @@ var _ = Describe("create-route Command", func() {
 				Expect(testUI.Out).To(Say("OK"))
 			})
 
-			It("creates the route", func() {
-				Expect(fakeActor.CreateRouteCallCount()).To(Equal(1))
-				expectedSpaceGUID, expectedDomainName, expectedHostname, _, _, expectedOptions := fakeActor.CreateRouteArgsForCall(0)
-				Expect(expectedSpaceGUID).To(Equal(spaceGUID))
-				Expect(expectedDomainName).To(Equal(domainName))
-				Expect(expectedHostname).To(Equal(hostname))
-				Expect(expectedOptions).To(Equal(options))
+			When("in a version of CAPI that does not support options", func() {
+				BeforeEach(func() {
+					fakeActor.CreateRouteReturns(resources.Route{
+						URL: domainName,
+					}, v7action.Warnings{"warnings-1", "warnings-2"}, nil)
+					cmdOptions = []string{}
+					cCAPIOldVersion = strconv.Itoa(1)
+					fakeConfig.APIVersionReturns(cCAPIOldVersion)
+				})
+
+				It("creates the route when no options are provided", func() {
+					Expect(fakeActor.CreateRouteCallCount()).To(Equal(1))
+					expectedSpaceGUID, expectedDomainName, expectedHostname, _, _, expectedOptions := fakeActor.CreateRouteArgsForCall(0)
+					Expect(expectedSpaceGUID).To(Equal(spaceGUID))
+					Expect(expectedDomainName).To(Equal(domainName))
+					Expect(expectedHostname).To(Equal(hostname))
+					Expect(expectedOptions).To(BeNil())
+				})
 			})
 
 			When("passing in a hostname", func() {
diff --git a/command/v7/map_route_command.go b/command/v7/map_route_command.go
@@ -72,21 +72,21 @@ func (cmd MapRouteCommand) Execute(args []string) error {
 		if _, ok := err.(actionerror.RouteNotFoundError); !ok {
 			return err
 		}
-		if cmd.Options != nil && len(cmd.Options) > 0 {
-			err := cmd.validateAPIVersionForPerRouteOptions()
-			if err != nil {
-				return err
-			}
-		}
-		routeOptions, wrongOptSpec := resources.CreateRouteOptions(cmd.Options)
-		if wrongOptSpec != nil {
-			return actionerror.RouteOptionError{
-				Name:       *wrongOptSpec,
-				DomainName: domain.Name,
-				Path:       path,
-				Host:       cmd.Hostname,
+
+		var routeOptions map[string]*string
+		if len(cmd.Options) > 0 && cmd.validateAPIVersionForPerRouteOptions() == nil {
+			var wrongOptSpec *string
+			routeOptions, wrongOptSpec = resources.CreateRouteOptions(cmd.Options)
+			if wrongOptSpec != nil {
+				return actionerror.RouteOptionError{
+					Name:       *wrongOptSpec,
+					DomainName: domain.Name,
+					Path:       path,
+					Host:       cmd.Hostname,
+				}
 			}
 		}
+
 		cmd.UI.DisplayTextWithFlavor("Creating route {{.URL}} for org {{.OrgName}} / space {{.SpaceName}} as {{.User}}...",
 			map[string]interface{}{
 				"URL":       url,
@@ -109,7 +109,7 @@ func (cmd MapRouteCommand) Execute(args []string) error {
 		}
 		cmd.UI.DisplayOK()
 	} else {
-		if cmd.Options != nil && len(cmd.Options) > 0 {
+		if len(cmd.Options) > 0 {
 			return actionerror.RouteOptionSupportError{ErrorText: "Route specific options can only be specified for nonexistent routes."}
 		}
 	}
diff --git a/command/v7/map_route_command_test.go b/command/v7/map_route_command_test.go
@@ -310,8 +310,8 @@ var _ = Describe("map-route Command", func() {
 						Expect(testUI.Err).To(Say("get-app-warnings"))
 						Expect(testUI.Err).To(Say("CC API version"))
 						Expect(testUI.Err).To(Say("does not support per-route options"))
-						Expect(executeErr).To(HaveOccurred())
-						Expect(fakeActor.CreateRouteCallCount()).To(Equal(0))
+						Expect(executeErr).NotTo(HaveOccurred())
+						Expect(fakeActor.CreateRouteCallCount()).To(Equal(1))
 					})
 				})
 
diff --git a/command/v7/shared/app_summary_displayer.go b/command/v7/shared/app_summary_displayer.go
@@ -79,6 +79,14 @@ func formatCPU(instance v7action.ProcessInstance) string {
 	return fmt.Sprintf("%.1f%%", instance.CPUEntitlement.Value*100)
 }
 
+func formatRoutable(b *bool) string {
+	if b == nil {
+		return "-"
+	}
+
+	return fmt.Sprintf("%t", *b)
+}
+
 func (display AppSummaryDisplayer) displayAppInstancesTable(processSummary v7action.ProcessSummary) {
 	table := [][]string{
 		{
@@ -90,6 +98,7 @@ func (display AppSummaryDisplayer) displayAppInstancesTable(processSummary v7act
 			display.UI.TranslateText("disk"),
 			display.UI.TranslateText("logging"),
 			display.UI.TranslateText("details"),
+			display.UI.TranslateText("ready"),
 		},
 	}
 
@@ -112,6 +121,7 @@ func (display AppSummaryDisplayer) displayAppInstancesTable(processSummary v7act
 				"LogRateLimit": formatLogRateLimit(instance.LogRateLimit),
 			}),
 			instance.Details,
+			formatRoutable(instance.Routable),
 		})
 	}
 
diff --git a/command/v7/shared/app_summary_displayer_test.go b/command/v7/shared/app_summary_displayer_test.go
diff --git a/command/v7/update_route_command.go b/command/v7/update_route_command.go
diff --git a/command/v7/update_route_command_test.go b/command/v7/update_route_command_test.go
diff --git a/go.mod b/go.mod
diff --git a/go.sum b/go.sum
diff --git a/integration/helpers/app_instance_table.go b/integration/helpers/app_instance_table.go
diff --git a/resources/deployment_resource.go b/resources/deployment_resource.go

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ func (actor Actor) CreateDeploymentForApplication(pushPlan PushPlan, eventStream`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`if len(pushPlan.InstanceSteps) > 0 {`
`22`		`- dep.Options.CanaryDeploymentOptions = resources.CanaryDeploymentOptions{Steps: []resources.CanaryStep{}}`
	`22`	`+ dep.Options.CanaryDeploymentOptions = &resources.CanaryDeploymentOptions{Steps: []resources.CanaryStep{}}`
`23`	`23`	`for _, w := range pushPlan.InstanceSteps {`
`24`	`24`	`dep.Options.CanaryDeploymentOptions.Steps = append(dep.Options.CanaryDeploymentOptions.Steps, resources.CanaryStep{InstanceWeight: w})`
`25`	`25`	`}`