std/go/core: added ability to register package-scoped DebugHandlers.

Author: hugosantos

std/go/core/checker.go

@@ -31,11 +31,11 @@ func ManualChecker(check CheckerFunc) Checker {
 	return manualChecker{check}
 }
 
-func ProvideLivenessCheck(ctx context.Context, _ *LivenessCheck) (Check, error) {
+func ProvideLivenessCheck(ctx context.Context, _ *LivenessCheckArgs) (Check, error) {
 	return Check{registerLiveness, InstantiationPathFromContext(ctx)}, nil
 }
 
-func ProvideReadinessCheck(ctx context.Context, _ *ReadinessCheck) (Check, error) {
+func ProvideReadinessCheck(ctx context.Context, _ *ReadinessCheckArgs) (Check, error) {
 	return Check{registerReadiness, InstantiationPathFromContext(ctx)}, nil
 }
 

std/go/core/coretypes.pb.go

@@ -8,5 +8,6 @@ package foundation.std.go.core;
 
 option go_package = "namespacelabs.dev/foundation/std/go/core";
 
-message LivenessCheck {}
-message ReadinessCheck {}
+message LivenessCheckArgs {}
+message ReadinessCheckArgs {}
+message DebugHandlerArgs {}

std/go/core/coretypes.proto

@@ -0,0 +1,39 @@
+package core
+
+import (
+	"context"
+	"sync"
+
+	"github.com/gorilla/mux"
+	"namespacelabs.dev/foundation/schema"
+)
+
+var debugHandlers struct {
+	mu       sync.RWMutex
+	handlers map[string]*mux.Router
+}
+
+type DebugHandler struct {
+	owner schema.PackageName
+}
+
+func (h DebugHandler) Mux() *mux.Router {
+	debugHandlers.mu.Lock()
+	defer debugHandlers.mu.Unlock()
+
+	if debugHandlers.handlers == nil {
+		debugHandlers.handlers = map[string]*mux.Router{}
+	}
+
+	if r, ok := debugHandlers.handlers[h.owner.String()]; ok {
+		return r
+	}
+
+	r := mux.NewRouter()
+	debugHandlers.handlers[h.owner.String()] = r
+	return r
+}
+
+func ProvideDebugHandler(ctx context.Context, _ *DebugHandlerArgs) (DebugHandler, error) {
+	return DebugHandler{InstantiationPathFromContext(ctx).Last()}, nil
+}

std/go/core/debughandler.go

@@ -5,10 +5,14 @@ import (
 	"context"
 )
 
-type _checkProvideLivenessCheck func(context.Context, *LivenessCheck) (Check, error)
+type _checkProvideDebugHandler func(context.Context, *DebugHandlerArgs) (DebugHandler, error)
+
+var _ _checkProvideDebugHandler = ProvideDebugHandler
+
+type _checkProvideLivenessCheck func(context.Context, *LivenessCheckArgs) (Check, error)
 
 var _ _checkProvideLivenessCheck = ProvideLivenessCheck
 
-type _checkProvideReadinessCheck func(context.Context, *ReadinessCheck) (Check, error)
+type _checkProvideReadinessCheck func(context.Context, *ReadinessCheckArgs) (Check, error)
 
 var _ _checkProvideReadinessCheck = ProvideReadinessCheck

std/go/core/deps.fn.go

@@ -15,4 +15,10 @@ func RegisterDebugEndpoints(mux *mux.Router) {
 	mux.Handle("/livez", livezEndpoint())
 	mux.Handle("/readyz", readyzEndpoint())
 	mux.Handle("/", StatusHandler())
-}
+
+	debugHandlers.mu.RLock()
+	defer debugHandlers.mu.RUnlock()
+	for pkg, handlers := range debugHandlers.handlers {
+		mux.Handle("/debug/"+pkg+"/", handlers)
+	}
+}

std/go/core/endpoints.go

@@ -2,12 +2,24 @@
 package core
 
 #Exports: {
+	DebugHandler: {
+		#Definition: {
+			packageName: "namespacelabs.dev/foundation/std/go/core"
+			type:        "DebugHandler"
+			typeDefinition: {
+				"typename": "foundation.std.go.core.DebugHandlerArgs"
+				"source": [
+					"coretypes.proto",
+				]
+			}
+		}
+	}
 	LivenessCheck: {
 		#Definition: {
 			packageName: "namespacelabs.dev/foundation/std/go/core"
 			type:        "LivenessCheck"
 			typeDefinition: {
-				"typename": "foundation.std.go.core.LivenessCheck"
+				"typename": "foundation.std.go.core.LivenessCheckArgs"
 				"source": [
 					"coretypes.proto",
 				]
@@ -19,7 +31,7 @@ package core
 			packageName: "namespacelabs.dev/foundation/std/go/core"
 			type:        "ReadinessCheck"
 			typeDefinition: {
-				"typename": "foundation.std.go.core.ReadinessCheck"
+				"typename": "foundation.std.go.core.ReadinessCheckArgs"
 				"source": [
 					"coretypes.proto",
 				]

std/go/core/exports.fn.cue

@@ -11,18 +11,25 @@ $coreTypesProto: inputs.#Proto & {
 extension: fn.#Extension & {
 	provides: {
 		LivenessCheck: {
-			input: $coreTypesProto.types.LivenessCheck
+			input: $coreTypesProto.types.LivenessCheckArgs
 			availableIn: {
 				go: type: "Check"
 			}
 		}
 
 		ReadinessCheck: {
-			input: $coreTypesProto.types.ReadinessCheck
+			input: $coreTypesProto.types.ReadinessCheckArgs
 			availableIn: {
 				go: type: "Check"
 			}
 		}
+
+		DebugHandler: {
+			input: $coreTypesProto.types.DebugHandlerArgs
+			availableIn: {
+				go: type: "DebugHandler"
+			}
+		}
 	}
 }
 

std/go/core/extension.cue

@@ -71,9 +71,9 @@ func (di *depInitializer) Instantiate(ctx context.Context, ref Reference, f func
 	isSingleton := ref.Scope == ""
 	if !ok {
 		if isSingleton {
-			return fmt.Errorf("No singleton provider found for package %s.", ref.Package)
+			return fmt.Errorf("no singleton provider found for package %s", ref.Package)
 		}
-		return fmt.Errorf("No provider found for type %s in package %s.", ref.Scope, ref.Package)
+		return fmt.Errorf("no provider found for type %s in package %s", ref.Scope, ref.Package)
 	}
 
 	var path *InstantiationPath