Skip to content

Agent Mesh

node: dispatch egress middleware by service type instead of hardcoding a2a

Tomas Tormo84fc8ea333a0
diff --git a/internal/node/a2a_service.go b/internal/node/a2a_service.go
index 3045739d..66a88f0a 100644
--- a/internal/node/a2a_service.go
+++ b/internal/node/a2a_service.go
@@ -49,18 +49,21 @@ func (s *A2AService) Init(ctx context.Context) error {
return nil
}
+func init() {
+ registerEgressMiddleware(api.ServiceTypeStringA2A, egressMiddleware{
+ gateRequest: a2aEgressGate,
+ modifyResponse: rewriteA2AAgentCard,
+ })
+}
+
// a2aCardBaseURL is the context key carrying the caller-facing mesh base URL
-// of an agent-card fetch, set by a2aEgressHook and consumed by the rewrite.
+// of an agent-card fetch, set by a2aEgressGate and consumed by the rewrite.
type a2aCardBaseURL struct{}
-// a2aEgressHook runs the caller-side A2A checks on a raw egress request:
+// a2aEgressGate runs the caller-side A2A checks on a raw egress request:
// the fail-closed labels gate and tagging agent-card fetches for rewrite.
// On refusal it writes the HTTP error itself and returns ok=false.
-func a2aEgressHook(node *SamNode, w http.ResponseWriter, r *http.Request) (*http.Request, bool) {
- parts := strings.SplitN(r.URL.Path, "/", 6)
- if len(parts) < 5 || !strings.EqualFold(parts[3], api.ServiceTypeStringA2A) {
- return r, true
- }
+func a2aEgressGate(node *SamNode, w http.ResponseWriter, r *http.Request, route egressRoute) (*http.Request, bool) {
if labelsHeader := r.Header.Get(api.HeaderSamRequiredLabels); labelsHeader != "" {
r.Header.Del(api.HeaderSamRequiredLabels)
required, err := parseRequiredLabels(labelsHeader)
@@ -68,19 +71,19 @@ func a2aEgressHook(node *SamNode, w http.ResponseWriter, r *http.Request) (*http
http.Error(w, fmt.Sprintf("Invalid %s header: %v", api.HeaderSamRequiredLabels, err), http.StatusBadRequest)
return r, false
}
- pid, err := peer.Decode(parts[2])
+ pid, err := peer.Decode(route.peerID)
if err != nil {
http.Error(w, "Invalid peer ID", http.StatusBadRequest)
return r, false
}
if err := node.VerifyPeerLabels(r.Context(), pid, required); err != nil {
- logger.Warnf("[A2A] label gate refused egress to %s: %v", parts[2], err)
+ logger.Warnf("[A2A] label gate refused egress to %s: %v", route.peerID, err)
http.Error(w, "Required labels not attested by provider", http.StatusForbidden)
return r, false
}
}
if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/.well-known/agent-card.json") {
- base := fmt.Sprintf("http://%s/sam/%s/%s/%s", r.Host, parts[2], parts[3], parts[4])
+ base := fmt.Sprintf("http://%s/sam/%s/%s/%s", r.Host, route.peerID, route.serviceType, route.serviceName)
r = r.WithContext(context.WithValue(r.Context(), a2aCardBaseURL{}, base))
}
return r, true
diff --git a/internal/node/a2a_service_test.go b/internal/node/a2a_service_test.go
index e5917cad..9a4c38f5 100644
--- a/internal/node/a2a_service_test.go
+++ b/internal/node/a2a_service_test.go
@@ -67,7 +67,7 @@ func TestA2AEgressHookNonA2APassthrough(t *testing.T) {
rec := httptest.NewRecorder()
req := httptest.NewRequest("GET", "/sam/12D3KooWpeer/mcp/svc/foo", nil)
req.Header.Set(api.HeaderSamRequiredLabels, "region=eu")
- _, ok := a2aEgressHook(nil, rec, req)
+ _, ok := applyEgressMiddleware(nil, rec, req)
if !ok {
t.Fatal("non-a2a path must pass through")
}
@@ -80,7 +80,7 @@ func TestA2AEgressHookMalformedLabels(t *testing.T) {
rec := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/sam/12D3KooWpeer/a2a/agent/", nil)
req.Header.Set(api.HeaderSamRequiredLabels, "not-a-label")
- _, ok := a2aEgressHook(nil, rec, req)
+ _, ok := applyEgressMiddleware(nil, rec, req)
if ok {
t.Fatal("malformed labels must be refused")
}
@@ -93,7 +93,7 @@ func TestA2AEgressHookTagsCardFetch(t *testing.T) {
rec := httptest.NewRecorder()
req := httptest.NewRequest("GET", "/sam/12D3KooWpeer/a2a/agent/.well-known/agent-card.json", nil)
req.Host = "127.0.0.1:8080"
- r2, ok := a2aEgressHook(nil, rec, req)
+ r2, ok := applyEgressMiddleware(nil, rec, req)
if !ok {
t.Fatal("card fetch must pass through")
}
@@ -177,7 +177,7 @@ func TestA2AEgressHookInvalidPeerID(t *testing.T) {
rec := httptest.NewRecorder()
req := httptest.NewRequest("GET", "/sam/not-a-peer/a2a/agent/", nil)
req.Header.Set(api.HeaderSamRequiredLabels, "region=eu")
- _, ok := a2aEgressHook(nil, rec, req)
+ _, ok := applyEgressMiddleware(nil, rec, req)
if ok {
t.Fatal("invalid peer ID must be refused")
}
@@ -230,7 +230,7 @@ func TestA2AEgressHookUppercaseTypeIsGated(t *testing.T) {
rec := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/sam/not-a-peer/A2A/agent/", nil)
req.Header.Set(api.HeaderSamRequiredLabels, "region=eu")
- _, ok := a2aEgressHook(nil, rec, req)
+ _, ok := applyEgressMiddleware(nil, rec, req)
if ok {
t.Fatal("uppercase A2A path must not bypass the labels gate")
}
diff --git a/internal/node/sidecar.go b/internal/node/sidecar.go
index 811dab74..4b6992ab 100644
--- a/internal/node/sidecar.go
+++ b/internal/node/sidecar.go
@@ -653,6 +653,61 @@ func handleDiscoverService(node *SamNode, w http.ResponseWriter, r *http.Request
}
}
+// egressMiddleware lets a service type hook raw egress traffic without the
+// proxy knowing the type exists. Types self-register from init().
+type egressMiddleware struct {
+ // gateRequest may refuse the request (writing the HTTP error itself,
+ // returning false) or return a derived request to forward.
+ gateRequest func(node *SamNode, w http.ResponseWriter, r *http.Request, route egressRoute) (*http.Request, bool)
+ // modifyResponse edits the proxied response; nil means no hook.
+ modifyResponse func(*http.Response) error
+}
+
+// egressRoute is the parsed /sam/{peer}/{type}/{svc}/{upstream} egress path,
+// with the service type lowercased to match how the remote ingress parses it.
+type egressRoute struct {
+ peerID string
+ serviceType string
+ serviceName string
+ upstreamPath string
+}
+
+// Keyed by lowercase service-type string; written only during init().
+var egressMiddlewares = map[string]egressMiddleware{}
+
+func registerEgressMiddleware(serviceType string, mw egressMiddleware) {
+ egressMiddlewares[strings.ToLower(serviceType)] = mw
+}
+
+// applyEgressMiddleware routes a raw egress request through the middleware
+// registered for its service type, if any.
+func applyEgressMiddleware(node *SamNode, w http.ResponseWriter, r *http.Request) (*http.Request, bool) {
+ parts := strings.SplitN(r.URL.Path, "/", 6)
+ if len(parts) < 5 {
+ return r, true
+ }
+ route := egressRoute{peerID: parts[2], serviceType: strings.ToLower(parts[3]), serviceName: parts[4]}
+ if len(parts) > 5 {
+ route.upstreamPath = parts[5]
+ }
+ mw, ok := egressMiddlewares[route.serviceType]
+ if !ok || mw.gateRequest == nil {
+ return r, true
+ }
+ return mw.gateRequest(node, w, r, route)
+}
+
+// egressModifyResponse dispatches to the middleware of the service type in
+// the rewritten path (/{type}/{svc}/...); types without a hook pass through.
+func egressModifyResponse(resp *http.Response) error {
+ parts := strings.SplitN(strings.TrimPrefix(resp.Request.URL.Path, "/"), "/", 2)
+ mw, ok := egressMiddlewares[strings.ToLower(parts[0])]
+ if !ok || mw.modifyResponse == nil {
+ return nil
+ }
+ return mw.modifyResponse(resp)
+}
+
func createEgressProxy(node *SamNode) http.Handler {
transport := libp2phttp.NewTransport(node.Host)
@@ -693,7 +748,7 @@ func createEgressProxy(node *SamNode) http.Handler {
logger.Debugf("[Proxy] Rewriting URL to libp2p://%s%s", req.URL.Host, req.URL.Path)
},
Transport: transport,
- ModifyResponse: rewriteA2AAgentCard,
+ ModifyResponse: egressModifyResponse,
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -709,7 +764,7 @@ func createEgressProxy(node *SamNode) http.Handler {
return
}
- r, ok := a2aEgressHook(node, w, r)
+ r, ok := applyEgressMiddleware(node, w, r)
if !ok {
return
}