actually set error message for files with aborted imports

importer/fetch_converter.go

@@ -121,24 +121,24 @@ func newFFmpegFetchConverter(job *Job) (c *ffmpegFetchConverter, err error) {
 
 	if c.stdin, err = c.cmd.StdinPipe(); err != nil {
 		c.log.append("stderr", "ERROR opening stdin pipe: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to open stdin pipe for ffmpeg: " + err.Error())
 	}
 
 	var stdout, stderr io.Reader
 	if stdout, err = c.cmd.StdoutPipe(); err != nil {
 		c.log.append("stderr", "ERROR opening stdout pipe: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to open stdout pipe for ffmpeg: " + err.Error())
 	}
 	c.stdout = newConvLogger(c.log, "stdout(ffmpeg)", stdout)
 	if stderr, err = c.cmd.StderrPipe(); err != nil {
 		c.log.append("stderr", "ERROR opening stderr pipe: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to open stderr pipe for ffmpeg: " + err.Error())
 	}
 	c.stderr = newConvLogger(c.log, "stderr(ffmpeg)", stderr)
 
 	if err = c.cmd.Start(); err != nil {
 		c.log.append("stderr", "ERROR starting ffmpeg: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to start ffmpeg: " + err.Error())
 	}
 	return
 }
@@ -187,15 +187,18 @@ func (c *ffmpegFetchConverter) Wait() (loudness interface{}, log JobLog, err err
 	if err = c.cmd.Wait(); err != nil {
 		if exiterr, ok := err.(*exec.ExitError); ok {
 			if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
-				exitcode := status.ExitStatus()
-				c.job.im.dbgLog.Printf("ffmpeg-converter: ffmpeg returned %d", exitcode)
-				c.log.append("stdout", fmt.Sprintf("ffmpeg returned %d", exitcode))
+				info := fmt.Sprintf("ffmpeg returned %d", status.ExitStatus())
+				c.job.im.dbgLog.Printf("ffmpeg-converter: %s", info)
+				c.log.append("stdout", info)
+				if err != nil {
+					err = errors.New(info)
+				}
 				return nil, c.log.log, err
 			}
 		}
-		c.job.im.errLog.Println("ffmpeg-converter: getting exit code of ffmpeg failed:", err)
-		c.log.append("stderr", "ERROR getting exit code of ffmpeg: "+err.Error())
-		return nil, c.log.log, err
+		c.job.im.errLog.Println("ffmpeg-converter: failed get exit code of ffmpeg:", err)
+		c.log.append("stderr", "ERROR failed get exit code of ffmpeg: "+err.Error())
+		return nil, c.log.log, errors.New("failed get exit code of ffmpeg: " + err.Error())
 	}
 
 	c.job.im.dbgLog.Println("ffmpeg-converter: ffmpeg returned 0 (success)")
@@ -203,6 +206,7 @@ func (c *ffmpegFetchConverter) Wait() (loudness interface{}, log JobLog, err err
 
 	if loudness, err = c.fetchLoudnormParams(); err != nil {
 		c.log.append("stderr", "ERROR fetching parameters from ffmpeg loudnorm filter: "+err.Error())
+		err = errors.New("failed to parse output of loudnorm filter: " + err.Error())
 	}
 	return loudness, c.log.log, err
 }

importer/job.go

