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/manager/manager_tasks.go

@@ -163,7 +163,9 @@ func (s *singleton) Generate(ctx context.Context, input models.GenerateMetadataI
 	if err := s.validateFFMPEG(); err != nil {
 		return 0, err
 	}
-	instance.Paths.Generated.EnsureTmpDir()
+	if err := instance.Paths.Generated.EnsureTmpDir(); err != nil {
+		logger.Warnf("could not generate temporary directory: %v", err)
+	}
 
 	sceneIDs, err := utils.StringSliceToIntSlice(input.SceneIDs)
 	if err != nil {
@@ -250,14 +252,18 @@ func (s *singleton) Generate(ctx context.Context, input models.GenerateMetadataI
 
 		// Start measuring how long the generate has taken. (consider moving this up)
 		start := time.Now()
-		instance.Paths.Generated.EnsureTmpDir()
+		if err = instance.Paths.Generated.EnsureTmpDir(); err != nil {
+			logger.Warnf("could not create temprary directory: %v", err)
+		}
 
 		for _, scene := range scenes {
 			progress.Increment()
 			if job.IsCancelled(ctx) {
 				logger.Info("Stopping due to user request")
 				wg.Wait()
-				instance.Paths.Generated.EmptyTmpDir()
+				if err := instance.Paths.Generated.EmptyTmpDir(); err != nil {
+					logger.Warnf("failure emptying temporary directory: %v", err)
+				}
 				return
 			}
 
@@ -340,7 +346,9 @@ func (s *singleton) Generate(ctx context.Context, input models.GenerateMetadataI
 			if job.IsCancelled(ctx) {
 				logger.Info("Stopping due to user request")
 				wg.Wait()
-				instance.Paths.Generated.EmptyTmpDir()
+				if err := instance.Paths.Generated.EmptyTmpDir(); err != nil {
+					logger.Warnf("failure emptying temporary directory: %v", err)
+				}
 				elapsed := time.Since(start)
 				logger.Info(fmt.Sprintf("Generate finished (%s)", elapsed))
 				return
@@ -365,7 +373,9 @@ func (s *singleton) Generate(ctx context.Context, input models.GenerateMetadataI
 
 		wg.Wait()
 
-		instance.Paths.Generated.EmptyTmpDir()
+		if err = instance.Paths.Generated.EmptyTmpDir(); err != nil {
+			logger.Warnf("failure emptying temporary directory: %v", err)
+		}
 		elapsed := time.Since(start)
 		logger.Info(fmt.Sprintf("Generate finished (%s)", elapsed))
 	})
@@ -383,7 +393,9 @@ func (s *singleton) GenerateScreenshot(ctx context.Context, sceneId string, at f
 
 // generate default screenshot if at is nil
 func (s *singleton) generateScreenshot(ctx context.Context, sceneId string, at *float64) int {
-	instance.Paths.Generated.EnsureTmpDir()
+	if err := instance.Paths.Generated.EnsureTmpDir(); err != nil {
+		logger.Warnf("failure generating screenshot: %v", err)
+	}
 
 	j := job.MakeJobExec(func(ctx context.Context, progress *job.Progress) {
 		sceneIdInt, err := strconv.Atoi(sceneId)