take optional Opts for modifying the http server (#219)

* take optional Opts for modifying the http server

* move to have separate constructor

* use the params

* comment to make Keiko happy

Author: rybit

server/options.go

@@ -0,0 +1,44 @@
+package server
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+// Opt will allow modification of the http server
+type Opt func(s *http.Server)
+
+// WithWriteTimeout will override the server's write timeout
+func WithWriteTimeout(dur time.Duration) Opt {
+	return func(s *http.Server) {
+		s.WriteTimeout = dur
+	}
+}
+
+// WithReadTimeout will override the server's read timeout
+func WithReadTimeout(dur time.Duration) Opt {
+	return func(s *http.Server) {
+		s.ReadTimeout = dur
+	}
+}
+
+// WithTLS will use the provided TLS configuration
+func WithTLS(cfg *tls.Config) Opt {
+	return func(s *http.Server) {
+		s.TLSConfig = cfg
+	}
+}
+
+// WithAddress will set the address field on the server
+func WithAddress(addr string) Opt {
+	return func(s *http.Server) {
+		s.Addr = addr
+	}
+}
+
+// WithHostAndPort will use them in the form host:port as the address field on the server
+func WithHostAndPort(host string, port int) Opt {
+	return WithAddress(fmt.Sprintf("%s:%d", host, port))
+}

server/server.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -16,6 +15,11 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const (
+	defaultPort       = 9090
+	defaultHealthPath = "/health"
+)
+
 // Server handles the setup and shutdown of the http server
 // for an API
 type Server struct {
@@ -52,44 +56,33 @@ type HealthChecker interface {
 	Healthy(w http.ResponseWriter, r *http.Request) error
 }
 
-func New(log logrus.FieldLogger, config Config, api APIDefinition) (*Server, error) {
-	var healthHandler router.APIHandler
-	if checker, ok := api.(HealthChecker); ok {
-		healthHandler = checker.Healthy
+// NewOpts will create the server with many defaults. You can use the opts to override them.
+// the one major default you can't change by this is the health path. This is set to /health
+// and be enabled.
+func NewOpts(log logrus.FieldLogger, api APIDefinition, opts ...Opt) (*Server, error) {
+	defaultOpts := []Opt{
+		WithHostAndPort("", defaultPort),
 	}
 
-	r := router.New(
-		log,
-		router.OptHealthCheck(config.HealthPath, healthHandler),
-		router.OptEnableTracing(api.Info().Name),
-		router.OptVersionHeader(api.Info().Name, api.Info().Version),
-		router.OptRecoverer(),
-	)
-
-	if err := api.Start(r); err != nil {
-		return nil, errors.Wrap(err, "Failed to start API")
-	}
+	return buildServer(log, api, append(defaultOpts, opts...), defaultHealthPath)
+}
 
-	s := Server{
-		log: log.WithField("component", "server"),
-		svr: &http.Server{
-			Addr:    fmt.Sprintf("%s:%d", config.Host, config.Port),
-			Handler: r,
-		},
-		api:  api,
-		done: make(chan bool),
+// New will build a server with the defaults in place
+func New(log logrus.FieldLogger, config Config, api APIDefinition) (*Server, error) {
+	opts := []Opt{
+		WithHostAndPort(config.Host, config.Port),
 	}
 
 	if config.TLS.Enabled {
 		tcfg, err := config.TLS.TLSConfig()
 		if err != nil {
 			return nil, errors.Wrap(err, "Failed to build TLS config")
 		}
-		s.svr.TLSConfig = tcfg
 		log.Info("TLS enabled")
+		opts = append(opts, WithTLS(tcfg))
 	}
 
-	return &s, nil
+	return buildServer(log, api, opts, config.HealthPath)
 }
 
 func (s *Server) Shutdown(to time.Duration) error {
@@ -172,3 +165,41 @@ func APIFunc(start func(router.Router) error, stop func(), info APIInfo) APIDefi
 		info:  info,
 	}
 }
+
+func buildRouter(log logrus.FieldLogger, api APIDefinition, healthPath string) router.Router {
+	var healthHandler router.APIHandler
+	if checker, ok := api.(HealthChecker); ok {
+		healthHandler = checker.Healthy
+	}
+
+	r := router.New(
+		log,
+		router.OptHealthCheck(healthPath, healthHandler),
+		router.OptEnableTracing(api.Info().Name),
+		router.OptVersionHeader(api.Info().Name, api.Info().Version),
+		router.OptRecoverer(),
+	)
+
+	return r
+}
+
+func buildServer(log logrus.FieldLogger, api APIDefinition, opts []Opt, healthPath string) (*Server, error) {
+	r := buildRouter(log, api, healthPath)
+
+	if err := api.Start(r); err != nil {
+		return nil, errors.Wrap(err, "Failed to start API")
+	}
+
+	svr := new(http.Server)
+	for _, o := range opts {
+		o(svr)
+	}
+	svr.Handler = r
+	s := Server{
+		log:  log.WithField("component", "server"),
+		svr:  svr,
+		api:  api,
+		done: make(chan bool),
+	}
+	return &s, nil
+}