Consolidate server creation, closes #46

main.go

@@ -260,82 +260,46 @@ func downloadCommand(key, url, file string) error {
 }
 
 func configureServerCommand(app *kingpin.Application) error {
-	var bindPort, bindAddr, password string
-
 	conf, err := newConfig()
 	if err != nil {
 		return err
 	}
 
-	defaultBind, err := config.GetGlobalConfig("bind", "0.0.0.0", conf)
-	if err != nil {
-		return err
-	}
-
-	defaultPort, err := config.GetGlobalConfig("port", "5060", conf)
+	s, err := server.New(conf, Version)
 	if err != nil {
 		return err
 	}
 
 	cmd := app.Command("server", "Run the proxy (and web) server")
 	cmd.Flag("port", "The port to listen on").
-		OverrideDefaultFromEnvar("PORT").
-		Default(defaultPort).
-		StringVar(&bindPort)
+		Default(s.Port).
+		StringVar(&s.Port)
 
 	cmd.Flag("bind", "The address to bind to").
-		Default(defaultBind).
-		StringVar(&bindAddr)
+		Default(s.Bind).
+		StringVar(&s.Bind)
 
 	cmd.Flag("passphrase", "Require a passphrase to view web interface").
 		Short('p').
-		StringVar(&password)
+		StringVar(&s.Passphrase)
 
 	configureGlobalFlags(cmd)
 	cmd.Action(func(c *kingpin.ParseContext) error {
 		applyGlobalFlags()
-		return serverCommand(bindAddr, bindPort, password)
+		return serverCommand(s)
 	})
 
 	return nil
 }
 
-func serverCommand(addr, port string, password string) error {
+func serverCommand(s *server.Server) error {
 	if globals.Debug {
 		go func() {
 			log.Println(http.ListenAndServe("localhost:6060", nil))
 		}()
 	}
 
-	v := Version
-	if v == "" {
-		v = "dev"
-	}
-
-	log.Infof("Cardigann %s", v)
-
-	conf, err := newConfig()
-	if err != nil {
-		return err
-	}
-
-	for _, dir := range config.GetDefinitionDirs() {
-		log.WithField("dir", dir).Debug("Adding dir to definition load path")
-	}
-
-	listenOn := fmt.Sprintf("%s:%s", addr, port)
-	log.Infof("Listening on %s", listenOn)
-
-	h, err := server.NewHandler(server.Params{
-		Passphrase: password,
-		Config:     conf,
-		Version:    Version,
-	})
-	if err != nil {
-		return err
-	}
-
-	return http.ListenAndServe(listenOn, h)
+	return s.Listen()
 }
 
 func configureTestDefinitionCommand(app *kingpin.Application) {
@@ -407,14 +371,8 @@ func configureServiceCommand(app *kingpin.Application) {
 	cmd.Action(func(c *kingpin.ParseContext) error {
 		log.Debugf("Running service action %s on platform %v.", action, service.Platform())
 
-		conf, err := newConfig()
-		if err != nil {
-			return err
-		}
-
 		prg, err := newProgram(programOpts{
 			UserService: userService,
-			Config:      conf,
 		})
 		if err != nil {
 			return err

server/server.go

@@ -0,0 +1,68 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+
+	"github.com/cardigann/cardigann/config"
+	"github.com/cardigann/cardigann/logger"
+)
+
+// Server is an http server which wraps the Handler
+type Server struct {
+	Bind, Port, Passphrase string
+	version                string
+	config                 config.Config
+}
+
+func New(conf config.Config, version string) (*Server, error) {
+	bind, err := config.GetGlobalConfig("bind", "0.0.0.0", conf)
+	if err != nil {
+		return nil, err
+	}
+
+	port, err := config.GetGlobalConfig("port", "5060", conf)
+	if err != nil {
+		return nil, err
+	}
+
+	passphrase, err := config.GetGlobalConfig("passphrase", "", conf)
+	if err != nil {
+		return nil, err
+	}
+
+	if envPort := os.Getenv("PORT"); envPort != "" {
+		port = envPort
+	}
+
+	if version == "" {
+		version = "dev"
+	}
+
+	return &Server{
+		Bind:       bind,
+		Port:       port,
+		Passphrase: passphrase,
+		config:     conf,
+		version:    version,
+	}, nil
+}
+
+func (s *Server) Listen() error {
+	logger.Logger.Infof("Cardigann %s", s.version)
+
+	listenOn := fmt.Sprintf("%s:%s", s.Bind, s.Port)
+	logger.Logger.Infof("Listening on %s", listenOn)
+
+	h, err := NewHandler(Params{
+		Passphrase: s.Passphrase,
+		Config:     s.config,
+		Version:    s.version,
+	})
+	if err != nil {
+		return err
+	}
+
+	return http.ListenAndServe(listenOn, h)
+}

service.go

@@ -4,25 +4,21 @@ import (
 	"encoding/json"
 	"fmt"
 	_ "log"
-	"net/http"
 	"os"
 
 	"github.com/Sirupsen/logrus"
-	"github.com/cardigann/cardigann/config"
 	"github.com/cardigann/cardigann/server"
 	"github.com/kardianos/service"
 )
 
 type programOpts struct {
 	UserService bool
-	Config      config.Config
 }
 
 type program struct {
 	exit    chan struct{}
 	service service.Service
 	logger  service.Logger
-	cfg     config.Config
 }
 
 func newProgram(opts programOpts) (*program, error) {
@@ -39,7 +35,7 @@ func newProgram(opts programOpts) (*program, error) {
 		},
 	}
 
-	prg := &program{cfg: opts.Config}
+	prg := &program{}
 	s, err := service.New(prg, svcConfig)
 	if err != nil {
 		return nil, err
@@ -58,36 +54,21 @@ func (p *program) Start(s service.Service) error {
 	go p.run()
 	return nil
 }
+
 func (p *program) run() error {
 	p.logger.Infof("Running service via %v.", service.Platform())
 
-	bind, err := config.GetGlobalConfig("bind", "0.0.0.0", p.cfg)
-	if err != nil {
-		return err
-	}
-
-	// support tools like gin that expect to set a PORT env
-	defaultPort := os.Getenv("PORT")
-	if defaultPort == "" {
-		defaultPort = "5060"
-	}
-
-	port, err := config.GetGlobalConfig("port", defaultPort, p.cfg)
+	conf, err := newConfig()
 	if err != nil {
 		return err
 	}
 
-	listenOn := fmt.Sprintf("%s:%s", bind, port)
-	p.logger.Infof("Listening on %s", listenOn)
-
-	h, err := server.NewHandler(server.Params{
-		Config: p.cfg,
-	})
+	s, err := server.New(conf, Version)
 	if err != nil {
 		return err
 	}
 
-	go http.ListenAndServe(listenOn, h)
+	go s.Listen()
 
 	// block until exit
 	<-p.exit