use functional options

Author: ChristianKniep

main.go

@@ -6,43 +6,67 @@ import (
 	"github.com/zpatrick/go-config"
 	"github.com/codegangsta/cli"
 	"github.com/qnib/doxy/proxy"
+	"fmt"
 )
 
+var (
+	dockerSocketFlag = cli.StringFlag{
+		Name:  "docker-socket",
+		Value: proxy.DOCKER_SOCKET,
+		Usage: "Docker host to connect to.",
+		EnvVar: "DOXY_DOCKER_SOCKET",
+	}
+	proxySocketFlag = cli.StringFlag{
+		Name:  "proxy-socket",
+		Value: proxy.PROXY_SOCKET,
+		Usage: "Proxy socket to be created",
+		EnvVar: "DOXY_PROXY_SOCKET",
+	}
+	debugFlag = cli.BoolFlag{
+		Name: "debug",
+		Usage: "Print proxy requests",
+		EnvVar: "DOXY_DEBUG",
+	}
+	patternFileFlag = cli.StringFlag{
+		Name:  "pattern-file",
+		Value: proxy.PATTERN_FILE,
+		Usage: "File holding line-separated regex-patterns to be allowed (comments allowed, use #)",
+		EnvVar: "DOXY_PATTERN_FILE",
+	}
+)
 
