Only listen on one port for HTTP (#67)

Gets rid of the external/internal differentiation.

Author: markuswustenberg

cmd/server/config.go

@@ -8,13 +8,11 @@ import (
 
 // Config holds configuration data read from a config file.
 type Config struct {
-	ExternalHost string
-	ExternalPort int
-	InternalHost string
-	InternalPort int
-	Cert         string
-	Key          string
-	Emailer      struct {
+	Host    string
+	Port    int
+	Cert    string
+	Key     string
+	Emailer struct {
 		Token string
 	}
 	Storer struct {

cmd/server/main.go

@@ -22,15 +22,13 @@ func main() {
 	}
 
 	s := server.New(server.Options{
-		Emailer:      createEmailer(c),
-		Storer:       createStorer(c, logger),
-		Logger:       logger,
-		ExternalHost: c.ExternalHost,
-		ExternalPort: c.ExternalPort,
-		InternalHost: c.InternalHost,
-		InternalPort: c.InternalPort,
-		Cert:         c.Cert,
-		Key:          c.Key,
+		Emailer: createEmailer(c),
+		Storer:  createStorer(c, logger),
+		Logger:  logger,
+		Host:    c.Host,
+		Port:    c.Port,
+		Cert:    c.Cert,
+		Key:     c.Key,
 	})
 
 	if err := s.Start(); err != nil {

development.toml

@@ -1,7 +1,5 @@
-ExternalHost = "localhost"
-ExternalPort = 2020
-InternalHost = "localhost"
-InternalPort = 2021
+Host = "localhost"
+Port = 2020
 Cert = "cert.pem"
 Key = "key.pem"
 

docker-compose.yaml

@@ -17,7 +17,6 @@ services:
       dockerfile: Dockerfile
     ports:
       - "2020:2020"
-      - "2021:2021"
     depends_on:
       - db
     restart: always

docker.toml

@@ -1,7 +1,5 @@
-ExternalHost = "localhost"
-ExternalPort = 2020
-InternalHost = "localhost"
-InternalPort = 2021
+Host = ""
+Port = 2020
 Cert = "cert.pem"
 Key = "key.pem"
 

production/etc/ahead.toml

@@ -5,7 +5,7 @@ app.example.com {
     # to otherhost2:2020
 
     health_path /health
-    health_port 2021
+    health_port 2020
     health_interval 10s
     health_timeout 5s
   }

production/etc/caddy/Caddyfile

@@ -10,9 +10,9 @@ import (
 	"github.com/maragudk/go-ahead/views"
 )
 
-func (s *Server) setupExternalRoutes() {
+func (s *Server) setupRoutes() {
 	// The views that can be requested by the browser
-	s.externalMux.Group(func(r chi.Router) {
+	s.mux.Group(func(r chi.Router) {
 		r.Use(middleware.Recoverer, handlers.NoClickjacking, handlers.StrictContentSecurityPolicy)
 		r.Use(s.sm.LoadAndSave)
 
@@ -28,7 +28,7 @@ func (s *Server) setupExternalRoutes() {
 	})
 
 	// The REST API
-	s.externalMux.Route("/api", func(r chi.Router) {
+	s.mux.Route("/api", func(r chi.Router) {
 		r.Use(middleware.Recoverer, handlers.JSONHeader)
 		r.Use(s.sm.LoadAndSave)
 
@@ -44,9 +44,12 @@ func (s *Server) setupExternalRoutes() {
 			r.Get("/session", handlers.Session())
 		})
 	})
-}
 
-func (s *Server) setupInternalRoutes() {
-	s.internalMux.Get("/health", handlers.Health(s.Storer))
-	s.internalMux.Get("/metrics", handlers.Metrics())
+	// Health and metrics
+	s.mux.Group(func(r chi.Router) {
+		r.Use(middleware.Recoverer)
+
+		r.Get("/health", handlers.Health(s.Storer))
+		r.Get("/metrics", handlers.Metrics())
+	})
 }

server/routes.go

@@ -23,29 +23,25 @@ import (
 
 // Server takes requests and responds. 😎
 type Server struct {
-	Emailer         *comms.Emailer
-	Storer          *storage.Storer
-	externalAddress string
-	internalAddress string
-	externalMux     *chi.Mux
-	internalMux     *chi.Mux
-	log             *log.Logger
-	cert            string
-	key             string
-	sm              *scs.SessionManager
+	Emailer *comms.Emailer
+	Storer  *storage.Storer
+	address string
+	mux     *chi.Mux
+	log     *log.Logger
+	cert    string
+	key     string
+	sm      *scs.SessionManager
 }
 
 // Options for New.
 type Options struct {
-	Emailer      *comms.Emailer
-	Storer       *storage.Storer
-	Logger       *log.Logger
-	ExternalHost string
-	ExternalPort int
-	InternalHost string
-	InternalPort int
-	Cert         string
-	Key          string
+	Emailer *comms.Emailer
+	Storer  *storage.Storer
+	Logger  *log.Logger
+	Host    string
+	Port    int
+	Cert    string
+	Key     string
 }
 
 // New creates a new Server.
@@ -55,20 +51,18 @@ func New(options Options) *Server {
 		logger = log.New(ioutil.Discard, "", 0)
 	}
 	return &Server{
-		Emailer:         options.Emailer,
-		Storer:          options.Storer,
-		externalAddress: net.JoinHostPort(options.ExternalHost, strconv.Itoa(options.ExternalPort)),
-		internalAddress: net.JoinHostPort(options.InternalHost, strconv.Itoa(options.InternalPort)),
-		externalMux:     chi.NewRouter(),
-		internalMux:     chi.NewRouter(),
-		log:             logger,
-		cert:            options.Cert,
-		key:             options.Key,
-		sm:              scs.New(),
+		Emailer: options.Emailer,
+		Storer:  options.Storer,
+		address: net.JoinHostPort(options.Host, strconv.Itoa(options.Port)),
+		mux:     chi.NewRouter(),
+		log:     logger,
+		cert:    options.Cert,
+		key:     options.Key,
+		sm:      scs.New(),
 	}
 }
 
-// Start the server, setting up listening for HTTP externally and internally, and notify systemd of readiness.
+// Start the server, set up listening for HTTP, and notify systemd of readiness.
 func (s *Server) Start() error {
 
 	if err := s.Storer.Connect(); err != nil {
@@ -78,18 +72,11 @@ func (s *Server) Start() error {
 	s.sm.Store = postgresstore.NewWithCleanupInterval(s.Storer.DB.DB, 0)
 	s.sm.Cookie.Secure = true
 
-	s.setupInternalRoutes()
-	s.setupExternalRoutes()
+	s.setupRoutes()
 
 	errs := make(chan error)
 	go func() {
-		if err := s.listenAndServeInternal(); err != nil {
-			errs <- err
-		}
-	}()
-
-	go func() {
-		if err := s.listenAndServeExternal(); err != nil {
+		if err := s.listenAndServe(); err != nil {
 			errs <- err
 		}
 	}()
@@ -102,46 +89,29 @@ func (s *Server) Start() error {
 	return errors2.Wrap(err, "could not listen and serve")
 }
 
-// listenAndServeExternal on the external address.
-// Note that all routes should be defined on externalMux before calling this.
-func (s *Server) listenAndServeExternal() error {
-	server := createHTTPServer(s.externalAddress, s.externalMux, s.log)
+// listenAndServe for HTTP.
+// Note that all routes should be defined on mux before calling this.
+func (s *Server) listenAndServe() error {
+	server := http.Server{
+		Addr:              s.address,
+		Handler:           s.mux,
+		ReadTimeout:       5 * time.Second,
+		ReadHeaderTimeout: 5 * time.Second,
+		WriteTimeout:      5 * time.Second,
+		IdleTimeout:       5 * time.Second,
+		ErrorLog:          s.log,
+	}
 
 	if s.key != "" && s.cert != "" {
-		s.log.Printf("Listening for external HTTPS on https://%v\n", s.externalAddress)
+		s.log.Printf("Listening for HTTPS on https://%v\n", s.address)
 		if err := server.ListenAndServeTLS(s.cert, s.key); err != nil && !errors.Is(err, http.ErrServerClosed) {
-			return errors2.Wrap(err, "could not start external https listener")
+			return errors2.Wrap(err, "could not start https listener")
 		}
 		return nil
 	}
-	s.log.Printf("Listening for external HTTP on http://%v\n", s.externalAddress)
+	s.log.Printf("Listening for HTTP on http://%v\n", s.address)
 	if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
-		return errors2.Wrap(err, "could not start external http listener")
+		return errors2.Wrap(err, "could not start http listener")
 	}
 	return nil
 }
-
-// listenAndServeInternal on the internal address.
-// Note that all routes should be defined on internalMux before calling this.
-func (s *Server) listenAndServeInternal() error {
-	server := createHTTPServer(s.internalAddress, s.internalMux, s.log)
-
-	s.log.Printf("Listening for internal HTTP on http://%v\n", s.internalAddress)
-	if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
-		return errors2.Wrap(err, "could not start internal http listener")
-	}
-	return nil
-}
-
-// createHTTPServer with aggressive timeouts.
-func createHTTPServer(addr string, handler http.Handler, log *log.Logger) http.Server {
-	return http.Server{
-		Addr:              addr,
-		Handler:           handler,
-		ReadTimeout:       5 * time.Second,
-		ReadHeaderTimeout: 5 * time.Second,
-		WriteTimeout:      5 * time.Second,
-		IdleTimeout:       5 * time.Second,
-		ErrorLog:          log,
-	}
-}

server/server.go

@@ -8,9 +8,8 @@ import (
 
 func TestNewServer(t *testing.T) {
 	t.Run("returns new server with http addresses set", func(t *testing.T) {
-		s := New(Options{ExternalPort: 123, InternalPort: 234, InternalHost: "localhost"})
+		s := New(Options{Port: 123})
 		require.NotNil(t, s)
-		require.Equal(t, ":123", s.externalAddress)
-		require.Equal(t, "localhost:234", s.internalAddress)
+		require.Equal(t, ":123", s.address)
 	})
 }