house cleaning: smaller optimizations

Author: rtfmkiesel

pkg/checksums/filewalker.go

@@ -8,10 +8,10 @@ import (
 )
 
 // Will recursively walk and send filepaths from root, who are smaller than sizeLimit to filepaths
-func DirectoryWalker(root string, sizeLimit int, filepaths chan<- string) (err error) {
-	logger.Info("Checking %s", root)
+func DirectoryWalker(root string, sizeLimit int, filepaths chan<- string) error {
+	logger.Debug("Checking %s", root)
 
-	err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			// Ignore a file if we get "Access is denied" error
 			if os.IsPermission(err) {

pkg/checksums/runner.go

@@ -17,55 +17,35 @@ type Result struct {
 func Runner(wg *sync.WaitGroup, filepaths <-chan string, results chan<- *Result, silenceErrors bool) {
 	defer wg.Done()
 
+	hashFuncs := []struct {
+		name string
+		fn   func(string) (string, error)
+	}{
+		{"SHA1", calcSHA1},
+		{"SHA256", calcSHA256},
+		{"MD5", calcMD5},
+	}
+
 	for filepath := range filepaths {
 		// The order of the hash checks was choosen based on the amount of hashes upon writing this bit
 		// SHA1 > SHA2 > MD5
 
-		sha1, err := calcSHA1(filepath)
-		if err != nil && !silenceErrors {
-			logger.Error(err)
-			continue
-		} else {
-			matched, driver := loldrivers.MatchHash(sha1)
-			if matched {
-				results <- &Result{
-					Filepath: filepath,
-					Checksum: sha1,
-					Driver:   driver,
+		for _, hash := range hashFuncs {
+			checksum, err := hash.fn(filepath)
+			if err != nil {
+				if !silenceErrors {
+					logger.Errorf("Error calculating %s for %s: %v", hash.name, filepath, err)
 				}
-
-				continue // No need to check others as there was a match
+				continue
 			}
-		}
-
-		sha256, err := calcSHA256(filepath)
-		if err != nil && !silenceErrors {
-			logger.Error(err)
-			continue
-		} else {
-			matched, driver := loldrivers.MatchHash(sha256)
-			if matched {
-				results <- &Result{
-					Filepath: filepath,
-					Checksum: sha256,
-					Driver:   driver,
-				}
-
-				continue // No need to check others as there was a match
-			}
-		}
 
-		md5, err := calcMD5(filepath)
-		if err != nil && !silenceErrors {
-			logger.Error(err)
-		} else {
-			matched, driver := loldrivers.MatchHash(md5)
-			if matched {
+			if matched, driver := loldrivers.MatchHash(checksum); matched {
 				results <- &Result{
 					Filepath: filepath,
-					Checksum: md5,
+					Checksum: checksum,
 					Driver:   driver,
 				}
+				break // Found a match, skip remaining hashes
 			}
 		}
 	}

pkg/loldrivers/loldrivers.go

@@ -1,6 +1,7 @@
 package loldrivers
 
 import (
+	"fmt"
 	"io"
 	"net/http"
 	"os"
@@ -9,41 +10,26 @@ import (
 )
 
 // Will load the drivers based on the selected mode (online, local (requires filePath), internal)
-func LoadDrivers(mode string, filePath string) (err error) {
-	var jsonData []byte
+func LoadDrivers(mode string, filePath string) error {
+	var (
+		jsonData []byte
+		err      error
+	)
 
 	switch mode {
 	case "online":
 		jsonData, err = downloadNewestData()
-		if err != nil {
-			logger.Error(err)
-			jsonData = internalDrivers // Fallback
-		}
-
 	case "local":
-		jsonData, err = func() (b []byte, err error) {
-			// Read the local .json file
-			fp, err := os.Open(filePath) // #nosec G304
-			if err != nil {
-				return nil, err
-			}
-			defer fp.Close()
-
-			b, err = io.ReadAll(fp)
-			if err != nil {
-				return nil, err
-			}
-
-			return b, nil
-		}()
-
-		if err != nil {
-			logger.Error(err)
-			jsonData = internalDrivers // Fallback
-		}
-
+		jsonData, err = os.ReadFile(filePath) // #nosec G304
 	case "internal":
-		// Use the built in ones
+		jsonData = internalDrivers
+	default:
+		return fmt.Errorf("invalid mode: %s", mode)
+	}
+
+	if err != nil {
+		logger.Error(err)
+		logger.Debug("Falling back to internal drivers")
 		jsonData = internalDrivers
 	}
 
@@ -55,7 +41,7 @@ func LoadDrivers(mode string, filePath string) (err error) {
 }
 
 // Will return true and a pointer to the matching driver, else return false and nil
-func MatchHash(hash string) (matched bool, match *Driver) {
+func MatchHash(hash string) (bool, *Driver) {
 	switch len(hash) {
 	case 32:
 		if driver := md5Sums[hash]; driver != nil {
@@ -74,9 +60,9 @@ func MatchHash(hash string) (matched bool, match *Driver) {
 	return false, nil
 }
 
-// Downloads the newset driver set from the loldrivers API
+// Downloads the newset driver set from the loldrivers.io API
 func downloadNewestData() ([]byte, error) {
-	logger.Info("Downloading the newest data set")
+	logger.Debug("Downloading the newest data set")
 
 	client := &http.Client{}
 	request, err := http.NewRequest("GET", "https://www.loldrivers.io/api/drivers.json", nil)

pkg/options/options.go

@@ -4,8 +4,9 @@ import (
 	"errors"
 	"time"
 
-	"github.com/rtfmkiesel/loldrivers-client/pkg/logger"
 	flag "github.com/spf13/pflag"
+
+	"github.com/rtfmkiesel/loldrivers-client/pkg/logger"
 )
 
 var (
@@ -25,28 +26,28 @@ type Options struct {
 }
 
 // Parse the command line options into an Options struct
-func Parse() (opt *Options, err error) {
-	opt = &Options{}
-	opt.StartTime = time.Now()
+func Parse() (*Options, error) {
+	opt := &Options{
+		StartTime: time.Now(),
+	}
+
+	var (
+		flagDir      string
+		flagGrepable bool
+		flagJson     bool
+	)
 
 	flag.StringVarP(&opt.Mode, "mode", "m", "online", "Operating Mode {online, local, internal}")
 	flag.StringVarP(&opt.ModeLocalFilePath, "driver-file", "f", "", "File path to 'drivers.json', when mode == local")
-
-	var flagDir string
 	flag.StringVarP(&flagDir, "scan-dir", "d", "", "Directory to scan for drivers (default: Windows driver folders)")
 	flag.IntVarP(&opt.ScanSizeLimit, "scan-size", "l", 10, "Size limit for files to scan in MB")
 	flag.IntVarP(&opt.ScanWorkers, "workers", "w", 20, "Number of checksum \"threads\" to spawn")
 	flag.BoolVarP(&opt.ScanShowErrors, "surpress-errors", "s", false, "Do not show file read errors when calculating checksums")
-
-	var flagGrepable bool
-	var flagJson bool
 	flag.BoolVarP(&flagGrepable, "grepable", "g", false, "Will only output found files for easy parsing")
 	flag.BoolVarP(&flagJson, "json", "j", false, "Format output as JSON")
 
 	flag.Parse()
 
-	logger.Verbose = true
-
 	switch opt.Mode {
 	case "online", "internal":
 		// we good
@@ -61,20 +62,25 @@ func Parse() (opt *Options, err error) {
 	// Only one output style
 	if flagGrepable && flagJson {
 		return nil, errors.New("only use '-g/--grepable' or '-j/--json', not both")
-	} else if flagGrepable {
+	}
+
+	switch {
+	case flagGrepable:
 		opt.OutputMode = "grep"
-		logger.Verbose = false
-	} else if flagJson {
+		logger.ShowDebugOutput = false
+	case flagJson:
 		opt.OutputMode = "json"
-		logger.Verbose = false
+		logger.ShowDebugOutput = false
+	default:
+		logger.ShowDebugOutput = true
 	}
 
-	if flagDir == "" {
+	if flagDir != "" {
+		// User specified a custom folder to scan
+		opt.ScanDirectories = []string{flagDir}
+	} else {
 		// User did not specify a path with '-d', use the default Windows directories
 		opt.ScanDirectories = windowsDriverDirs
-	} else {
-		// User specified a custom folder to scan
-		opt.ScanDirectories = append(opt.ScanDirectories, flagDir)
 	}
 
 	printBanner()
@@ -83,7 +89,7 @@ func Parse() (opt *Options, err error) {
 }
 
 func printBanner() {
-	logger.PlainStderr(`
+	logger.Stderr(`
   ╔─────────────────────────────────────╗
   │          LOLDrivers-client          │
   │      https://www.loldrivers.io      │