Skip to content

Agent Mesh

internal/identity, internal/node: add unit regression tests for bugfixes and library hooks

Antonio Ojeaa29a404dc43a
diff --git a/internal/identity/biscuit_test.go b/internal/identity/biscuit_test.go
index f4e7d4b3..da7a3ce1 100644
--- a/internal/identity/biscuit_test.go
+++ b/internal/identity/biscuit_test.go
@@ -29,6 +29,7 @@ import (
"github.com/google/agentmesh/api"
"github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-libp2p/core/peer"
+ "google.golang.org/protobuf/types/known/timestamppb"
)
// testTimeout bounds datalog evaluation in these tests. It is deliberately
@@ -856,3 +857,103 @@ func TestMintBiscuitToken_PublishFacts(t *testing.T) {
t.Error("a delegated credential grants publishing nothing")
}
}
+
+func TestInspectVerifiedBiscuit_ExtractsAuthorityLabels(t *testing.T) {
+ pub, priv, err := ed25519.GenerateKey(rand.Reader)
+ if err != nil {
+ t.Fatal(err)
+ }
+ privNode, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ peerID, err := peer.IDFromPrivateKey(privNode)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ roles := []*api.PolicyRole{{Name: api.RoleNode, AllowedPublish: []string{"*"}}}
+ wantLabels := map[string]string{"env": "prod", "jurisdiction": "eu"}
+
+ t.Run("authority labels extracted on base and TAR-attenuated tokens", func(t *testing.T) {
+ raw, err := MintBootstrapBiscuitToken(priv, peerID, api.RoleNode, time.Now().Add(time.Hour), roles, wantLabels)
+ if err != nil {
+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)
+ }
+ claims, err := InspectVerifiedBiscuit(raw, []ed25519.PublicKey{pub}, testTimeout)
+ if err != nil {
+ t.Fatalf("InspectVerifiedBiscuit(base): %v", err)
+ }
+ if len(claims.Labels) != len(wantLabels) {
+ t.Fatalf("Labels len = %d (%v), want %v", len(claims.Labels), claims.Labels, wantLabels)
+ }
+ for k, want := range wantLabels {
+ if got := claims.Labels[k]; got != want {
+ t.Errorf("Labels[%q] = %q, want %q", k, got, want)
+ }
+ }
+
+ attenuated, err := AttenuateBiscuit(raw, &api.TaskAuthorizationRule{
+ Name: "triage-1",
+ ExpireTime: timestamppb.New(time.Now().Add(10 * time.Minute)),
+ Rules: []*api.TaskRule{
+ {AllowedServices: []string{"a2a://assistant"}},
+ },
+ })
+ if err != nil {
+ t.Fatalf("AttenuateBiscuit: %v", err)
+ }
+ attClaims, err := InspectVerifiedBiscuit(attenuated, []ed25519.PublicKey{pub}, testTimeout)
+ if err != nil {
+ t.Fatalf("InspectVerifiedBiscuit(attenuated): %v", err)
+ }
+ for k, want := range wantLabels {
+ if got := attClaims.Labels[k]; got != want {
+ t.Errorf("attenuated Labels[%q] = %q, want %q", k, got, want)
+ }
+ }
+ })
+
+ t.Run("unlabeled token leaves Labels empty", func(t *testing.T) {
+ raw, err := MintBootstrapBiscuitToken(priv, peerID, api.RoleNode, time.Now().Add(time.Hour), roles, nil)
+ if err != nil {
+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)
+ }
+ claims, err := InspectVerifiedBiscuit(raw, []ed25519.PublicKey{pub}, testTimeout)
+ if err != nil {
+ t.Fatalf("InspectVerifiedBiscuit: %v", err)
+ }
+ if len(claims.Labels) != 0 {
+ t.Errorf("Labels = %v, want empty", claims.Labels)
+ }
+ })
+
+ t.Run("forged label fact in appended block rejected", func(t *testing.T) {
+ raw, err := MintBootstrapBiscuitToken(priv, peerID, api.RoleNode, time.Now().Add(time.Hour), roles, nil)
+ if err != nil {
+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)
+ }
+ parsed, err := biscuit.Unmarshal(raw)
+ if err != nil {
+ t.Fatalf("Unmarshal: %v", err)
+ }
+ blk := parsed.CreateBlock()
+ if err := blk.AddFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactLabel,
+ IDs: []biscuit.Term{biscuit.String("env"), biscuit.String("forged")},
+ }}); err != nil {
+ t.Fatalf("AddFact: %v", err)
+ }
+ forged, err := parsed.Append(rand.Reader, blk.Build())
+ if err != nil {
+ t.Fatalf("Append: %v", err)
+ }
+ forgedBytes, err := forged.Serialize()
+ if err != nil {
+ t.Fatalf("Serialize: %v", err)
+ }
+ if _, err := InspectVerifiedBiscuit(forgedBytes, []ed25519.PublicKey{pub}, testTimeout); !errors.Is(err, ErrAppendedBlocks) {
+ t.Fatalf("InspectVerifiedBiscuit(forged label block) err = %v, want wrapping %v", err, ErrAppendedBlocks)
+ }
+ })
+}
diff --git a/internal/node/ingress_test.go b/internal/node/ingress_test.go
index 3de2c6ff..437de1c1 100644
--- a/internal/node/ingress_test.go
+++ b/internal/node/ingress_test.go
@@ -34,8 +34,10 @@ import (
"github.com/golang-jwt/jwt/v5"
"github.com/google/agentmesh/api"
"github.com/google/agentmesh/internal/identity"
+ libp2phttp "github.com/libp2p/go-libp2p-http"
libp2pcrypto "github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-libp2p/core/peer"
+ "google.golang.org/protobuf/types/known/timestamppb"
)
func mustTestPeerID(t *testing.T) (peer.ID, libp2pcrypto.PrivKey) {
@@ -705,3 +707,237 @@ func TestExternalIngressHandler(t *testing.T) {
}
})
}
+
+func TestStartIngressServer_PropagatesMeshTaskHeader(t *testing.T) {
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ provider, cleanupProvider := startBareNode(t, ctx)
+ defer cleanupProvider()
+ caller, cleanupCaller := startBareNode(t, ctx)
+ defer cleanupCaller()
+
+ enrollUnderRoot(t, provider, caller)
+
+ if err := caller.Host.Connect(ctx, peer.AddrInfo{ID: provider.Host.ID(), Addrs: provider.Host.Addrs()}); err != nil {
+ t.Fatalf("Connect: %v", err)
+ }
+ if err := caller.VerifyProvider(ctx, provider.Host.ID(), nil, ""); err != nil {
+ t.Fatalf("VerifyProvider handshake: %v", err)
+ }
+
+ var captured http.Header
+ provider.services.insertService(&fakeService{
+ info: &api.ServiceInfo{
+ Type: api.ServiceType_SERVICE_TYPE_A2A,
+ Name: "assistant",
+ },
+ handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ captured = r.Header.Clone()
+ w.WriteHeader(http.StatusOK)
+ }),
+ })
+
+ baseBiscuit, err := caller.Store.LoadIdentity()
+ if err != nil {
+ t.Fatalf("LoadIdentity: %v", err)
+ }
+
+ client := &http.Client{Transport: libp2phttp.NewTransport(caller.Host)}
+ targetURL := "libp2p://" + provider.Host.ID().String() + "/a2a/assistant/tasks"
+
+ t.Run("untasked Biscuit strips spoofed X-Mesh-Task", func(t *testing.T) {
+ captured = nil
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, strings.NewReader(`{}`))
+ if err != nil {
+ t.Fatalf("NewRequest: %v", err)
+ }
+ req.Header.Set(api.HeaderMeshBiscuit, base64.StdEncoding.EncodeToString(baseBiscuit))
+ req.Header.Set(api.HeaderMeshTask, "spoofed-task")
+
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("client.Do: %v", err)
+ }
+ _ = resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ t.Fatalf("status = %d, want 200", resp.StatusCode)
+ }
+ if got := captured.Get(api.HeaderMeshTask); got != "" {
+ t.Errorf("X-Mesh-Task = %q, want empty when Biscuit has no task block", got)
+ }
+ })
+
+ t.Run("nested TAR Biscuit propagates innermost X-Mesh-Task", func(t *testing.T) {
+ captured = nil
+ exp := timestamppb.New(time.Now().Add(10 * time.Minute))
+ outerTok, err := identity.AttenuateBiscuit(baseBiscuit, &api.TaskAuthorizationRule{
+ Name: "triage-42",
+ ExpireTime: exp,
+ Rules: []*api.TaskRule{
+ {AllowedServices: []string{"a2a://assistant"}},
+ },
+ })
+ if err != nil {
+ t.Fatalf("AttenuateBiscuit(outer): %v", err)
+ }
+ innerTok, err := identity.AttenuateBiscuit(outerTok, &api.TaskAuthorizationRule{
+ Name: "step-2",
+ ExpireTime: exp,
+ Rules: []*api.TaskRule{
+ {AllowedServices: []string{"a2a://assistant"}},
+ },
+ })
+ if err != nil {
+ t.Fatalf("AttenuateBiscuit(inner): %v", err)
+ }
+ sealedTok, err := identity.SealBiscuit(innerTok)
+ if err != nil {
+ t.Fatalf("SealBiscuit: %v", err)
+ }
+
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, strings.NewReader(`{}`))
+ if err != nil {
+ t.Fatalf("NewRequest: %v", err)
+ }
+ req.Header.Set(api.HeaderMeshBiscuit, base64.StdEncoding.EncodeToString(sealedTok))
+ req.Header.Set(api.HeaderMeshTask, "spoofed-task")
+
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("client.Do: %v", err)
+ }
+ _ = resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ t.Fatalf("status = %d, want 200", resp.StatusCode)
+ }
+ if got := captured.Get(api.HeaderMeshTask); got != "step-2" {
+ t.Errorf("X-Mesh-Task = %q, want %q", got, "step-2")
+ }
+ })
+}
+
+func TestPreferredRouterIngressURL_PrefersAttachedRouter(t *testing.T) {
+ routerA, _ := mustTestPeerID(t)
+ routerB, _ := mustTestPeerID(t)
+
+ n := &AgentMeshNode{
+ attached: make(map[peer.ID]bool),
+ routerCatalog: []routerCandidate{
+ {AddrInfo: peer.AddrInfo{ID: routerA}, IngressURL: "https://a.ingress.example/"},
+ {AddrInfo: peer.AddrInfo{ID: routerB}, IngressURL: "https://b.ingress.example/"},
+ },
+ }
+
+ urls := n.RouterIngressURLs()
+ if len(urls) != 2 || urls[0] != "https://a.ingress.example" || urls[1] != "https://b.ingress.example" {
+ t.Fatalf("RouterIngressURLs() = %v, want [https://a.ingress.example https://b.ingress.example]", urls)
+ }
+ if got := n.PreferredRouterIngressURL(); got != "https://a.ingress.example" {
+ t.Errorf("PreferredRouterIngressURL() with none attached = %q, want https://a.ingress.example", got)
+ }
+
+ n.attached[routerB] = true
+ if got := n.PreferredRouterIngressURL(); got != "https://b.ingress.example" {
+ t.Errorf("PreferredRouterIngressURL() with routerB attached = %q, want https://b.ingress.example", got)
+ }
+}
+
+type fakeObservableIngressService struct {
+ fakeService
+ announce bool
+ ingressActive bool
+}
+
+func (f *fakeObservableIngressService) NoAnnounce() bool { return !f.announce }
+func (f *fakeObservableIngressService) SetIngressActive(active bool) { f.ingressActive = active }
+func (f *fakeObservableIngressService) ExternalIngressAllowed() bool { return f.ingressActive }
+
+func TestServiceRegistry_UnannouncedAndExternalIngressGate(t *testing.T) {
+ t.Run("unannounced service skips Provide and Withdraw", func(t *testing.T) {
+ dht := &fakeIngressDHT{}
+ reg := newServiceRegistryForTest(dht)
+
+ svc := &fakeObservableIngressService{
+ fakeService: fakeService{
+ info: &api.ServiceInfo{
+ Name: "hidden-agent",
+ Type: api.ServiceType_SERVICE_TYPE_A2A,
+ Ingress: &api.ServiceIngress{AuthMode: api.IngressAuthMode_INGRESS_AUTH_MODE_PASSTHROUGH},
+ },
+ handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {}),
+ },
+ announce: false,
+ }
+ if err := reg.Register(context.Background(), svc); err != nil {
+ t.Fatalf("Register: %v", err)
+ }
+ if len(dht.calls) != 0 || len(dht.ingressCalls) != 0 {
+ t.Errorf("unannounced Register called DHT (plain=%d, ingress=%d), want 0", len(dht.calls), len(dht.ingressCalls))
+ }
+ if svc.ingressActive {
+ t.Error("expected ingressActive=false when service is not announced")
+ }
+ if err := reg.Unregister(context.Background(), "hidden-agent"); err != nil {
+ t.Fatalf("Unregister: %v", err)
+ }
+ if len(dht.withdrawn) != 0 {
+ t.Errorf("unannounced Unregister called Withdraw %d times, want 0", len(dht.withdrawn))
+ }
+ })
+
+ t.Run("refused ingress sets observer inactive and gates externalIngressHandler 404", func(t *testing.T) {
+ cpPub, cpPriv, err := ed25519.GenerateKey(rand.Reader)
+ if err != nil {
+ t.Fatalf("GenerateKey: %v", err)
+ }
+ routerPID, _ := mustTestPeerID(t)
+ _, servingPriv := mustTestPeerID(t)
+ routerTok, err := identity.MintBootstrapBiscuitToken(
+ cpPriv, routerPID, api.RoleRouter, time.Now().Add(time.Hour),
+ []*api.PolicyRole{{Name: api.RoleRouter}}, nil,
+ )
+ if err != nil {
+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)
+ }
+
+ dht := &fakeIngressDHT{failIngressErr: errors.New("router refused ingress role ceiling")}
+ reg := newServiceRegistryForTest(dht)
+ svc := &fakeObservableIngressService{
+ fakeService: fakeService{
+ info: &api.ServiceInfo{
+ Name: "gated-agent",
+ Type: api.ServiceType_SERVICE_TYPE_A2A,
+ Ingress: &api.ServiceIngress{AuthMode: api.IngressAuthMode_INGRESS_AUTH_MODE_PASSTHROUGH},
+ },
+ handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ }),
+ },
+ announce: true,
+ ingressActive: true,
+ }
+ if err := reg.Register(context.Background(), svc); err != nil {
+ t.Fatalf("Register: %v", err)
+ }
+ if svc.ingressActive {
+ t.Fatal("expected SetIngressActive(false) when router refused ProvideWithIngress")
+ }
+
+ n := &AgentMeshNode{
+ config: Options{PrivKey: servingPriv},
+ services: reg,
+ trustedKeys: []TrustedKey{{Key: cpPub, ReceivedAt: time.Now()}},
+ BiscuitTimeout: time.Second,
+ }
+ req := httptest.NewRequest(http.MethodPost, "http://mesh/a2a/gated-agent/events", strings.NewReader(`{}`))
+ req.RemoteAddr = routerPID.String()
+ req.Header.Set(api.HeaderMeshBiscuit, base64.StdEncoding.EncodeToString(routerTok))
+ req.Header.Set(api.HeaderMeshIngress, api.IngressAuthModeStringPassthrough)
+ rec := httptest.NewRecorder()
+ n.externalIngressHandler().ServeHTTP(rec, req)
+ if rec.Code != http.StatusNotFound {
+ t.Fatalf("externalIngressHandler status = %d, want 404 when ExternalIngressAllowed() is false: %s", rec.Code, rec.Body.String())
+ }
+ })
+}
diff --git a/internal/node/mcp_handlers_test.go b/internal/node/mcp_handlers_test.go
index 0ca44e39..e5234ab7 100644
--- a/internal/node/mcp_handlers_test.go
+++ b/internal/node/mcp_handlers_test.go
@@ -144,11 +144,29 @@ func TestHandleFindRemoteTools_SelfPeerRejected(t *testing.T) {
node, cleanup := startBareNode(t, ctx)
defer cleanup()
- _, _, err := node.handleFindRemoteTools(ctx, &mcp.CallToolRequest{}, FindRemoteToolsParams{
- PeerID: node.Host.ID().String(),
- })
- if err == nil {
- t.Fatal("expected error when peer_id equals self peer ID")
+ cidv1Self := peer.ToCid(node.Host.ID()).String()
+ if cidv1Self == node.Host.ID().String() {
+ t.Fatalf("expected CIDv1 encoding %q to differ from canonical PeerID %q", cidv1Self, node.Host.ID().String())
+ }
+
+ for _, tc := range []struct {
+ name string
+ peerID string
+ }{
+ {name: "canonical base58 self peer_id", peerID: node.Host.ID().String()},
+ {name: "CIDv1 multibase self peer_id", peerID: cidv1Self},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ _, _, err := node.handleFindRemoteTools(ctx, &mcp.CallToolRequest{}, FindRemoteToolsParams{
+ PeerID: tc.peerID,
+ })
+ if err == nil {
+ t.Fatalf("expected error when peer_id=%q equals self peer ID, got nil", tc.peerID)
+ }
+ if !strings.Contains(err.Error(), "is this node; cross-mesh discovery cannot target self") {
+ t.Errorf("error = %v, want self-peer rejection message", err)
+ }
+ })
}
}
diff --git a/internal/node/node.go b/internal/node/node.go
index 42bccbe6..c37d2b8e 100644
--- a/internal/node/node.go
+++ b/internal/node/node.go
@@ -2663,7 +2663,7 @@ func (n *AgentMeshNode) StartIngressServer(ctx context.Context) error {
if len(claims.Roles) > 0 {
r.Header.Set(api.HeaderMeshRoles, strings.Join(claims.Roles, ","))
}
- if t := outermostTaskName(claims.TaskRules); t != "" {
+ if t := claims.InnermostTaskName(); t != "" {
r.Header.Set(api.HeaderMeshTask, t)
}
}
@@ -2938,15 +2938,6 @@ func (n *AgentMeshNode) startCatalogReportLoop(ctx context.Context, initialDelay
}()
}
-func outermostTaskName(rules []*api.TaskAuthorizationRule) string {
- for i := len(rules) - 1; i >= 0; i-- {
- if rules[i] != nil && rules[i].GetName() != "" {
- return rules[i].GetName()
- }
- }
- return ""
-}
-
// Services returns the node's local service registry (available after Start).
func (n *AgentMeshNode) Services() *ServiceRegistry {
return n.services
diff --git a/internal/node/oidc_test.go b/internal/node/oidc_test.go
index 2c81debd..290caf5a 100644
--- a/internal/node/oidc_test.go
+++ b/internal/node/oidc_test.go
@@ -902,3 +902,73 @@ func TestRenewWithRefreshToken(t *testing.T) {
t.Errorf("Expected updated refresh token 'new_refresh_token_456', got '%s'", newRefresh)
}
}
+
+func TestOIDCMethodsRejectPlaintextNonLoopbackTransport(t *testing.T) {
+ prevGlobal := allowInsecureControlPlane.Load()
+ SetAllowInsecureControlPlane(false)
+ t.Cleanup(func() { SetAllowInsecureControlPlane(prevGlobal) })
+
+ // 192.0.2.10 is RFC 5737 TEST-NET-1: if RoundTrip attempted a TCP dial
+ // instead of failing at api.ValidateControlPlaneTransport, the short context
+ // would time out with context.DeadlineExceeded rather than a transport policy error.
+ ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
+ defer cancel()
+
+ strictNode := &AgentMeshNode{BiscuitTimeout: 500 * time.Millisecond}
+ // An in-process node opting into AllowInsecureControlPlane must stay scoped
+ // to that instance and leave strictNode rejecting plaintext non-loopback URLs.
+ _ = &AgentMeshNode{
+ BiscuitTimeout: 500 * time.Millisecond,
+ config: Options{AllowInsecureControlPlane: true},
+ }
+
+ const nonLoopbackIssuer = "http://192.0.2.10:8080"
+ cases := []struct {
+ name string
+ call func() error
+ }{
+ {
+ name: "DiscoverTokenURL",
+ call: func() error {
+ _, err := strictNode.DiscoverTokenURL(ctx, nonLoopbackIssuer)
+ return err
+ },
+ },
+ {
+ name: "DiscoverEndpointsWithDevice",
+ call: func() error {
+ _, err := strictNode.DiscoverEndpointsWithDevice(ctx, nonLoopbackIssuer)
+ return err
+ },
+ },
+ {
+ name: "DeviceLogin",
+ call: func() error {
+ _, err := strictNode.DeviceLogin(ctx, nonLoopbackIssuer+"/device", nonLoopbackIssuer+"/token", "client-id", "aud", false)
+ return err
+ },
+ },
+ {
+ name: "RefreshJWT",
+ call: func() error {
+ _, _, err := strictNode.RefreshJWT(ctx, nonLoopbackIssuer+"/token", "client-id", "", "rt-123")
+ return err
+ },
+ },
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ err := tc.call()
+ if err == nil {
+ t.Fatalf("%s accepted plaintext non-loopback URL %s, want error", tc.name, nonLoopbackIssuer)
+ }
+ if ctx.Err() != nil {
+ t.Fatalf("%s dialed the network and hit context deadline (%v) instead of failing closed at transport check: %v", tc.name, ctx.Err(), err)
+ }
+ if !strings.Contains(strings.ToLower(err.Error()), "https") && !strings.Contains(strings.ToLower(err.Error()), "plaintext") && !strings.Contains(strings.ToLower(err.Error()), "insecure") {
+ t.Errorf("%s error = %v, want transport policy rejection mentioning https/plaintext/insecure", tc.name, err)
+ }
+ })
+ }
+}
diff --git a/internal/node/store_test.go b/internal/node/store_test.go
index 10f76fb7..bd4627e2 100644
--- a/internal/node/store_test.go
+++ b/internal/node/store_test.go
@@ -578,3 +578,42 @@ func TestGetDefaultDataDir(t *testing.T) {
t.Fatalf("GetDefaultDataDir = %q, want %q", got, custom)
}
}
+
+func TestStore_SetOnChange(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("NewStore: %v", err)
+ }
+ defer func() { _ = store.Close() }()
+
+ calls := 0
+ var hookErr error
+ store.SetOnChange(func() error {
+ calls++
+ return hookErr
+ })
+
+ if err := store.SaveKey([]byte("priv-key")); err != nil {
+ t.Fatalf("SaveKey: %v", err)
+ }
+ if err := store.SaveIdentity([]byte("biscuit")); err != nil {
+ t.Fatalf("SaveIdentity: %v", err)
+ }
+ if err := store.SaveRefreshToken("rt-rotated"); err != nil {
+ t.Fatalf("SaveRefreshToken: %v", err)
+ }
+ if err := store.SetCredential(&api.MemberCredential{OidcSession: &api.OIDCSession{RefreshToken: "rt-2"}}); err != nil {
+ t.Fatalf("SetCredential: %v", err)
+ }
+ if err := store.ResetMeshIdentity(); err != nil {
+ t.Fatalf("ResetMeshIdentity: %v", err)
+ }
+ if calls != 5 {
+ t.Fatalf("onChange calls = %d, want 5", calls)
+ }
+
+ hookErr = errors.New("sync disk full")
+ if err := store.SaveRefreshToken("rt-3"); !errors.Is(err, hookErr) {
+ t.Fatalf("SaveRefreshToken with failing onChange = %v, want %v", err, hookErr)
+ }
+}
diff --git a/sdk/meshnet/a2a.go b/sdk/meshnet/a2a.go
index 0ba4d182..5fbac58a 100644
--- a/sdk/meshnet/a2a.go
+++ b/sdk/meshnet/a2a.go
@@ -506,7 +506,7 @@ func (s *Server) callerInfoFromRequest(r *http.Request) (*CallerInfo, bool) {
caller.Principal = claims.Principal()
caller.Roles = slices.Clone(claims.Roles)
caller.Labels = maps.Clone(claims.Labels)
- caller.Task = outermostTaskName(claims.TaskRules)
+ caller.Task = claims.InnermostTaskName()
if externalIngress {
if actor := cmp.Or(claims.ActorNodePeerID, claims.NodePeerID); actor != "" {
if id, pErr := peer.Decode(actor); pErr == nil {
@@ -527,15 +527,6 @@ func (s *Server) callerInfoFromRequest(r *http.Request) (*CallerInfo, bool) {
return caller, externalIngress
}
-func outermostTaskName(rules []*api.TaskAuthorizationRule) string {
- for i := len(rules) - 1; i >= 0; i-- {
- if rules[i] != nil && rules[i].GetName() != "" {
- return rules[i].GetName()
- }
- }
- return ""
-}
-
const (
a2aAgentCardEscapedPath = "/.well-known/agent-card.json"
maxAgentCardBytes = 1 << 20