fix: routing

cmd/serve.go

@@ -13,8 +13,6 @@ import (
 	"github.com/formancehq/auth/pkg/delegatedauth"
 	"github.com/formancehq/auth/pkg/oidc"
 	"github.com/formancehq/auth/pkg/storage/sqlstorage"
-	"github.com/gorilla/mux"
-	sharedhealth "github.com/numary/go-libs/sharedhealth/pkg"
 	"github.com/numary/go-libs/sharedlogging"
 	"github.com/numary/go-libs/sharedotlp/pkg/sharedotlptraces"
 	"github.com/pkg/errors"
@@ -134,10 +132,8 @@ var serveCmd = &cobra.Command{
 			api.Module(":8080", baseUrl),
 			oidc.Module(key, baseUrl, o.Clients...),
 			authorization.Module(),
-			fx.Invoke(func(router *mux.Router, healthController *sharedhealth.HealthController) {
-				router.Path("/_healthcheck").HandlerFunc(healthController.Check)
-			}),
-			sqlstorage.Module(viper.GetString(postgresUriFlag), viper.GetBool(debugFlag), key, o.Clients),
+			sqlstorage.Module(sqlstorage.KindPostgres, viper.GetString(postgresUriFlag),
+				viper.GetBool(debugFlag), key, o.Clients...),
 			delegatedauth.Module(),
 			fx.Invoke(func() {
 				sharedlogging.Infof("App started.")

docker-compose.yml

@@ -14,7 +14,9 @@ services:
     volumes:
       - ./dex-config.yaml:/etc/dex/config.docker.yaml
       - ./pkg/web:/app/web
-    network_mode: service:auth
+    ports:
+    - '5556:5556/tcp'
+    - '8080:8080/tcp'
 
   postgres:
     image: postgres:alpine
@@ -34,6 +36,7 @@ services:
     build:
       context: .
       dockerfile: reflex.Dockerfile
+    network_mode: service:dex
     healthcheck:
       test: curl -s -f -k http://localhost:8080/_healthcheck > /dev/null || exit 1
       interval: 3s
@@ -50,6 +53,7 @@ services:
       - serve
     environment:
 #      DEBUG: 1
+      CGO_ENABLED: 0
       CONFIG: ./config.yaml
       POSTGRES_URI: host=postgres user=auth password=auth dbname=auth port=5432 sslmode=disable
       CAOS_OIDC_DEV: 1
@@ -63,12 +67,10 @@ services:
     depends_on:
       - postgres
       - jaeger
+      - dex
     volumes:
       - .:/src
     working_dir: /src
-    ports:
-      - '5556:5556/tcp'
-      - '8080:8080/tcp'
 
   frontend:
     image: node:alpine

pkg/api/authorization/module.go

@@ -11,14 +11,14 @@ import (
 
 func Module() fx.Option {
 	return fx.Options(
-		fx.Invoke(func(router *mux.Router, o op.OpenIDProvider) error {
+		fx.Invoke(fx.Annotate(func(router *mux.Router, o op.OpenIDProvider) error {
 			return router.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
 				route.Handler(
 					middleware(o)(route.GetHandler()),
 				)
 				return nil
 			})
-		}),
+		}, fx.ParamTags(`name:"prefixedRouter"`))),
 	)
 }
 

pkg/api/module.go

@@ -1,32 +1,21 @@
 package api
 
 import (
-	"context"
 	"net/url"
 
-	"github.com/gorilla/mux"
+	"github.com/formancehq/auth/pkg/api/routing"
 	sharedhealth "github.com/numary/go-libs/sharedhealth/pkg"
 	"go.uber.org/fx"
 )
 
 func Module(addr string, baseUrl *url.URL) fx.Option {
 	return fx.Options(
-		sharedhealth.Module(),
 		sharedhealth.ProvideHealthCheck(delegatedOIDCServerAvailability),
-		fx.Provide(func(healthController *sharedhealth.HealthController) *mux.Router {
-			return NewRouter(baseUrl, healthController)
-		}),
+		routing.Module(addr, baseUrl),
 		fx.Invoke(
-			addClientRoutes,
-			addScopeRoutes,
-			addUserRoutes,
+			fx.Annotate(addClientRoutes, fx.ParamTags(``, `name:"prefixedRouter"`)),
+			fx.Annotate(addScopeRoutes, fx.ParamTags(``, `name:"prefixedRouter"`)),
+			fx.Annotate(addUserRoutes, fx.ParamTags(``, `name:"prefixedRouter"`)),
 		),
-		fx.Invoke(func(lc fx.Lifecycle, router *mux.Router) {
-			lc.Append(fx.Hook{
-				OnStart: func(ctx context.Context) error {
-					return StartServer(addr, router)
-				},
-			})
-		}),
 	)
 }

pkg/api/routing/context.go

@@ -0,0 +1,31 @@
+package routing
+
+import (
+	"context"
+)
+
+var contextKey = struct{}{}
+
+type contextHolder struct {
+	port int
+}
+
+func NewContext(ctx context.Context) context.Context {
+	return context.WithValue(ctx, contextKey, &contextHolder{})
+}
+
+func setPort(ctx context.Context, port int) {
+	v := ctx.Value(contextKey)
+	if v == nil {
+		return
+	}
+	v.(*contextHolder).port = port
+}
+
+func ListeningPort(ctx context.Context) int {
+	v := ctx.Value(contextKey)
+	if v == nil {
+		return 0
+	}
+	return v.(*contextHolder).port
+}

pkg/api/routing/module.go

@@ -0,0 +1,48 @@
+package routing
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+
+	"github.com/gorilla/mux"
+	sharedhealth "github.com/numary/go-libs/sharedhealth/pkg"
+	"go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
+	"go.uber.org/fx"
+)
+
+func CreateRootRouter(baseUrl *url.URL, healthController *sharedhealth.HealthController) (*mux.Router, *mux.Router) {
+	rootRouter := mux.NewRouter()
+	rootRouter.Use(otelmux.Middleware("auth"))
+	rootRouter.Use(func(handler http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			handler.ServeHTTP(w, r)
+		})
+	})
+	rootRouter.Path("/_healthcheck").HandlerFunc(healthController.Check)
+
+	subRouter := rootRouter
+	if baseUrl.Path != "/" {
+		subRouter = subRouter.PathPrefix(baseUrl.Path).Subrouter()
+		subRouter.Path("/_healthcheck").HandlerFunc(healthController.Check)
+	}
+
+	return rootRouter, subRouter
+}
+
+func Module(addr string, baseUrl *url.URL) fx.Option {
+	return fx.Options(
+		sharedhealth.Module(),
+		fx.Provide(fx.Annotate(func(healthController *sharedhealth.HealthController) (*mux.Router, *mux.Router) {
+			return CreateRootRouter(baseUrl, healthController)
+		}, fx.ResultTags(`name:"rootRouter"`, `name:"prefixedRouter"`))),
+		fx.Invoke(fx.Annotate(func(lc fx.Lifecycle, router *mux.Router, healthController *sharedhealth.HealthController) {
+			lc.Append(fx.Hook{
+				OnStart: func(ctx context.Context) error {
+					return StartServer(ctx, addr, router)
+				},
+			})
+		}, fx.ParamTags(``, `name:"rootRouter"`))),
+	)
+}

