Refactor main for testing and organization

main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -23,25 +24,72 @@ type result struct {
 	err error
 }
 
+type app struct {
+	vargs     *PluginArgs
+	workspace *drone.Workspace
+	client    AWS
+	jobs      []job
+}
+
 var (
 	buildCommit string
 )
 
+var MissingAwsValuesMessage = "Must set access_key, secret_key, and bucket"
+
 func main() {
 	fmt.Printf("Drone S3 Sync Plugin built from %s\n", buildCommit)
 
-	vargs := PluginArgs{}
+	a := newApp()
-	workspace := drone.Workspace{}
 
-	plugin.Param("vargs", &vargs)
+	err := a.loadVargs()
-	plugin.Param("workspace", &workspace)
+	if err != nil {
-	if err := plugin.Parse(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 
-	if len(vargs.Key) == 0 || len(vargs.Secret) == 0 || len(vargs.Bucket) == 0 {
+	err = a.sanitizeInputs()
-		return
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+    a.createClient()
+
+	a.createSyncJobs()
+	a.createInvalidateJob()
+	a.runJobs()
+
+	fmt.Println("done!")
+}
+
+func newApp() *app {
+	return &app{
+		vargs:     &PluginArgs{},
+		workspace: &drone.Workspace{},
+		jobs:      make([]job, 1, 1),
+	}
+}
+
+func (a *app) loadVargs() error {
+	plugin.Param("vargs", a.vargs)
+	plugin.Param("workspace", a.workspace)
+    
+	err := plugin.Parse()
+	return err
+
+}
+
+func (a *app) createClient() {
+	a.client = NewAWS(*a.vargs)
+}
+
+func (a *app) sanitizeInputs() error {
+	vargs := a.vargs
+	workspace := a.workspace
+
+	if len(a.vargs.Key) == 0 || len(a.vargs.Secret) == 0 || len(a.vargs.Bucket) == 0 {
+		return errors.New(MissingAwsValuesMessage)
 	}
 
 	if len(vargs.Region) == 0 {
@@ -57,15 +105,19 @@ func main() {
 		vargs.Target = vargs.Target[1:]
 	}
 
-	client := NewAWS(vargs)
+	return nil
-	remote, err := client.List(vargs.Target)
+}
+
+func (a *app) createSyncJobs() {
+	vargs := a.vargs
+	remote, err := a.client.List(vargs.Target)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 
 	local := make([]string, 1, 1)
-	jobs := make([]job, 1, 1)
+
 	err = filepath.Walk(vargs.Source, func(path string, info os.FileInfo, err error) error {
 		if err != nil || info.IsDir() {
 			return err
@@ -79,7 +131,7 @@ func main() {
 			}
 		}
 		local = append(local, localPath)
-		jobs = append(jobs, job{
+		a.jobs = append(a.jobs, job{
 			local:  filepath.Join(vargs.Source, localPath),
 			remote: filepath.Join(vargs.Target, localPath),
 			action: "upload",
@@ -95,51 +147,59 @@ func main() {
 	for path, location := range vargs.Redirects {
 		path = strings.TrimPrefix(path, "/")
 		local = append(local, path)
-		jobs = append(jobs, job{
+		a.jobs = append(a.jobs, job{
 			local:  path,
 			remote: location,
 			action: "redirect",
 		})
 	}
+    if (a.vargs.Delete) {
+        for _, r := range remote {
+            found := false
+            for _, l := range local {
+                if l == r {
+                    found = true
+                    break
+                }
+            }
 
-	for _, r := range remote {
+            if !found {
-		found := false
+                a.jobs = append(a.jobs, job{
-		for _, l := range local {
+                    local:  "",
-			if l == r {
+                    remote: r,
-				found = true
+                    action: "delete",
-				break
+                })
-			}
+            }
-		}
+        }
+    }
+}
 
-		if !found {
+func (a *app) createInvalidateJob() {
-			jobs = append(jobs, job{
+	if len(a.vargs.CloudFrontDistribution) > 0 {
-				local:  "",
+		a.jobs = append(a.jobs, job{
-				remote: r,
-				action: "delete",
-			})
-		}
-	}
-
-	if len(vargs.CloudFrontDistribution) > 0 {
-		jobs = append(jobs, job{
 			local:  "",
-			remote: filepath.Join("/", vargs.Target, "*"),
+			remote: filepath.Join("/", a.vargs.Target, "*"),
 			action: "invalidateCloudFront",
 		})
 	}
+}
 
+func (a *app) runJobs() {
+	vargs := a.vargs
+	client := a.client
 	jobChan := make(chan struct{}, maxConcurrent)
-	results := make(chan *result, len(jobs))
+	results := make(chan *result, len(a.jobs))
 
 	fmt.Printf("Synchronizing with bucket \"%s\"\n", vargs.Bucket)
-	for _, j := range jobs {
+	for _, j := range a.jobs {
 		jobChan <- struct{}{}
 		go func(j job) {
+			var err error
 			if j.action == "upload" {
 				err = client.Upload(j.local, j.remote)
 			} else if j.action == "redirect" {
 				err = client.Redirect(j.local, j.remote)
-			} else if j.action == "delete" && vargs.Delete {
+			} else if j.action == "delete" {
 				err = client.Delete(j.remote)
 			} else if j.action == "invalidateCloudFront" {
 				client.Invalidate(j.remote)
@@ -151,15 +211,13 @@ func main() {
 		}(j)
 	}
 
-	for _ = range jobs {
+	for _ = range a.jobs {
 		r := <-results
 		if r.err != nil {
 			fmt.Printf("ERROR: failed to %s %s to %s: %+v\n", r.j.action, r.j.local, r.j.remote, r.err)
 			os.Exit(1)
 		}
 	}
-
-	fmt.Println("done!")
 }
 
 func debug(format string, args ...interface{}) {