rework of credentials to use interfaces+structs

Author: aztechian

internal/app/bridgr/config/docker.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"bridgr/internal/app/bridgr"
 	"fmt"
 	"log"
 	"path"
@@ -50,6 +51,7 @@ func parseDocker(conf tempConfig) Docker {
 	default:
 		log.Printf("DEBUG: Unknown configuration section for Docker: %+v", cfgBlock)
 	}
+	bridgr.Debugf("Final Docker configuration %+v", d)
 	return d
 }
 

internal/app/bridgr/config/files.go

@@ -16,9 +16,8 @@ type Files struct {
 
 // FileItem is a discreet file definition object
 type FileItem struct {
-	Source   string
-	Target   string
-	Protocol string
+	Source *url.URL
+	Target string
 }
 
 // BaseDir is the top-level directory name for all objects written out under the Files worker
@@ -50,17 +49,24 @@ func parseFiles(conf tempConfig) Files {
 }
 
 func (f *FileItem) parseSimple(s string) error {
-	f.Protocol = getFileProtocol(s)
-	f.Source = s
+	url, err := url.Parse(s)
+	if err != nil {
+		return err
+	}
+	// setProtocol(url)
+	f.Source = url
 	f.Target = getFileTarget(s)
 	return nil
 }
 
 func (f *FileItem) parseComplex(s map[interface{}]interface{}) error {
 	source := s["source"].(string)
 	target := s["target"].(string)
-	f.Protocol = getFileProtocol(source)
-	f.Source = source
+	url, err := url.Parse(source)
+	if err != nil {
+		return err
+	}
+	f.Source = url
 	if strings.HasSuffix(target, "/") {
 		f.Target = filepath.Join(new(Files).BaseDir(), target, filepath.Base(source))
 	} else {
@@ -69,14 +75,6 @@ func (f *FileItem) parseComplex(s map[interface{}]interface{}) error {
 	return nil
 }
 
-func getFileProtocol(src string) string {
-	url, _ := url.Parse(src)
-	if url.Scheme == "" {
-		return "file"
-	}
-	return url.Scheme
-}
-
 func getFileTarget(src string) string {
 	return filepath.Join(new(Files).BaseDir(), filepath.Base(src))
 }

internal/app/bridgr/config/files_internal_test.go

@@ -1,11 +1,20 @@
 package config
 
 import (
+	"net/url"
 	"os"
 	"path"
 	"testing"
+
+	"github.com/google/go-cmp/cmp"
 )
 
+var rootFile, _ = url.Parse("/afile.xyz")
+var relativeFile, _ = url.Parse("my/file.abc")
+var file, _ = url.Parse("file://some/file/toget.zip")
+var httpFile, _ = url.Parse("http://mysite.com/file.gz")
+var httpsFile, _ = url.Parse("https://mysite.com/archive.tar")
+var blahFile, _ = url.Parse("blah://mysite.com/file.js")
 var cwd, _ = os.Getwd()
 var dir = path.Join(cwd, "packages", "files")
 
@@ -23,6 +32,7 @@ func TestParseFiles(t *testing.T) {
 		{"nil", tempConfig{Files: nil}, 0, 0, 0},
 		{"non string", tempConfig{Files: []interface{}{2}}, 0, 0, 0},
 		{"multiple entries", tempConfig{Files: []interface{}{"file1.zip", "file2.tar"}}, 2, 2, 0},
+		{"error - bad url", tempConfig{Files: []interface{}{"\x7f"}}, 0, 0, 0},
 	}
 
 	for _, test := range tests {
@@ -40,24 +50,26 @@ func TestParseSimple(t *testing.T) {
 	tests := []struct {
 		given    string
 		expected FileItem
+		isError  bool
 	}{
-		{"/afile.zyx", FileItem{"/afile.zyx", path.Join(dir, "afile.zyx"), "file"}},
-		{"my/file.abc", FileItem{"my/file.abc", path.Join(dir, "file.abc"), "file"}},
-		{"file://some/file/toget.zip", FileItem{"file://some/file/toget.zip", path.Join(dir, "toget.zip"), "file"}},
-		{"http://mysite.com/file.gz", FileItem{"http://mysite.com/file.gz", path.Join(dir, "file.gz"), "http"}},
-		{"https://mysite.com/archive.tar", FileItem{"https://mysite.com/archive.tar", path.Join(dir, "archive.tar"), "https"}},
-		{"blah://mysite.com/file.js", FileItem{"blah://mysite.com/file.js", path.Join(dir, "file.js"), "blah"}},
+		{rootFile.String(), FileItem{rootFile, path.Join(dir, "afile.xyz")}, false},
+		{relativeFile.String(), FileItem{relativeFile, path.Join(dir, "file.abc")}, false},
+		{file.String(), FileItem{file, path.Join(dir, "toget.zip")}, false},
+		{httpFile.String(), FileItem{httpFile, path.Join(dir, "file.gz")}, false},
+		{httpsFile.String(), FileItem{httpsFile, path.Join(dir, "archive.tar")}, false},
+		{blahFile.String(), FileItem{blahFile, path.Join(dir, "file.js")}, false},
+		{"\x7f", FileItem{}, true},
 	}
 
 	for _, test := range tests {
 		t.Run(test.given, func(t *testing.T) {
 			result := FileItem{}
 			err := result.parseSimple(test.given)
-			if err != nil {
-				t.Errorf("Got error from parseSimple: %s", err)
+			if err != nil && !test.isError {
+				t.Error(err)
 			}
-			if result != test.expected {
-				t.Errorf("Expected %+v from parseSimple(), got %+v", test.expected, result)
+			if !cmp.Equal(result, test.expected) {
+				t.Errorf("unexpected result from parseSimple() %s", cmp.Diff(result, test.expected))
 			}
 		})
 	}
@@ -67,48 +79,27 @@ func TestParseComplex(t *testing.T) {
 	tests := []struct {
 		given    map[interface{}]interface{}
 		expected FileItem
+		isError  bool
 	}{
-		{map[interface{}]interface{}{"source": "/afile.zyx", "target": "/afile.zyx"}, FileItem{"/afile.zyx", path.Join(dir, "afile.zyx"), "file"}},
-		{map[interface{}]interface{}{"source": "my/file.abc", "target": "file.xyz"}, FileItem{"my/file.abc", path.Join(dir, "file.xyz"), "file"}},
-		{map[interface{}]interface{}{"source": "my/file.bac", "target": "myfolder/"}, FileItem{"my/file.bac", path.Join(dir, "myfolder", "file.bac"), "file"}},
-		{map[interface{}]interface{}{"source": "file://some/file/toget.zip", "target": "file.toget.zip"}, FileItem{"file://some/file/toget.zip", path.Join(dir, "file.toget.zip"), "file"}},
-		{map[interface{}]interface{}{"source": "http://mysite.com/file.gz", "target": "file.gz"}, FileItem{"http://mysite.com/file.gz", path.Join(dir, "file.gz"), "http"}},
-		{map[interface{}]interface{}{"source": "https://mysite.com/archive.tar", "target": "archive.tgz"}, FileItem{"https://mysite.com/archive.tar", path.Join(dir, "archive.tgz"), "https"}},
-		{map[interface{}]interface{}{"source": "blah://mysite.com/file.js", "target": "myfile.js"}, FileItem{"blah://mysite.com/file.js", path.Join(dir, "myfile.js"), "blah"}},
+		{map[interface{}]interface{}{"source": rootFile.String(), "target": "/afile.zyx"}, FileItem{rootFile, path.Join(dir, "afile.zyx")}, false},
+		{map[interface{}]interface{}{"source": relativeFile.String(), "target": "file.xyz"}, FileItem{relativeFile, path.Join(dir, "file.xyz")}, false},
+		{map[interface{}]interface{}{"source": relativeFile.String(), "target": "myfolder/"}, FileItem{relativeFile, path.Join(dir, "myfolder", "file.abc")}, false},
+		{map[interface{}]interface{}{"source": file.String(), "target": "file.toget.zip"}, FileItem{file, path.Join(dir, "file.toget.zip")}, false},
+		{map[interface{}]interface{}{"source": httpFile.String(), "target": "file.gz"}, FileItem{httpFile, path.Join(dir, "file.gz")}, false},
+		{map[interface{}]interface{}{"source": httpsFile.String(), "target": "archive.tgz"}, FileItem{httpsFile, path.Join(dir, "archive.tgz")}, false},
+		{map[interface{}]interface{}{"source": blahFile.String(), "target": "myfile.js"}, FileItem{blahFile, path.Join(dir, "myfile.js")}, false},
+		{map[interface{}]interface{}{"source": "\x7f", "target": "*shrug*"}, FileItem{}, true},
 	}
 
 	for _, test := range tests {
 		t.Run(test.given["source"].(string), func(t *testing.T) {
 			result := FileItem{}
 			err := result.parseComplex(test.given)
-			if err != nil {
-				t.Errorf("Got error from parseComplex: %s", err)
+			if err != nil && !test.isError {
+				t.Error(err)
 			}
-			if result != test.expected {
-				t.Errorf("Expected %s from parseComplex(), got %s", test.expected, result)
-			}
-		})
-	}
-}
-
-func TestGetFileProtocol(t *testing.T) {
-	tests := []struct {
-		given    string
-		expected string
-	}{
-		{"/afile.zyx", "file"},
-		{"my/file.abc", "file"},
-		{"file://some/file/toget.zip", "file"},
-		{"http://mysite.com/file.gz", "http"},
-		{"https://mysite.com/archive.tar", "https"},
-		{"blah://mysite.com/file.js", "blah"},
-	}
-
-	for _, test := range tests {
-		t.Run(test.given, func(t *testing.T) {
-			result := getFileProtocol(test.given)
-			if result != test.expected {
-				t.Errorf("Expected %s from getFileProtocol(), got %s", test.expected, result)
+			if !cmp.Equal(result, test.expected) {
+				t.Errorf("unexpected result from parseComplex() %s", cmp.Diff(result, test.expected))
 			}
 		})
 	}

internal/app/bridgr/workers/credentials.go

@@ -0,0 +1,47 @@
+package workers
+
+import (
+	"encoding/base64"
+	"net/url"
+)
+
+// CredentialReader is the interface that wraps a Credential Read method
+// The Reader should get credential information from somewhere (usually the runtime environment), and returns
+// a Credential struct as well as a boolean that indicates whether the reading of credential pieces (ie, Username, Password and/or Token) was successful.
+// Success is not strictly whether the pieces of information were found, but whether they existed in the environment to be read. A Credential struct with
+// empty strings for its fields is still a valid Credential
+type CredentialReader interface {
+	Read(*url.URL) (Credential, bool)
+}
+
+// CredentialWriter is the interface wrapping the Write method for Credentials
+// Write may write a credential to any form (string, another struct), and any medium (memory, file, etc).
+type CredentialWriter interface {
+	Write(Credential) error
+}
+
+// CredentialReaderWriter is an interface that combines both the CredentialReader and CredentialWriter
+type CredentialReaderWriter interface {
+	CredentialReader
+	CredentialWriter
+}
+
+// Credential encapsulates a username/password pair
+type Credential struct {
+	Username string
+	Password string
+}
+
+// Conjoin returns a string with the Credential content joined by a ':' (colon character)
+func (c *Credential) Conjoin() string {
+	return c.Username + ":" + c.Password
+}
+
+// Base64 returns a string with the provided Credential content base64 encoded after being joined by ':' (colon character)
+func (c *Credential) Base64() string {
+	value := c.Conjoin()
+	if value == ":" {
+		return ""
+	}
+	return base64.StdEncoding.EncodeToString([]byte(value))
+}

internal/app/bridgr/workers/credentials_test.go

@@ -0,0 +1,48 @@
+package workers_test
+
+import (
+	"bridgr/internal/app/bridgr/workers"
+	"testing"
+)
+
+func TestConjoined(t *testing.T) {
+	tests := []struct {
+		name   string
+		cred   workers.Credential
+		expect string
+	}{
+		{"user and password", workers.Credential{Username: "me", Password: "myself"}, "me:myself"},
+		{"empty credential", workers.Credential{}, ":"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result := test.cred.Conjoin()
+			if result != test.expect {
+				t.Errorf("Expected %s from Conjoin() but got %s", test.expect, result)
+			}
+		})
+	}
+}
+
+func TestBase64(t *testing.T) {
+	tests := []struct {
+		name   string
+		cred   workers.Credential
+		expect string
+	}{
+		{"user and password", workers.Credential{Username: "me", Password: "myself"}, "bWU6bXlzZWxm"},
+		{"empty creds", workers.Credential{}, ""},
+		{"only username", workers.Credential{Username: "michael"}, "bWljaGFlbDo="},
+		{"only password", workers.Credential{Password: "bluth"}, "OmJsdXRo"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result := test.cred.Base64()
+			if result != test.expect {
+				t.Errorf("Expected %s but got %s", test.expect, result)
+			}
+		})
+	}
+}

internal/app/bridgr/workers/docker.go

@@ -4,6 +4,8 @@ import (
 	"bridgr/internal/app/bridgr"
 	"bridgr/internal/app/bridgr/config"
 	"context"
+	"encoding/base64"
+	"encoding/json"
 	"io"
 	"io/ioutil"
 	"os"
@@ -22,6 +24,11 @@ type Docker struct {
 	Cli    client.ImageAPIClient
 }
 
+type dockerCredential struct {
+	types.AuthConfig
+	workerCredentialReader
+}
+
 // NewDocker creates a Docker worker from the configuration object
 func NewDocker(conf *config.BridgrConf) Worker {
 	_ = os.MkdirAll(conf.Docker.BaseDir(), os.ModePerm)
@@ -116,3 +123,17 @@ func (d *Docker) tagForRemote(local reference.Named) string {
 	_ = d.Cli.ImageTag(context.Background(), local.Name(), remoteTag)
 	return remoteTag
 }
+
+func (credWriter *dockerCredential) Write(c Credential) error {
+	credWriter.Username = c.Username
+	credWriter.Password = c.Password
+	return nil
+}
+
+func (credWriter *dockerCredential) String() string {
+	if credWriter.Username == "" && credWriter.Password == "" {
+		return ""
+	}
+	jsonAuth, _ := json.Marshal(credWriter)
+	return base64.URLEncoding.EncodeToString(jsonAuth)
+}