pkg/api/routing/module_test.go

@@ -0,0 +1,64 @@
+package routing
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/fx"
+)
+
+func testWithUrl(t *testing.T, urlStr string) {
+	u, err := url.Parse(urlStr)
+	require.NoError(t, err)
+
+	ctx := NewContext(context.Background())
+
+	app := fx.New(
+		fx.Invoke(fx.Annotate(func(router *mux.Router) {
+			router.Path("/subpath-with-prefix").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusNoContent)
+			})
+		}, fx.ParamTags(`name:"prefixedRouter"`))),
+		fx.Invoke(fx.Annotate(func(router *mux.Router) {
+			router.Path("/subpath-to-root").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusNoContent)
+			})
+		}, fx.ParamTags(`name:"rootRouter"`))),
+		Module(":0", u),
+		fx.NopLogger,
+	)
+
+	require.NoError(t, app.Start(ctx))
+	defer func() {
+		require.NoError(t, app.Stop(ctx))
+	}()
+
+	serverUrl := fmt.Sprintf("http://localhost:%d", ListeningPort(ctx))
+	serverUrlWithPath := fmt.Sprintf("%s%s", serverUrl, u.Path)
+
+	rsp, err := http.Get(fmt.Sprintf("%s/_healthcheck", serverUrlWithPath))
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
+
+	rsp, err = http.Get(fmt.Sprintf("%s/_healthcheck", serverUrl))
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
+
+	rsp, err = http.Get(fmt.Sprintf("%s/subpath-with-prefix", serverUrlWithPath))
+	require.NoError(t, err)
+	require.Equal(t, http.StatusNoContent, rsp.StatusCode)
+
+	rsp, err = http.Get(fmt.Sprintf("%s/subpath-to-root", serverUrl))
+	require.NoError(t, err)
+	require.Equal(t, http.StatusNoContent, rsp.StatusCode)
+}
+
+func TestModule(t *testing.T) {
+	testWithUrl(t, "http://localhost")
+	testWithUrl(t, "http://localhost/any/sub/path")
+}

