add gosimple linter and clean up linter violations

devigned · devigned · commit 19ea37919e2c · 2021-01-27T12:54:10.000-05:00
diff --git a/.golangci.yml b/.golangci.yml
@@ -17,6 +17,7 @@ linters:
     - goimports
     - golint
     - gosec
+    - gosimple
     - govet
     - ineffassign
     - interfacer
diff --git a/api/v1alpha3/azurecluster_validation.go b/api/v1alpha3/azurecluster_validation.go
@@ -151,7 +151,7 @@ func validateSubnets(subnets Subnets, fldPath *field.Path) field.ErrorList {
 		}
 	}
 	for k, v := range requiredSubnetRoles {
-		if v == false {
+		if !v {
 			allErrs = append(allErrs, field.Required(fldPath,
 				fmt.Sprintf("required role %s not included in provided subnets", k)))
 		}
@@ -197,8 +197,7 @@ func validateInternalLBIPAddress(address string, cidrs []string, fldPath *field.
 // validateIngressRule validates an IngressRule
 func validateIngressRule(ingressRule *IngressRule, fldPath *field.Path) *field.Error {
 	if ingressRule.Priority < 100 || ingressRule.Priority > 4096 {
-		return field.Invalid(fldPath, ingressRule.Priority,
-			fmt.Sprintf("ingress priorities should be between 100 and 4096"))
+		return field.Invalid(fldPath, ingressRule.Priority, "ingress priorities should be between 100 and 4096")
 	}
 
 	return nil
@@ -234,13 +233,13 @@ func validateAPIServerLB(lb LoadBalancerSpec, old LoadBalancerSpec, cidrs []stri
 	// There should only be one IP config.
 	if len(lb.FrontendIPs) != 1 {
 		allErrs = append(allErrs, field.Invalid(fldPath.Child("frontendIPConfigs"), lb.FrontendIPs,
-			fmt.Sprintf("API Server Load balancer should have 1 Frontend IP configuration")))
+			"API Server Load balancer should have 1 Frontend IP configuration"))
 	} else {
 		// if Internal, IP config should not have a public IP.
 		if lb.Type == Internal {
 			if lb.FrontendIPs[0].PublicIP != nil {
 				allErrs = append(allErrs, field.Forbidden(fldPath.Child("frontendIPConfigs").Index(0).Child("publicIP"),
-					fmt.Sprintf("Internal Load Balancers cannot have a Public IP")))
+					"Internal Load Balancers cannot have a Public IP"))
 			}
 			if lb.FrontendIPs[0].PrivateIPAddress != "" {
 				if err := validateInternalLBIPAddress(lb.FrontendIPs[0].PrivateIPAddress, cidrs,
@@ -257,7 +256,7 @@ func validateAPIServerLB(lb LoadBalancerSpec, old LoadBalancerSpec, cidrs []stri
 		if lb.Type == Public {
 			if lb.FrontendIPs[0].PrivateIPAddress != "" {
 				allErrs = append(allErrs, field.Forbidden(fldPath.Child("frontendIPConfigs").Index(0).Child("privateIP"),
-					fmt.Sprintf("Public Load Balancers cannot have a Private IP")))
+					"Public Load Balancers cannot have a Private IP"))
 			}
 		}
 	}
diff --git a/api/v1alpha3/azuremachine_validation.go b/api/v1alpha3/azuremachine_validation.go
@@ -168,11 +168,8 @@ func ValidateManagedDisk(old, new ManagedDisk, fieldPath *field.Path) field.Erro
 func validateDiffDiskSetings(d *DiffDiskSettings, fldPath *field.Path) *field.Error {
 	if d != nil {
 		if d.Option != string(compute.Local) {
-			return field.Invalid(
-				fldPath.Child("option"),
-				d,
-				fmt.Sprintf("changing ephemeral os settings after machine creation is not allowed"),
-			)
+			msg := "changing ephemeral os settings after machine creation is not allowed"
+			return field.Invalid(fldPath.Child("option"), d, msg)
 		}
 	}
 	return nil
@@ -183,25 +180,18 @@ func validateDiffDiskSettingsUpdate(old, new *DiffDiskSettings, fieldPath *field
 	fldPath := fieldPath.Child("diffDiskSettings")
 
 	if old == nil && new != nil {
-		allErrs = append(allErrs, field.Invalid(fldPath, new, fmt.Sprintf("enabling ephemeral os after machine creation is not allowed")))
+		allErrs = append(allErrs, field.Invalid(fldPath, new, "enabling ephemeral os after machine creation is not allowed"))
 		return allErrs
 	}
 	if old != nil && new == nil {
-		allErrs = append(allErrs, field.Invalid(fldPath, new, fmt.Sprintf("disabling ephemeral os after machine creation is not allowed")))
+		allErrs = append(allErrs, field.Invalid(fldPath, new, "disabling ephemeral os after machine creation is not allowed"))
 		return allErrs
 	}
 
 	if old != nil && new != nil {
 		if old.Option != new.Option {
-			allErrs = append(
-				allErrs,
-				field.Invalid(
-					fldPath.Child("option"),
-					new,
-					fmt.Sprintf("changing ephemeral os settings after machine creation is not allowed"),
-				),
-			)
-			return allErrs
+			msg := "changing ephemeral os settings after machine creation is not allowed"
+			return append(allErrs, field.Invalid(fldPath.Child("option"), new, msg))
 		}
 	}
 
diff --git a/cloud/scope/cluster.go b/cloud/scope/cluster.go
@@ -472,7 +472,7 @@ func (s *ClusterScope) APIServerHost() string {
 // SetFailureDomain will set the spec for a for a given key
 func (s *ClusterScope) SetFailureDomain(id string, spec clusterv1.FailureDomainSpec) {
 	if s.AzureCluster.Status.FailureDomains == nil {
-		s.AzureCluster.Status.FailureDomains = make(clusterv1.FailureDomains, 0)
+		s.AzureCluster.Status.FailureDomains = make(clusterv1.FailureDomains)
 	}
 	s.AzureCluster.Status.FailureDomains[id] = spec
 }
diff --git a/cloud/scope/machine.go b/cloud/scope/machine.go
@@ -122,7 +122,7 @@ func (m *MachineScope) TagsSpecs() []azure.TagsSpec {
 // PublicIPSpecs returns the public IP specs.
 func (m *MachineScope) PublicIPSpecs() []azure.PublicIPSpec {
 	var spec []azure.PublicIPSpec
-	if m.AzureMachine.Spec.AllocatePublicIP == true {
+	if m.AzureMachine.Spec.AllocatePublicIP {
 		spec = append(spec, azure.PublicIPSpec{
 			Name: azure.GenerateNodePublicIPName(m.Name()),
 		})
@@ -168,7 +168,7 @@ func (m *MachineScope) NICSpecs() []azure.NICSpec {
 		}
 	}
 	specs := []azure.NICSpec{spec}
-	if m.AzureMachine.Spec.AllocatePublicIP == true {
+	if m.AzureMachine.Spec.AllocatePublicIP {
 		specs = append(specs, azure.NICSpec{
 			Name:                  azure.GeneratePublicNICName(m.Name()),
 			MachineName:           m.Name(),
diff --git a/cloud/services/scalesets/scalesets_test.go b/cloud/services/scalesets/scalesets_test.go
@@ -513,7 +513,7 @@ func TestReconcileVMSS(t *testing.T) {
 			err := s.Reconcile(context.TODO())
 			if tc.expectedError != "" {
 				g.Expect(err).To(HaveOccurred())
-				g.Expect(err).To(MatchError(tc.expectedError), fmt.Sprintf("%s", err.Error()))
+				g.Expect(err).To(MatchError(tc.expectedError), err.Error())
 			} else {
 				g.Expect(err).NotTo(HaveOccurred())
 			}
diff --git a/cloud/services/tags/tags.go b/cloud/services/tags/tags.go
@@ -68,7 +68,7 @@ func (s *Service) Reconcile(ctx context.Context) error {
 			if err != nil {
 				return errors.Wrapf(err, "failed to get existing tags")
 			}
-			tags := make(map[string]*string, 0)
+			tags := make(map[string]*string)
 			if result.Properties != nil && result.Properties.Tags != nil {
 				tags = result.Properties.Tags
 			}
diff --git a/cloud/services/virtualmachines/virtualmachines.go b/cloud/services/virtualmachines/virtualmachines.go
@@ -251,9 +251,11 @@ func (s *Service) generateImagePlan() *compute.Plan {
 	if err != nil {
 		return nil
 	}
-	if image.Marketplace == nil || image.Marketplace.ThirdPartyImage == false {
+
+	if image.Marketplace == nil || !image.Marketplace.ThirdPartyImage {
 		return nil
 	}
+
 	if image.Marketplace.Publisher == "" || image.Marketplace.SKU == "" || image.Marketplace.Offer == "" {
 		return nil
 	}
diff --git a/controllers/azurejson_machine_controller.go b/controllers/azurejson_machine_controller.go
@@ -68,10 +68,7 @@ type filterUnclonedMachinesPredicate struct {
 }
 
 func (f filterUnclonedMachinesPredicate) Create(e event.CreateEvent) bool {
-	return f.Generic(event.GenericEvent{
-		Meta:   e.Meta,
-		Object: e.Object,
-	})
+	return f.Generic(event.GenericEvent(e))
 }
 
 func (f filterUnclonedMachinesPredicate) Update(e event.UpdateEvent) bool {
diff --git a/internal/test/env/env.go b/internal/test/env/env.go
@@ -53,7 +53,7 @@ var (
 	logger                 = record.NewLogger(record.WithThreshold(to.IntPtr(1)), record.WithWriter(ginkgo.GinkgoWriter))
 	scheme                 = runtime.NewScheme()
 	env                    *envtest.Environment
-	clusterAPIVersionRegex = regexp.MustCompile("^(\\W)sigs.k8s.io/cluster-api v(.+)")
+	clusterAPIVersionRegex = regexp.MustCompile(`^(\W)sigs.k8s.io/cluster-api v(.+)`)
 )
 
 func init() {

Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ func validateSubnets(subnets Subnets, fldPath *field.Path) field.ErrorList {`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`for k, v := range requiredSubnetRoles {`
`154`		`- if v == false {`
	`154`	`+ if !v {`
`155`	`155`	`allErrs = append(allErrs, field.Required(fldPath,`
`156`	`156`	`fmt.Sprintf("required role %s not included in provided subnets", k)))`
`157`	`157`	`}`
`@@ -197,8 +197,7 @@ func validateInternalLBIPAddress(address string, cidrs []string, fldPath *field.`
`197`	`197`	`// validateIngressRule validates an IngressRule`
`198`	`198`	`func validateIngressRule(ingressRule IngressRule, fldPath field.Path) *field.Error {`
`199`	`199`	`if ingressRule.Priority < 100 \|\| ingressRule.Priority > 4096 {`
`200`		`- return field.Invalid(fldPath, ingressRule.Priority,`
`201`		`- fmt.Sprintf("ingress priorities should be between 100 and 4096"))`
	`200`	`+ return field.Invalid(fldPath, ingressRule.Priority, "ingress priorities should be between 100 and 4096")`
`202`	`201`	`}`
`203`	`202`
`204`	`203`	`return nil`
`@@ -234,13 +233,13 @@ func validateAPIServerLB(lb LoadBalancerSpec, old LoadBalancerSpec, cidrs []stri`
`234`	`233`	`// There should only be one IP config.`
`235`	`234`	`if len(lb.FrontendIPs) != 1 {`
`236`	`235`	`allErrs = append(allErrs, field.Invalid(fldPath.Child("frontendIPConfigs"), lb.FrontendIPs,`
`237`		`- fmt.Sprintf("API Server Load balancer should have 1 Frontend IP configuration")))`
	`236`	`+ "API Server Load balancer should have 1 Frontend IP configuration"))`
`238`	`237`	`} else {`
`239`	`238`	`// if Internal, IP config should not have a public IP.`
`240`	`239`	`if lb.Type == Internal {`
`241`	`240`	`if lb.FrontendIPs[0].PublicIP != nil {`
`242`	`241`	`allErrs = append(allErrs, field.Forbidden(fldPath.Child("frontendIPConfigs").Index(0).Child("publicIP"),`
`243`		`- fmt.Sprintf("Internal Load Balancers cannot have a Public IP")))`
	`242`	`+ "Internal Load Balancers cannot have a Public IP"))`
`244`	`243`	`}`
`245`	`244`	`if lb.FrontendIPs[0].PrivateIPAddress != "" {`
`246`	`245`	`if err := validateInternalLBIPAddress(lb.FrontendIPs[0].PrivateIPAddress, cidrs,`
`@@ -257,7 +256,7 @@ func validateAPIServerLB(lb LoadBalancerSpec, old LoadBalancerSpec, cidrs []stri`
`257`	`256`	`if lb.Type == Public {`
`258`	`257`	`if lb.FrontendIPs[0].PrivateIPAddress != "" {`
`259`	`258`	`allErrs = append(allErrs, field.Forbidden(fldPath.Child("frontendIPConfigs").Index(0).Child("privateIP"),`
`260`		`- fmt.Sprintf("Public Load Balancers cannot have a Private IP")))`
	`259`	`+ "Public Load Balancers cannot have a Private IP"))`
`261`	`260`	`}`
`262`	`261`	`}`
`263`	`262`	`}`
Original file line number	Diff line number	Diff line change
`@@ -472,7 +472,7 @@ func (s *ClusterScope) APIServerHost() string {`
`472`	`472`	`// SetFailureDomain will set the spec for a for a given key`
`473`	`473`	`func (s *ClusterScope) SetFailureDomain(id string, spec clusterv1.FailureDomainSpec) {`
`474`	`474`	`if s.AzureCluster.Status.FailureDomains == nil {`
`475`		`- s.AzureCluster.Status.FailureDomains = make(clusterv1.FailureDomains, 0)`
	`475`	`+ s.AzureCluster.Status.FailureDomains = make(clusterv1.FailureDomains)`
`476`	`476`	`}`
`477`	`477`	`s.AzureCluster.Status.FailureDomains[id] = spec`
`478`	`478`	`}`
Original file line number	Diff line number	Diff line change
`@@ -513,7 +513,7 @@ func TestReconcileVMSS(t *testing.T) {`
`513`	`513`	`err := s.Reconcile(context.TODO())`
`514`	`514`	`if tc.expectedError != "" {`
`515`	`515`	`g.Expect(err).To(HaveOccurred())`
`516`		`- g.Expect(err).To(MatchError(tc.expectedError), fmt.Sprintf("%s", err.Error()))`
	`516`	`+ g.Expect(err).To(MatchError(tc.expectedError), err.Error())`
`517`	`517`	`} else {`
`518`	`518`	`g.Expect(err).NotTo(HaveOccurred())`
`519`	`519`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ func (s *Service) Reconcile(ctx context.Context) error {`
`68`	`68`	`if err != nil {`
`69`	`69`	`return errors.Wrapf(err, "failed to get existing tags")`
`70`	`70`	`}`
`71`		`- tags := make(map[string]*string, 0)`
	`71`	`+ tags := make(map[string]*string)`
`72`	`72`	`if result.Properties != nil && result.Properties.Tags != nil {`
`73`	`73`	`tags = result.Properties.Tags`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -251,9 +251,11 @@ func (s Service) generateImagePlan() compute.Plan {`
`251`	`251`	`if err != nil {`
`252`	`252`	`return nil`
`253`	`253`	`}`
`254`		`- if image.Marketplace == nil \|\| image.Marketplace.ThirdPartyImage == false {`
	`254`	`+`
	`255`	`+ if image.Marketplace == nil \|\| !image.Marketplace.ThirdPartyImage {`
`255`	`256`	`return nil`
`256`	`257`	`}`
	`258`	`+`
`257`	`259`	`if image.Marketplace.Publisher == "" \|\| image.Marketplace.SKU == "" \|\| image.Marketplace.Offer == "" {`
`258`	`260`	`return nil`
`259`	`261`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,10 +68,7 @@ type filterUnclonedMachinesPredicate struct {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`func (f filterUnclonedMachinesPredicate) Create(e event.CreateEvent) bool {`
`71`		`- return f.Generic(event.GenericEvent{`
`72`		`- Meta: e.Meta,`
`73`		`- Object: e.Object,`
`74`		`- })`
	`71`	`+ return f.Generic(event.GenericEvent(e))`
`75`	`72`	`}`
`76`	`73`
`77`	`74`	`func (f filterUnclonedMachinesPredicate) Update(e event.UpdateEvent) bool {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ var (`
`53`	`53`	`logger = record.NewLogger(record.WithThreshold(to.IntPtr(1)), record.WithWriter(ginkgo.GinkgoWriter))`
`54`	`54`	`scheme = runtime.NewScheme()`
`55`	`55`	`env *envtest.Environment`
`56`		`- clusterAPIVersionRegex = regexp.MustCompile("^(\\W)sigs.k8s.io/cluster-api v(.+)")`
	`56`	+ clusterAPIVersionRegex = regexp.MustCompile(`^(\W)sigs.k8s.io/cluster-api v(.+)`)
`57`	`57`	`)`
`58`	`58`
`59`	`59`	`func init() {`