Add --exclude flag (to avoid uploading thumbnails)

README.md

@@ -1,4 +1,4 @@
-# Automatically upload screenshots from your computer into a discord channel
+# Automatically upload screenshots into a discord channel
 
 This program automatically uploads new screenshots that appear in a folder on your computer to Discord and posts them in a channel:
 
@@ -16,11 +16,16 @@ Point it at your Steam screenshot folder, or similar, and shortly after you hit
 
 ### Binaries
 
-TBD
+Binaries are available for Mac, Linux and Windows [here](https://github.com/tardisx/discord-auto-upload/releases/latest).
+
+Put them somewhere on your path and run from the command line.
+
+The windows version comes with a .bat file to make this a little easier - edit the `dau.bat` file to include your webhook URL and
+other parameters, then you can simply double click `dau.bat` to start `dau` running.
 
 #### From source
 
-TBD
+You'll need to [download Go](https://golang.org/dl/) check the code out somewhere, and 'go build'.
 
 ## Using it
 
@@ -32,8 +37,6 @@ Thus, you do not have to worry about pointing `dau` at a directory full of image
 
 If `dau` is on your path, you can run it from your screenshot folder and there is then no need to specify the path to your images.
 
-Note that currently `dau` does not look in subdirectories. Please submit an issue if this is a use case for you.
-
 The only two mandatory command line parameters are the discord webhook URL:
 
 `--webhook URL` - the webhook URL (see [here](https://support.discordapp.com/hc/en-us/articles/228383668-Intro-to-Webhooks) for details).
@@ -47,10 +50,14 @@ subdirectories will also be scanned.
 
 Other parameters are:
 
+`--exclude <string>` - exclude any files that contain this string (commonly used to avoid uploading thumbnails).
+
 `--watch xx` - specify how many seconds to wait between scanning the directory. The default is 10 seconds.
 
 `--username <username>` - an arbitrary string to show as the bot's username in the channel.
 
+`--no-watermark` - don't watermark images with a reference to this tool.
+
 `--help` - show command line help.
 
 `--version` - show the version.

build-release.pl

@@ -7,7 +7,7 @@ open my $fh, "<", "dau.go" || die $!;
 
 my $version;
 while (<$fh>) {
-  $version = $1 if /^const\s+current_version.*?"([\d\.]+)"/;
+  $version = $1 if /^const\s+currentVersion.*?"([\d\.]+)"/;
 }
 close $fh;
 

dau.go

@@ -1,49 +1,66 @@
 package main
 
 import (
-  "fmt"
-  "strings"
-  "github.com/pborman/getopt"
-  "path/filepath"
-  "os"
-  "time"
-  "net/http"
-  "log"
-  "io"
 	"bytes"
-  "mime/multipart"
 	"encoding/json"
+	"fmt"
+	"io"
 	"io/ioutil"
+	"log"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"image"
+
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+
+	"github.com/fogleman/gg"
+	"github.com/pborman/getopt"
+	"golang.org/x/image/font/inconsolata"
 )
 
-const current_version = "0.4"
+const currentVersion = "0.6"
 
-var last_check     = time.Now()
+var lastCheck = time.Now()
-var new_last_check = time.Now()
+var newLastCheck = time.Now()
 
-var webhook_url  string
+// Config for the application
-var username     string
+type Config struct {
+	webhookURL  string
+	path        string
+	watch       int
+	username    string
+	noWatermark bool
+	exclude     string
+}
 
 func main() {
-  webhook_opt, path, watch, username_opt := parse_options()
-  webhook_url = webhook_opt
-  username    = username_opt
 
-  check_path(path)
+	config := parseOptions()
-  check_updates()
 
-  log.Print("Waiting for images to appear in ", path)
+	checkPath(config.path)
+	checkUpdates()
 
+	log.Print("Waiting for images to appear in ", config.path)
 	// wander the path, forever
 	for {
-    err := filepath.Walk(path, check_file)
+		err := filepath.Walk(config.path,
-    if err != nil { log.Fatal("could not watch path", err) }
+			func(path string, f os.FileInfo, err error) error { return checkFile(path, f, err, config) })
-    last_check = new_last_check
+		if err != nil {
-    time.Sleep(time.Duration(watch)*time.Second)
+			log.Fatal("could not watch path", err)
+		}
+		lastCheck = newLastCheck
+		time.Sleep(time.Duration(config.watch) * time.Second)
 	}
 }
 
-func check_path(path string) {
+func checkPath(path string) {
 	src, err := os.Stat(path)
 	if err != nil {
 		log.Fatal(err)
@@ -54,115 +71,138 @@ func check_path(path string) {
 	}
 }
 
-func check_updates() {
+func checkUpdates() {
 
 	type GithubRelease struct {
-    Html_url string
+		HTMLURL string
-    Tag_name string
+		TagName string
 		Name    string
 		Body    string
 	}
 
-  client := &http.Client{ Timeout: time.Second * 5 }
+	client := &http.Client{Timeout: time.Second * 5}
 	resp, err := client.Get("https://api.github.com/repos/tardisx/discord-auto-upload/releases/latest")
-  if (err != nil) {
+	if err != nil {
 		log.Fatal("could not check for updates:", err)
 	}
 	defer resp.Body.Close()
 	body, err := ioutil.ReadAll(resp.Body)
-  if (err != nil) {
+	if err != nil {
 		log.Fatal("could not check read update response")
 	}
 
 	var latest GithubRelease
 	err = json.Unmarshal(body, &latest)
 
-  if (err != nil) {
+	if err != nil {
 		log.Fatal("could not parse JSON: ", err)
 	}
 
-  if (current_version < latest.Tag_name) {
+	if currentVersion < latest.TagName {
-    fmt.Printf("You are currently on version %s, but version %s is available\n", current_version, latest.Tag_name)
+		fmt.Printf("You are currently on version %s, but version %s is available\n", currentVersion, latest.TagName)
 		fmt.Println("----------- Release Info -----------")
 		fmt.Println(latest.Body)
 		fmt.Println("------------------------------------")
+		fmt.Println("Upgrade at https://github.com/tardisx/discord-auto-upload/releases/latest")
 	}
 
 }
 
-func parse_options() (webhook_url string, path string, watch int, username string) {
+func parseOptions() Config {
 
+	var newConfig Config
 	// Declare the flags to be used
 	webhookFlag := getopt.StringLong("webhook", 'w', "", "discord webhook URL")
 	pathFlag := getopt.StringLong("directory", 'd', "", "directory to scan, optional, defaults to current directory")
-  watchFlag    := getopt.Int16Long ("watch",     's', 10, "time between scans")
+	watchFlag := getopt.Int16Long("watch", 's', 10, "time between scans")
 	usernameFlag := getopt.StringLong("username", 'u', "", "username for the bot upload")
-  helpFlag     := getopt.BoolLong  ("help",      'h', "help")
+	excludeFlag := getopt.StringLong("exclude", 'x', "", "exclude files containing this string")
-  versionFlag  := getopt.BoolLong  ("version",   'v', "show version")
+	noWatermarkFlag := getopt.BoolLong("no-watermark", 'n', "do not put a watermark on images before uploading")
+	helpFlag := getopt.BoolLong("help", 'h', "help")
+	versionFlag := getopt.BoolLong("version", 'v', "show version")
 	getopt.SetParameters("")
 
 	getopt.Parse()
 
-  if (*helpFlag) {
+	if *helpFlag {
 		getopt.PrintUsage(os.Stderr)
 		os.Exit(0)
 	}
 
-  if (*versionFlag) {
+	if *versionFlag {
 		fmt.Println("dau - https://github.com/tardisx/discord-auto-upload")
-    fmt.Printf("Version: %s\n", current_version)
+		fmt.Printf("Version: %s\n", currentVersion)
 		os.Exit(0)
 	}
 
-  if ! getopt.IsSet("directory") {
+	if !getopt.IsSet("directory") {
 		*pathFlag = "./"
 		log.Println("Defaulting to current directory")
 	}
 
-  if ! getopt.IsSet("webhook") {
+	if !getopt.IsSet("webhook") {
 		log.Fatal("ERROR: You must specify a --webhook URL")
 	}
 
-  return *webhookFlag, *pathFlag, int(*watchFlag), *usernameFlag
+	newConfig.path = *pathFlag
+	newConfig.webhookURL = *webhookFlag
+	newConfig.watch = int(*watchFlag)
+	newConfig.username = *usernameFlag
+	newConfig.noWatermark = *noWatermarkFlag
+	newConfig.exclude = *excludeFlag
+
+	return newConfig
 }
 
-func check_file(path string, f os.FileInfo, err error) error {
+func checkFile(path string, f os.FileInfo, err error, config Config) error {
 
-  if f.ModTime().After(last_check) && f.Mode().IsRegular() {
+	if f.ModTime().After(lastCheck) && f.Mode().IsRegular() {
 
-    if file_eligible(path) {
+		if fileEligible(config, path) {
 			// process file
-      process_file(path)
+			processFile(config, path)
 		}
 
-    if new_last_check.Before(f.ModTime()) {
+		if newLastCheck.Before(f.ModTime()) {
-      new_last_check = f.ModTime()
+			newLastCheck = f.ModTime()
 		}
 	}
 
 	return nil
 }
 
-func file_eligible(file string) (bool) {
+func fileEligible(config Config, file string) bool {
+
+	if config.exclude != "" && strings.Contains(file, config.exclude) {
+		return false
+	}
+
 	extension := strings.ToLower(filepath.Ext(file))
 	if extension == ".png" || extension == ".jpg" || extension == ".gif" {
 		return true
 	}
+
 	return false
 }
 
-func process_file(file string) {
+func processFile(config Config, file string) {
+
+	if !config.noWatermark {
+		log.Print("Copying to temp location and watermarking ", file)
+		file = mungeFile(file)
+	}
+
 	log.Print("Uploading ", file)
 
-  extraParams := map[string]string{ }
+	extraParams := map[string]string{}
 
-  if (username != "") {
+	if config.username != "" {
-    extraParams["username"] = username
+		extraParams["username"] = config.username
 	}
 
 	type DiscordAPIResponseAttachment struct {
-    Url string
+		URL      string
-    Proxy_url string
+		ProxyURL string
 		Size     int
 		Width    int
 		Height   int
@@ -171,53 +211,84 @@ func process_file(file string) {
 
 	type DiscordAPIResponse struct {
 		Attachments []DiscordAPIResponseAttachment
-    Id int64 `json:",string"`
+		ID          int64 `json:",string"`
 	}
 
-  request, err := newfileUploadRequest(webhook_url, extraParams, "file", file)
+	var retriesRemaining = 5
+	for retriesRemaining > 0 {
+		request, err := newfileUploadRequest(config.webhookURL, extraParams, "file", file)
 		if err != nil {
 			log.Fatal(err)
 		}
 		start := time.Now()
-  client := &http.Client{ Timeout: time.Second * 30 }
+		client := &http.Client{Timeout: time.Second * 30}
 		resp, err := client.Do(request)
 		if err != nil {
-
+			log.Print("Error performing request:", err)
-    log.Fatal("Error performing request:", err)
+			retriesRemaining--
-
+			sleepForRetries(retriesRemaining)
+			continue
 		} else {
 
-    if (resp.StatusCode != 200) {
+			if resp.StatusCode != 200 {
 				log.Print("Bad response from server:", resp.StatusCode)
-      return
+				retriesRemaining--
+				sleepForRetries(retriesRemaining)
+				continue
 			}
 
-    res_body, err := ioutil.ReadAll(resp.Body)
+			resBody, err := ioutil.ReadAll(resp.Body)
-    if (err != nil) {
+			if err != nil {
-      log.Fatal("could not deal with body", err)
+				log.Print("could not deal with body: ", err)
+				retriesRemaining--
+				sleepForRetries(retriesRemaining)
+				continue
 			}
 			resp.Body.Close()
 
 			var res DiscordAPIResponse
-    err = json.Unmarshal(res_body, &res)
+			err = json.Unmarshal(resBody, &res)
 
-    if (err != nil) {
+			if err != nil {
 				log.Print("could not parse JSON: ", err)
-      fmt.Println("Response was:", string(res_body[:]))
+				fmt.Println("Response was:", string(resBody[:]))
-      return
+				retriesRemaining--
+				sleepForRetries(retriesRemaining)
+				continue
 			}
-    if (len(res.Attachments) < 1) {
+			if len(res.Attachments) < 1 {
 				log.Print("bad response - no attachments?")
-      return
+				retriesRemaining--
+				sleepForRetries(retriesRemaining)
+				continue
 			}
 			var a = res.Attachments[0]
 			elapsed := time.Since(start)
 			rate := float64(a.Size) / elapsed.Seconds() / 1024.0
 
-    log.Printf("Uploaded to %s %dx%d", a.Url, a.Width, a.Height)
+			log.Printf("Uploaded to %s %dx%d", a.URL, a.Width, a.Height)
-    log.Printf("id: %d, %d bytes transferred in %.2f seconds (%.2f KiB/s)", res.Id, a.Size, elapsed.Seconds(), rate)
+			log.Printf("id: %d, %d bytes transferred in %.2f seconds (%.2f KiB/s)", res.ID, a.Size, elapsed.Seconds(), rate)
+			break
+		}
 	}
 
+	if !config.noWatermark {
+		log.Print("Removing temporary file ", file)
+		os.Remove(file)
+	}
+
+	if retriesRemaining == 0 {
+		log.Fatal("Failed to upload, even after retries")
+	}
+}
+
+func sleepForRetries(retry int) {
+	if retry == 0 {
+		return
+	}
+	retryTime := (6-retry)*(6-retry) + 6
+	log.Printf("Will retry in %d seconds (%d remaining attempts)", retryTime, retry)
+	// time.Sleep(time.Duration(retryTime) * time.Second)
 }
 
 func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (*http.Request, error) {
@@ -234,6 +305,9 @@ func newfileUploadRequest(uri string, params map[string]string, paramName, path
 		return nil, err
 	}
 	_, err = io.Copy(part, file)
+	if err != nil {
+		log.Fatal("Could not copy: ", err)
+	}
 
 	for key, val := range params {
 		_ = writer.WriteField(key, val)
@@ -247,3 +321,46 @@ func newfileUploadRequest(uri string, params map[string]string, paramName, path
 	req.Header.Set("Content-Type", writer.FormDataContentType())
 	return req, err
 }
+
+func mungeFile(path string) string {
+
+	reader, err := os.Open(path)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer reader.Close()
+
+	im, _, err := image.Decode(reader)
+	if err != nil {
+		log.Fatal(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)
+
+	tempfile, err := ioutil.TempFile("", "dau")
+	if err != nil {
+		log.Fatal(err)
+	}
+	tempfile.Close()
+	os.Remove(tempfile.Name())
+	actualName := tempfile.Name() + ".png"
+
+	dc.SavePNG(actualName)
+	return actualName
+}