Improve error handling

Author: TickleThePanda

rpi-timelapse/src/timelapse-camera.go

@@ -2,10 +2,11 @@ package main
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"log"
-	"os"
+	"strings"
 	"sync"
 	"time"
 
@@ -17,7 +18,7 @@ type TimelapseCamera struct {
 	CurrentTicker    *time.Ticker
 	Mutex            sync.Mutex
 	RequestsChannel  chan<- *CameraSettings
-	ResponsesChannel <-chan *bytes.Reader
+	ResponsesChannel <-chan ImageResult
 }
 
 func (tt *TimelapseCamera) StartTimelapse(t *TimelapseSettings) {
@@ -50,9 +51,14 @@ func (tt *TimelapseCamera) StartTimelapse(t *TimelapseSettings) {
 
 }
 
-func (c *TimelapseCamera) CameraServer() (requests chan<- *CameraSettings, responses <-chan *bytes.Reader) {
+type ImageResult struct {
+	Reader *bytes.Reader
+	Error  error
+}
+
+func (c *TimelapseCamera) CameraServer() (requests chan<- *CameraSettings, responses <-chan ImageResult) {
 	reqs := make(chan *CameraSettings, 1)
-	ress := make(chan *bytes.Reader, 1)
+	ress := make(chan ImageResult, 1)
 
 	go func() {
 		for cameraSettings := range reqs {
@@ -70,32 +76,52 @@ func (c *TimelapseCamera) CameraServer() (requests chan<- *CameraSettings, respo
 			s.Encoding = raspicam.EncodingPNG
 
 			errCh := make(chan error)
+
+			wasError := false
+			var imageResultError strings.Builder
 			go func() {
 				for x := range errCh {
-					fmt.Fprintf(os.Stderr, "%v\n", x)
+					wasError = true
+					imageResultError.WriteString(x.Error())
+					imageResultError.WriteRune('\n')
 				}
 			}()
 
 			var b *bytes.Buffer = &bytes.Buffer{}
 			log.Println("Capturing image")
 			raspicam.Capture(s, b, errCh)
 			log.Println("Returning image")
-			ress <- bytes.NewReader(b.Bytes())
+
+			if wasError {
+				ress <- ImageResult{
+					Error: errors.New(imageResultError.String()),
+				}
+			} else {
+				ress <- ImageResult{
+					Reader: bytes.NewReader(b.Bytes()),
+				}
+			}
 		}
 	}()
 
 	return reqs, ress
 }
 
-func (c *TimelapseCamera) CaptureImage(cameraSettings *CameraSettings, w io.Writer) {
+func (c *TimelapseCamera) CaptureImage(cameraSettings *CameraSettings, w io.Writer) error {
 
 	log.Println("Requesting image")
 	c.RequestsChannel <- cameraSettings
-	reader := <-c.ResponsesChannel
+	result := <-c.ResponsesChannel
+
+	if result.Error != nil {
+		return fmt.Errorf("error getting image: %w", result.Error)
+	}
+
 	log.Println("Receiving image")
-	_, err := io.Copy(w, reader)
+	_, err := io.Copy(w, result.Reader)
 	if err != nil {
-		log.Printf("Error copying %s", err.Error())
+		return fmt.Errorf("error copying: %w", err)
 	}
 
+	return nil
 }

rpi-timelapse/src/timelapse-store.go

@@ -124,7 +124,7 @@ func (store *TimelapseStore) GetCurrentTimelapse() (*TimelapseSettings, error) {
 	}
 }
 
-func (store *TimelapseStore) StoreImage(imageCapturer func(*CameraSettings, io.Writer)) error {
+func (store *TimelapseStore) StoreImage(imageCapturer func(*CameraSettings, io.Writer) error) error {
 
 	err := store.InitTimelapseDirs()
 	if err != nil {
@@ -152,7 +152,15 @@ func (store *TimelapseStore) StoreImage(imageCapturer func(*CameraSettings, io.W
 		return fmt.Errorf("unable to store new image: %w", err)
 	}
 
-	imageCapturer(&t.Camera, file)
+	captureErr := imageCapturer(&t.Camera, file)
+	if captureErr != nil {
+		log.Printf("Deleting failed image %v", filePath)
+		removeErr := os.Remove(filePath)
+		if removeErr != nil {
+			return fmt.Errorf("unable to capture image and clean up after: %w and %v", captureErr, removeErr)
+		}
+		return fmt.Errorf("unable to capture image: %w", captureErr)
+	}
 
 	return nil
 }
@@ -212,11 +220,13 @@ func (store *TimelapseStore) ImageByName(name string, w io.Writer) error {
 
 	path := store.TimelapseImageDir(t) + "/" + name
 
-	log.Printf("Waiting for image to be written: %s", path)
-	for store.OpenFiles[path] {
-		time.Sleep(time.Duration(100) * time.Millisecond)
+	if store.OpenFiles[path] {
+		log.Printf("Waiting for image to be written: %s", path)
+		for store.OpenFiles[path] {
+			time.Sleep(time.Duration(100) * time.Millisecond)
+		}
+		log.Printf("Finished waiting for image to be written: %s", path)
 	}
-	log.Printf("Finished waiting for image to be written: %s", path)
 
 	imageFile, err := os.OpenFile(path, os.O_RDONLY, 0755)
 	defer func() {