feat: add linter config (#341)

Author: sa7mon

.golangci.yml

@@ -0,0 +1,25 @@
+linters-settings:
+  misspell:
+    locale: US
+  gosec:
+    excludes:
+      - G115 # Flags for potentially-unsafe casting of ints
+
+issues:
+  exclude-rules:
+    - path: provider/providers.go # TLS verification is skipped when provider.Insecure() == true
+      text: "InsecureSkipVerify"
+
+linters:
+  enable:
+    - gosec
+    - govet
+    - loggercheck
+    - misspell
+    - revive
+    - sloglint
+    - tparallel
+    - unconvert
+    - unparam
+    - unused
+    - whitespace

bucket/bucket.go

@@ -28,19 +28,19 @@ var bucketRe = regexp.MustCompile(`[^.\-a-z0-9]`)
 
 type Bucket struct {
 	//gorm.Model
-	ID                uint           `gorm:"primarykey" json:",omitempty"`
-	Name              string         `json:"name" gorm:"name;size:64;index"`
-	Region            string         `json:"region" gorm:"size:20"`
-	Exists            uint8          `json:"exists"`
-	DateScanned       time.Time      `json:"date_scanned"`
-	Objects           []BucketObject `json:"objects"`
-	ObjectsEnumerated bool           `json:"objects_enumerated"`
-	Provider          string         `json:"provider"`
-	NumObjects        int32          `json:"num_objects"`
+	ID                uint      `gorm:"primarykey" json:",omitempty"`
+	Name              string    `json:"name" gorm:"name;size:64;index"`
+	Region            string    `json:"region" gorm:"size:20"`
+	Exists            uint8     `json:"exists"`
+	DateScanned       time.Time `json:"date_scanned"`
+	Objects           []Object  `json:"objects"`
+	ObjectsEnumerated bool      `json:"objects_enumerated"`
+	Provider          string    `json:"provider"`
+	NumObjects        int32     `json:"num_objects"`
 
 	// Total size of all bucket objects in bytes
 	BucketSize       uint64 `json:"bucket_size"`
-	OwnerId          string `json:"owner_id"`
+	OwnerID          string `json:"owner_id"`
 	OwnerDisplayName string `json:"owner_display_name"`
 
 	PermAuthUsersRead        uint8 `json:"perm_auth_users_read"`
@@ -56,7 +56,7 @@ type Bucket struct {
 	PermAllUsersFullControl uint8 `json:"perm_all_users_full_control"`
 }
 
-type BucketObject struct {
+type Object struct {
 	//gorm.Model
 	ID       uint   `gorm:"primarykey" json:",omitempty"`
 	Key      string `json:"key" gorm:"type:string;size:1024"` // Keys can be up to 1,024 bytes long, UTF-8 encoded plus an additional byte just in case. https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html
@@ -82,63 +82,63 @@ func NewBucket(name string) Bucket {
 	}
 }
 
-func (bucket *Bucket) String() string {
-	if bucket.Exists == BucketNotExist {
-		return fmt.Sprintf("%v | bucket_not_exist", bucket.Name)
+func (b *Bucket) String() string {
+	if b.Exists == BucketNotExist {
+		return fmt.Sprintf("%v | bucket_not_exist", b.Name)
 	}
 
 	var authUserPerms []string
-	if bucket.PermAuthUsersRead == PermissionAllowed {
+	if b.PermAuthUsersRead == PermissionAllowed {
 		authUserPerms = append(authUserPerms, "READ")
 	}
-	if bucket.PermAuthUsersWrite == PermissionAllowed {
+	if b.PermAuthUsersWrite == PermissionAllowed {
 		authUserPerms = append(authUserPerms, "WRITE")
 	}
-	if bucket.PermAuthUsersReadACL == PermissionAllowed {
+	if b.PermAuthUsersReadACL == PermissionAllowed {
 		authUserPerms = append(authUserPerms, "READ_ACP")
 	}
-	if bucket.PermAuthUsersWriteACL == PermissionAllowed {
+	if b.PermAuthUsersWriteACL == PermissionAllowed {
 		authUserPerms = append(authUserPerms, "WRITE_ACP")
 	}
-	if bucket.PermAuthUsersFullControl == PermissionAllowed {
+	if b.PermAuthUsersFullControl == PermissionAllowed {
 		authUserPerms = append(authUserPerms, "FULL_CONTROL")
 	}
 
 	var allUsersPerms []string
-	if bucket.PermAllUsersRead == PermissionAllowed {
+	if b.PermAllUsersRead == PermissionAllowed {
 		allUsersPerms = append(allUsersPerms, "READ")
 	}
-	if bucket.PermAllUsersWrite == PermissionAllowed {
+	if b.PermAllUsersWrite == PermissionAllowed {
 		allUsersPerms = append(allUsersPerms, "WRITE")
 	}
-	if bucket.PermAllUsersReadACL == PermissionAllowed {
+	if b.PermAllUsersReadACL == PermissionAllowed {
 		allUsersPerms = append(allUsersPerms, "READ_ACP")
 	}
-	if bucket.PermAllUsersWriteACL == PermissionAllowed {
+	if b.PermAllUsersWriteACL == PermissionAllowed {
 		allUsersPerms = append(allUsersPerms, "WRITE_ACP")
 	}
-	if bucket.PermAllUsersFullControl == PermissionAllowed {
+	if b.PermAllUsersFullControl == PermissionAllowed {
 		allUsersPerms = append(allUsersPerms, "FULL_CONTROL")
 	}
 
 	return fmt.Sprintf("AuthUsers: [%v] | AllUsers: [%v]", strings.Join(authUserPerms, ", "), strings.Join(allUsersPerms, ", "))
 }
 
-func (bucket *Bucket) Permissions() map[*types.Grantee]map[string]uint8 {
+func (b *Bucket) Permissions() map[*types.Grantee]map[string]uint8 {
 	return map[*types.Grantee]map[string]uint8{
 		groups.AllUsersv2: {
-			"READ":         bucket.PermAllUsersRead,
-			"WRITE":        bucket.PermAllUsersWrite,
-			"READ_ACP":     bucket.PermAllUsersReadACL,
-			"WRITE_ACP":    bucket.PermAllUsersWriteACL,
-			"FULL_CONTROL": bucket.PermAllUsersFullControl,
+			"READ":         b.PermAllUsersRead,
+			"WRITE":        b.PermAllUsersWrite,
+			"READ_ACP":     b.PermAllUsersReadACL,
+			"WRITE_ACP":    b.PermAllUsersWriteACL,
+			"FULL_CONTROL": b.PermAllUsersFullControl,
 		},
 		groups.AuthenticatedUsersv2: {
-			"READ":         bucket.PermAuthUsersRead,
-			"WRITE":        bucket.PermAuthUsersWrite,
-			"READ_ACP":     bucket.PermAuthUsersReadACL,
-			"WRITE_ACP":    bucket.PermAuthUsersWriteACL,
-			"FULL_CONTROL": bucket.PermAuthUsersFullControl,
+			"READ":         b.PermAuthUsersRead,
+			"WRITE":        b.PermAuthUsersWrite,
+			"READ_ACP":     b.PermAuthUsersReadACL,
+			"WRITE_ACP":    b.PermAuthUsersWriteACL,
+			"FULL_CONTROL": b.PermAuthUsersFullControl,
 		},
 	}
 }
@@ -179,45 +179,45 @@ func ReadFromFile(bucketFile string, bucketChan chan Bucket) error {
 	return nil
 }
 
-// ParseAclOutputv2 TODO: probably move this to providers.go
-func (bucket *Bucket) ParseAclOutputv2(aclOutput *s3.GetBucketAclOutput) error {
-	bucket.OwnerId = *aclOutput.Owner.ID
+// ParseACLOutputV2 TODO: probably move this to providers.go
+func (b *Bucket) ParseACLOutputV2(aclOutput *s3.GetBucketAclOutput) error {
+	b.OwnerID = *aclOutput.Owner.ID
 	if aclOutput.Owner.DisplayName != nil {
-		bucket.OwnerDisplayName = *aclOutput.Owner.DisplayName
+		b.OwnerDisplayName = *aclOutput.Owner.DisplayName
 	}
 	// Since we can read the permissions, there should be no unknowns. Set all to denied, then read each grant and
 	// set the corresponding permission to allowed.
-	bucket.DenyAll()
+	b.DenyAll()
 
-	for _, b := range aclOutput.Grants {
-		if b.Grantee != nil && b.Grantee.Type == "Group" && *b.Grantee.URI == groups.AllUsersGroup {
-			switch b.Permission {
+	for _, g := range aclOutput.Grants {
+		if g.Grantee != nil && g.Grantee.Type == "Group" && *g.Grantee.URI == groups.AllUsersGroup {
+			switch g.Permission {
 			case types.PermissionRead:
-				bucket.PermAllUsersRead = PermissionAllowed
+				b.PermAllUsersRead = PermissionAllowed
 			case types.PermissionWrite:
-				bucket.PermAllUsersWrite = PermissionAllowed
+				b.PermAllUsersWrite = PermissionAllowed
 			case types.PermissionReadAcp:
-				bucket.PermAllUsersReadACL = PermissionAllowed
+				b.PermAllUsersReadACL = PermissionAllowed
 			case types.PermissionWriteAcp:
-				bucket.PermAllUsersWriteACL = PermissionAllowed
+				b.PermAllUsersWriteACL = PermissionAllowed
 			case types.PermissionFullControl:
-				bucket.PermAllUsersFullControl = PermissionAllowed
+				b.PermAllUsersFullControl = PermissionAllowed
 			default:
 				break
 			}
 		}
-		if b.Grantee != nil && b.Grantee.Type == "Group" && *b.Grantee.URI == groups.AuthUsersGroup {
-			switch b.Permission {
+		if g.Grantee != nil && g.Grantee.Type == "Group" && *g.Grantee.URI == groups.AuthUsersGroup {
+			switch g.Permission {
 			case types.PermissionRead:
-				bucket.PermAuthUsersRead = PermissionAllowed
+				b.PermAuthUsersRead = PermissionAllowed
 			case types.PermissionWrite:
-				bucket.PermAuthUsersWrite = PermissionAllowed
+				b.PermAuthUsersWrite = PermissionAllowed
 			case types.PermissionReadAcp:
-				bucket.PermAuthUsersReadACL = PermissionAllowed
+				b.PermAuthUsersReadACL = PermissionAllowed
 			case types.PermissionWriteAcp:
-				bucket.PermAuthUsersWriteACL = PermissionAllowed
+				b.PermAuthUsersWriteACL = PermissionAllowed
 			case types.PermissionFullControl:
-				bucket.PermAuthUsersFullControl = PermissionAllowed
+				b.PermAuthUsersFullControl = PermissionAllowed
 			default:
 				break
 			}
@@ -230,9 +230,8 @@ func (bucket *Bucket) ParseAclOutputv2(aclOutput *s3.GetBucketAclOutput) error {
 func Permission(canDo bool) uint8 {
 	if canDo {
 		return PermissionAllowed
-	} else {
-		return PermissionDenied
 	}
+	return PermissionDenied
 }
 
 func IsValidS3BucketName(bucketName string) bool {

bucket/bucket_test.go

@@ -246,8 +246,9 @@ func TestBucket_ParseAclOutputv2(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t2 *testing.T) {
+			t2.Parallel()
 			b := NewBucket("mytestbucket")
-			err := b.ParseAclOutputv2(&tt.acl)
+			err := b.ParseACLOutputV2(&tt.acl)
 			assert.Nil(t2, err)
 
 			for grantee, perms := range tt.expectedAllowed {
@@ -382,8 +383,8 @@ func TestBucket_String(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t2 *testing.T) {
+			t2.Parallel()
 			assert.Equal(t2, tt.string, tt.bucket.String())
 		})
 	}
-
 }

cmd/mqingest/mqingest.go

@@ -33,15 +33,15 @@ type BucketMessage struct {
 func main() {
 	var filename string
 	var url string
-	var queue_name string
+	var queueName string
 
 	flag.StringVar(&filename, "file", "", "File name of buckets to send to MQ")
 	flag.StringVar(&url, "url", "amqp://guest:guest@localhost:5672/", "AMQP URI of RabbitMQ server")
-	flag.StringVar(&queue_name, "queue", "", "Name of message queue to publish buckets to")
+	flag.StringVar(&queueName, "queue", "", "Name of message queue to publish buckets to")
 
 	flag.Parse()
 
-	if filename == "" || queue_name == "" {
+	if filename == "" || queueName == "" {
 		fmt.Println("Flags 'file' and 'queue' are required")
 		printUsage()
 		os.Exit(1)
@@ -56,16 +56,16 @@ func main() {
 	defer ch.Close()
 
 	// Declare dead letter queue
-	dlq, dlErr := ch.QueueDeclare(queue_name+"_dead", true, false, false,
+	dlq, dlErr := ch.QueueDeclare(queueName+"_dead", true, false, false,
 		false, nil)
 	failOnError(dlErr, "Failed to declare dead letter queue")
 
 	q, err := ch.QueueDeclare(
-		queue_name, // name
-		true,       // durable
-		false,      // delete when unused
-		false,      // exclusive
-		false,      // no-wait
+		queueName, // name
+		true,      // durable
+		false,     // delete when unused
+		false,     // exclusive
+		false,     // no-wait
 		amqp.Table{
 			"x-dead-letter-exchange":    "",
 			"x-dead-letter-routing-key": dlq.Name,
@@ -112,12 +112,11 @@ func main() {
 		if err != nil {
 			failOnError(err, "Failed to publish to channel")
 		}
-		msgsPublished += 1
+		msgsPublished++
 	}
 	if err := fileScanner.Err(); err != nil {
 		failOnError(err, "fileScanner failed")
 	}
 
-	log.Printf("%v bucket names published to queue %v\n", msgsPublished, queue_name)
-
+	log.Printf("%v bucket names published to queue %v\n", msgsPublished, queueName)
 }

cmd/regioncheck/regioncheck.go

@@ -45,35 +45,35 @@ func GetRegionsDO() ([]string, error) {
 	}
 
 	regions := []string{}
-	doc.Find("h3#other-products + table thead tr th").Each(func(i int, t *goquery.Selection) {
+	doc.Find("h3#other-products + table thead tr th").Each(func(_ int, t *goquery.Selection) {
 		regions = append(regions, t.Text())
 	})
 
-	spaces_supported := []bool{}
-	doc.Find("h3#other-products + table tbody tr").Each(func(i int, t *goquery.Selection) {
+	spacesSupported := []bool{}
+	doc.Find("h3#other-products + table tbody tr").Each(func(_ int, t *goquery.Selection) {
 		// For each row, check the first cell for a value of "Spaces"
 		rowHeader := t.Find("td").First().Text()
 		if rowHeader == "Spaces" {
 			// For each cell in the "Spaces" row, check if the contents are not empty - meaning Spaces is supported
-			t.Find("td").Each(func(j int, v *goquery.Selection) {
+			t.Find("td").Each(func(_ int, v *goquery.Selection) {
 				supported := v.Text() != ""
-				spaces_supported = append(spaces_supported, supported)
+				spacesSupported = append(spacesSupported, supported)
 			})
 		}
 	})
 
-	supported_regions := []string{}
+	supportedRegions := []string{}
 	for i := 0; i < len(regions); i++ {
 		if regions[i] == "Product" {
 			continue
 		}
-		if spaces_supported[i] {
-			supported_regions = append(supported_regions, strings.ToLower(regions[i]))
+		if spacesSupported[i] {
+			supportedRegions = append(supportedRegions, strings.ToLower(regions[i]))
 		}
 	}
 
 	// Return slice of region names
-	return supported_regions, nil
+	return supportedRegions, nil
 }
 
 // GetRegionsLinode fetches region names from Linode docs HTML page. Linode also provides this info via
@@ -105,7 +105,7 @@ func GetRegionsLinode() ([]string, error) {
 	}
 
 	regions := []string{}
-	doc.Find(".rdmd-table:nth-of-type(1) tbody tr td:nth-of-type(2)").Each(func(i int, t *goquery.Selection) {
+	doc.Find(".rdmd-table:nth-of-type(1) tbody tr td:nth-of-type(2)").Each(func(_ int, t *goquery.Selection) {
 		regions = append(regions, t.Text())
 	})
 
@@ -152,7 +152,7 @@ func main() {
 	for name, get := range p {
 		name := name
 		get := get
-		go func(w *sync.WaitGroup) {
+		go func(_ *sync.WaitGroup) {
 			results[name], errors[name] = get()
 			wg.Done()
 		}(&wg)