Skip to content

Agent Mesh

node: publish a circuit address for every router it reserved on

Antonio Ojea87e17ca1790f
diff --git a/internal/node/node.go b/internal/node/node.go
index ad12750f..e6ece048 100644
--- a/internal/node/node.go
+++ b/internal/node/node.go
@@ -2617,27 +2617,64 @@ func (n *AgentMeshNode) StartIngressServer(ctx context.Context) error {
// announceFilter selects which of the host's addresses are published to the
// mesh (via Identify and DHT provider records). Relay addresses always pass:
// their IP belongs to the router, and dropping one would strand a node behind
-// NAT.
+// NAT. The routers the node holds a reservation on are added as circuit
+// addresses: AutoRelay publishes those only for a router on a public IP, and
+// a mesh on private or loopback addresses would otherwise publish no path to
+// a node that is reachable through its routers alone.
func (n *AgentMeshNode) announceFilter(addrs []multiaddr.Multiaddr) []multiaddr.Multiaddr {
announcePrivate := n.config.AnnouncePrivateAddrs == nil || *n.config.AnnouncePrivateAddrs
- if n.config.AllowLoopback && announcePrivate {
- return addrs
- }
- var filtered []multiaddr.Multiaddr
- for _, addr := range addrs {
- if hasCircuit(addr) {
+ if !n.config.AllowLoopback || !announcePrivate {
+ var filtered []multiaddr.Multiaddr
+ for _, addr := range addrs {
+ if hasCircuit(addr) {
+ filtered = append(filtered, addr)
+ continue
+ }
+ if !n.config.AllowLoopback && isLoopbackOrLinkLocal(addr) {
+ continue
+ }
+ if !announcePrivate && isPrivateIP(addr) {
+ continue
+ }
filtered = append(filtered, addr)
- continue
}
- if !n.config.AllowLoopback && isLoopbackOrLinkLocal(addr) {
+ addrs = filtered
+ }
+ extra := n.reservedCircuitAddrs(addrs)
+ if len(extra) == 0 {
+ return addrs
+ }
+ out := make([]multiaddr.Multiaddr, 0, len(addrs)+len(extra))
+ out = append(out, addrs...)
+ return append(out, extra...)
+}
+
+// reservedCircuitAddrs is one <router>/p2p/<id>/p2p-circuit address per
+// address of each router AutoRelay holds a reservation on, leaving out those
+// already in have.
+func (n *AgentMeshNode) reservedCircuitAddrs(have []multiaddr.Multiaddr) []multiaddr.Multiaddr {
+ if n.connMgr == nil {
+ return nil
+ }
+ seen := make(map[string]bool, len(have))
+ for _, a := range have {
+ seen[a.String()] = true
+ }
+ var out []multiaddr.Multiaddr
+ for _, c := range n.routerCandidates() {
+ if !n.connMgr.IsProtected(c.ID, autorelayTag) {
continue
}
- if !announcePrivate && isPrivateIP(addr) {
- continue
+ circuit := multiaddr.StringCast("/p2p/" + c.ID.String() + "/p2p-circuit")
+ for _, addr := range c.Addrs {
+ full := addr.Encapsulate(circuit)
+ if !seen[full.String()] {
+ seen[full.String()] = true
+ out = append(out, full)
+ }
}
- filtered = append(filtered, addr)
}
- return filtered
+ return out
}
func isLoopbackOrLinkLocal(addr multiaddr.Multiaddr) bool {
diff --git a/internal/node/node_test.go b/internal/node/node_test.go
index ba6af459..3cc081fd 100644
--- a/internal/node/node_test.go
+++ b/internal/node/node_test.go
@@ -36,6 +36,7 @@ import (
"github.com/libp2p/go-libp2p/core/peer"
"github.com/libp2p/go-libp2p/p2p/discovery/routing"
"github.com/libp2p/go-libp2p/p2p/discovery/util"
+ "github.com/libp2p/go-libp2p/p2p/net/connmgr"
"github.com/libp2p/go-msgio"
"github.com/multiformats/go-multiaddr"
"google.golang.org/protobuf/proto"
@@ -115,6 +116,54 @@ func TestAnnounceFilter(t *testing.T) {
}
}
+// A router AutoRelay holds a reservation on is announced as a circuit
+// address even when AutoRelay itself publishes none for it (a router on a
+// loopback or private IP); a router merely attached is not, and an address
+// AutoRelay already published is not repeated.
+func TestAnnounceFilterAddsReservedCircuits(t *testing.T) {
+ cm, err := connmgr.NewConnManager(10, 20)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _ = cm.Close() })
+ realCandidate := func() routerCandidate {
+ priv, _, err := crypto.GenerateEd25519Key(nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ id, err := peer.IDFromPrivateKey(priv)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return routerCandidate{AddrInfo: peer.AddrInfo{ID: id}}
+ }
+ reserved := realCandidate()
+ reserved.Addrs = []multiaddr.Multiaddr{multiaddr.StringCast("/ip4/127.0.0.1/tcp/4501"), multiaddr.StringCast("/ip4/10.0.0.7/tcp/4501")}
+ attachedOnly := realCandidate()
+ attachedOnly.Addrs = []multiaddr.Multiaddr{multiaddr.StringCast("/ip4/127.0.0.1/tcp/4502")}
+ n := &AgentMeshNode{config: Options{AllowLoopback: true}, connMgr: cm}
+ n.routerCatalog = []routerCandidate{reserved, attachedOnly}
+ cm.Protect(attachedOnly.ID, routerTag)
+ cm.Protect(reserved.ID, routerTag)
+ cm.Protect(reserved.ID, autorelayTag)
+
+ already := multiaddr.StringCast("/ip4/10.0.0.7/tcp/4501/p2p/" + reserved.ID.String() + "/p2p-circuit")
+ got := n.announceFilter([]multiaddr.Multiaddr{multiaddr.StringCast("/ip4/127.0.0.1/tcp/5002"), already})
+ want := []string{
+ "/ip4/127.0.0.1/tcp/5002",
+ already.String(),
+ "/ip4/127.0.0.1/tcp/4501/p2p/" + reserved.ID.String() + "/p2p-circuit",
+ }
+ if len(got) != len(want) {
+ t.Fatalf("announced %v, want %v", got, want)
+ }
+ for i, addr := range got {
+ if addr.String() != want[i] {
+ t.Errorf("addr %d: got %s, want %s", i, addr, want[i])
+ }
+ }
+}
+
func TestHandleBannedEvent(t *testing.T) {
priv, _, err := crypto.GenerateEd25519Key(nil)
if err != nil {
diff --git a/internal/node/routers.go b/internal/node/routers.go
index e80015e8..2b252497 100644
--- a/internal/node/routers.go
+++ b/internal/node/routers.go
@@ -46,6 +46,11 @@ type routerCandidate struct {
// take the router before a stranger.
const routerTag = "agentmesh-router"
+// autorelayTag is the tag go-libp2p's AutoRelay protects a relay with once
+// it holds a reservation there; reading it is how the node knows which
+// routers relay for it.
+const autorelayTag = "autorelay"
+
// candidatesFromInfo reads the routers /info lists. A control plane that
// predates RouterInfo lists addresses only; those become candidates without
// labels or load.