feat: various refactoring

Signed-off-by: Liam Stanley <me@liamstanley.io>

Author: lrstanley

config.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/apex/log"
 	arlo "github.com/jeffreydwalter/arlo-go"
 	"github.com/phayes/permbits"
 	"gopkg.in/AlecAivazis/survey.v1"
@@ -32,26 +33,27 @@ func readConfig(path string) error {
 	}
 
 	if perms := permbits.FileMode(fi.Mode()); perms != 0o600 {
-		logger.Printf("warning: permissions of %q are insecure: %s, please use 0600", path, perms)
+		logger.WithFields(log.Fields{
+			"path": path,
+			"mode": perms,
+		}).Warn("permissions of config file are insecure, please use 0600")
 	}
 
 	b, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
 
-	if err := yaml.Unmarshal(b, conf); err != nil {
+	err = yaml.Unmarshal(b, conf)
+	if err != nil {
 		return err
 	}
 	return nil
 }
 
 type CommandSetup struct{}
 
-func (cmd *CommandSetup) Execute(args []string) error {
-	logger.SetFlags(0)
-	cli.Ensure()
-
+func (cmd *CommandSetup) Execute(_ []string) error {
 login:
 	questions := []*survey.Question{
 		{
@@ -70,23 +72,23 @@ login:
 		return err
 	}
 
-	logger.Println("validating login...")
+	logger.Info("validating login")
 	if _, err = arlo.Login(conf.Username, conf.Password); err != nil {
-		logger.Println(err)
-		logger.Println("please enter new credentials")
+		logger.WithError(err).Error("failed to login, please enter new credentials")
 		goto login
 	}
 
-	f, err := os.OpenFile(cli.ConfigFile, os.O_RDWR|os.O_CREATE, 0o600)
+	f, err := os.OpenFile(cli.Flags.ConfigFile, os.O_RDWR|os.O_CREATE, 0o600)
 	if err != nil {
-		logger.Fatalf("error creating %q: %v", cli.ConfigFile, err)
+		logger.Fatalf("error creating %q: %v", cli.Flags.ConfigFile, err)
 	}
 	defer f.Close()
 
-	if _, err := fmt.Fprintf(f, "---\nusername: %s\npassword: %s\n", conf.Username, conf.Password); err != nil {
-		logger.Fatalf("error writing to %q: %v", cli.ConfigFile, err)
+	_, err = fmt.Fprintf(f, "---\nusername: %s\npassword: %s\n", conf.Username, conf.Password)
+	if err != nil {
+		logger.Fatalf("error writing to %q: %v", cli.Flags.ConfigFile, err)
 	}
-	logger.Printf("successfully wrote %q", cli.ConfigFile)
 
+	logger.WithField("config", cli.Flags.ConfigFile).Info("successfully wrote config")
 	return nil
 }

fetch.go

@@ -11,6 +11,7 @@ import (
 	"text/template"
 	"time"
 
+	"github.com/apex/log"
 	arlo "github.com/jeffreydwalter/arlo-go"
 	sempool "github.com/lrstanley/go-sempool"
 )
@@ -28,42 +29,50 @@ type RecordingTemplate struct {
 }
 
 func fetch() {
-	logger.Printf("logging into arlo with account: %s", conf.Username)
+	logger.WithField("account", conf.Username).Info("logging into arlo")
 	api, err := arlo.Login(conf.Username, conf.Password)
 	if err != nil {
 		logger.Fatalf("failed to login: %s\n", err)
 	}
-	logger.Println("login successful")
+	logger.Info("successfully logged in")
 
 	cmap := make(map[string]*arlo.Camera)
 
-	logger.Println("looking for cameras on account")
+	logger.Info("looking for cameras on account")
 	for i := 0; i < len(api.Cameras); i++ {
-		logger.Printf("found camera %q (id: %s)", api.Cameras[i].DeviceName, api.Cameras[i].DeviceId)
+		logger.WithFields(log.Fields{
+			"name": api.Cameras[i].DeviceName,
+			"id":   api.Cameras[i].DeviceId,
+		}).Info("found camera")
+
 		name := reStripName.ReplaceAllString(api.Cameras[i].DeviceName, "_")
 		name = reTrimUnderscore.ReplaceAllString(name, "_")
 		name = strings.Trim(name, "_")
 		if name != api.Cameras[i].DeviceName {
-			logger.Printf("renaming %q to %q", api.Cameras[i].DeviceName, name)
+			logger.WithFields(log.Fields{
+				"old": api.Cameras[i].DeviceName,
+				"new": name,
+			}).Info("renaming camera")
+
 			api.Cameras[i].DeviceName = name
 		}
 
 		cmap[api.Cameras[i].DeviceId] = &api.Cameras[i]
 	}
 
 	now := time.Now()
-	start := now.Add(-time.Duration(cli.History) * 24 * time.Hour)
+	start := now.Add(-time.Duration(cli.Flags.History) * 24 * time.Hour)
 
-	logger.Println("fetching library")
+	logger.Info("fetching library")
 	library, err := api.GetLibrary(start, now)
 	if err != nil {
-		logger.Fatal(err)
+		logger.WithError(err).Fatal("failed to fetch library")
 	}
-	logger.Printf("successfully fetched library; %d items found", len(*library))
+	logger.WithField("count", len(*library)).Info("successfully fetched library")
 
-	pool := sempool.New(cli.MaxConcurrent)
+	pool := sempool.New(cli.Flags.MaxConcurrent)
 
-	for _, recording := range *library {
+	for _, recording := range *library { // nolint:gocritic
 		pool.Slot()
 
 		go func(r *arlo.Recording) {
@@ -77,34 +86,47 @@ func fetch() {
 			rtmpl.Timestamp = rtmpl.Time.Format("2006.01.02-15.04.05")
 
 			filename := strings.Builder{}
-			tpl := template.Must(template.New("filename").Parse(cli.NameFormat))
-			if err := tpl.Execute(&filename, rtmpl); err != nil {
+			tpl := template.Must(template.New("filename").Parse(cli.Flags.NameFormat))
+
+			err = tpl.Execute(&filename, rtmpl)
+			if err != nil {
 				logger.Fatalf("error executing filename template for recording %q: %v", r.UniqueId, err)
 			}
 
-			fullFn := filepath.Join(cli.OutputDir, filename.String())
+			fullFn := filepath.Join(cli.Flags.OutputDir, filename.String())
 
-			if err := os.MkdirAll(filepath.Dir(fullFn), 0o755); err != nil {
+			err = os.MkdirAll(filepath.Dir(fullFn), 0o755)
+			if err != nil {
 				logger.Fatalf("error creating dir %q: %v", filepath.Dir(fullFn), err)
 			}
 
-			if _, err := os.Stat(fullFn); err == nil {
-				logger.Printf("skipping %s/%s, already downloaded", rtmpl.Camera.DeviceName, r.Name)
+			_, err = os.Stat(fullFn)
+			if err == nil {
+				logger.WithFields(log.Fields{
+					"camera": rtmpl.Camera.DeviceName,
+					"name":   r.Name,
+				}).Info("skipping, already downloaded")
 				return
 			}
 
-			f, err := os.Create(fullFn)
+			var f *os.File
+			f, err = os.Create(fullFn)
 			if err != nil {
-				logger.Fatal(err)
+				logger.WithError(err).Fatal("failed to create file")
 			}
 			defer f.Close()
 
-			logger.Printf("streaming recording %s/%s to file: %q", rtmpl.Camera.DeviceName, r.Name, fullFn)
-			if err := api.DownloadFile(r.PresignedContentUrl, f); err != nil {
-				logger.Fatal(err)
+			logger.WithFields(log.Fields{
+				"camera": rtmpl.Camera.DeviceName,
+				"name":   r.Name,
+			}).Info("downloading")
+
+			err = api.DownloadFile(r.PresignedContentUrl, f)
+			if err != nil {
+				logger.WithError(err).Fatal("failed to download file")
 			}
-			logger.Printf("finished downloading %q", r.Name)
-		}(&recording)
+			logger.WithField("name", r.Name).Info("finished downloading")
+		}(&recording) // nolint:gosec
 	}
 
 	pool.Wait()

main.go

@@ -4,69 +4,66 @@
 package main
 
 import (
-	"fmt"
-	"io"
-	"log"
-	"os"
 	"os/user"
 	"path/filepath"
 
-	flags "github.com/jessevdk/go-flags"
+	"github.com/apex/log"
+	"github.com/lrstanley/clix"
 )
 
-var (
+const (
 	version = "master"
 	commit  = "latest"
 	date    = "-"
+)
 
-	cli    = &Flags{}
-	logger = log.New(os.Stdout, "", log.LstdFlags)
+var (
+	logger log.Interface
+	cli    = &clix.CLI[Flags]{
+		Links: clix.GithubLinks("github.com/lrstanley/arlo-dl", "master", "https://liam.sh"),
+		VersionInfo: &clix.VersionInfo[Flags]{
+			Version: version,
+			Commit:  commit,
+			Date:    date,
+		},
+	}
 )
 
 type Flags struct {
 	ConfigFile    string `short:"c" long:"config-file" description:"configuration file (see 'arlo-dl setup', default: $HOME/.arlo-dl.yaml)"`
 	OutputDir     string `short:"o" long:"output-dir" description:"location to store recordings" default:"arlo-recordings"`
 	History       int    `long:"history" description:"how many days back to download" default:"14"`
-	Quiet         bool   `short:"q" long:"quiet" description:"don't log to stdout"`
-	VersionFlag   bool   `short:"v" long:"version" description:"display the version of arlo-dl and exit"`
 	MaxConcurrent int    `short:"C" long:"max-concurrent" description:"maximum amount of recordings to download concurrently" default:"2"`
 	NameFormat    string `short:"f" long:"name-format" description:"go-template format for the file name" default:"{{.Camera.DeviceName}}/{{.Time.Year}}/{{.Time.Month}}/{{.Timestamp}}-{{.Recording.Name}}.mp4"`
 
 	CommandSetup CommandSetup `command:"setup" description:"generate a config for use with arlo-dl"`
 }
 
 func (f *Flags) Ensure() {
-	if cli.Quiet {
-		logger.SetOutput(io.Discard)
-	}
-
-	if cli.ConfigFile == "" {
+	if cli.Flags.ConfigFile == "" {
 		usr, err := user.Current()
 		if err != nil {
-			logger.Fatal(err)
+			logger.WithError(err).Fatal("failed to get current user")
 		}
-		cli.ConfigFile = filepath.Join(usr.HomeDir, ".arlo-dl.yaml")
+		cli.Flags.ConfigFile = filepath.Join(usr.HomeDir, ".arlo-dl.yaml")
 	}
 }
 
 func main() {
-	var err error
-	parser := flags.NewParser(cli, flags.HelpFlag)
-	parser.SubcommandsOptional = true
-	if _, err = parser.Parse(); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
+	cli.LoggerConfig.Pretty = true
+	_ = cli.ParseWithInit(func() error {
+		logger = cli.Logger
+		cli.Flags.Ensure()
 
-	cli.Ensure()
+		return nil
+	}, clix.OptSubcommandsOptional)
 
-	if parser.Active != nil {
-		os.Exit(0)
-	}
+	logger = cli.Logger
+	cli.Flags.Ensure()
 
-	logger.Printf("reading config at %q", cli.ConfigFile)
-	if err = readConfig(cli.ConfigFile); err != nil {
-		logger.Fatalf("error reading config: %v", err)
+	logger.WithField("config", cli.Flags.ConfigFile).Info("reading config")
+	if err := readConfig(cli.Flags.ConfigFile); err != nil {
+		logger.WithError(err).Fatal("failed to read config")
 	}
 
 	fetch()