Apply linter autofixes: internal/vaultik (refs #61)

internal/vaultik/prune.go

@@ -2,6 +2,7 @@ package vaultik
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -23,20 +24,24 @@ type PruneOptions struct {
 // confirming with the user.
 func (v *Vaultik) NukeRemote(force bool) error {
 	if !force {
-		return fmt.Errorf("nuke requires --force (this deletes ALL remote snapshots and blobs)")
+		return errors.New("nuke requires --force (this deletes ALL remote snapshots and blobs)")
 	}
 
 	v.UI.Begin("Removing all snapshot metadata from backup destination store.")
+
 	if _, err := v.RemoveAllSnapshots(&RemoveOptions{Force: true}); err != nil {
 		return fmt.Errorf("removing all snapshots: %w", err)
 	}
 
 	v.UI.Begin("Removing any blobs still present in backup destination store.")
-	if err := v.PruneBlobs(&PruneOptions{Force: true}); err != nil {
+
+	err := v.PruneBlobs(&PruneOptions{Force: true})
+	if err != nil {
 		return fmt.Errorf("pruning blobs: %w", err)
 	}
 
 	v.UI.Complete("Backup destination store is now empty.")
+
 	return nil
 }
 
@@ -55,7 +60,8 @@ type PruneBlobsResult struct {
 // prefer this method over PruneDatabase or PruneBlobs individually
 // unless it specifically wants one half.
 func (v *Vaultik) Prune(opts *PruneOptions) error {
-	if err := v.EnsureStorageBinding(); err != nil {
+	err := v.EnsureStorageBinding()
+	if err != nil {
 		return err
 	}
 	// First reconcile local snapshot records against remote metadata:
@@ -63,12 +69,15 @@ func (v *Vaultik) Prune(opts *PruneOptions) error {
 	// store is treated as gone. This used to be the separate 'snapshot
 	// cleanup' command and is now folded in so a single 'vaultik prune'
 	// gets the local index fully back in sync with the destination.
-	if err := v.CleanupLocalSnapshots(); err != nil {
+	err = v.CleanupLocalSnapshots()
+	if err != nil {
 		return fmt.Errorf("reconciling local snapshots with remote: %w", err)
 	}
+
 	if _, err := v.PruneDatabase(); err != nil {
 		return fmt.Errorf("pruning local database: %w", err)
 	}
+
 	return v.PruneBlobs(opts)
 }
 
@@ -92,27 +101,35 @@ func (v *Vaultik) PruneBlobs(opts *PruneOptions) error {
 
 	if len(unreferencedBlobs) == 0 {
 		log.Info("No unreferenced blobs found")
+
 		if opts.JSON {
 			return v.outputPruneBlobsJSON(result)
 		}
+
 		v.printlnStdout("No unreferenced blobs to remove.")
+
 		return nil
 	}
 
 	log.Info("Found unreferenced blobs", "count", len(unreferencedBlobs), "total_size", humanize.Bytes(uint64(totalSize)))
+
 	if !opts.JSON {
 		v.printfStdout("Found %d unreferenced blob(s) totaling %s\n", len(unreferencedBlobs), humanize.Bytes(uint64(totalSize)))
 	}
 
 	if !opts.Force && !opts.JSON {
 		v.printfStdout("\nDelete %d unreferenced blob(s)? [y/N] ", len(unreferencedBlobs))
+
 		var confirm string
 		if _, err := v.scanStdin(&confirm); err != nil {
 			v.printlnStdout("Cancelled")
+
 			return nil
 		}
+
 		if strings.ToLower(confirm) != "y" {
 			v.printlnStdout("Cancelled")
+
 			return nil
 		}
 	}
@@ -124,6 +141,7 @@ func (v *Vaultik) PruneBlobs(opts *PruneOptions) error {
 	}
 
 	v.printfStdout("\nDeleted %d blob(s) totaling %s\n", result.BlobsDeleted, humanize.Bytes(uint64(result.BytesFreed)))
+
 	if result.BlobsFailed > 0 {
 		v.printfStdout("Failed to delete %d blob(s)\n", result.BlobsFailed)
 	}
@@ -140,6 +158,7 @@ func (v *Vaultik) collectReferencedBlobs() (map[string]bool, error) {
 	if err != nil {
 		return nil, fmt.Errorf("listing snapshot keys: %w", err)
 	}
+
 	log.Info("Found manifests in remote storage", "count", len(remoteKeys))
 
 	allBlobsReferenced := make(map[string]bool)
@@ -147,18 +166,23 @@ func (v *Vaultik) collectReferencedBlobs() (map[string]bool, error) {
 
 	for _, remoteKey := range remoteKeys {
 		log.Debug("Processing manifest", "remote_key", remoteKey)
+
 		manifest, err := v.downloadManifestByKey(remoteKey)
 		if err != nil {
 			log.Error("Failed to download manifest", "remote_key", remoteKey, "error", err)
+
 			continue
 		}
+
 		for _, blob := range manifest.Blobs {
 			allBlobsReferenced[blob.Hash] = true
 		}
+
 		manifestCount++
 	}
 
 	log.Info("Processed manifests", "count", manifestCount, "unique_blobs_referenced", len(allBlobsReferenced))
+
 	return allBlobsReferenced, nil
 }
 
@@ -166,12 +190,14 @@ func (v *Vaultik) collectReferencedBlobs() (map[string]bool, error) {
 func (v *Vaultik) listUniqueSnapshotIDs() ([]string, error) {
 	objectCh := v.Storage.ListStream(v.ctx, "metadata/")
 	seen := make(map[string]bool)
+
 	var snapshotIDs []string
 
 	for object := range objectCh {
 		if object.Err != nil {
 			return nil, fmt.Errorf("listing metadata objects: %w", object.Err)
 		}
+
 		parts := strings.Split(object.Key, "/")
 		if len(parts) >= 2 && parts[0] == "metadata" && parts[1] != "" {
 			if strings.HasSuffix(object.Key, "/") || strings.Contains(object.Key, "/manifest.json.zst") {
@@ -183,12 +209,14 @@ func (v *Vaultik) listUniqueSnapshotIDs() ([]string, error) {
 			}
 		}
 	}
+
 	return snapshotIDs, nil
 }
 
 // listAllRemoteBlobs returns a map of all blob hashes to their sizes in remote storage
 func (v *Vaultik) listAllRemoteBlobs() (map[string]int64, error) {
 	log.Info("Listing all blobs in storage")
+
 	allBlobs := make(map[string]int64)
 	blobObjectCh := v.Storage.ListStream(v.ctx, "blobs/")
 
@@ -196,6 +224,7 @@ func (v *Vaultik) listAllRemoteBlobs() (map[string]int64, error) {
 		if object.Err != nil {
 			return nil, fmt.Errorf("listing blobs: %w", object.Err)
 		}
+
 		parts := strings.Split(object.Key, "/")
 		if len(parts) == 4 && parts[0] == "blobs" {
 			allBlobs[parts[3]] = object.Size
@@ -203,19 +232,24 @@ func (v *Vaultik) listAllRemoteBlobs() (map[string]int64, error) {
 	}
 
 	log.Info("Found blobs in storage", "count", len(allBlobs))
+
 	return allBlobs, nil
 }
 
 // findUnreferencedBlobs returns blob hashes not referenced by any manifest and their total size
 func (v *Vaultik) findUnreferencedBlobs(allBlobs map[string]int64, referenced map[string]bool) ([]string, int64) {
-	var unreferenced []string
-	var totalSize int64
+	var (
+		unreferenced []string
+		totalSize    int64
+	)
+
 	for hash, size := range allBlobs {
 		if !referenced[hash] {
 			unreferenced = append(unreferenced, hash)
 			totalSize += size
 		}
 	}
+
 	return unreferenced, totalSize
 }
 
@@ -226,8 +260,10 @@ func (v *Vaultik) deleteUnreferencedBlobs(unreferencedBlobs []string, allBlobs m
 	for i, hash := range unreferencedBlobs {
 		blobPath := fmt.Sprintf("blobs/%s/%s/%s", hash[:2], hash[2:4], hash)
 
-		if err := v.Storage.Delete(v.ctx, blobPath); err != nil {
+		err := v.Storage.Delete(v.ctx, blobPath)
+		if err != nil {
 			log.Error("Failed to delete blob", "hash", hash, "error", err)
+
 			continue
 		}
 
@@ -256,5 +292,6 @@ func (v *Vaultik) deleteUnreferencedBlobs(unreferencedBlobs []string, allBlobs m
 func (v *Vaultik) outputPruneBlobsJSON(result *PruneBlobsResult) error {
 	encoder := json.NewEncoder(v.Stdout)
 	encoder.SetIndent("", "  ")
+
 	return encoder.Encode(result)
 }