pkg/api/routing/server.go

@@ -0,0 +1,29 @@
+package routing
+
+import (
+	"context"
+	"net"
+	"net/http"
+)
+
+func StartServer(ctx context.Context, addr string, handler http.Handler) error {
+	socket, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
+	}
+
+	tcpAddr, err := net.ResolveTCPAddr(socket.Addr().Network(), socket.Addr().String())
+	if err != nil {
+		panic(err)
+	}
+
+	setPort(ctx, tcpAddr.Port)
+
+	go func() {
+		err := http.Serve(socket, handler)
+		if err != nil {
+			panic(err)
+		}
+	}()
+	return nil
+}

pkg/oidc/module.go

@@ -15,9 +15,9 @@ import (
 
 func Module(privateKey *rsa.PrivateKey, baseUrl *url.URL, staticClients ...auth.StaticClient) fx.Option {
 	return fx.Options(
-		fx.Invoke(func(router *mux.Router, provider op.OpenIDProvider, storage Storage, relyingParty rp.RelyingParty) {
+		fx.Invoke(fx.Annotate(func(router *mux.Router, provider op.OpenIDProvider, storage Storage, relyingParty rp.RelyingParty) {
 			AddRoutes(router, provider, storage, relyingParty, baseUrl)
-		}),
+		}, fx.ParamTags(`name:"rootRouter"`))),
 		fx.Provide(fx.Annotate(func(storage Storage, relyingParty rp.RelyingParty) *storageFacade {
 			return NewStorageFacade(storage, relyingParty, privateKey, staticClients...)
 		}, fx.As(new(op.Storage)))),

pkg/storage/sqlstorage/database.go

@@ -15,6 +15,10 @@ import (
 	"gorm.io/gorm/logger"
 )
 
+const (
+	KindPostgres = "postgres"
+)
+
 // TODO: Replace by sharedlogging
 func newLogger(debug bool) logger.Interface {
 	out := io.Discard
@@ -54,11 +58,18 @@ func MigrateTables(ctx context.Context, db *gorm.DB) error {
 	)
 }
 
-func gormModule(uri string, debug bool) fx.Option {
+var drivers = map[string]func(string) gorm.Dialector{}
+
+func registerDriverConstructor(kind string, constructor func(string) gorm.Dialector) {
+	drivers[kind] = constructor
+}
+
+func init() {
+	registerDriverConstructor(KindPostgres, OpenPostgresDatabase)
+}
+
+func gormModule(kind, uri string, debug bool) fx.Option {
 	return fx.Options(
-		fx.Provide(func() gorm.Dialector {
-			return OpenPostgresDatabase(uri)
-		}),
 		fx.Provide(func(d gorm.Dialector) (*gorm.DB, error) {
 			return LoadGorm(d, debug)
 		}),
@@ -70,5 +81,8 @@ func gormModule(uri string, debug bool) fx.Option {
 				},
 			})
 		}),
+		fx.Provide(func() gorm.Dialector {
+			return drivers[kind](uri)
+		}),
 	)
 }