Merge pull request #7 from aaronvb/refactor-to-channels

Refactor to channels

Author: aaronvb

.github/workflows/builds.yml

@@ -19,7 +19,7 @@ jobs:
         name: Set up Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.15
+          go-version: 1.16
       -
         name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v2

.github/workflows/tests.yml

@@ -16,7 +16,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.15
+        go-version: 1.16
 
     - name: Run tests
-      run: go test -v ./...
+      run: go test -race -v ./...

cmd/protocol.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"github.com/aaronvb/request_hole/pkg/protocol"
 	"github.com/aaronvb/request_hole/pkg/renderer"
 	"github.com/aaronvb/request_hole/pkg/server"
 	"github.com/spf13/cobra"
@@ -20,25 +21,42 @@ func init() {
 }
 
 func http(cmd *cobra.Command, args []string) {
-	logOutput := &renderer.Logger{
-		File: LogFile,
-		Port: Port,
-		Addr: Address,
+	renderers := make([]renderer.Renderer, 0)
+
+	// Collect flag data into struct to use with renderers
+	flagData := server.FlagData{
+		Addr:         Address,
+		BuildInfo:    BuildInfo,
+		Details:      Details,
+		LogFile:      LogFile,
+		Port:         Port,
+		ResponseCode: ResponseCode,
 	}
-	output := &renderer.Printer{
-		Port:      Port,
-		Addr:      Address,
-		BuildInfo: BuildInfo,
-		LogFile:   LogFile,
-		Details:   Details}
-
-	httpServer := server.Http{
+
+	printer := &renderer.Printer{Details: Details}
+	renderers = append(renderers, printer)
+
+	if LogFile != "" {
+		logger := &renderer.Logger{
+			FilePath: LogFile,
+			Details:  Details,
+			Addr:     Address,
+			Port:     Port,
+		}
+		renderers = append(renderers, logger)
+	}
+
+	httpServer := &protocol.Http{
 		Addr:         Address,
 		Port:         Port,
 		ResponseCode: ResponseCode,
-		Output:       output,
-		LogOutput:    logOutput,
-		Details:      Details}
+	}
+
+	srv := server.Server{
+		FlagData:  flagData,
+		Protocol:  httpServer,
+		Renderers: renderers,
+	}
 
-	httpServer.Start()
+	srv.Start()
 }

cmd/root.go

@@ -5,11 +5,11 @@ import "github.com/spf13/cobra"
 
 var (
 	Address      string
-	Port         int
-	ResponseCode int
 	BuildInfo    map[string]string
 	Details      bool
 	LogFile      string
+	Port         int
+	ResponseCode int
 )
 
 var rootCmd = &cobra.Command{

go.mod

@@ -1,6 +1,6 @@
 module github.com/aaronvb/request_hole
 
-go 1.15
+go 1.16
 
 require (
 	github.com/aaronvb/logparams v1.0.0

pkg/server/http.go renamed to pkg/protocol/http.go

@@ -1,61 +1,67 @@
-package server
+package protocol
 
 import (
 	"fmt"
 	"log"
 	"net/http"
+	"sync"
 
 	"github.com/aaronvb/logparams"
 	"github.com/aaronvb/logrequest"
-	"github.com/aaronvb/request_hole/pkg/renderer"
 	"github.com/gorilla/mux"
 	"github.com/pterm/pterm"
 )
 
+// Http is the protocol for accepting http requests.
 type Http struct {
-	// Port is the port the HTTP server will run on.
-	Port int
-
 	// Addr is the address the HTTP server will bind to.
 	Addr string
 
+	// Port is the port the HTTP server will run on.
+	Port int
+
 	// ResponseCode is the response which out endpoint will return.
 	// Default is 200 if no response code is passed.
 	ResponseCode int
 
-	// Output is the Renderer interface.
-	Output renderer.Renderer
-
-	// LogOutput
-	LogOutput renderer.Renderer
-
-	// Determines if header details should be shown with the request
-	Details bool
+	// rendererChannel is the channel which we send a RequestPayload to when
+	// receiving an incoming request to the Http protocol.
+	rendererChannels []chan RequestPayload
 }
 
 // Start will start the HTTP server.
-func (s *Http) Start() {
-	s.Output.Start()
-	s.LogOutput.Start()
-
+//
+// Sets the channel on our struct so that incoming requests can be sent over it.
+//
+// In the case that we cannot start this server, we send a signal to our quit channel
+// to close renderers.
+func (s *Http) Start(wg *sync.WaitGroup, c []chan RequestPayload, quits []chan int) {
 	addr := fmt.Sprintf("%s:%d", s.Addr, s.Port)
-	errorLog := log.New(&renderer.PrinterLog{Prefix: pterm.Error}, "", 0)
+	errorLog := log.New(&httpErrorLog{}, "", 0)
 
 	srv := &http.Server{
 		Addr:     addr,
 		ErrorLog: errorLog,
 		Handler:  s.routes(),
 	}
 
+	s.rendererChannels = c
+
+	defer wg.Done()
+
 	err := srv.ListenAndServe()
-	s.Output.Fatal(err)
+	str := pterm.Error.WithShowLineNumber(false).Sprintf("%s\n", err)
+	pterm.Printo(str) // Overwrite last line
+
+	for _, quit := range quits {
+		quit <- 1
+	}
 }
 
 // routes handles the routes for our HTTP server and currently accepts any path.
 func (s *Http) routes() http.Handler {
 	r := mux.NewRouter()
 	r.PathPrefix("/").HandlerFunc(s.defaultHandler)
-
 	r.Use(s.logRequest)
 
 	return r
@@ -75,12 +81,24 @@ func (s *Http) logRequest(next http.Handler) http.Handler {
 		fields := lr.ToFields()
 		params := logparams.LogParams{Request: r, HidePrefix: true}
 
-		s.Output.IncomingRequest(fields, params.ToString())
-		s.LogOutput.IncomingRequest(fields, params.ToString())
+		req := RequestPayload{
+			Fields:  fields,
+			Params:  params.ToString(),
+			Headers: r.Header,
+		}
 
-		if s.Details {
-			s.Output.IncomingRequestHeaders(r.Header)
-			s.LogOutput.IncomingRequestHeaders(r.Header)
+		for _, rendererChannel := range s.rendererChannels {
+			rendererChannel <- req
 		}
 	})
 }
+
+// httpErrorLog implements the logger interface.
+type httpErrorLog struct{}
+
+// Write let's us override the logger required for http errors and
+// prints to the terminal using pterm.
+func (e *httpErrorLog) Write(b []byte) (n int, err error) {
+	pterm.Error.WithShowLineNumber(false).Println(string(b))
+	return len(b), nil
+}