initial commit for bridge

Author: Code-Hex

.github/workflows/issues.yml

@@ -0,0 +1,11 @@
+name: 'good first issue'
+on: [issues]
+
+jobs:
+  labels:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: Code-Hex/[email protected]
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          issue-labels: '["good first issue"]'

.github/workflows/test.yml

@@ -0,0 +1,28 @@
+on:
+  push:
+    branches:
+      - "main"
+    tags:
+      - "v*.*.*"
+  pull_request:
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+    - uses: actions/setup-go@v2
+      with:
+        go-version: '^1.18'
+    - name: Declare some variables
+      id: vars
+      run: |
+        echo "::set-output name=coverage_txt::${RUNNER_TEMP}/coverage.txt"
+    - name: Test Coverage (pkg)
+      run: go test ./... -race -coverprofile=${{ steps.vars.outputs.coverage_txt }}
+    - name: Upload coverage
+      uses: codecov/codecov-action@v2
+      with:
+        files: ${{ steps.vars.outputs.coverage_txt }}

.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+bridge

bridge.go

@@ -0,0 +1,73 @@
+package bridge
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/basemachina/bridge/bridgehttp"
+	"github.com/basemachina/bridge/internal/auth"
+	"github.com/basemachina/bridge/internal/ctxtime"
+	"github.com/basemachina/bridge/internal/proxy"
+	"github.com/go-logr/logr"
+)
+
+const (
+	OKPath    = "/ok"
+	OKMessage = "bridge is ready"
+	ProxyPath = "/htproxy"
+)
+
+// Env stores configuration settings extract from enviromental variables
+// The practice getting from environmental variables comes from https://12factor.net.
+type Env struct {
+	// Port is port to listen HTTP server. Default is 8080.
+	Port string `envconfig:"PORT" default:"8080" description:"bridge を HTTP としてサーブするために利用します。"`
+
+	// LogLevel is INFO or DEBUG. Default is "INFO".
+	LogLevel string `envconfig:"LOG_LEVEL" default:"INFO"`
+
+	// APIURL is an url of basemachina.
+	APIURL string `envconfig:"BASEMACHINA_API_URL" default:"https://api.basemachina.com"`
+
+	// FetchInterval is interval to fetch
+	FetchInterval time.Duration `envconfig:"FETCH_INTERVAL" default:"1h" description:"認可処理に利用する公開鍵を更新する間隔です。"`
+
+	// FetchTimeout is timeout to fetch
+	FetchTimeout time.Duration `envconfig:"FETCH_TIMEOUT" default:"10s" description:"認可処理に利用する公開鍵を更新するタイムアウトです。"`
+
+	// TenantID is ID of tenant
+	TenantID string `envconfig:"TENANT_ID" default:"" description:"認可処理に利用します。設定されると指定されたテナント ID 以外からのリクエストを拒否します。"`
+}
+
+// HTTPHandlerConfig is a config to setup bridge http handler.
+type HTTPHandlerConfig struct {
+	Logger          logr.Logger
+	PublicKeyGetter auth.PublicKeyGetter
+	TenantID        string
+	Middlewares     []bridgehttp.Middleware
+}
+
+// NewHTTPHandler is a handler for handling any requests.
+func NewHTTPHandler(c *HTTPHandlerConfig) http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc(OKPath, func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			w.WriteHeader(http.StatusMethodNotAllowed)
+			return
+		}
+		w.Write([]byte(OKMessage))
+	})
+	middlewares := append(c.Middlewares,
+		ctxtime.Middleware(),
+		auth.Middleware(&auth.MiddlewareConfig{
+			TenantID:        c.TenantID,
+			Logger:          c.Logger.WithName("auth"),
+			PublicKeyGetter: c.PublicKeyGetter,
+		}),
+	)
+	mux.Handle(ProxyPath, bridgehttp.UseMiddlewares(
+		proxy.NewProxy(c.Logger.WithName("proxy")),
+		middlewares...,
+	))
+	return mux
+}

bridge_test.go

@@ -0,0 +1,27 @@
+package bridge
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/basemachina/bridge/internal/testlogr"
+)
+
+func TestNewHTTPHandler(t *testing.T) {
+	t.Run("ok path", func(t *testing.T) {
+		h := NewHTTPHandler(&HTTPHandlerConfig{
+			Logger: testlogr.Logger,
+		})
+		req := httptest.NewRequest("GET", OKPath, nil)
+		rec := httptest.NewRecorder()
+		h.ServeHTTP(rec, req)
+
+		if rec.Code != http.StatusOK {
+			t.Fatalf("want status code %d but got %d", http.StatusOK, rec.Code)
+		}
+		if got := rec.Body.String(); OKMessage != got {
+			t.Fatalf("want message %q but got %q", OKMessage, got)
+		}
+	})
+}

