init: Initial commit

app/server/gateway.go

@@ -0,0 +1,67 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+
+	"git.secnex.io/secnex/api-gateway/config"
+	"git.secnex.io/secnex/masterlog"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+type Gateway struct {
+	router *chi.Mux
+	config config.Config
+	routes *Routes
+	proxy  *Proxy
+}
+
+func NewGateway(config config.Config) *Gateway {
+	r := chi.NewRouter()
+
+	for _, feature := range config.GetFeatures() {
+		switch feature {
+		case "request_id":
+			r.Use(middleware.RequestID)
+		case "real_ip":
+			r.Use(middleware.RealIP)
+		case "logger":
+			r.Use(middleware.Logger)
+		}
+	}
+
+	r.Route("/_/health", func(r chi.Router) {
+		r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte("OK"))
+		})
+	})
+
+	return &Gateway{config: config, router: r, routes: nil, proxy: nil}
+}
+
+func (g *Gateway) SetRoutes(routes *Routes) {
+	g.routes = routes
+}
+
+func (g *Gateway) SetProxy(proxy *Proxy) {
+	g.proxy = proxy
+}
+
+func (g *Gateway) Start() {
+	masterlog.Info("Starting gateway", map[string]interface{}{
+		"host": g.config.GetGatewayConfiguration().Host,
+		"port": g.config.GetGatewayConfiguration().Port,
+	})
+	for path, handler := range g.routes.handlers {
+		masterlog.Info("Registering route", map[string]interface{}{
+			"path": path,
+		})
+		g.router.Handle(path, handler)
+	}
+
+	gatewayConfig := g.config.GetGatewayConfiguration()
+
+	http.ListenAndServe(fmt.Sprintf("%s:%d", gatewayConfig.Host, gatewayConfig.Port), g.router)
+}

app/server/proxy.go

@@ -0,0 +1,42 @@
+package server
+
+import (
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+
+	"git.secnex.io/secnex/api-gateway/config"
+)
+
+type Proxy struct {
+	proxies  []config.ProxyConfiguration
+	handlers map[string]http.Handler
+}
+
+func NewProxy(proxies []config.ProxyConfiguration) *Proxy {
+	handlers := make(map[string]http.Handler)
+	for _, proxy := range proxies {
+		backend, err := url.Parse(proxy.Target)
+		if err != nil {
+			log.Fatalf("Failed to parse proxy target: %v", err)
+		}
+		p := httputil.NewSingleHostReverseProxy(backend)
+		originalDirector := p.Director
+		p.Director = func(r *http.Request) {
+			originalDirector(r)
+			r.Host = backend.Host
+		}
+		handlers[proxy.Host] = p
+	}
+	return &Proxy{proxies: proxies, handlers: handlers}
+}
+
+func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	handler, ok := p.handlers[r.Host]
+	if !ok {
+		http.NotFound(w, r)
+		return
+	}
+	handler.ServeHTTP(w, r)
+}

app/server/routes.go

@@ -0,0 +1,85 @@
+package server
+
+import (
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+
+	"git.secnex.io/secnex/api-gateway/config"
+	"git.secnex.io/secnex/api-gateway/middlewares"
+	"git.secnex.io/secnex/masterlog"
+)
+
+type Routes struct {
+	routes   []config.RouteConfiguration
+	handlers map[string]http.Handler
+}
+
+func NewRoutes(routes []config.RouteConfiguration, apis []config.ApiConfiguration) *Routes {
+	handlers := createHandlers(routes, apis)
+	return &Routes{routes: routes, handlers: handlers}
+}
+
+func findApi(apis []config.ApiConfiguration, id string) *config.ApiConfiguration {
+	for _, api := range apis {
+		if api.ID == id {
+			return &api
+		}
+	}
+	return nil
+}
+
+func createHandlers(routes []config.RouteConfiguration, apis []config.ApiConfiguration) map[string]http.Handler {
+	handlers := make(map[string]http.Handler)
+	for _, route := range routes {
+		masterlog.Debug("Creating handler for route", map[string]interface{}{
+			"path": route.Path,
+			"id":   route.ID,
+		})
+		api := findApi(apis, route.ID)
+		if api == nil {
+			log.Fatalf("API not found: %s", route.ID)
+			continue
+		}
+		backendUrl, err := url.Parse(
+			api.Target,
+		)
+		if err != nil {
+			log.Fatalf("Failed to parse backend URL: %v", err)
+		}
+		proxy := httputil.NewSingleHostReverseProxy(backendUrl)
+		handlers[route.Path] = proxy
+		if route.StripPrefix.Enabled {
+			masterlog.Debug("Stripping prefix", map[string]interface{}{
+				"id":     route.ID,
+				"path":   route.Path,
+				"prefix": route.StripPrefix.Prefix,
+			})
+			handlers[route.Path] = http.StripPrefix(route.StripPrefix.Prefix, handlers[route.Path])
+		}
+		if route.Security.WAF.Enabled {
+			masterlog.Debug("Applying WAF middleware", map[string]interface{}{
+				"id":      route.ID,
+				"path":    route.Path,
+				"methods": route.Security.WAF.Methods,
+			})
+			handlers[route.Path] = middlewares.WAF(handlers[route.Path], route.Security.WAF)
+		}
+		if route.Security.Auth.Enabled {
+			masterlog.Debug("Applying auth middleware", map[string]interface{}{
+				"id":     route.ID,
+				"path":   route.Path,
+				"type":   route.Security.Auth.Type,
+				"header": route.Security.Auth.Header,
+			})
+			handlers[route.Path] = middlewares.Auth(
+				handlers[route.Path],
+				route.Security.Auth.Type,
+				route.Security.Auth.Header,
+				route.Security.Auth.Path,
+			)
+		}
+	}
+	return handlers
+}