UI Dev Proxy

Author: webbgeorge

.gitignore

@@ -0,0 +1 @@
+ui-dev-proxy

Makefile

@@ -0,0 +1,10 @@
+build:
+	go build -o ui-dev-proxy main.go
+
+test:
+	go vet ./...
+	go test -race -short ./...
+	bash -c 'diff -u <(echo -n) <(gofmt -s -d .)'
+
+fmt:
+	go fmt ./...

README.md

@@ -0,0 +1,72 @@
+# UI Dev Proxy
+
+Proxy tool for development of UIs.
+
+## Installation
+
+```
+go get -u github.com/JSainsburyPLC/ui-dev-proxy
+```
+
+## Usage
+
+```
+# start proxy server with default backend and config file
+ui-dev-proxy start -u https://default-backend-url.example.com -c proxy-config.json
+```
+
+For additional options see help
+
+```
+ui-dev-proxy start --help
+```
+
+## How it works
+
+The proxy can handle requests in 3 different ways:
+
+* Pass through to backend when path matches pattern in config route
+* Return a mock response when request matches config route (when mocks are enabled)
+* Pass through to default backend, if request doesn't match any config routes
+
+## Configuring your UI app
+
+Routes are configured in a JSON file, which is passed to the proxy using the "-c" flag.
+
+See `examples/config.json`
+
+### Proxy type routes
+
+```
+{
+  "type": "proxy", // Required
+  "path_pattern": "^/test-ui/.*", // regex to match request path. Required
+  "backend": "http://localhost:3000" // backend scheme and host to proxy to. Required
+}
+```
+
+### Mock type routes
+
+```
+{
+  "type": "mock", // Required
+  "mock": {
+    "request": { // parameters to match the inbound request on.
+      "method": "GET", // match the method of the request. Optional
+      "path": "^/api/v1/product/.*", // match the path of the request. Required
+      "query": "include=.*" // match the query string of the request. Optional
+    },
+    "response": { // definition of the mock data to respond with.
+      "status": 200, // the status code. Required
+      "body": "mocks/product.json", // string body, or path to JSON file. Required
+      "cookies": [ // set cookies. Optional
+        {
+          "name": "SOME_COOKIE",
+          "value": "1234567890",
+          "maxAge": 604800
+        }
+      ]
+    }
+  }
+}
+```

commands/start.go

@@ -0,0 +1,96 @@
+package commands
+
+import (
+	"github.com/JSainsburyPLC/ui-dev-proxy/domain"
+	"github.com/JSainsburyPLC/ui-dev-proxy/proxy"
+	"github.com/urfave/cli"
+	"log"
+	"net/url"
+)
+
+func StartCommand(logger *log.Logger, confProvider domain.ConfigProvider) cli.Command {
+	return cli.Command{
+		Name:  "start",
+		Usage: "Start the proxy",
+		Flags: []cli.Flag{
+			cli.StringFlag{
+				Name:     "default-backend-url, u",
+				Usage:    "the default backend to use",
+				Required: true,
+			},
+			cli.StringFlag{
+				Name:     "config, c",
+				Usage:    "Load configuration from 'FILE'",
+				Required: true,
+			},
+			cli.IntFlag{
+				Name:  "port, p",
+				Usage: "The port to start proxy on",
+				Value: 8080,
+			},
+			cli.BoolFlag{
+				Name:  "enable-mocks, m",
+				Usage: "Turn on mocks",
+			},
+			cli.BoolFlag{
+				Name:  "tls-enabled",
+				Usage: "Turn on TLS (tls-certfile and tls-keyfile both required if this is true)",
+			},
+			cli.StringFlag{
+				Name:  "tls-certfile",
+				Usage: "Path to TLS certificate file",
+			},
+			cli.StringFlag{
+				Name:  "tls-keyfile",
+				Usage: "Path to TLS key file",
+			},
+		},
+		Action: startAction(logger, confProvider),
+	}
+}
+
+func startAction(logger *log.Logger, confProvider domain.ConfigProvider) cli.ActionFunc {
+	return func(c *cli.Context) error {
+		logger.Println("Starting UI Dev Proxy...")
+
+		defaultBackendUrl := c.String("default-backend-url")
+		confFile := c.String("config")
+		port := c.Int("port")
+		mocksEnabled := c.Bool("enable-mocks")
+		tlsEnabled := c.Bool("tls-enabled")
+		tlsCertfile := c.String("tls-certfile")
+		tlsKeyfile := c.String("tls-keyfile")
+
+		logger.Printf("Default backend URL: %s\n", defaultBackendUrl)
+		logger.Printf("Config file: %s\n", confFile)
+		logger.Printf("Port: %d\n", port)
+		logger.Printf("Mocks enabled: %t\n", mocksEnabled)
+		logger.Printf("TLS enabled: %t\n", tlsEnabled)
+		if tlsEnabled {
+			logger.Printf("TLS certfile: %s\n", tlsCertfile)
+			logger.Printf("TLS keyfile: %s\n", tlsKeyfile)
+		}
+
+		conf, err := confProvider(confFile)
+		if err != nil {
+			return cli.NewExitError(err, 1)
+		}
+
+		defaultBackend, err := url.Parse(defaultBackendUrl)
+		if err != nil {
+			return cli.NewExitError(err, 1)
+		}
+
+		p := proxy.NewProxy(port, conf, defaultBackend, mocksEnabled, logger)
+
+		if tlsEnabled {
+			p.TlsEnabled = true
+			p.TlsCertFile = tlsCertfile
+			p.TlsKeyFile = tlsKeyfile
+		}
+
+		p.Start()
+
+		return nil
+	}
+}

domain/config.go

@@ -0,0 +1,68 @@
+package domain
+
+import (
+	"encoding/json"
+	"net/url"
+	"regexp"
+)
+
+const (
+	RouteTypeProxy = "proxy"
+	RouteTypeMock  = "mock"
+)
+
+type Config struct {
+	Routes []Route `json:"routes"`
+}
+
+type Route struct {
+	Type        string       `json:"type"`
+	PathPattern *PathPattern `json:"path_pattern"`
+	Backend     *Backend     `json:"backend"`
+	Mock        *Mock        `json:"mock"`
+}
+
+type PathPattern struct {
+	*regexp.Regexp
+}
+
+func (p *PathPattern) UnmarshalJSON(data []byte) error {
+	var s string
+	err := json.Unmarshal(data, &s)
+	if err != nil {
+		return err
+	}
+
+	r, err := regexp.Compile(s)
+	if err != nil {
+		return err
+	}
+
+	p.Regexp = r
+
+	return nil
+}
+
+type Backend struct {
+	*url.URL
+}
+
+func (p *Backend) UnmarshalJSON(data []byte) error {
+	var s string
+	err := json.Unmarshal(data, &s)
+	if err != nil {
+		return err
+	}
+
+	u, err := url.Parse(s)
+	if err != nil {
+		return err
+	}
+
+	p.URL = u
+
+	return nil
+}
+
+// TODO: the path arg here is a leaky abstraction - fix it
+type ConfigProvider func(path string) (Config, error)