update golang to 1.24.3 [v8]

.github/workflows/golangci-lint.yml

@@ -36,7 +36,7 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.61
+          version: v1.64
           args: -v --exclude-dirs cf --exclude-dirs fixtures --exclude-dirs plugin --exclude-dirs command/plugin
   format:
     name: Run go fmt

cf/actors/push.go

@@ -7,6 +7,8 @@ import (
 	"path/filepath"
 	"runtime"
 
+	"errors"
+
 	"code.cloudfoundry.org/cli/cf/api/applicationbits"
 	"code.cloudfoundry.org/cli/cf/api/resources"
 	"code.cloudfoundry.org/cli/cf/appfiles"
@@ -186,29 +188,29 @@ func (actor PushActorImpl) ValidateAppParams(apps []models.AppParams) []error {
 		appName := app.Name
 
 		if app.HealthCheckType != nil && *app.HealthCheckType != "http" && app.HealthCheckHTTPEndpoint != nil {
-			errs = append(errs, fmt.Errorf(T("Health check type must be 'http' to set a health check HTTP endpoint.")))
+			errs = append(errs, errors.New(T("Health check type must be 'http' to set a health check HTTP endpoint.")))
 		}
 
 		if app.Routes != nil {
 			if app.Hosts != nil {
-				errs = append(errs, fmt.Errorf(T("Application {{.AppName}} must not be configured with both 'routes' and 'host'/'hosts'", map[string]interface{}{"AppName": appName})))
+				errs = append(errs, errors.New(T("Application {{.AppName}} must not be configured with both 'routes' and 'host'/'hosts'", map[string]interface{}{"AppName": appName})))
 			}
 
 			if app.Domains != nil {
-				errs = append(errs, fmt.Errorf(T("Application {{.AppName}} must not be configured with both 'routes' and 'domain'/'domains'", map[string]interface{}{"AppName": appName})))
+				errs = append(errs, errors.New(T("Application {{.AppName}} must not be configured with both 'routes' and 'domain'/'domains'", map[string]interface{}{"AppName": appName})))
 			}
 
 			if app.NoHostname != nil {
-				errs = append(errs, fmt.Errorf(T("Application {{.AppName}} must not be configured with both 'routes' and 'no-hostname'", map[string]interface{}{"AppName": appName})))
+				errs = append(errs, errors.New(T("Application {{.AppName}} must not be configured with both 'routes' and 'no-hostname'", map[string]interface{}{"AppName": appName})))
 			}
 		}
 
 		if app.BuildpackURL != nil && app.DockerImage != nil {
-			errs = append(errs, fmt.Errorf(T("Application {{.AppName}} must not be configured with both 'buildpack' and 'docker'", map[string]interface{}{"AppName": appName})))
+			errs = append(errs, errors.New(T("Application {{.AppName}} must not be configured with both 'buildpack' and 'docker'", map[string]interface{}{"AppName": appName})))
 		}
 
 		if app.Path != nil && app.DockerImage != nil {
-			errs = append(errs, fmt.Errorf(T("Application {{.AppName}} must not be configured with both 'docker' and 'path'", map[string]interface{}{"AppName": appName})))
+			errs = append(errs, errors.New(T("Application {{.AppName}} must not be configured with both 'docker' and 'path'", map[string]interface{}{"AppName": appName})))
 		}
 	}
 

cf/actors/routes.go

@@ -233,15 +233,15 @@ func (routeActor routeActor) FindAndBindRoute(routeName string, app models.Appli
 
 func validateRoute(routeName string, domainType string, port int, path string) error {
 	if domainType == tcp && path != "" {
-		return fmt.Errorf(T("Path not allowed in TCP route {{.RouteName}}",
+		return errors.New(T("Path not allowed in TCP route {{.RouteName}}",
 			map[string]interface{}{
 				"RouteName": routeName,
 			},
 		))
 	}
 
 	if domainType == "" && port != 0 {
-		return fmt.Errorf(T("Port not allowed in HTTP route {{.RouteName}}",
+		return errors.New(T("Port not allowed in HTTP route {{.RouteName}}",
 			map[string]interface{}{
 				"RouteName": routeName,
 			},
@@ -288,7 +288,7 @@ func parseRoute(routeName string, findFunc func(domainName string) (models.Domai
 		return routeParts[0], domain, false, nil
 	}
 
-	return "", models.DomainFields{}, true, fmt.Errorf(T(
+	return "", models.DomainFields{}, true, errors.New(T(
 		"The route {{.RouteName}} did not match any existing domains.",
 		map[string]interface{}{
 			"RouteName": routeName,

cf/api/resources/events.go

@@ -57,12 +57,12 @@ func (resource EventResourceOldV2) ToFields() models.EventFields {
 		GUID:      resource.Metadata.GUID,
 		Name:      T("app crashed"),
 		Timestamp: resource.Entity.Timestamp,
-		Description: fmt.Sprintf(T("instance: {{.InstanceIndex}}, reason: {{.ExitDescription}}, exit_status: {{.ExitStatus}}",
+		Description: T("instance: {{.InstanceIndex}}, reason: {{.ExitDescription}}, exit_status: {{.ExitStatus}}",
 			map[string]interface{}{
 				"InstanceIndex":   resource.Entity.InstanceIndex,
 				"ExitDescription": resource.Entity.ExitDescription,
 				"ExitStatus":      strconv.Itoa(resource.Entity.ExitStatus),
-			})),
+			}),
 	}
 }
 

cf/api/stacks/stacks.go

@@ -41,7 +41,7 @@ func (repo CloudControllerStackRepository) FindByGUID(guid string) (models.Stack
 			return models.Stack{}, errNotFound
 		}
 
-		return models.Stack{}, fmt.Errorf(T("Error retrieving stacks: {{.Error}}", map[string]interface{}{
+		return models.Stack{}, errors.New(T("Error retrieving stacks: {{.Error}}", map[string]interface{}{
 			"Error": err.Error(),
 		}))
 	}

cf/api/users.go

@@ -290,7 +290,7 @@ func userGUIDPath(apiEndpoint, userGUID, orgGUID string, role models.Role) (stri
 func (repo CloudControllerUserRepository) SetSpaceRoleByGUID(userGUID, spaceGUID, orgGUID string, role models.Role) error {
 	rolePath, found := spaceRoleToPathMap[role]
 	if !found {
-		return fmt.Errorf(T("Invalid Role {{.Role}}", map[string]interface{}{"Role": role}))
+		return errors.New(T("Invalid Role {{.Role}}", map[string]interface{}{"Role": role}))
 	}
 
 	err := repo.assocUserWithOrgByUserGUID(userGUID, orgGUID)
@@ -330,7 +330,7 @@ func (repo CloudControllerUserRepository) SetSpaceRoleByUsername(username, space
 func (repo CloudControllerUserRepository) UnsetSpaceRoleByGUID(userGUID, spaceGUID string, role models.Role) error {
 	rolePath, found := spaceRoleToPathMap[role]
 	if !found {
-		return fmt.Errorf(T("Invalid Role {{.Role}}", map[string]interface{}{"Role": role}))
+		return errors.New(T("Invalid Role {{.Role}}", map[string]interface{}{"Role": role}))
 	}
 	apiURL := fmt.Sprintf("/v2/spaces/%s/%s/%s", spaceGUID, rolePath, userGUID)
 
@@ -343,7 +343,7 @@ func (repo CloudControllerUserRepository) checkSpaceRole(spaceGUID string, role
 	rolePath, found := spaceRoleToPathMap[role]
 
 	if !found {
-		apiErr = fmt.Errorf(T("Invalid Role {{.Role}}",
+		apiErr = errors.New(T("Invalid Role {{.Role}}",
 			map[string]interface{}{"Role": role}))
 	}
 
@@ -373,7 +373,7 @@ func rolePath(role models.Role) (string, error) {
 	path, found := orgRoleToPathMap[role]
 
 	if !found {
-		return "", fmt.Errorf(T("Invalid Role {{.Role}}",
+		return "", errors.New(T("Invalid Role {{.Role}}",
 			map[string]interface{}{"Role": role}))
 	}
 	return path, nil

cf/commandregistry/registry.go

@@ -35,9 +35,10 @@ func initI18nFunc() bool {
 	T = Init(config)
 
 	if err != nil {
-		fmt.Fprintf(os.Stderr, fmt.Sprintf("%s\n", T(configErrTemplate, map[string]interface{}{
+		msg := T(configErrTemplate, map[string]interface{}{
 			"FilePath": configv3.ConfigFilePath(),
-		})))
+		})
+		fmt.Fprintf(os.Stderr, "%s\n", msg)
 	}
 	return true
 }

cf/commands/api.go

@@ -61,8 +61,8 @@ func (cmd API) Execute(c flags.FlagContext) error {
 
 	} else if len(c.Args()) == 0 {
 		if cmd.config.APIEndpoint() == "" {
-			cmd.ui.Say(fmt.Sprintf(T("No api endpoint set. Use '{{.Name}}' to set an endpoint",
-				map[string]interface{}{"Name": terminal.CommandColor(cf.Name + " api")})))
+			cmd.ui.Say(T("No api endpoint set. Use '{{.Name}}' to set an endpoint",
+				map[string]interface{}{"Name": terminal.CommandColor(cf.Name + " api")}))
 		} else {
 			cmd.ui.Say(T("API endpoint: {{.APIEndpoint}} (API version: {{.APIVersion}})",
 				map[string]interface{}{"APIEndpoint": terminal.EntityNameColor(cmd.config.APIEndpoint()),
@@ -106,8 +106,8 @@ func (cmd API) setAPIEndpoint(endpoint string, skipSSL bool, cmdName string) err
 		switch typedErr := err.(type) {
 		case *errors.InvalidSSLCert:
 			cfAPICommand := terminal.CommandColor(fmt.Sprintf("%s %s --skip-ssl-validation", cf.Name, cmdName))
-			tipMessage := fmt.Sprintf(T("TIP: Use '{{.APICommand}}' to continue with an insecure API endpoint",
-				map[string]interface{}{"APICommand": cfAPICommand}))
+			tipMessage := T("TIP: Use '{{.APICommand}}' to continue with an insecure API endpoint",
+				map[string]interface{}{"APICommand": cfAPICommand})
 			return errors.New(T("Invalid SSL Cert for {{.URL}}\n{{.TipMessage}}",
 				map[string]interface{}{"URL": typedErr.URL, "TipMessage": tipMessage}))
 		default:

cf/commands/application/app.go

@@ -183,15 +183,15 @@ func (cmd *ShowApp) ShowApp(app models.Application, orgName, spaceName string) e
 			uihelpers.ColoredInstanceState(instance),
 			instance.Since.Format("2006-01-02 03:04:05 PM"),
 			fmt.Sprintf("%.1f%%", instance.CPUUsage*100),
-			fmt.Sprintf(T("{{.MemUsage}} of {{.MemQuota}}",
+			T("{{.MemUsage}} of {{.MemQuota}}",
 				map[string]interface{}{
 					"MemUsage": formatters.ByteSize(instance.MemUsage),
-					"MemQuota": formatters.ByteSize(instance.MemQuota)})),
-			fmt.Sprintf(T("{{.DiskUsage}} of {{.DiskQuota}}",
+					"MemQuota": formatters.ByteSize(instance.MemQuota)}),
+			T("{{.DiskUsage}} of {{.DiskQuota}}",
 				map[string]interface{}{
 					"DiskUsage": formatters.ByteSize(instance.DiskUsage),
-					"DiskQuota": formatters.ByteSize(instance.DiskQuota)})),
-			fmt.Sprintf("%s", instance.Details),
+					"DiskQuota": formatters.ByteSize(instance.DiskQuota)}),
+			instance.Details,
 		)
 	}
 

cf/commands/application/copy_source.go

@@ -2,7 +2,6 @@ package application
 
 import (
 	"errors"
-	"fmt"
 	"strings"
 
 	"code.cloudfoundry.org/cli/cf/api/applications"
@@ -171,7 +170,7 @@ func (cmd *CopySource) findSpaceFields(targetOrg, targetSpace string) (models.Sp
 	}
 
 	if !foundSpace {
-		return models.SpaceFields{}, fmt.Errorf(T("Could not find space {{.Space}} in organization {{.Org}}",
+		return models.SpaceFields{}, errors.New(T("Could not find space {{.Space}} in organization {{.Org}}",
 			map[string]interface{}{
 				"Space": terminal.EntityNameColor(targetSpace),
 				"Org":   terminal.EntityNameColor(targetOrg),
@@ -183,14 +182,14 @@ func (cmd *CopySource) findSpaceFields(targetOrg, targetSpace string) (models.Sp
 }
 
 func buildCopyString(sourceAppName, targetAppName, targetOrgName, targetSpaceName, username string) string {
-	return fmt.Sprintf(T("Copying source from app {{.SourceApp}} to target app {{.TargetApp}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
+	return T("Copying source from app {{.SourceApp}} to target app {{.TargetApp}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
 		map[string]interface{}{
 			"SourceApp": terminal.EntityNameColor(sourceAppName),
 			"TargetApp": terminal.EntityNameColor(targetAppName),
 			"OrgName":   terminal.EntityNameColor(targetOrgName),
 			"SpaceName": terminal.EntityNameColor(targetSpaceName),
 			"Username":  terminal.EntityNameColor(username),
 		},
-	))
+	)
 
 }

cf/commands/application/push.go

@@ -784,7 +784,7 @@ func (cmd *Push) getAppParamsFromContext(c flags.FlagContext) (models.AppParams,
 	if c.String("t") != "" {
 		timeout, err := strconv.Atoi(c.String("t"))
 		if err != nil {
-			return models.AppParams{}, fmt.Errorf("Error: %s", fmt.Errorf(T("Invalid timeout param: {{.Timeout}}\n{{.Err}}",
+			return models.AppParams{}, fmt.Errorf("Error: %s", errors.New(T("Invalid timeout param: {{.Timeout}}\n{{.Err}}",
 				map[string]interface{}{"Timeout": c.String("t"), "Err": err.Error()})))
 		}
 
@@ -798,7 +798,7 @@ func (cmd *Push) getAppParamsFromContext(c flags.FlagContext) (models.AppParams,
 	case "http", "none", "port", "process":
 		appParams.HealthCheckType = &healthCheckType
 	default:
-		return models.AppParams{}, fmt.Errorf("Error: %s", fmt.Errorf(T("Invalid health-check-type param: {{.healthCheckType}}",
+		return models.AppParams{}, fmt.Errorf("Error: %s", errors.New(T("Invalid health-check-type param: {{.healthCheckType}}",
 			map[string]interface{}{"healthCheckType": healthCheckType})))
 	}
 

cf/commands/application/ssh.go

@@ -107,10 +107,10 @@ func (cmd *SSH) Execute(fc flags.FlagContext) error {
 	if fc.IsSet("i") {
 		instanceIndex := fc.Int("i")
 		if instanceIndex < 0 {
-			return fmt.Errorf(T("The application instance index cannot be negative"))
+			return errors.New(T("The application instance index cannot be negative"))
 		}
 		if instanceIndex >= cmd.appReq.GetApplication().InstanceCount {
-			return fmt.Errorf(T("The specified application instance does not exist"))
+			return errors.New(T("The specified application instance does not exist"))
 		}
 	}
 

cf/commands/application/start.go

@@ -340,7 +340,7 @@ func (cmd *Start) waitForOneRunningInstance(app models.Application) error {
 			}
 
 			if count.flapping > 0 || count.crashed > 0 {
-				return fmt.Errorf(T("Start unsuccessful\n\nTIP: use '{{.Command}}' for more information",
+				return errors.New(T("Start unsuccessful\n\nTIP: use '{{.Command}}' for more information",
 					map[string]interface{}{"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name, app.Name))}))
 			}
 
@@ -393,40 +393,40 @@ func (cmd Start) fetchInstanceCount(appGUID string) (instanceCount, error) {
 }
 
 func instancesDetails(count instanceCount) string {
-	details := []string{fmt.Sprintf(T("{{.RunningCount}} of {{.TotalCount}} instances running",
-		map[string]interface{}{"RunningCount": count.running, "TotalCount": count.total}))}
+	details := []string{T("{{.RunningCount}} of {{.TotalCount}} instances running",
+		map[string]interface{}{"RunningCount": count.running, "TotalCount": count.total})}
 
 	if count.starting > 0 {
 		if len(count.startingDetails) == 0 {
-			details = append(details, fmt.Sprintf(T("{{.StartingCount}} starting",
-				map[string]interface{}{"StartingCount": count.starting})))
+			details = append(details, T("{{.StartingCount}} starting",
+				map[string]interface{}{"StartingCount": count.starting}))
 		} else {
 			info := []string{}
 			for d := range count.startingDetails {
 				info = append(info, d)
 			}
 			sort.Strings(info)
-			details = append(details, fmt.Sprintf(T("{{.StartingCount}} starting ({{.Details}})",
+			details = append(details, T("{{.StartingCount}} starting ({{.Details}})",
 				map[string]interface{}{
 					"StartingCount": count.starting,
 					"Details":       strings.Join(info, ", "),
-				})))
+				}))
 		}
 	}
 
 	if count.down > 0 {
-		details = append(details, fmt.Sprintf(T("{{.DownCount}} down",
-			map[string]interface{}{"DownCount": count.down})))
+		details = append(details, T("{{.DownCount}} down",
+			map[string]interface{}{"DownCount": count.down}))
 	}
 
 	if count.flapping > 0 {
-		details = append(details, fmt.Sprintf(T("{{.FlappingCount}} failing",
-			map[string]interface{}{"FlappingCount": count.flapping})))
+		details = append(details, T("{{.FlappingCount}} failing",
+			map[string]interface{}{"FlappingCount": count.flapping}))
 	}
 
 	if count.crashed > 0 {
-		details = append(details, fmt.Sprintf(T("{{.CrashedCount}} crashed",
-			map[string]interface{}{"CrashedCount": count.crashed})))
+		details = append(details, T("{{.CrashedCount}} crashed",
+			map[string]interface{}{"CrashedCount": count.crashed}))
 	}
 
 	return strings.Join(details, ", ")

cf/commands/buildpack/create_buildpack.go

@@ -115,7 +115,7 @@ func (cmd *CreateBuildpack) Execute(c flags.FlagContext) error {
 func (cmd CreateBuildpack) createBuildpack(buildpackName string, c flags.FlagContext) (buildpack models.Buildpack, apiErr error) {
 	position, err := strconv.Atoi(c.Args()[2])
 	if err != nil {
-		apiErr = fmt.Errorf(T("Error {{.ErrorDescription}} is being passed in as the argument for 'Position' but 'Position' requires an integer.  For more syntax help, see `cf create-buildpack -h`.", map[string]interface{}{"ErrorDescription": c.Args()[2]}))
+		apiErr = errors.New(T("Error {{.ErrorDescription}} is being passed in as the argument for 'Position' but 'Position' requires an integer.  For more syntax help, see `cf create-buildpack -h`.", map[string]interface{}{"ErrorDescription": c.Args()[2]}))
 		return
 	}
 

cf/commands/serviceaccess/service_access.go

@@ -1,7 +1,6 @@
 package serviceaccess
 
 import (
-	"fmt"
 	"strings"
 
 	"code.cloudfoundry.org/cli/cf/actors"
@@ -124,7 +123,7 @@ func (cmd *ServiceAccess) Execute(c flags.FlagContext) error {
 
 func (cmd ServiceAccess) printTable(brokers []models.ServiceBroker) error {
 	for _, serviceBroker := range brokers {
-		cmd.ui.Say(fmt.Sprintf(T("broker: {{.Name}}", map[string]interface{}{"Name": serviceBroker.Name})))
+		cmd.ui.Say(T("broker: {{.Name}}", map[string]interface{}{"Name": serviceBroker.Name}))
 
 		table := cmd.ui.Table([]string{"", T("service"), T("plan"), T("access"), T("orgs")})
 		for _, service := range serviceBroker.Services {

cf/commands/target.go

@@ -111,7 +111,7 @@ func (cmd Target) setOrganization(orgName string) error {
 
 	org, apiErr := cmd.orgRepo.FindByName(orgName)
 	if apiErr != nil {
-		return fmt.Errorf(T("Could not target org.\n{{.APIErr}}",
+		return errors.New(T("Could not target org.\n{{.APIErr}}",
 			map[string]interface{}{"APIErr": apiErr.Error()}))
 	}
 
@@ -128,7 +128,7 @@ func (cmd Target) setSpace(spaceName string) error {
 
 	space, apiErr := cmd.spaceRepo.FindByName(spaceName)
 	if apiErr != nil {
-		return fmt.Errorf(T("Unable to access space {{.SpaceName}}.\n{{.APIErr}}",
+		return errors.New(T("Unable to access space {{.SpaceName}}.\n{{.APIErr}}",
 			map[string]interface{}{"SpaceName": spaceName, "APIErr": apiErr.Error()}))
 	}
 

cf/commands/user/delete_user.go

@@ -76,7 +76,7 @@ func (cmd *DeleteUser) Execute(c flags.FlagContext) error {
 	switch err.(type) {
 	case nil:
 		if len(users) > 1 {
-			return fmt.Errorf(T(
+			return errors.New(T(
 				"Error deleting user {{.Username}} \nThe user exists in multiple origins.",
 				map[string]interface{}{
 					"Username": username,

cf/manifest/generate_manifest.go

@@ -194,7 +194,7 @@ func (m *appManifest) Save(f io.Writer) error {
 	for _, app := range m.contents {
 		appMap, mapErr := generateAppMap(app)
 		if mapErr != nil {
-			return fmt.Errorf(T("Error saving manifest: {{.Error}}", map[string]interface{}{
+			return errors.New(T("Error saving manifest: {{.Error}}", map[string]interface{}{
 				"Error": mapErr.Error(),
 			}))
 		}