remove options struct, yay!

Signed-off-by: Victor Vieux <victorvieux@gmail.com>

cli/cli.go

@@ -104,7 +104,7 @@ func Run() {
 			Flags: []cli.Flag{
 				flStore,
 				flStrategy, flFilter,
-				flHosts, flHeartBeat,
+				flHosts,
 				flTLS, flTLSCaCert, flTLSCert, flTLSKey, flTLSVerify,
 				flEnableCors,
 				flCluster, flClusterOpt},

cli/help.go

@@ -25,7 +25,8 @@ ARGUMENTS:
             {{printf "\t"}} * <ip1>,<ip2>{{end}}{{if .Flags}}
 OPTIONS:
    {{range .Flags}}{{.}}
-   {{end}}{{if (eq .Name "manage")}}{{printf "\t * swarm.overcommit=0.05\tovercommit to apply on resources\n"}}{{end}}{{ end }}
+   {{end}}{{if (eq .Name "manage")}}{{printf "\t * swarm.overcommit=0.05\tovercommit to apply on resources"}}
+                                    {{printf "\t * swarm.heartbeat=25\ttime in second between each heartbeat"}}{{end}}{{ end }}
 `
 
 }

cli/manage.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io/ioutil"
 	"path"
-	"strconv"
 
 	log "github.com/Sirupsen/logrus"
 	"github.com/codegangsta/cli"
@@ -120,18 +119,7 @@ func manage(c *cli.Context) {
 
 	sched := scheduler.New(s, fs)
 
-	hb, err := strconv.ParseUint(c.String("heartbeat"), 0, 32)
-	if hb < 1 || err != nil {
-		log.Fatal("--heartbeat should be an unsigned integer and greater than 0")
-	}
-	options := &cluster.Options{
-		TLSConfig: tlsConfig,
-		Opts:      c.StringSlice("cluster-opt"),
-		Discovery: dflag,
-		Heartbeat: hb,
-	}
-
-	cluster, err := swarm.NewCluster(sched, store, options)
+	cluster, err := swarm.NewCluster(sched, store, tlsConfig, dflag, c.StringSlice("cluster-opt"))
 	if err != nil {
 		log.Fatal(err)
 	}

cluster/options.go

@@ -1,11 +1,47 @@
 package cluster
 
-import "crypto/tls"
+import (
+	"strconv"
+	"strings"
+)
 
-// Options is exported
-type Options struct {
-	TLSConfig *tls.Config
-	Opts      []string
-	Discovery string
-	Heartbeat uint64
+// DriverOpts are key=values options
+type DriverOpts []string
+
+// String returns a string from the driver options
+func (do DriverOpts) String(key string) (string, bool) {
+	for _, opt := range do {
+		kv := strings.SplitN(opt, "=", 2)
+		if kv[0] == key {
+			return kv[1], true
+		}
+	}
+	return "", false
+}
+
+// Int returns an int64 from the driver options
+func (do DriverOpts) Int(key string) (int64, bool) {
+	if value, ok := do.String(key); ok {
+		v, _ := strconv.ParseInt(value, 0, 64)
+		return v, true
+	}
+	return 0, false
+}
+
+// Uint returns an int64 from the driver options
+func (do DriverOpts) Uint(key string) (uint64, bool) {
+	if value, ok := do.String(key); ok {
+		v, _ := strconv.ParseUint(value, 0, 64)
+		return v, true
+	}
+	return 0, false
+}
+
+// Float returns a float64 from the driver options
+func (do DriverOpts) Float(key string) (float64, bool) {
+	if value, ok := do.String(key); ok {
+		v, _ := strconv.ParseFloat(value, 64)
+		return v, true
+	}
+	return 0.0, false
 }

cluster/options_test.go

@@ -0,0 +1,97 @@
+package cluster
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var opts = DriverOpts{"foo1=bar", "foo2=-5", "foo3=7", "foo4=0.6"}
+
+func TestString(t *testing.T) {
+	val, ok := opts.String("foo1")
+	assert.True(t, ok)
+	assert.Equal(t, val, "bar")
+
+	val, ok = opts.String("foo2")
+	assert.True(t, ok)
+	assert.Equal(t, val, "-5")
+
+	val, ok = opts.String("foo3")
+	assert.True(t, ok)
+	assert.Equal(t, val, "7")
+
+	val, ok = opts.String("foo4")
+	assert.True(t, ok)
+	assert.Equal(t, val, "0.6")
+
+	val, ok = opts.String("invalid")
+	assert.False(t, ok)
+	assert.Equal(t, val, "")
+}
+
+func TestInt(t *testing.T) {
+	val, ok := opts.Int("foo1")
+	assert.True(t, ok)
+	assert.Equal(t, val, 0)
+
+	val, ok = opts.Int("foo2")
+	assert.True(t, ok)
+	assert.Equal(t, val, -5)
+
+	val, ok = opts.Int("foo3")
+	assert.True(t, ok)
+	assert.Equal(t, val, 7)
+
+	val, ok = opts.Int("foo4")
+	assert.True(t, ok)
+	assert.Equal(t, val, 0)
+
+	val, ok = opts.Int("invalid")
+	assert.False(t, ok)
+	assert.Equal(t, val, 0)
+}
+
+func TestUint(t *testing.T) {
+	val, ok := opts.Uint("foo1")
+	assert.True(t, ok)
+	assert.Equal(t, val, uint(0))
+
+	val, ok = opts.Uint("foo2")
+	assert.True(t, ok)
+	assert.Equal(t, val, uint(0))
+
+	val, ok = opts.Uint("foo3")
+	assert.True(t, ok)
+	assert.Equal(t, val, uint(7))
+
+	val, ok = opts.Uint("foo4")
+	assert.True(t, ok)
+	assert.Equal(t, val, uint(0))
+
+	val, ok = opts.Uint("invalid")
+	assert.False(t, ok)
+	assert.Equal(t, val, uint(0))
+}
+
+func TestFloat(t *testing.T) {
+	val, ok := opts.Float("foo1")
+	assert.True(t, ok)
+	assert.Equal(t, val, 0.0)
+
+	val, ok = opts.Float("foo2")
+	assert.True(t, ok)
+	assert.Equal(t, val, -5.0)
+
+	val, ok = opts.Float("foo3")
+	assert.True(t, ok)
+	assert.Equal(t, val, 7.0)
+
+	val, ok = opts.Float("foo4")
+	assert.True(t, ok)
+	assert.Equal(t, val, 0.6)
+
+	val, ok = opts.Float("invalid")
+	assert.False(t, ok)
+	assert.Equal(t, val, 0.0)
+}

cluster/swarm/cluster.go

@@ -1,11 +1,11 @@
 package swarm
 
 import (
+	"crypto/tls"
 	"errors"
 	"fmt"
 	"io"
 	"sort"
-	"strconv"
 	"strings"
 	"sync"
 
@@ -24,43 +24,41 @@ import (
 type Cluster struct {
 	sync.RWMutex
 
-	eventHandler    cluster.EventHandler
-	engines         map[string]*cluster.Engine
-	scheduler       *scheduler.Scheduler
-	options         *cluster.Options
-	store           *state.Store
+	eventHandler cluster.EventHandler
+	engines      map[string]*cluster.Engine
+	scheduler    *scheduler.Scheduler
+	store        *state.Store
+
 	overcommitRatio float64
+	discovery       string
+	heartbeat       uint64
+	TLSConfig       *tls.Config
 }
 
 // NewCluster is exported
-func NewCluster(scheduler *scheduler.Scheduler, store *state.Store, options *cluster.Options) (cluster.Cluster, error) {
+func NewCluster(scheduler *scheduler.Scheduler, store *state.Store, TLSConfig *tls.Config, dflag string, options cluster.DriverOpts) (cluster.Cluster, error) {
 	log.WithFields(log.Fields{"name": "swarm"}).Debug("Initializing cluster")
 
 	cluster := &Cluster{
 		engines:         make(map[string]*cluster.Engine),
 		scheduler:       scheduler,
-		options:         options,
 		store:           store,
 		overcommitRatio: 0.05,
+		discovery:       dflag,
+		TLSConfig:       TLSConfig,
 	}
 
-	for _, opt := range options.Opts {
-		kv := strings.SplitN(opt, "=", 2)
-		switch kv[0] {
-		case "swarm.overcommit":
-			overcommit, err := strconv.ParseFloat(kv[1], 64)
-			if err != nil {
-				return nil, err
-			}
-			cluster.overcommitRatio = overcommit
-		default:
-			return nil, fmt.Errorf("unsuported opt %q", kv[0])
-		}
+	if val, ok := options.Float("swarm.overcommit"); ok {
+		cluster.overcommitRatio = val
+	}
+
+	if cluster.heartbeat, _ = options.Uint("swarm.heartbeat"); cluster.heartbeat < 1 {
+		return nil, errors.New("heartbeat should be an unsigned integer and greater than 0")
 	}
 
 	// get the list of entries from the discovery service
 	go func() {
-		d, err := discovery.New(options.Discovery, options.Heartbeat)
+		d, err := discovery.New(cluster.discovery, cluster.heartbeat)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -169,7 +167,7 @@ func (c *Cluster) newEntries(entries []*discovery.Entry) {
 		go func(m *discovery.Entry) {
 			if !c.hasEngine(m.String()) {
 				engine := cluster.NewEngine(m.String(), c.overcommitRatio)
-				if err := engine.Connect(c.options.TLSConfig); err != nil {
+				if err := engine.Connect(c.TLSConfig); err != nil {
 					log.Error(err)
 					return
 				}

test/integration/helpers.bash

@@ -99,7 +99,7 @@ function swarm_manage() {
 		discovery="$@"
 	fi
 
-	"$SWARM_BINARY" manage -H "$SWARM_HOST" --heartbeat=1 "$discovery" &
+	"$SWARM_BINARY" manage -H "$SWARM_HOST" --cluster-opt "swarm.heartbeat=1" "$discovery" &
 	SWARM_PID=$!
 	wait_until_reachable "$SWARM_HOST"
 	retry 10 1 check_swarm_nodes