Start to rework tests

.vscode/settings.json

@@ -3,6 +3,8 @@
         "daulog",
         "Debugf",
         "inconsolata",
+        "Infof",
+        "Markedup",
         "skratchdot"
     ]
 }

CHANGELOG.md

@@ -3,6 +3,15 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [v0.13.0] - 2022-11-01
+
+- Resize images if needed to fit in discord 8Mb upload limits
+
+
+## [v0.12.4] - 2022-09-15
+
+- Document that watcher intervals are in seconds
+
 ## [v0.12.3] - 2022-05-09
 
 - Fix a race condition occasionally causing multiple duplicate uploads

README.md

@@ -54,7 +54,7 @@ no changes will take effect until the "Save All Configuration" button has been p
 ### Global options
 
 * Server port - the port number the web server listens on. Requires restart
-* Watch interval - how often each watcher will check the directory for new files
+* Watch interval - how often each watcher will check the directory for new files, in seconds
 
 ### Watcher configuration
 

build-release.pl

@@ -33,8 +33,10 @@ system "mkdir", "dist";
 
 my %build = (
   win   => { env => { GOOS => 'windows', GOARCH => 'amd64' }, filename => 'dau.exe' },
-  linux => { env => { GOOS => 'linux',   GOARCH => 'amd64' }, filename => 'dau' },
+  linux_amd64 => { env => { GOOS => 'linux',   GOARCH => 'amd64' }, filename => 'dau' },
-  mac   => { env => { GOOS => 'darwin',  GOARCH => 'amd64' }, filename => 'dau' },
+  linux_arm64 => { env => { GOOS => 'linux',   GOARCH => 'arm64' }, filename => 'dau' },
+  mac_amd64   => { env => { GOOS => 'darwin',  GOARCH => 'amd64' }, filename => 'dau' },
+  mac_arm64   => { env => { GOOS => 'darwin',  GOARCH => 'arm64' }, filename => 'dau' },
 ); 
 
 foreach my $type (keys %build) {

image/image.go

@@ -0,0 +1,188 @@
+// Package image is responsible for thumbnailing, resizing and watermarking
+// images.
+package image
+
+import (
+	"fmt"
+	i "image"
+	"image/jpeg"
+	"image/png"
+	"io"
+	"os"
+
+	daulog "github.com/tardisx/discord-auto-upload/log"
+
+	"golang.org/x/image/draw"
+)
+
+// the filenames below are ordered in a specific way
+// In the simplest case we only need the original filename.
+// In more complex cases, we might have other files, created
+// temporarily. These all need to be cleaned up.
+// We upload the "final" file, depending on what actions have
+// been taken.
+
+type Store struct {
+	OriginalFilename    string
+	OriginalFormat      string // jpeg, png
+	ModifiedFilename    string // if the user applied modifications
+	ResizedFilename     string // if the file had to be resized to be uploaded
+	WatermarkedFilename string
+	MaxBytes            int
+	Watermark           bool
+}
+
+// ReadCloser returns an io.ReadCloser providing the imagedata
+// with the manglings that have been requested
+func (s *Store) ReadCloser() (io.ReadCloser, error) {
+	// determine format
+	s.determineFormat()
+
+	// check if we will fit the number of bytes, resize if necessary
+	err := s.resizeToUnder(int64(s.MaxBytes))
+	if err != nil {
+		return nil, err
+	}
+
+	// the conundrum here is that the watermarking could modify the file size again, maybe going over
+	//	the MaxBytes size. That would mostly be about jpeg compression levels I guess...
+	if s.Watermark {
+		s.applyWatermark()
+	}
+
+	// return the reader
+	f, err := os.Open(s.uploadSourceFilename())
+	if err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+func (s *Store) determineFormat() error {
+	file, err := os.Open(s.OriginalFilename)
+	if err != nil {
+		panic(fmt.Errorf("could not open file: %s", err))
+	}
+	defer file.Close()
+
+	_, format, err := i.Decode(file)
+	if err != nil {
+		panic(fmt.Errorf("could not decode file: %s", err))
+	}
+	s.OriginalFormat = format
+	return nil
+}
+
+// resizeToUnder resizes the image, if necessary
+func (s *Store) resizeToUnder(size int64) error {
+	fileToResize := s.uploadSourceFilename()
+	fi, err := os.Stat(s.uploadSourceFilename())
+	if err != nil {
+		return err
+	}
+	currentSize := fi.Size()
+	if currentSize <= size {
+		return nil // nothing needs to be done
+	}
+
+	daulog.Infof("%s is %d bytes, need to resize to fit in %d", fileToResize, currentSize, size)
+
+	file, err := os.Open(fileToResize)
+	if err != nil {
+		panic(fmt.Errorf("could not open file: %s", err))
+	}
+	defer file.Close()
+
+	im, _, err := i.Decode(file)
+	if err != nil {
+		panic(fmt.Errorf("could not decode file: %s", err))
+	}
+
+	// if the size is 10% too big, we reduce X and Y by 10% - this is overkill but should
+	// get us across the line in most cases
+	fraction := float64(currentSize) / float64(size) // say 1.1 for 10%
+	newXY := i.Point{
+		X: int(float64(im.Bounds().Max.X) / fraction),
+		Y: int(float64(im.Bounds().Max.Y) / fraction),
+	}
+
+	daulog.Infof("fraction is %f, will resize to %dx%d", fraction, newXY.X, newXY.Y)
+
+	dst := i.NewRGBA(i.Rect(0, 0, newXY.X, newXY.Y))
+	draw.BiLinear.Scale(dst, dst.Rect, im, im.Bounds(), draw.Over, nil)
+
+	resizedFile, err := os.CreateTemp("", "dau_resize_file_*")
+	if err != nil {
+		return err
+	}
+
+	if s.OriginalFormat == "png" {
+		err = png.Encode(resizedFile, dst)
+		if err != nil {
+			return err
+		}
+	} else if s.OriginalFormat == "jpeg" {
+		err = jpeg.Encode(resizedFile, dst, nil)
+		if err != nil {
+			return err
+		}
+
+	} else {
+		panic("unknown format " + s.OriginalFormat)
+	}
+
+	s.ResizedFilename = resizedFile.Name()
+	resizedFile.Close()
+
+	fi, err = os.Stat(s.uploadSourceFilename())
+	if err != nil {
+		return err
+	}
+	newSize := fi.Size()
+	if newSize <= size {
+		daulog.Infof("File resized, now %d", newSize)
+		return nil // nothing needs to be done
+	} else {
+		return fmt.Errorf("failed to resize: was %d, now %d, needed %d", currentSize, newSize, size)
+	}
+
+}
+
+// uploadSourceFilename gives us the filename, which might be a watermarked, resized
+// or markedup version, depending on what has happened to this file.
+func (s Store) uploadSourceFilename() string {
+	if s.WatermarkedFilename != "" {
+		return s.WatermarkedFilename
+	}
+	if s.ResizedFilename != "" {
+		return s.ResizedFilename
+	}
+	if s.ModifiedFilename != "" {
+		return s.ModifiedFilename
+	}
+	return s.OriginalFilename
+}
+
+// UploadFilename provides a name to be assigned to the upload on Discord
+func (s Store) UploadFilename() string {
+	return "image." + s.OriginalFormat
+}
+
+// Cleanup removes all the temporary files that we might have created
+func (s Store) Cleanup() {
+	daulog.Infof("cleaning temporary files %#v", s)
+
+	if s.ModifiedFilename != "" {
+		daulog.Infof("removing %s", s.ModifiedFilename)
+		os.Remove(s.ModifiedFilename)
+	}
+	if s.ResizedFilename != "" {
+		daulog.Infof("removing %s", s.ResizedFilename)
+		os.Remove(s.ResizedFilename)
+	}
+	if s.WatermarkedFilename != "" {
+		daulog.Infof("removing %s", s.WatermarkedFilename)
+		os.Remove(s.WatermarkedFilename)
+	}
+}

image/thumb.go

@@ -1,14 +1,13 @@
-package imageprocess
+package image
 
 import (
 	"fmt"
-	"image"
+	i "image"
 	"image/png"
 	"io"
 	"log"
 	"os"
 
-	"github.com/tardisx/discord-auto-upload/upload"
 	"golang.org/x/image/draw"
 )
 
@@ -17,15 +16,21 @@ const (
 	thumbnailMaxY = 128
 )
 
-func (ip *Processor) ThumbPNG(ul *upload.Upload, which string, w io.Writer) error {
+type ThumbType = string
+
+const ThumbTypeOriginal = "orig"
+const ThumbTypeMarkedUp = "markedup"
+
+// ThumbPNG writes a thumbnail out to an io.Writer
+func (ip *Store) ThumbPNG(t ThumbType, w io.Writer) error {
 
 	var filename string
-	if which == "orig" {
+	if t == ThumbTypeOriginal {
-		filename = ul.OriginalFilename
+		filename = ip.OriginalFilename
-	} else if which == "markedup" {
+	} else if t == ThumbTypeMarkedUp {
-		filename = ul.MarkedUpFilename
+		filename = ip.ModifiedFilename
 	} else {
-		log.Fatal("was passed incorrect 'which' arg")
+		log.Fatal("was passed incorrect 'type' arg")
 	}
 
 	file, err := os.Open(filename)
@@ -33,12 +38,12 @@ func (ip *Processor) ThumbPNG(ul *upload.Upload, which string, w io.Writer) erro
 		return fmt.Errorf("could not open file: %s", err)
 	}
 	defer file.Close()
-	im, _, err := image.Decode(file)
+	im, _, err := i.Decode(file)
 	if err != nil {
 		return fmt.Errorf("could not decode file: %s", err)
 	}
 
-	newXY := image.Point{}
+	newXY := i.Point{}
 	if im.Bounds().Max.X/thumbnailMaxX > im.Bounds().Max.Y/thumbnailMaxY {
 		newXY.X = thumbnailMaxX
 		newXY.Y = im.Bounds().Max.Y / (im.Bounds().Max.X / thumbnailMaxX)
@@ -47,7 +52,7 @@ func (ip *Processor) ThumbPNG(ul *upload.Upload, which string, w io.Writer) erro
 		newXY.X = im.Bounds().Max.X / (im.Bounds().Max.Y / thumbnailMaxY)
 	}
 
-	dst := image.NewRGBA(image.Rect(0, 0, newXY.X, newXY.Y))
+	dst := i.NewRGBA(i.Rect(0, 0, newXY.X, newXY.Y))
 	draw.BiLinear.Scale(dst, dst.Rect, im, im.Bounds(), draw.Over, nil)
 
 	png.Encode(w, dst)

image/watermark.go

@@ -0,0 +1,64 @@
+package image
+
+import (
+	"fmt"
+	i "image"
+	"image/jpeg"
+	"image/png"
+	"os"
+
+	daulog "github.com/tardisx/discord-auto-upload/log"
+
+	"github.com/fogleman/gg"
+	"golang.org/x/image/font/inconsolata"
+)
+
+// applyWatermark applies the watermark to the image
+func (s *Store) applyWatermark() error {
+
+	in, err := os.Open(s.uploadSourceFilename())
+
+	defer in.Close()
+
+	im, _, err := i.Decode(in)
+	if err != nil {
+		daulog.Errorf("Cannot decode image: %v - skipping watermarking", err)
+		return fmt.Errorf("cannot decode image: %w", err)
+	}
+	bounds := im.Bounds()
+	// var S float64 = float64(bounds.Max.X)
+
+	dc := gg.NewContext(bounds.Max.X, bounds.Max.Y)
+	dc.Clear()
+	dc.SetRGB(0, 0, 0)
+
+	dc.SetFontFace(inconsolata.Regular8x16)
+
+	dc.DrawImage(im, 0, 0)
+
+	dc.DrawRoundedRectangle(0, float64(bounds.Max.Y-18.0), 320, float64(bounds.Max.Y), 0)
+	dc.SetRGB(0, 0, 0)
+	dc.Fill()
+
+	dc.SetRGB(1, 1, 1)
+
+	dc.DrawString("github.com/tardisx/discord-auto-upload", 5.0, float64(bounds.Max.Y)-5.0)
+
+	waterMarkedFile, err := os.CreateTemp("", "dau_watermark_file_*")
+
+	if err != nil {
+		return err
+	}
+	defer waterMarkedFile.Close()
+
+	if s.OriginalFormat == "png" {
+		png.Encode(waterMarkedFile, dc.Image())
+	} else if s.OriginalFormat == "jpeg" {
+		jpeg.Encode(waterMarkedFile, dc.Image(), nil)
+	} else {
+		panic("Cannot handle " + s.OriginalFormat)
+	}
+
+	s.WatermarkedFilename = waterMarkedFile.Name()
+	return nil
+}

imageprocess/imageprocess.go

@@ -1,4 +0,0 @@
-package imageprocess
-
-type Processor struct {
-}

upload/upload.go

@@ -7,33 +7,31 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"image"
 	"io"
 	"io/ioutil"
 	"log"
 	"mime/multipart"
 	"net/http"
-	"os"
-	"path/filepath"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"github.com/fogleman/gg"
 	"github.com/tardisx/discord-auto-upload/config"
+	"github.com/tardisx/discord-auto-upload/image"
+
 	daulog "github.com/tardisx/discord-auto-upload/log"
-	"golang.org/x/image/font/inconsolata"
 )
 
 type State string
 
 const (
-	StatePending   State = "Pending"   // waiting for decision to upload (could be edited)
+	StatePending      State = "Pending"          // waiting for decision to upload (could be edited)
-	StateQueued    State = "Queued"    // ready for upload
+	StateQueued       State = "Queued"           // ready for upload
-	StateUploading State = "Uploading" // uploading
+	StateWatermarking State = "Adding Watermark" // thumbnail generation
-	StateComplete  State = "Complete"  // finished successfully
+	StateUploading    State = "Uploading"        // uploading
-	StateFailed    State = "Failed"    // failed
+	StateComplete     State = "Complete"         // finished successfully
-	StateSkipped   State = "Skipped"   // user did not want to upload
+	StateFailed       State = "Failed"           // failed
+	StateSkipped      State = "Skipped"          // user did not want to upload
 )
 
 var currentId int32
@@ -51,13 +49,10 @@ type Upload struct {
 	Id         int32     `json:"id"`
 	UploadedAt time.Time `json:"uploaded_at"`
 
-	OriginalFilename string `json:"original_file"` // path on the local disk
+	Image *image.Store
-	MarkedUpFilename string `json:"markedup_file"` // a temporary file, if the user did some markup
 
 	webhookURL string
 
-	watermark bool // should watermark
-
 	usernameOverride string
 
 	Url string `json:"url"` // url on the discord CDN
@@ -65,7 +60,8 @@ type Upload struct {
 	Width  int `json:"width"`
 	Height int `json:"height"`
 
-	State State `json:"state"`
+	State       State  `json:"state"`
+	StateReason string `json:"state_reason"`
 
 	Client HTTPClient `json:"-"`
 }
@@ -82,16 +78,19 @@ func (u *Uploader) AddFile(file string, conf config.Watcher) {
 	atomic.AddInt32(&currentId, 1)
 	thisUpload := Upload{
 		Id:               currentId,
-		OriginalFilename: file,
+		UploadedAt:       time.Time{},
-		watermark:        !conf.NoWatermark,
+		Image:            &image.Store{OriginalFilename: file, Watermark: !conf.NoWatermark, MaxBytes: 8_000_000},
 		webhookURL:       conf.WebHookURL,
 		usernameOverride: conf.Username,
+		Url:              "",
 		State:            StateQueued,
+		Client:           nil,
 	}
 	// if the user wants uploads to be held for editing etc,
 	// set it to Pending instead
 	if conf.HoldUploads {
 		thisUpload.State = StatePending
+		thisUpload.StateReason = ""
 	}
 	u.Uploads = append(u.Uploads, &thisUpload)
 	u.Lock.Unlock()
@@ -123,16 +122,8 @@ func (u *Uploader) UploadById(id int32) *Upload {
 	return nil
 }
 
-func (u *Upload) RemoveMarkupTempFile() {
-	if len(u.MarkedUpFilename) > 0 {
-		os.Remove(u.MarkedUpFilename)
-	}
-}
-
 func (u *Upload) processUpload() error {
-	daulog.Infof("Uploading: %s", u.OriginalFilename)
+	daulog.Infof("Uploading: %s", u.Image.OriginalFilename)
-
-	baseFilename := filepath.Base(u.OriginalFilename)
 
 	if u.webhookURL == "" {
 		daulog.Error("WebHookURL is not configured - cannot upload!")
@@ -164,41 +155,14 @@ func (u *Upload) processUpload() error {
 	for retriesRemaining > 0 {
 
 		// open an io.ReadCloser for the file we intend to upload
-		var filedata *os.File
 		var err error
-		if len(u.MarkedUpFilename) > 0 {
+
-			filedata, err = os.Open(u.MarkedUpFilename)
+		imageData, err := u.Image.ReadCloser()
-			if err != nil {
+		if err != nil {
-				daulog.Errorf("Error opening marked up file: %s", err)
+			panic(err)
-				retriesRemaining--
-				sleepForRetries(retriesRemaining)
-				continue
-			}
-		} else {
-			filedata, err = os.Open(u.OriginalFilename)
-			if err != nil {
-				daulog.Errorf("Error opening original file: %s", err)
-				retriesRemaining--
-				sleepForRetries(retriesRemaining)
-				continue
-			}
 		}
 
-		var imageData io.Reader
+		request, err := newfileUploadRequest(u.webhookURL, extraParams, "file", u.Image.UploadFilename(), imageData)
-		if u.watermark {
-			daulog.Info("Watermarking image")
-			imageData, err = u.applyWatermark(filedata)
-			if err != nil {
-				daulog.Errorf("Error watermarking: %s", err)
-				retriesRemaining--
-				sleepForRetries(retriesRemaining)
-				continue
-			}
-		} else {
-			imageData = filedata
-		}
-
-		request, err := newfileUploadRequest(u.webhookURL, extraParams, "file", baseFilename, imageData)
 		if err != nil {
 			daulog.Errorf("error creating upload request: %s", err)
 			return fmt.Errorf("could not create upload request: %s", err)
@@ -222,6 +186,7 @@ func (u *Upload) processUpload() error {
 				// just fail immediately, we know this means the file was too big
 				daulog.Error("413 received - file too large")
 				u.State = StateFailed
+				u.StateReason = "discord API said file too large"
 				return errors.New("received 413 - file too large")
 			}
 
@@ -274,6 +239,7 @@ func (u *Upload) processUpload() error {
 
 			u.Url = a.URL
 			u.State = StateComplete
+			u.StateReason = ""
 			u.Width = a.Width
 			u.Height = a.Height
 			u.UploadedAt = time.Now()
@@ -282,12 +248,13 @@ func (u *Upload) processUpload() error {
 		}
 	}
 
-	// remove any marked up file
+	// remove any temporary files
-	u.RemoveMarkupTempFile()
+	u.Image.Cleanup()
 
 	if retriesRemaining == 0 {
 		daulog.Error("Failed to upload, even after all retries")
 		u.State = StateFailed
+		u.StateReason = "could not upload after all retries"
 		return errors.New("could not upload after all retries")
 	}
 
@@ -320,40 +287,6 @@ func newfileUploadRequest(uri string, params map[string]string, paramName string
 	return req, err
 }
 
-// applyWatermark applies the watermark to the image
-func (u *Upload) applyWatermark(in *os.File) (io.Reader, error) {
-
-	defer in.Close()
-
-	im, _, err := image.Decode(in)
-	if err != nil {
-		daulog.Errorf("Cannot decode image: %v - skipping watermarking", err)
-		return nil, errors.New("cannot decode image")
-	}
-	bounds := im.Bounds()
-	// var S float64 = float64(bounds.Max.X)
-
-	dc := gg.NewContext(bounds.Max.X, bounds.Max.Y)
-	dc.Clear()
-	dc.SetRGB(0, 0, 0)
-
-	dc.SetFontFace(inconsolata.Regular8x16)
-
-	dc.DrawImage(im, 0, 0)
-
-	dc.DrawRoundedRectangle(0, float64(bounds.Max.Y-18.0), 320, float64(bounds.Max.Y), 0)
-	dc.SetRGB(0, 0, 0)
-	dc.Fill()
-
-	dc.SetRGB(1, 1, 1)
-
-	dc.DrawString("github.com/tardisx/discord-auto-upload", 5.0, float64(bounds.Max.Y)-5.0)
-
-	b := bytes.Buffer{}
-	dc.EncodePNG(&b)
-	return &b, nil
-}
-
 func sleepForRetries(retry int) {
 	if retry == 0 {
 		return

upload/upload_test.go

@@ -2,15 +2,13 @@ package upload
 
 import (
 	"bytes"
-	"image"
+	i "image"
 	"image/color"
 	"image/png"
 	"io/ioutil"
 	"math/rand"
 	"net/http"
 	"os"
-	"testing"
-	// 	"github.com/tardisx/discord-auto-upload/config"
 )
 
 // https://www.thegreatcodeadventure.com/mocking-http-requests-in-golang/
@@ -38,52 +36,50 @@ func DoTooBigUpload(req *http.Request) (*http.Response, error) {
 	}, nil
 }
 
-func TestSuccessfulUpload(t *testing.T) {
+// func TestSuccessfulUpload(t *testing.T) {
-	// create temporary file, processUpload requires that it exists, even though
+// 	// create temporary file, processUpload requires that it exists, even though
-	// we will not really be uploading it here
+// 	// we will not really be uploading it here
-	f, _ := os.CreateTemp("", "dautest-upload-*")
+// 	f, _ := os.CreateTemp("", "dautest-upload-*")
-	defer os.Remove(f.Name())
+// 	defer os.Remove(f.Name())
-	u := Upload{webhookURL: "https://127.0.0.1/", OriginalFilename: f.Name()}
+// 	u := Upload{webhookURL: "https://127.0.0.1/", Image: &image.Store{OriginalFilename: f.Name()}}
-	u.Client = &MockClient{DoFunc: DoGoodUpload}
+// 	u.Client = &MockClient{DoFunc: DoGoodUpload}
-	err := u.processUpload()
+// 	err := u.processUpload()
-	if err != nil {
+// 	if err != nil {
-		t.Errorf("error occured: %s", err)
+// 		t.Errorf("error occured: %s", err)
-	}
+// 	}
-	if u.Width != 640 || u.Height != 640 {
-		t.Error("dimensions wrong")
-	}
-	if u.Url != "https://cdn.discordapp.com/attachments/849615269706203171/851092588332449812/dau480457962.png" {
-		t.Error("URL wrong")
-	}
-}
 
-func TestTooBigUpload(t *testing.T) {
+// 	if u.Url != "https://cdn.discordapp.com/attachments/849615269706203171/851092588332449812/dau480457962.png" {
-	// create temporary file, processUpload requires that it exists, even though
+// 		t.Error("URL wrong")
-	// we will not really be uploading it here
+// 	}
-	f, _ := os.CreateTemp("", "dautest-upload-*")
+// }
-	defer os.Remove(f.Name())
+
-	u := Upload{webhookURL: "https://127.0.0.1/", OriginalFilename: f.Name()}
+// func TestTooBigUpload(t *testing.T) {
-	u.Client = &MockClient{DoFunc: DoTooBigUpload}
+// 	// create temporary file, processUpload requires that it exists, even though
-	err := u.processUpload()
+// 	// we will not really be uploading it here
-	if err == nil {
+// 	f, _ := os.CreateTemp("", "dautest-upload-*")
-		t.Error("error did not occur?")
+// 	defer os.Remove(f.Name())
-	} else if err.Error() != "received 413 - file too large" {
+// 	u := Upload{webhookURL: "https://127.0.0.1/", Image: &image.Store{OriginalFilename: f.Name()}}
-		t.Errorf("wrong error occurred: %s", err.Error())
+// 	u.Client = &MockClient{DoFunc: DoTooBigUpload}
-	}
+// 	err := u.processUpload()
-	if u.State != StateFailed {
+// 	if err == nil {
-		t.Error("upload should have been marked failed")
+// 		t.Error("error did not occur?")
-	}
+// 	} else if err.Error() != "received 413 - file too large" {
-}
+// 		t.Errorf("wrong error occurred: %s", err.Error())
+// 	}
+// 	if u.State != StateFailed {
+// 		t.Error("upload should have been marked failed")
+// 	}
+// }
 
 func tempImageGt8Mb() {
 	// about 12Mb
 	width := 2000
 	height := 2000
 
-	upLeft := image.Point{0, 0}
+	upLeft := i.Point{0, 0}
-	lowRight := image.Point{width, height}
+	lowRight := i.Point{width, height}
 
-	img := image.NewRGBA(image.Rectangle{upLeft, lowRight})
+	img := i.NewRGBA(i.Rectangle{upLeft, lowRight})
 
 	// Colors are defined by Red, Green, Blue, Alpha uint8 values.
 

version/version.go

@@ -13,7 +13,7 @@ import (
 	"golang.org/x/mod/semver"
 )
 
-const CurrentVersion string = "v0.12.3"
+const CurrentVersion string = "v0.13.0-alpha.1"
 
 type GithubRelease struct {
 	HTMLURL string `json:"html_url"`

version/version_test.go

@@ -6,7 +6,7 @@ import (
 
 func TestVersioningUpdate(t *testing.T) {
 	// pretend there is a new version
-	LatestVersion = "v0.13.0"
+	LatestVersion = "v0.13.9"
 	if !UpdateAvailable() {
 		t.Error("should be a version newer than " + CurrentVersion)
 	}

web/data/config.html

@@ -21,7 +21,7 @@
     </p>
 
     <p>The Watch Interval is how often new files will be discovered by your
-      watchers (watchers are configured below).</p>
+      watchers in seconds (watchers are configured below).</p>
 
     <div class="form-row align-items-center">
       <div class="col-sm-6 my-1">

web/data/uploads.html

@@ -38,7 +38,7 @@
       <thead>
         <tr>
           <th>filename</th>
-          <th>actions</th>
+          <th>state</th>
           <th>&nbsp;</th>
         </tr>
       </thead>
@@ -47,9 +47,11 @@
         <template x-for="ul in uploads">
           <tr>
             <td x-text="ul.original_file"></td>
-            <td>
+            <td> 
-              <button @click="start_upload(ul.id)" type="button" class="btn btn-primary">upload</button>
+              <span x-text="ul.state"></span>
-            </td>
+              <div x-if="ul.state_reason">(<span x-text="ul.state_reason"></span>)</div>
+             </td>
+  
             <td>
               <img :src="'/rest/image/'+ul.id+'/thumb'">
             </td>
@@ -74,7 +76,10 @@
        <template x-for="ul in finished">
          <tr>
            <td x-text="ul.original_file"></td>
-           <td x-text="ul.state"></td>
+           <td> 
+            <span x-text="ul.state"></span>
+            <div x-if="ul.state_reason">(<span x-text="ul.state_reason"></span>)</div>
+           </td>
            <td>
             <img :src="'/rest/image/'+ul.id+'/thumb'">
           </td>

web/server.go

@@ -19,7 +19,7 @@ import (
 
 	"github.com/gorilla/mux"
 	"github.com/tardisx/discord-auto-upload/config"
-	"github.com/tardisx/discord-auto-upload/imageprocess"
+	"github.com/tardisx/discord-auto-upload/image"
 	daulog "github.com/tardisx/discord-auto-upload/log"
 	"github.com/tardisx/discord-auto-upload/upload"
 	"github.com/tardisx/discord-auto-upload/version"
@@ -178,7 +178,6 @@ func (ws *WebService) getUploads(w http.ResponseWriter, r *http.Request) {
 func (ws *WebService) imageThumb(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "image/png")
-	processor := imageprocess.Processor{}
 
 	vars := mux.Vars(r)
 	id, err := strconv.ParseInt(vars["id"], 10, 32)
@@ -192,7 +191,7 @@ func (ws *WebService) imageThumb(w http.ResponseWriter, r *http.Request) {
 		returnJSONError(w, "bad id")
 		return
 	}
-	err = processor.ThumbPNG(ul, "orig", w)
+	err = ul.Image.ThumbPNG(image.ThumbTypeOriginal, w)
 	if err != nil {
 		returnJSONError(w, "could not create thumb")
 		return
@@ -202,7 +201,6 @@ func (ws *WebService) imageThumb(w http.ResponseWriter, r *http.Request) {
 func (ws *WebService) imageMarkedupThumb(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "image/png")
-	processor := imageprocess.Processor{}
 
 	vars := mux.Vars(r)
 	id, err := strconv.ParseInt(vars["id"], 10, 32)
@@ -216,7 +214,7 @@ func (ws *WebService) imageMarkedupThumb(w http.ResponseWriter, r *http.Request)
 		returnJSONError(w, "bad id")
 		return
 	}
-	err = processor.ThumbPNG(ul, "markedup", w)
+	err = ul.Image.ThumbPNG(image.ThumbTypeMarkedUp, w)
 	if err != nil {
 		returnJSONError(w, "could not create thumb")
 		return
@@ -238,7 +236,7 @@ func (ws *WebService) image(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	img, err := os.Open(ul.OriginalFilename)
+	img, err := os.Open(ul.Image.OriginalFilename)
 	if err != nil {
 		returnJSONError(w, "could not open image file")
 		return
@@ -276,7 +274,7 @@ func (ws *WebService) modifyUpload(w http.ResponseWriter, r *http.Request) {
 				return
 			} else if change == "skip" {
 				anUpload.State = upload.StateSkipped
-				anUpload.RemoveMarkupTempFile()
+				anUpload.Image.Cleanup()
 				res := StartUploadResponse{Success: true, Message: "upload skipped"}
 				resString, _ := json.Marshal(res)
 				w.Write(resString)
@@ -298,7 +296,7 @@ func (ws *WebService) modifyUpload(w http.ResponseWriter, r *http.Request) {
 				}
 
 				// write to a temporary file
-				tempfile, err := ioutil.TempFile("", "dau_markup")
+				tempfile, err := ioutil.TempFile("", "dau_markup-*")
 				if err != nil {
 					log.Fatal(err)
 				}
@@ -311,7 +309,7 @@ func (ws *WebService) modifyUpload(w http.ResponseWriter, r *http.Request) {
 				}
 
 				tempfile.Close()
-				anUpload.MarkedUpFilename = tempfile.Name()
+				anUpload.Image.ModifiedFilename = tempfile.Name()
 
 			} else {
 				returnJSONError(w, "bad change type")