Add proxy server feature.

CHANGELOG.md

@@ -7,6 +7,7 @@
 * Remove backward compatibility with previous versions to go 1.13
 * Add `-watcher` flag to reload the server with any changes on `imposters` folder
 * Fix searching imposter files mechanism
+* Add proxy server feature
 
 ## v0.3.3 (2019/05/11)
 

cmd/killgrave/main.go

@@ -104,10 +104,16 @@ func runServer(host string, port int, cfg killgrave.Config) server.Server {
 		Handler: handlers.CORS(server.PrepareAccessControl(cfg.CORS)...)(router),
 	}
 
+	proxyServer, err := server.NewProxy(cfg.Proxy.Url, cfg.Proxy.Mode)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	s := server.NewServer(
 		cfg.ImpostersPath,
 		router,
 		httpServer,
+		proxyServer,
 	)
 	if err := s.Build(); err != nil {
 		log.Fatal(err)

internal/config.go

@@ -1,6 +1,7 @@
 package killgrave
 
 import (
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -11,10 +12,11 @@ import (
 
 // Config representation of config file yaml
 type Config struct {
-	ImpostersPath string     `yaml:"imposters_path"`
-	Port          int        `yaml:"port"`
-	Host          string     `yaml:"host"`
-	CORS          ConfigCORS `yaml:"cors"`
+	ImpostersPath string      `yaml:"imposters_path"`
+	Port          int         `yaml:"port"`
+	Host          string      `yaml:"host"`
+	CORS          ConfigCORS  `yaml:"cors"`
+	Proxy         ConfigProxy `yaml:"proxy"`
 }
 
 // ConfigCORS representation of section CORS of the yaml
@@ -26,6 +28,43 @@ type ConfigCORS struct {
 	AllowCredentials bool     `yaml:"allow_credentials"`
 }
 
+// ConfigProxy is a representation of section proxy of the yaml
+type ConfigProxy struct {
+	Url  string    `yaml:"url"`
+	Mode ProxyMode `yaml:"mode"`
+}
+
+// ProxyMode is enumeration of proxy server modes
+type ProxyMode int
+
+const (
+	// ProxyNone server is off
+	ProxyNone ProxyMode = iota
+	// ProxyMissing handle only missing requests are proxied
+	ProxyMissing
+	// ProxyAll all requests are proxied
+	ProxyAll
+)
+
+// UnmarshalYAML implementation of yaml.Unmarshaler interface
+func (mode *ProxyMode) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var textMode string
+	if err := unmarshal(&textMode); err != nil {
+		return err
+	}
+	switch textMode {
+	case "all":
+		*mode = ProxyAll
+	case "missing":
+		*mode = ProxyMissing
+	case "none":
+		*mode = ProxyNone
+	default:
+		return errors.New("unknown proxy mode: " + textMode)
+	}
+	return nil
+}
+
 // ConfigOpt function to encapsulate optional parameters
 type ConfigOpt func(cfg *Config) error
 

internal/config_test.go

@@ -37,6 +37,45 @@ func TestNewConfig(t *testing.T) {
 	}
 }
 
+func TestProxyModeUnmarshal(t *testing.T) {
+	testCases := map[string]struct {
+		input    interface{}
+		expected ProxyMode
+		err      error
+	}{
+		"valid mode all":     {"all", ProxyAll, nil},
+		"valid mode missing": {"missing", ProxyMissing, nil},
+		"valid mode none":    {"none", ProxyNone, nil},
+		"empty mode":         {"", ProxyNone, errors.New("error")},
+		"invalid mode":       {"nonsens23e", ProxyNone, errors.New("error")},
+		"error input":        {123, ProxyNone, errors.New("error")},
+	}
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			var mode ProxyMode
+			err := mode.UnmarshalYAML(func(i interface{}) error {
+				s := i.(*string)
+				input, ok := tc.input.(string)
+				if !ok {
+					return errors.New("error")
+				}
+				*s = input
+				return nil
+			})
+			if err != nil && tc.err == nil {
+				t.Fatalf("not expected any erros and got %v", err)
+			}
+
+			if err == nil && tc.err != nil {
+				t.Fatalf("expected an error and got nil")
+			}
+			if tc.expected != mode {
+				t.Fatalf("expected: %v, got: %v", tc.expected, mode)
+			}
+		})
+	}
+}
+
 func validConfig() Config {
 	return Config{
 		ImpostersPath: "test/testdata/imposters",

internal/server/http/proxy.go

@@ -0,0 +1,32 @@
+package http
+
+import (
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+
+	killgrave "github.com/friendsofgo/killgrave/internal"
+)
+
+// Proxy represent reverse proxy server.
+type Proxy struct {
+	server *httputil.ReverseProxy
+	mode   killgrave.ProxyMode
+}
+
+// NewProxy creates new proxy server.
+func NewProxy(rawurl string, mode killgrave.ProxyMode) (*Proxy, error) {
+	u, err := url.Parse(rawurl)
+	if err != nil {
+		return nil, err
+	}
+	reverseProxy := httputil.NewSingleHostReverseProxy(u)
+	return &Proxy{reverseProxy, mode}, nil
+}
+
+// Handler returns handler that sends request to another server.
+func (p *Proxy) Handler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		p.server.ServeHTTP(w, r)
+	}
+}