bridgehttp/http.go

@@ -0,0 +1,14 @@
+package bridgehttp
+
+import "net/http"
+
+// Middleware is middleware for http.Handler
+type Middleware func(http.Handler) http.Handler
+
+// UseMiddlewares uses some middlewares when handled specified h (http.Handler)
+func UseMiddlewares(h http.Handler, middlewares ...Middleware) http.Handler {
+	for i := len(middlewares) - 1; i >= 0; i-- {
+		h = middlewares[i](h)
+	}
+	return h
+}

bridgehttp/http_test.go

@@ -0,0 +1,38 @@
+package bridgehttp
+
+import (
+	"bytes"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestUseMiddlewares(t *testing.T) {
+	var buf bytes.Buffer
+	baseHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf.WriteString("handler")
+	})
+	alpha := []string{"A", "B", "C"}
+	middlewares := make([]Middleware, 0, len(alpha))
+	for _, v := range alpha {
+		v := v
+		middlewares = append(middlewares, func(next http.Handler) http.Handler {
+			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				buf.WriteString(v)
+				next.ServeHTTP(w, r)
+				buf.WriteString(v)
+			})
+		})
+	}
+
+	h := UseMiddlewares(baseHandler, middlewares...)
+	req := httptest.NewRequest("GET", "/", nil)
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+
+	want := "ABChandlerCBA"
+	got := buf.String()
+	if want != got {
+		t.Errorf("want %q, but got %q", want, got)
+	}
+}

cmd/bridge/container.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/basemachina/bridge"
+	"github.com/go-logr/logr"
+)
+
+type Container struct {
+	HTTPServer  *http.Server
+	FetchWorker *FetchWorker
+	Logger      logr.Logger
+}
+
+func BridgeContainerProvider() (*Container, func(), error) {
+	env, err := ReadFromEnv()
+	if err != nil {
+		return nil, nil, err
+	}
+	logger, cleanup, err := NewLogger(env)
+	if err != nil {
+		return nil, nil, err
+	}
+	fetchWorker, cleanup2, err := NewFetchWorker(env, logger)
+	if err != nil {
+		return nil, nil, err
+	}
+	httpHandlerConfig := &bridge.HTTPHandlerConfig{
+		Logger:          logger,
+		PublicKeyGetter: fetchWorker,
+		TenantID:        env.TenantID,
+	}
+	handler := bridge.NewHTTPHandler(httpHandlerConfig)
+	server, cleanup3, err := NewHTTPServer(env, handler)
+	if err != nil {
+		cleanup2()
+		cleanup()
+		return nil, nil, err
+	}
+	container := &Container{
+		HTTPServer:  server,
+		FetchWorker: fetchWorker,
+		Logger:      logger,
+	}
+	return container, func() {
+		cleanup3()
+		cleanup2()
+		cleanup()
+	}, nil
+}

cmd/bridge/env.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/basemachina/bridge"
+	"github.com/kelseyhightower/envconfig"
+)
+
+// ReadFromEnv reads configuration from environmental variables
+// defined by Env struct.
+func ReadFromEnv() (*bridge.Env, error) {
+	var env bridge.Env
+	if err := envconfig.Process("", &env); err != nil {
+		return nil, fmt.Errorf("failed to process envconfig: %w", err)
+	}
+	return &env, nil
+}

cmd/bridge/env_test.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"os"
+	"testing"
+)
+
+func TestReadFromEnv(t *testing.T) {
+	reset := setenvs(t, map[string]string{
+		"PORT": "10000",
+	})
+	t.Cleanup(reset)
+
+	env, err := ReadFromEnv()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	const wantPort = "10000"
+	if got := env.Port; got != wantPort {
+		t.Fatalf("got %v, want %v", got, wantPort)
+	}
+}
+
+func setenv(t *testing.T, k, v string) func() {
+	t.Helper()
+
+	prev := os.Getenv(k)
+	if err := os.Setenv(k, v); err != nil {
+		t.Fatal(err)
+	}
+	return func() {
+		if prev == "" {
+			os.Unsetenv(k)
+		} else {
+			if err := os.Setenv(k, prev); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
+
+func setenvs(t *testing.T, kv map[string]string) func() {
+	t.Helper()
+
+	resetFuncs := make([]func(), 0, len(kv))
+	for k, v := range kv {
+		resetFunc := setenv(t, k, v)
+		resetFuncs = append(resetFuncs, resetFunc)
+	}
+	return func() {
+		for _, resetFunc := range resetFuncs {
+			resetFunc()
+		}
+	}
+}