@@ -71,7 +71,7 @@ func (job *Job) run() error {
 	defer close(job.subC.done)
 
 	if !atomic.CompareAndSwapUint32((*uint32)(&job.State), uint32(JobPending), uint32(JobRunning)) {
-		job.im.store.UpdateFileImportState(job.Show, job.ID, store.ImportAborted)
+		job.im.store.SetFileImportStateAborted(job.Show, job.ID, "canceled by user or timeout")
 		// the job was canceled before job.Start() could initialize the context and because of this
 		// job.Cancel() only set the state to JobCanceled... so we simulate a canceled context here
 		return context.Canceled
@@ -82,18 +82,18 @@ func (job *Job) run() error {
 	close(job.subC.running)
 
 	if err := job.initializeSource(); err != nil {
-		job.im.store.UpdateFileImportState(job.Show, job.ID, store.ImportAborted)
+		job.im.store.SetFileImportStateAborted(job.Show, job.ID, "failed to initialize source: "+err.Error())
 		return err
 	}
 	// job.source is now initialized and points to a valid source
 	job.im.dbgLog.Printf("job source is ready, fetching %d bytes from %s", job.source.Len(), job.source.String())
 	loudness, err := job.fetch()
 	if err != nil {
-		job.im.store.UpdateFileImportState(job.Show, job.ID, store.ImportAborted)
+		job.im.store.SetFileImportStateAborted(job.Show, job.ID, "fetching file failed: "+err.Error())
 		return err
 	}
 	if err = job.normalize(loudness); err != nil {
-		job.im.store.UpdateFileImportState(job.Show, job.ID, store.ImportAborted)
+		job.im.store.SetFileImportStateAborted(job.Show, job.ID, "normalizing file failed: "+err.Error())
 		return err
 	}
 	job.im.store.UpdateFileImportState(job.Show, job.ID, store.ImportDone)
@@ -144,7 +144,7 @@ func (job *Job) Start(ctx context.Context, timeout time.Duration) (err error) {
 		}
 	default:
 		// the work channel is already full so we need to drop all new jobs...
-		job.im.store.UpdateFileImportState(job.Show, job.ID, store.ImportAborted)
+		job.im.store.SetFileImportStateAborted(job.Show, job.ID, "enqueuing import failed: too many pending jobs")
 		job.cancel()
 		job.cleanup()
 		return ErrTooManyJobs

importer/normalize_converter.go

@@ -25,6 +25,7 @@
 package importer
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os/exec"
@@ -84,24 +85,24 @@ func newFFmpegNormalizeConverter(job *Job, params *ffmpegLoudnormParams) (c *ffm
 
 	if c.stdin, err = c.cmd.StdinPipe(); err != nil {
 		c.log.append("stderr", "ERROR opening stdin pipe: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to open stdin pipe for ffmpeg: " + err.Error())
 	}
 
 	var stdout, stderr io.Reader
 	if stdout, err = c.cmd.StdoutPipe(); err != nil {
 		c.log.append("stderr", "ERROR opening stdout pipe: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to open stdout pipe for ffmpeg: " + err.Error())
 	}
 	c.stdout = newConvLogger(c.log, "stdout(ffmpeg)", stdout)
 	if stderr, err = c.cmd.StderrPipe(); err != nil {
 		c.log.append("stderr", "ERROR opening stderr pipe: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to open stderr pipe for ffmpeg: " + err.Error())
 	}
 	c.stderr = newConvLogger(c.log, "stderr(ffmpeg)", stderr)
 
 	if err = c.cmd.Start(); err != nil {
 		c.log.append("stderr", "ERROR starting ffmpeg: "+err.Error())
-		return nil, err
+		return nil, errors.New("failed to start ffmpeg: " + err.Error())
 	}
 	return
 }
@@ -121,15 +122,18 @@ func (c *ffmpegNormalizeConverter) Wait() (log JobLog, err error) {
 	if err = c.cmd.Wait(); err != nil {
 		if exiterr, ok := err.(*exec.ExitError); ok {
 			if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
-				exitcode := status.ExitStatus()
-				c.job.im.dbgLog.Printf("ffmpeg-converter: ffmpeg returned %d", exitcode)
-				c.log.append("stdout", fmt.Sprintf("ffmpeg returned %d", exitcode))
+				info := fmt.Sprintf("ffmpeg returned %d", status.ExitStatus())
+				c.job.im.dbgLog.Printf("ffmpeg-converter: %s", info)
+				c.log.append("stdout", info)
+				if err != nil {
+					err = errors.New(info)
+				}
 				return c.log.log, err
 			}
 		}
 		c.job.im.errLog.Println("ffmpeg-converter: getting exit code of ffmpeg failed:", err)
 		c.log.append("stderr", "ERROR getting exit code of ffmpeg: "+err.Error())
-		return c.log.log, err
+		return c.log.log, errors.New("failed get exit code of ffmpeg: " + err.Error())
 	}
 
 	c.job.im.dbgLog.Println("ffmpeg-converter: ffmpeg returned 0 (success)")

store/files.go

@@ -123,6 +123,19 @@ func (st *Store) UpdateFileImportState(show string, id uint64, state ImportState
 	return file, nil
 }
 
+func (st *Store) SetFileImportStateAborted(show string, id uint64, error string) (file *File, err error) {
+	file = &File{ID: id}
+	var fields map[string]interface{}
+	fields = make(map[string]interface{})
+	fields["source__import__state"] = ImportAborted
+	fields["source__import__error"] = error
+
+	if err := st.db.Model(&file).Where("show_name = ?", show).Update(fields).Error; err != nil {
+		return nil, err
+	}
+	return file, nil
+}
+
 func (st *Store) UpdateFileSourceHash(show string, id uint64, hash string) (*File, error) {
 	file := &File{ID: id}
 	if err := st.db.Model(&file).Where("show_name = ?", show).Update("source__hash", hash).Error; err != nil {