internal/server/http/proxy_test.go

@@ -0,0 +1,66 @@
+package http
+
+import (
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	killgrave "github.com/friendsofgo/killgrave/internal"
+)
+
+func TestNewProxy(t *testing.T) {
+	testCases := map[string]struct {
+		rawUrl string
+		mode   killgrave.ProxyMode
+		err    error
+	}{
+		"valid all":       {"all", killgrave.ProxyAll, nil},
+		"valid mode none": {"none", killgrave.ProxyNone, nil},
+		"error rawUrl":    {":http!/gogle.com", killgrave.ProxyNone, errors.New("error")},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			proxy, err := NewProxy(tc.rawUrl, tc.mode)
+			if err != nil && tc.err == nil {
+				t.Fatalf("not expected any erros and got %v", err)
+			}
+
+			if err == nil && tc.err != nil {
+				t.Fatalf("expected an error and got nil")
+			}
+			if err != nil {
+				return
+			}
+			if tc.mode != proxy.mode {
+				t.Fatalf("expected: %v, got: %v", tc.mode, proxy.mode)
+			}
+		})
+	}
+}
+
+func TestProxyHandler(t *testing.T) {
+	isRequestHandled := false
+	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		isRequestHandled = true
+	}))
+	defer backend.Close()
+
+	proxy, err := NewProxy(backend.URL, killgrave.ProxyAll)
+	if err != nil {
+		t.Fatal("NewProxy failed: ", err)
+	}
+
+	frontend := httptest.NewServer(proxy.Handler())
+	defer frontend.Close()
+
+	_, err = http.Get(frontend.URL)
+	if err != nil {
+		t.Fatal("Frontend GET method failed: ", err)
+	}
+	if isRequestHandled != true {
+		t.Fatal("Request was not proxied to backend server")
+	}
+
+}

internal/server/http/server.go

@@ -30,14 +30,16 @@ type Server struct {
 	impostersPath string
 	router        *mux.Router
 	httpServer    http.Server
+	proxy         *Proxy
 }
 
 // NewServer initialize the mock server
-func NewServer(p string, r *mux.Router, httpServer http.Server) Server {
+func NewServer(p string, r *mux.Router, httpServer http.Server, proxyServer *Proxy) Server {
 	return Server{
 		impostersPath: p,
 		router:        r,
 		httpServer:    httpServer,
+		proxy:         proxyServer,
 	}
 }
 
@@ -73,6 +75,9 @@ func PrepareAccessControl(config killgrave.ConfigCORS) (h []handlers.CORSOption)
 // Build read all the files on the impostersPath and add different
 // handlers for each imposter
 func (s *Server) Build() error {
+	if s.proxy.mode == killgrave.ProxyAll {
+		s.handleAll(s.proxy.Handler())
+	}
 	if _, err := os.Stat(s.impostersPath); os.IsNotExist(err) {
 		return fmt.Errorf("%w: the directory %s doesn't exists", err, s.impostersPath)
 	}
@@ -83,6 +88,7 @@ func (s *Server) Build() error {
 		findImposters(s.impostersPath, imposterFileCh)
 		done <- true
 	}()
+loop:
 	for {
 		select {
 		case f := <-imposterFileCh:
@@ -97,9 +103,13 @@ func (s *Server) Build() error {
 		case <-done:
 			close(imposterFileCh)
 			close(done)
-			return nil
+			break loop
 		}
 	}
+	if s.proxy.mode == killgrave.ProxyMissing {
+		s.handleAll(s.proxy.Handler())
+	}
+	return nil
 }
 
 // Run run launch a previous configured http server if any error happens while the starting process
@@ -155,3 +165,7 @@ func (s Server) unmarshalImposters(imposterFileName string, imposters *[]Imposte
 	}
 	return nil
 }
+
+func (s *Server) handleAll(h http.HandlerFunc) {
+	s.router.PathPrefix("/").HandlerFunc(h)
+}