-func RunApp(ctx *cli.Context) {
-	log.Printf("[II] Start Version: %s", ctx.App.Version)
-	cfg := config.NewConfig([]config.Provider{config.NewCLI(ctx, true)})
-	newSock, _ := cfg.String("proxy-socket")
+func EvalOptions(cfg *config.Config) (po []proxy.ProxyOption) {
+	s, _ := cfg.Settings()
+	ps, _ := cfg.String("proxy-socket")
+	fmt.Printf("%v | dS:%s\n", s, ps)
+	proxySock, _ := cfg.String("proxy-socket")
+	po = append(po, proxy.WithProxySocket(proxySock))
 	dockerSock, _ := cfg.String("docker-socket")
+	po = append(po, proxy.WithDockerSocket(dockerSock))
 	debug, _ := cfg.Bool("debug")
+	po = append(po, proxy.WithDebugValue(debug))
+	return
+}
+
+func EvalPatternOpts(cfg *config.Config) (proxy.ProxyOption) {
 	patternsFile, _ := cfg.String("pattern-file")
 	reader, err := os.Open(patternsFile)
 	defer reader.Close()
 	patterns := []string{}
 	if err != nil {
 		log.Printf("Error reading patterns file (%s), using default patterns\n", err.Error())
-		patterns = []string{
-			`^/(v\d\.\d+/)?containers(/\w+)?/(json|stats|top)$`,
-			`^/(v\d\.\d+/)?services(/[0-9a-f]+)?$`,
-			`^/(v\d\.\d+/)?tasks(/\w+)?$`,
-			`^/(v\d\.\d+/)?networks(/\w+)?$`,
-			`^/(v\d\.\d+/)?volumes(/\w+)?$`,
-			`^/(v\d\.\d+/)?nodes(/\w+)?$`,
-			`^/(v\d\.\d+/)?info$`,
-			`^/(v\d\.\d+/)?version$`,
-			"^/_ping$",
-		}
-		if debug {
-			for i, p := range patterns {
-				log.Printf("%-3d: %s\n", i,p)
-			}
-
-		}
-	} else {
-		patterns, err  = proxy.ReadPatterns(reader)
+		return proxy.WithPatterns(proxy.DEFAULT_PATTERNS)
 	}
-	p := proxy.NewProxy(newSock, dockerSock, debug)
-	p.AddPatterns(patterns)
+	patterns, err  = proxy.ReadPatterns(reader)
+	return proxy.WithPatterns(patterns)
+}
+
+func RunApp(ctx *cli.Context) {
+	log.Printf("[II] Start Version: %s", ctx.App.Version)
+	cfg := config.NewConfig([]config.Provider{config.NewCLI(ctx, true)})
+	po := EvalOptions(cfg)
+	po = append(po, EvalPatternOpts(cfg))
+	p := proxy.NewProxy(po...)
 	p.Run()
 }
 
@@ -52,26 +76,10 @@ func main() {
 	app.Usage = "doxy [options]"
 	app.Version = "0.1.1"
 	app.Flags = []cli.Flag{
-		cli.StringFlag{
-			Name:  "docker-socket",
-			Value: "/var/run/docker.sock",
-			Usage: "Docker host to connect to.",
-			EnvVar: "DOXY_DOCKER_SOCKET",
-		}, cli.StringFlag{
-			Name:  "proxy-socket",
-			Value: "/tmp/doxy.sock",
-			Usage: "Proxy socket to be created",
-			EnvVar: "DOXY_PROXY_SOCKET",
-		}, cli.BoolFlag{
-			Name: "debug",
-			Usage: "Print proxy requests",
-			EnvVar: "DOXY_DEBUG",
-		}, cli.StringFlag{
-			Name:  "pattern-file",
-			Value: "/etc/doxy.pattern",
-			Usage: "File holding line-separated regex-patterns to be allowed (comments allowed, use #)",
-			EnvVar: "DOXY_PATTERN_FILE",
-	},
+		dockerSocketFlag,
+		proxySocketFlag,
+		debugFlag,
+		patternFileFlag,
 	}
 	app.Action = RunApp
 	app.Run(os.Args)

main_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"testing"
+	"github.com/zpatrick/go-config"
+	"github.com/qnib/doxy/proxy"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEvalOptions(t *testing.T) {
+	myCfg := map[string]string{
+		"proxy-socket": "proxy.sock",
+		"docker-socket": "docker.sock",
+		"debug": "true",
+	}
+	cfg := config.NewConfig([]config.Provider{config.NewStatic(myCfg)})
+	got := EvalOptions(cfg)
+	p := proxy.NewProxy(got...)
+	exp := map[string]interface{}{
+		"docker-socket": "docker.sock",
+		"proxy-socket": "proxy.sock",
+		"debug": true,
+		"patterns": []string{},
+	}
+	assert.Equal(t, exp, p.GetOptions())
+}
+
+func TestEvalPatternOpts(t *testing.T) {
+	cfg := config.NewConfig([]config.Provider{config.NewStatic(map[string]string{
+		"docker-socket": "docker.sock",
+		"proxy-socket": "proxy.sock",
+		"pattern-file": "some.file",
+	})})
+	got := EvalPatternOpts(cfg)
+	p := proxy.NewProxy(got)
+	exp := map[string]interface{}{
+		"docker-socket": "/var/run/docker.sock",
+		"proxy-socket": "/tmp/doxy.sock",
+		"debug": false,
+		"patterns": proxy.DEFAULT_PATTERNS,
+	}
+	opts := p.GetOptions()
+	assert.Equal(t, exp, opts)
+}

proxy/main.go

@@ -7,7 +7,26 @@ import (
 	"syscall"
 	"os/signal"
 	"github.com/urfave/negroni"
+)
+
+const (
+	DOCKER_SOCKET = "/var/run/docker.sock"
+	PROXY_SOCKET = "/tmp/doxy.sock"
+	PATTERN_FILE = "/etc/doxy.pattern"
+)
 
+var (
+	DEFAULT_PATTERNS = []string{
+		`^/(v\d\.\d+/)?containers(/\w+)?/(json|stats|top)$`,
+		`^/(v\d\.\d+/)?services(/[0-9a-f]+)?$`,
+		`^/(v\d\.\d+/)?tasks(/\w+)?$`,
+		`^/(v\d\.\d+/)?networks(/\w+)?$`,
+		`^/(v\d\.\d+/)?volumes(/\w+)?$`,
+		`^/(v\d\.\d+/)?nodes(/\w+)?$`,
+		`^/(v\d\.\d+/)?info$`,
+		`^/(v\d\.\d+/)?version$`,
+		"^/_ping$",
+	}
 )
 
 type Proxy struct {
@@ -16,21 +35,27 @@ type Proxy struct {
 	patterns 				[]string
 }
 
-func NewProxy(newsock, oldsock string, debug bool) Proxy {
+func NewProxy(opts ...ProxyOption) Proxy {
+	options := defaultProxyOptions
+	for _, o := range opts {
+		o(&options)
+	}
 	return Proxy{
-		dockerSocket: oldsock,
-		newSocket: newsock,
-		debug: debug,
-		patterns: []string{},
+		dockerSocket: options.DockerSocket,
+		newSocket: options.ProxySocket,
+		debug: options.Debug,
+		patterns: options.Patterns,
 	}
 }
 
-func (p *Proxy) AddPatterns(patterns []string) {
-	p.patterns = append(p.patterns,patterns...)
-}
-
-func (p *Proxy) AddPattern(pattern string) {
-	p.patterns = append(p.patterns,pattern)
+func (p *Proxy) GetOptions() map[string]interface{} {
+	opt := map[string]interface{}{
+		"docker-socket": p.dockerSocket,
+		"proxy-socket": p.newSocket,
+		"debug": p.debug,
+		"patterns": p.patterns,
+	}
+	return opt
 }
 
 func (p *Proxy) Run() {

proxy/main_test.go

@@ -5,14 +5,56 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestProxy_AddPattern(t *testing.T) {
-	p := NewProxy("new", "old", false)
-	p.AddPattern("mypat1")
+
+func TestProxy_NewProxyWithPattern(t *testing.T) {
+	p := NewProxy(
+		WithProxySocket("new"),
+		WithDockerSocket("old"),
+		WithPattern("mypat1"),
+	)
 	assert.Equal(t, []string{"mypat1"}, p.patterns)
+	assert.False(t, p.debug, "Debug should be false by default")
 }
 
-func TestProxy_AddPatterns(t *testing.T) {
-	p := NewProxy("new", "old", false)
-	p.AddPatterns([]string{"mypat1","mypat2"})
+func TestProxy_NewProxyWithPatterns(t *testing.T) {
+	p := NewProxy(
+		WithProxySocket("new"),
+		WithDockerSocket("old"),
+		WithPatterns([]string{"mypat1","mypat2"}),
+	)
 	assert.Equal(t, []string{"mypat1","mypat2"}, p.patterns)
+	assert.False(t, p.debug, "Debug should be false by default")
+
+}
+
+func TestProxy_NewProxyWithDebugEnabled(t *testing.T) {
+	p := NewProxy(
+		WithProxySocket("new"),
+		WithDockerSocket("old"),
+		WithDebugEnabled(),
+	)
+	assert.True(t, p.debug, "Debug should be set")
+}
+func TestProxy_NewProxyWithDebugValue(t *testing.T) {
+	p := NewProxy(
+		WithProxySocket("new"),
+		WithDockerSocket("old"),
+		WithDebugValue(true),
+	)
+	assert.True(t, p.debug, "Debug should be set")
 }
+
+func TestProxy_GetOptions(t *testing.T) {
+	p := NewProxy(
+		WithProxySocket("proxy.sock"),
+		WithDockerSocket("docker.sock"),
+		WithPattern("mypat1"),
+	)
+	exp := map[string]interface{}{
+		"docker-socket": "docker.sock",
+		"proxy-socket": "proxy.sock",
+		"debug": false,
+		"patterns": []string{"mypat1"},
+	}
+	assert.Equal(t, exp, p.GetOptions())
+}

proxy/options.go

@@ -0,0 +1,54 @@
+package proxy
+
+type ProxyOptions struct {
+	DockerSocket 	string
+	ProxySocket 	string
+	Debug 			bool
+	Patterns 		[]string
+}
+
+var defaultProxyOptions = ProxyOptions{
+	DockerSocket: DOCKER_SOCKET,
+	ProxySocket: PROXY_SOCKET,
+	Debug: false,
+	Patterns: []string{},
+}
+
+type ProxyOption func(*ProxyOptions)
+
+func WithDockerSocket(s string) ProxyOption {
+	return func(o *ProxyOptions) {
+		o.DockerSocket = s
+	}
+}
+
+func WithProxySocket(s string) ProxyOption {
+	return func(o *ProxyOptions) {
+		o.ProxySocket = s
+	}
+}
+
+func WithDebugValue(d bool) ProxyOption {
+	return func(o *ProxyOptions) {
+		o.Debug = d
+	}
+}
+
+func WithDebugEnabled() ProxyOption {
+	return func(o *ProxyOptions) {
+		o.Debug = true
+	}
+}
+
+func WithPattern(p string) ProxyOption {
+	return func(o *ProxyOptions) {
+		o.Patterns = append(o.Patterns, p)
+	}
+}
+
+func WithPatterns(p []string) ProxyOption {
+	return func(o *ProxyOptions) {
+		o.Patterns = p
+	}
+}
+