Skip to content

Agent Mesh

address comments

Antonio Ojeabb1ec6d2224f
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.go
index dfedae7f..bf8622f7 100644
--- a/cmd/sam-node/main.go
+++ b/cmd/sam-node/main.go
@@ -136,7 +136,11 @@ func parseLabelsFlag(s string) (map[string]string, error) {
if !ok {
return nil, fmt.Errorf("invalid label %q: expected key=value", part)
}
- labels[strings.TrimSpace(k)] = strings.TrimSpace(v)
+ key := strings.TrimSpace(k)
+ if _, exists := labels[key]; exists {
+ return nil, fmt.Errorf("duplicate label key %q", key)
+ }
+ labels[key] = strings.TrimSpace(v)
}
return labels, nil
}
diff --git a/cmd/sam-node/main_test.go b/cmd/sam-node/main_test.go
new file mode 100644
index 00000000..19ae03cf
--- /dev/null
+++ b/cmd/sam-node/main_test.go
@@ -0,0 +1,36 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import "testing"
+
+func TestParseLabelsFlag(t *testing.T) {
+ if got, err := parseLabelsFlag(""); got != nil || err != nil {
+ t.Errorf("empty flag: got %v, %v; want nil, nil", got, err)
+ }
+
+ got, err := parseLabelsFlag(" region=eu , team=platform ,,")
+ if err != nil || len(got) != 2 || got["region"] != "eu" || got["team"] != "platform" {
+ t.Errorf("parse should split key=value pairs: got %v, %v", got, err)
+ }
+
+ if _, err := parseLabelsFlag("noequals"); err == nil {
+ t.Error("entry without '=' must be rejected")
+ }
+
+ if _, err := parseLabelsFlag("region=us-east-1,region=us-west-1"); err == nil {
+ t.Error("duplicate label key must be rejected")
+ }
+}
diff --git a/internal/controlplane/server.go b/internal/controlplane/server.go
index 845e88f1..f7b8aefb 100644
--- a/internal/controlplane/server.go
+++ b/internal/controlplane/server.go
@@ -279,7 +279,8 @@ func (s *Server) runKeyRotationLoop() {
case <-ticker.C:
// Replicas share one DB but tick independently; only the replica
// that wins this claim may rotate for the current window.
- claimed, err := s.store.ClaimKeyRotation(s.ctx, time.Now(), s.config.KeyRotationInterval)
+ now := time.Now()
+ claimed, err := s.store.ClaimKeyRotation(s.ctx, now, s.config.KeyRotationInterval)
if err != nil {
logger.Errorf("Failed to claim key rotation window: %v", err)
continue
@@ -293,11 +294,20 @@ func (s *Server) runKeyRotationLoop() {
newPub, newPriv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
logger.Errorf("Failed to generate key pair for rotation: %v", err)
+ // Give up the window so a retry isn't stuck waiting a full interval.
+ if relErr := s.store.ReleaseKeyRotationClaim(s.ctx, now, s.config.KeyRotationInterval); relErr != nil {
+ logger.Errorf("Failed to release key rotation claim: %v", relErr)
+ }
continue
}
err = s.store.RotateKeys(s.ctx, newPriv, newPub, s.config.KeyGracePeriod)
if err != nil {
logger.Errorf("Failed to rotate keyring: %v", err)
+ // Same as above: don't let a failed rotation strand the mesh
+ // on unrotated keys until the next full interval.
+ if relErr := s.store.ReleaseKeyRotationClaim(s.ctx, now, s.config.KeyRotationInterval); relErr != nil {
+ logger.Errorf("Failed to release key rotation claim: %v", relErr)
+ }
} else {
logger.Infof("Key rotation committed. New current public key: %s", hex.EncodeToString(newPub))
if err := s.getMeshAdapter().PublishEvent(s.ctx, api.MeshEvent_KEY_ROTATION, "", newPub); err != nil {
diff --git a/internal/node/middleware.go b/internal/node/middleware.go
index 34eee8c4..29a9a3e0 100644
--- a/internal/node/middleware.go
+++ b/internal/node/middleware.go
@@ -17,6 +17,7 @@ package node
import (
"crypto/ed25519"
"fmt"
+ "runtime/debug"
"sync/atomic"
"github.com/biscuit-auth/biscuit-go/v2"
@@ -43,7 +44,7 @@ func recoverStreamHandler(name string, next network.StreamHandler) network.Strea
return func(s network.Stream) {
defer func() {
if r := recover(); r != nil {
- logger.Errorf("[%s] panic recovered from peer %s: %v", name, s.Conn().RemotePeer(), r)
+ logger.Errorf("[%s] panic recovered from peer %s: %v\n%s", name, s.Conn().RemotePeer(), r, debug.Stack())
_ = s.Reset()
}
}()
diff --git a/internal/node/openai_facade_test.go b/internal/node/openai_facade_test.go
index ede3d50b..4fc1b3b6 100644
--- a/internal/node/openai_facade_test.go
+++ b/internal/node/openai_facade_test.go
@@ -473,6 +473,9 @@ func TestParseRequiredLabels(t *testing.T) {
if _, err := parseRequiredLabels("bad key!=v"); err == nil {
t.Error("invalid label key must be rejected")
}
+ if _, err := parseRequiredLabels("region=us-east-1,region=us-west-1"); err == nil {
+ t.Error("duplicate label key must be rejected")
+ }
}
func TestRankProviders_LabelMatchIsExactAndCaseSensitive(t *testing.T) {
diff --git a/internal/node/openai_scorer.go b/internal/node/openai_scorer.go
index 686f157a..5fd33cea 100644
--- a/internal/node/openai_scorer.go
+++ b/internal/node/openai_scorer.go
@@ -64,6 +64,9 @@ func parseRequiredLabels(h string) (map[string]string, error) {
if out == nil {
out = make(map[string]string)
}
+ if _, exists := out[k]; exists {
+ return nil, fmt.Errorf("duplicate label key %q", k)
+ }
out[k] = v
}
return out, nil
diff --git a/internal/router/router.go b/internal/router/router.go
index 80f5d20c..a9dfbe75 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -26,6 +26,7 @@ import (
"net/http"
"os"
"path/filepath"
+ "runtime/debug"
"strings"
"sync"
"sync/atomic"
@@ -829,7 +830,7 @@ func recoverStreamHandler(name string, next network.StreamHandler) network.Strea
return func(s network.Stream) {
defer func() {
if rec := recover(); rec != nil {
- logger.Errorf("[%s] panic recovered from peer %s: %v", name, s.Conn().RemotePeer(), rec)
+ logger.Errorf("[%s] panic recovered from peer %s: %v\n%s", name, s.Conn().RemotePeer(), rec, debug.Stack())
_ = s.Reset()
}
}()
diff --git a/internal/storage/sql_store.go b/internal/storage/sql_store.go
index 45fa0005..1eb94957 100644
--- a/internal/storage/sql_store.go
+++ b/internal/storage/sql_store.go
@@ -545,6 +545,15 @@ func (s *SQLStore) ClaimKeyRotation(ctx context.Context, now time.Time, interval
return n == 1, nil
}
+// ReleaseKeyRotationClaim implements Store. It only resets the deadline if
+// it still holds the exact value this claim set, so it can't clobber a
+// newer claim.
+func (s *SQLStore) ReleaseKeyRotationClaim(ctx context.Context, now time.Time, interval time.Duration) error {
+ query := s.rebind(`UPDATE rotation_lock SET next_rotation_at = ? WHERE id = 1 AND next_rotation_at = ?`)
+ _, err := s.db.ExecContext(ctx, query, now.UnixMilli(), now.Add(interval).UnixMilli())
+ return err
+}
+
// RotateKeys implements Store.
func (s *SQLStore) RotateKeys(ctx context.Context, newPriv ed25519.PrivateKey, newPub ed25519.PublicKey, gracePeriod time.Duration) error {
tx, err := s.db.BeginTx(ctx, nil)
diff --git a/internal/storage/sql_store_test.go b/internal/storage/sql_store_test.go
index f92d43e7..077a82a2 100644
--- a/internal/storage/sql_store_test.go
+++ b/internal/storage/sql_store_test.go
@@ -177,6 +177,39 @@ func TestClaimKeyRotation(t *testing.T) {
}
}
+func TestReleaseKeyRotationClaim(t *testing.T) {
+ store := newTestStore(t)
+ defer func() { _ = store.Close() }()
+
+ ctx := context.Background()
+ t0 := time.Now()
+ interval := 24 * time.Hour
+
+ claimed, err := store.ClaimKeyRotation(ctx, t0, interval)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if !claimed {
+ t.Fatal("expected first claim to succeed")
+ }
+
+ // A failed rotation releases the claim instead of stranding the window
+ // for a full interval.
+ if err := store.ReleaseKeyRotationClaim(ctx, t0, interval); err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ // The window can now be reclaimed immediately, without waiting for the
+ // interval to elapse.
+ claimed, err = store.ClaimKeyRotation(ctx, t0.Add(time.Second), interval)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if !claimed {
+ t.Fatal("expected claim to succeed after release")
+ }
+}
+
func TestClaimKeyRotationConcurrent(t *testing.T) {
store := newTestStore(t)
defer func() { _ = store.Close() }()
diff --git a/internal/storage/storage.go b/internal/storage/storage.go
index 44b4abb0..ac5e24ba 100644
--- a/internal/storage/storage.go
+++ b/internal/storage/storage.go
@@ -119,6 +119,12 @@ type Store interface {
// interval), false if another replica already claimed this window.
ClaimKeyRotation(ctx context.Context, now time.Time, interval time.Duration) (bool, error)
+ // ReleaseKeyRotationClaim reverts a claim won via ClaimKeyRotation with
+ // the same now/interval back to its pre-claim deadline, so the window
+ // can be retried without waiting a full interval. Callers use this when
+ // the rotation that followed a successful claim failed.
+ ReleaseKeyRotationClaim(ctx context.Context, now time.Time, interval time.Duration) error
+
// SaveInitialKey sets the initial key pair if no keys exist yet.
SaveInitialKey(ctx context.Context, priv ed25519.PrivateKey, pub ed25519.PublicKey) error