Errcheck phase 1 (#1715)

* Avoid redundant logging in migrations

Return the error and let the caller handle the logging of the error if
needed.

While here, defer m.Close() to the function boundary.

* Treat errors as values

Use %v rather than %s and pass the errors directly.

* Generate a wrapped error on stat-failure

* Log 3 unchecked errors

Rather than ignore errors, log them at
the WARNING log level.

The server has been functioning without these, so assume they are not at
the ERROR level.

* Propagate errors upward

Failure in path generation was ignored. Propagate the errors upward the
call stack, so it can be handled at the level of orchestration.

* Warn on errors

Log errors rather than quenching them.

Errors are logged at the Warn-level for now.

* Check error when creating test databases

Use the builtin log package and stop the program fatally on error.

* Add warnings to uncheck task errors

Focus on the task system in a single commit, logging unchecked
errors as warnings.

* Warn-on-error in API routes

Look through the API routes, and make sure errors are being logged if
they occur. Prefer the Warn-log-level because none of these has proven
to be fatal in the system up until now.

* Propagate error when adding Util API

* Propagate error on adding util API

* Return unhandled error

* JS log API: propagate and log errors

* JS Plugins: log GQL addition failures.

* Warn on failure to write to stdin

* Warn on failure to stop task

* Wrap viper.BindEnv

The current viper code only errors if no name is provided, so it should
never fail. Rewrite the code flow to factor through a panic-function.

This removes error warnings from this part of the code.

* Log errors in concurrency test

If we can't initialize the configuration, treat the test as a failure.

* Warn on errors in configuration code

* Plug an unchecked error in gallery zip walking

* Warn on screenshot serving failure

* Warn on encoder screenshot failure

* Warn on errors in path-handling code

* Undo the errcheck on configurations for now.

* Use one-line initializers where applicable

rather than using

  err := f()
  if err!= nil { ..

prefer the shorter

  if err := f(); err != nil { ..

If f() isn't too long of a name, or wraps a function with a body.

pkg/plugin/js.go

@@ -2,6 +2,7 @@ package plugin
 
 import (
 	"errors"
+	"fmt"
 	"path/filepath"
 	"sync"
 
@@ -71,10 +72,21 @@ func (t *jsPluginTask) Start() error {
 		return err
 	}
 
-	t.vm.Set("input", t.input)
-	js.AddLogAPI(t.vm, t.progress)
-	js.AddUtilAPI(t.vm)
-	js.AddGQLAPI(t.vm, t.input.ServerConnection.SessionCookie, t.gqlHandler)
+	if err := t.vm.Set("input", t.input); err != nil {
+		return fmt.Errorf("error setting input: %w", err)
+	}
+
+	if err := js.AddLogAPI(t.vm, t.progress); err != nil {
+		return fmt.Errorf("error adding log API: %w", err)
+	}
+
+	if err := js.AddUtilAPI(t.vm); err != nil {
+		return fmt.Errorf("error adding util API: %w", err)
+	}
+
+	if err := js.AddGQLAPI(t.vm, t.input.ServerConnection.SessionCookie, t.gqlHandler); err != nil {
+		return fmt.Errorf("error adding GraphQL API: %w", err)
+	}
 
 	t.vm.Interrupt = make(chan func(), 1)
 

pkg/plugin/js/gql.go

@@ -103,9 +103,15 @@ func gqlRequestFunc(vm *otto.Otto, cookie *http.Cookie, gqlHandler http.Handler)
 	}
 }
 
-func AddGQLAPI(vm *otto.Otto, cookie *http.Cookie, gqlHandler http.Handler) {
+func AddGQLAPI(vm *otto.Otto, cookie *http.Cookie, gqlHandler http.Handler) error {
 	gql, _ := vm.Object("({})")
-	gql.Set("Do", gqlRequestFunc(vm, cookie, gqlHandler))
+	if err := gql.Set("Do", gqlRequestFunc(vm, cookie, gqlHandler)); err != nil {
+		return fmt.Errorf("unable to set GraphQL Do function: %w", err)
+	}
 
-	vm.Set("gql", gql)
+	if err := vm.Set("gql", gql); err != nil {
+		return fmt.Errorf("unable to set gql: %w", err)
+	}
+
+	return nil
 }

pkg/plugin/js/log.go

@@ -2,6 +2,7 @@ package js
 
 import (
 	"encoding/json"
+	"fmt"
 	"math"
 
 	"github.com/robertkrimen/otto"
@@ -64,14 +65,29 @@ func logProgressFunc(c chan float64) func(call otto.FunctionCall) otto.Value {
 	}
 }
 
-func AddLogAPI(vm *otto.Otto, progress chan float64) {
+func AddLogAPI(vm *otto.Otto, progress chan float64) error {
 	log, _ := vm.Object("({})")
-	log.Set("Trace", logTrace)
-	log.Set("Debug", logDebug)
-	log.Set("Info", logInfo)
-	log.Set("Warn", logWarn)
-	log.Set("Error", logError)
-	log.Set("Progress", logProgressFunc(progress))
+	if err := log.Set("Trace", logTrace); err != nil {
+		return fmt.Errorf("error setting Trace: %w", err)
+	}
+	if err := log.Set("Debug", logDebug); err != nil {
+		return fmt.Errorf("error setting Debug: %w", err)
+	}
+	if err := log.Set("Info", logInfo); err != nil {
+		return fmt.Errorf("error setting Info: %w", err)
+	}
+	if err := log.Set("Warn", logWarn); err != nil {
+		return fmt.Errorf("error setting Warn: %w", err)
+	}
+	if err := log.Set("Error", logError); err != nil {
+		return fmt.Errorf("error setting Error: %w", err)
+	}
+	if err := log.Set("Progress", logProgressFunc(progress)); err != nil {
+		return fmt.Errorf("error setting Progress: %v", err)
+	}
+	if err := vm.Set("log", log); err != nil {
+		return fmt.Errorf("unable to set log: %w", err)
+	}
 
-	vm.Set("log", log)
+	return nil
 }

pkg/plugin/js/util.go

@@ -1,6 +1,7 @@
 package js
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/robertkrimen/otto"
@@ -14,9 +15,15 @@ func sleepFunc(call otto.FunctionCall) otto.Value {
 	return otto.UndefinedValue()
 }
 
-func AddUtilAPI(vm *otto.Otto) {
+func AddUtilAPI(vm *otto.Otto) error {
 	util, _ := vm.Object("({})")
-	util.Set("Sleep", sleepFunc)
+	if err := util.Set("Sleep", sleepFunc); err != nil {
+		return fmt.Errorf("unable to set sleep func: %w", err)
+	}
 
-	vm.Set("util", util)
+	if err := vm.Set("util", util); err != nil {
+		return fmt.Errorf("unable to set util: %w", err)
+	}
+
+	return nil
 }

pkg/plugin/plugins.go

@@ -219,7 +219,9 @@ func (c Cache) executePostHooks(ctx context.Context, hookType HookTriggerEnum, h
 
 			select {
 			case <-ctx.Done():
-				task.Stop()
+				if err := task.Stop(); err != nil {
+					logger.Warnf("could not stop task: %v", err)
+				}
 				return fmt.Errorf("operation cancelled")
 			case <-c:
 				// task finished normally

pkg/plugin/raw.go

@@ -51,7 +51,9 @@ func (t *rawPluginTask) Start() error {
 		defer stdin.Close()
 
 		inBytes, _ := json.Marshal(t.input)
-		io.WriteString(stdin, string(inBytes))
+		if k, err := io.WriteString(stdin, string(inBytes)); err != nil {
+			logger.Warnf("error writing input to plugins stdin (wrote %v bytes out of %v): %v", k, len(string(inBytes)), err)
+		}
 	}()
 
 	stderr, err := cmd.StderrPipe()