podman-remote.conf enablement

add the ability for the podman remote client to use a configuration file
which describes its connections. users can now define a connection the
configuration and then call it by name like:

podman-remote -c connection1

and the destination and user will be derived from the configuration
file.  if no -c is provided, we look for a connection in the
configuration file designated as 'default'.  If the configuration file
has only one connection, it will be deemed the 'default'.

Signed-off-by: baude <bbaude@redhat.com>

9 files changed, 341 insertions, 3 deletions

diff --git a/cmd/podman/cliconfig/config.go b/cmd/podman/cliconfig/config.go
index aaa4513d8..61ea26cf7 100644
--- a/cmd/podman/cliconfig/config.go
+++ b/cmd/podman/cliconfig/config.go
@@ -33,9 +33,11 @@ type MainFlags struct {
 	LogLevel   string
 	TmpDir     string
 
-	RemoteUserName string
-	RemoteHost     string
-	VarlinkAddress string
+	RemoteUserName       string
+	RemoteHost           string
+	VarlinkAddress       string
+	ConnectionName       string
+	RemoteConfigFilePath string
 }
 
 type AttachValues struct {
diff --git a/cmd/podman/main_remote.go b/cmd/podman/main_remote.go
index c8bb3ad3e..1b8db44a7 100644
--- a/cmd/podman/main_remote.go
+++ b/cmd/podman/main_remote.go
@@ -9,6 +9,8 @@ import (
 const remote = true
 
 func init() {
+	rootCmd.PersistentFlags().StringVarP(&MainGlobalOpts.ConnectionName, "connection", "c", "", "remote connection name")
+	rootCmd.PersistentFlags().StringVar(&MainGlobalOpts.RemoteConfigFilePath, "remote-config-path", "", "alternate path for configuration file")
 	rootCmd.PersistentFlags().StringVar(&MainGlobalOpts.RemoteUserName, "username", "", "username on the remote host")
 	rootCmd.PersistentFlags().StringVar(&MainGlobalOpts.RemoteHost, "remote-host", "", "remote host")
 	// TODO maybe we allow the altering of this for bridge connections?
diff --git a/cmd/podman/remoteclientconfig/config.go b/cmd/podman/remoteclientconfig/config.go
new file mode 100644
index 000000000..01f293ec3
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/config.go
@@ -0,0 +1,21 @@
+package remoteclientconfig
+
+const remoteConfigFileName string = "podman-remote.conf"
+
+// RemoteConfig describes the podman remote configuration file
+type RemoteConfig struct {
+	Connections map[string]RemoteConnection
+}
+
+// RemoteConnection describes the attributes of a podman-remote endpoint
+type RemoteConnection struct {
+	Destination string `toml:"destination"`
+	Username    string `toml:"username"`
+	IsDefault   bool   `toml:"default"`
+}
+
+// GetConfigFilePath is a simple helper to export the configuration file's
+// path based on arch, etc
+func GetConfigFilePath() string {
+	return getConfigFilePath()
+}
diff --git a/cmd/podman/remoteclientconfig/config_darwin.go b/cmd/podman/remoteclientconfig/config_darwin.go
new file mode 100644
index 000000000..b94941381
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/config_darwin.go
@@ -0,0 +1,12 @@
+package remoteclientconfig
+
+import (
+	"path/filepath"
+
+	"github.com/docker/docker/pkg/homedir"
+)
+
+func getConfigFilePath() string {
+	homeDir := homedir.Get()
+	return filepath.Join(homeDir, ".config", "containers", remoteConfigFileName)
+}
diff --git a/cmd/podman/remoteclientconfig/config_linux.go b/cmd/podman/remoteclientconfig/config_linux.go
new file mode 100644
index 000000000..b94941381
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/config_linux.go
@@ -0,0 +1,12 @@
+package remoteclientconfig
+
+import (
+	"path/filepath"
+
+	"github.com/docker/docker/pkg/homedir"
+)
+
+func getConfigFilePath() string {
+	homeDir := homedir.Get()
+	return filepath.Join(homeDir, ".config", "containers", remoteConfigFileName)
+}
diff --git a/cmd/podman/remoteclientconfig/config_windows.go b/cmd/podman/remoteclientconfig/config_windows.go
new file mode 100644
index 000000000..fa6ffca63
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/config_windows.go
@@ -0,0 +1,12 @@
+package remoteclientconfig
+
+import (
+	"path/filepath"
+
+	"github.com/docker/docker/pkg/homedir"
+)
+
+func getConfigFilePath() string {
+	homeDir := homedir.Get()
+	return filepath.Join(homeDir, "AppData", "podman", remoteConfigFileName)
+}
diff --git a/cmd/podman/remoteclientconfig/configfile.go b/cmd/podman/remoteclientconfig/configfile.go
new file mode 100644
index 000000000..aa3e82a31
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/configfile.go
@@ -0,0 +1,62 @@
+package remoteclientconfig
+
+import (
+	"io"
+
+	"github.com/BurntSushi/toml"
+	"github.com/pkg/errors"
+)
+
+// ReadRemoteConfig takes an io.Reader representing the remote configuration
+// file and returns a remoteconfig
+func ReadRemoteConfig(reader io.Reader) (*RemoteConfig, error) {
+	var remoteConfig RemoteConfig
+	// the configuration file does not exist
+	if reader == nil {
+		return &remoteConfig, ErrNoConfigationFile
+	}
+	_, err := toml.DecodeReader(reader, &remoteConfig)
+	if err != nil {
+		return nil, err
+	}
+	// We need to validate each remote connection has fields filled out
+	for name, conn := range remoteConfig.Connections {
+		if len(conn.Destination) < 1 {
+			return nil, errors.Errorf("connection %s has no destination defined", name)
+		}
+	}
+	return &remoteConfig, err
+}
+
+// GetDefault returns the default RemoteConnection. If there is only one
+// connection, we assume it is the default as well
+func (r *RemoteConfig) GetDefault() (*RemoteConnection, error) {
+	if len(r.Connections) == 0 {
+		return nil, ErrNoDefinedConnections
+	}
+	for _, v := range r.Connections {
+		if len(r.Connections) == 1 {
+			// if there is only one defined connection, we assume it is
+			// the default whether tagged as such or not
+			return &v, nil
+		}
+		if v.IsDefault {
+			return &v, nil
+		}
+	}
+	return nil, ErrNoDefaultConnection
+}
+
+// GetRemoteConnection "looks up" a remote connection by name and returns it in the
+// form of a RemoteConnection
+func (r *RemoteConfig) GetRemoteConnection(name string) (*RemoteConnection, error) {
+	if len(r.Connections) == 0 {
+		return nil, ErrNoDefinedConnections
+	}
+	for k, v := range r.Connections {
+		if k == name {
+			return &v, nil
+		}
+	}
+	return nil, errors.Wrap(ErrConnectionNotFound, name)
+}
diff --git a/cmd/podman/remoteclientconfig/configfile_test.go b/cmd/podman/remoteclientconfig/configfile_test.go
new file mode 100644
index 000000000..66e0a4693
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/configfile_test.go
@@ -0,0 +1,201 @@
+package remoteclientconfig
+
+import (
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var goodConfig = `
+[connections]
+
+[connections.homer]
+destination = "192.168.1.1"
+username = "myuser"
+default = true
+
+[connections.bart]
+destination = "foobar.com"
+username = "root"
+`
+var noDest = `
+[connections]
+
+[connections.homer]
+destination = "192.168.1.1"
+username = "myuser"
+default = true
+
+[connections.bart]
+username = "root"
+`
+
+var noUser = `
+[connections]
+
+[connections.homer]
+destination = "192.168.1.1"
+`
+
+func makeGoodResult() *RemoteConfig {
+	var goodConnections = make(map[string]RemoteConnection)
+	goodConnections["homer"] = RemoteConnection{
+		Destination: "192.168.1.1",
+		Username:    "myuser",
+		IsDefault:   true,
+	}
+	goodConnections["bart"] = RemoteConnection{
+		Destination: "foobar.com",
+		Username:    "root",
+	}
+	var goodResult = RemoteConfig{
+		Connections: goodConnections,
+	}
+	return &goodResult
+}
+
+func makeNoUserResult() *RemoteConfig {
+	var goodConnections = make(map[string]RemoteConnection)
+	goodConnections["homer"] = RemoteConnection{
+		Destination: "192.168.1.1",
+	}
+	var goodResult = RemoteConfig{
+		Connections: goodConnections,
+	}
+	return &goodResult
+}
+
+func TestReadRemoteConfig(t *testing.T) {
+	type args struct {
+		reader io.Reader
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *RemoteConfig
+		wantErr bool
+	}{
+		// good test should pass
+		{"good", args{reader: strings.NewReader(goodConfig)}, makeGoodResult(), false},
+		// a connection with no destination is an error
+		{"nodest", args{reader: strings.NewReader(noDest)}, nil, true},
+		// a connnection with no user is OK
+		{"nouser", args{reader: strings.NewReader(noUser)}, makeNoUserResult(), false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ReadRemoteConfig(tt.args.reader)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ReadRemoteConfig() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ReadRemoteConfig() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestRemoteConfig_GetDefault(t *testing.T) {
+	good := make(map[string]RemoteConnection)
+	good["homer"] = RemoteConnection{
+		Username:    "myuser",
+		Destination: "192.168.1.1",
+		IsDefault:   true,
+	}
+	good["bart"] = RemoteConnection{
+		Username:    "root",
+		Destination: "foobar.com",
+	}
+	noDefault := make(map[string]RemoteConnection)
+	noDefault["homer"] = RemoteConnection{
+		Username:    "myuser",
+		Destination: "192.168.1.1",
+	}
+	noDefault["bart"] = RemoteConnection{
+		Username:    "root",
+		Destination: "foobar.com",
+	}
+	single := make(map[string]RemoteConnection)
+	single["homer"] = RemoteConnection{
+		Username:    "myuser",
+		Destination: "192.168.1.1",
+	}
+
+	none := make(map[string]RemoteConnection)
+
+	type fields struct {
+		Connections map[string]RemoteConnection
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		want    *RemoteConnection
+		wantErr bool
+	}{
+		// A good toml should return the connection that is marked isDefault
+		{"good", fields{Connections: makeGoodResult().Connections}, &RemoteConnection{"192.168.1.1", "myuser", true}, false},
+		// If nothing is marked as isDefault and there is more than one connection, error should occur
+		{"nodefault", fields{Connections: noDefault}, nil, true},
+		// if nothing is marked as isDefault but there is only one connection, the one connection is considered the default
+		{"single", fields{Connections: none}, nil, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &RemoteConfig{
+				Connections: tt.fields.Connections,
+			}
+			got, err := r.GetDefault()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("RemoteConfig.GetDefault() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("RemoteConfig.GetDefault() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestRemoteConfig_GetRemoteConnection(t *testing.T) {
+	type fields struct {
+		Connections map[string]RemoteConnection
+	}
+	type args struct {
+		name string
+	}
+
+	blank := make(map[string]RemoteConnection)
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    *RemoteConnection
+		wantErr bool
+	}{
+		// Good connection
+		{"goodhomer", fields{Connections: makeGoodResult().Connections}, args{name: "homer"}, &RemoteConnection{"192.168.1.1", "myuser", true}, false},
+		// Good connection
+		{"goodbart", fields{Connections: makeGoodResult().Connections}, args{name: "bart"}, &RemoteConnection{"foobar.com", "root", false}, false},
+		// Getting an unknown connection should result in error
+		{"noexist", fields{Connections: makeGoodResult().Connections}, args{name: "foobar"}, nil, true},
+		// Getting a connection when there are none should result in an error
+		{"none", fields{Connections: blank}, args{name: "foobar"}, nil, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &RemoteConfig{
+				Connections: tt.fields.Connections,
+			}
+			got, err := r.GetRemoteConnection(tt.args.name)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("RemoteConfig.GetRemoteConnection() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("RemoteConfig.GetRemoteConnection() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/cmd/podman/remoteclientconfig/errors.go b/cmd/podman/remoteclientconfig/errors.go
new file mode 100644
index 000000000..2689d3b49
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/errors.go
@@ -0,0 +1,14 @@
+package remoteclientconfig
+
+import "errors"
+
+var (
+	// ErrNoDefaultConnection no default connection is defined in the podman-remote.conf file
+	ErrNoDefaultConnection = errors.New("no default connection is defined")
+	// ErrNoDefinedConnections no connections are defined in the podman-remote.conf file
+	ErrNoDefinedConnections = errors.New("no remote connections have been defined")
+	// ErrConnectionNotFound unable to lookup connection by name
+	ErrConnectionNotFound = errors.New("remote connection not found by name")
+	// ErrNoConfigationFile no config file found
+	ErrNoConfigationFile = errors.New("no configuration file found")
+)