[ddm-api] PUT /peer for state-machine-bypassing peer injection

Fills out the testing work for `ddmd` in Omicron.

Includes:
- Adds a `PUT /peer` admin endpoint, gated at v2.0.0 (MULTICAST_SUPPORT), that
  injects a `PeerInfo` directly into the in-memory peer table at a supplied
  interface index. Intended for fixtures running ddmd with `--no-state-machine`.

  Note that in typical operations the discovery handler will overwrite any
  directly-injected entry the next time a peer is observed on that interface.

- Extracts the `get_peers` and `put_peer` impl bodies into
  `do_get_peers` / `do_put_peer` free functions in `ddm/src/admin.rs`,
  mirroring `mgd::bgp_admin::do_bgp_apply`, so the endpoints can be
  exercised in-process.

- Adds `tests::put_peer_round_trips` over a tempdir-backed setup covering the
  round-trip and same interface-index overwrite invariant.

- Adds a `put_peer` synthetic injection into the `run_trio_tests` smoke test
  that exercises the full HTTP path through the generated client against a
  running ddmd.

Author: zeeshanlakhani

Cargo.lock

@@ -72,6 +72,23 @@ pub trait DdmAdminApi {
         params: Path<latest::admin::ExpirePathParams>,
     ) -> Result<HttpResponseUpdatedNoContent, HttpError>;
 
+    /// Set peer information for a given interface index, bypassing the state machine.
+    ///
+    /// Intended for test fixtures that run `ddmd` with `--no-state-machine`.
+    /// In a normal run, discovery writes peer entries keyed by interface
+    /// index whenever it processes an advertisement, so any directly-injected
+    /// entry for an active interface will be overwritten the next time a
+    /// peer is observed there.
+    #[endpoint {
+        method = PUT,
+        path = "/peer",
+        versions = VERSION_MULTICAST_SUPPORT..
+    }]
+    async fn put_peer(
+        ctx: RequestContext<Self::Context>,
+        request: TypedBody<latest::admin::PutPeerRequest>,
+    ) -> Result<HttpResponseUpdatedNoContent, HttpError>;
+
     #[endpoint { method = GET, path = "/originated" }]
     async fn get_originated(
         ctx: RequestContext<Self::Context>,

ddm-api/src/lib.rs

@@ -8,6 +8,7 @@ pub mod admin {
     pub use crate::v1::admin::EnableStatsRequest;
     pub use crate::v1::admin::ExpirePathParams;
     pub use crate::v1::admin::PrefixMap;
+    pub use crate::v2::admin::PutPeerRequest;
 }
 
 pub mod db {

ddm-types/versions/src/latest.rs

@@ -0,0 +1,16 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use super::db::PeerInfo;
+
+/// Body for `PUT /peer`. Sets `info` at the slot keyed by `if_index`
+/// (interface index) in the in-memory peer map.
+#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
+pub struct PutPeerRequest {
+    pub if_index: u32,
+    pub info: PeerInfo,
+}

ddm-types/versions/src/multicast_support/admin.rs

@@ -5,5 +5,6 @@
 //! Types from API version 2 (MULTICAST_SUPPORT) that add multicast
 //! group management to the DDM admin API.
 
+pub mod admin;
 pub mod db;
 pub mod exchange;

ddm-types/versions/src/multicast_support/mod.rs

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dev-dependencies]
 pretty_assertions.workspace = true
+tempfile = "3"
 
 [dependencies]
 slog.workspace = true

ddm/Cargo.toml

@@ -6,7 +6,9 @@ use crate::db::Db;
 use crate::sm::{AdminEvent, Event, PrefixSet, SmContext};
 use ddm_api::DdmAdminApi;
 use ddm_api::ddm_admin_api_mod;
-use ddm_types::admin::{EnableStatsRequest, ExpirePathParams, PrefixMap};
+use ddm_types::admin::{
+    EnableStatsRequest, ExpirePathParams, PrefixMap, PutPeerRequest,
+};
 use ddm_types::db::{MulticastRoute, PeerInfo, TunnelRoute};
 use ddm_types::exchange::PathVector;
 use dropshot::ApiDescription;
@@ -112,8 +114,7 @@ impl DdmAdminApi for DdmAdminApiImpl {
     async fn get_peers(
         ctx: RequestContext<Self::Context>,
     ) -> Result<HttpResponseOk<HashMap<u32, PeerInfo>>, HttpError> {
-        let ctx = lock!(ctx.context());
-        Ok(HttpResponseOk(ctx.db.peers()))
+        Ok(HttpResponseOk(do_get_peers(ctx.context())))
     }
 
     async fn get_peers_v1(
@@ -151,6 +152,14 @@ impl DdmAdminApi for DdmAdminApiImpl {
         Ok(HttpResponseUpdatedNoContent())
     }
 
+    async fn put_peer(
+        ctx: RequestContext<Self::Context>,
+        request: TypedBody<PutPeerRequest>,
+    ) -> Result<HttpResponseUpdatedNoContent, HttpError> {
+        do_put_peer(ctx.context(), request.into_inner());
+        Ok(HttpResponseUpdatedNoContent())
+    }
+
     async fn get_originated(
         ctx: RequestContext<Self::Context>,
     ) -> Result<HttpResponseOk<HashSet<Ipv6Net>>, HttpError> {
@@ -481,3 +490,93 @@ pub fn api_description()
 {
     ddm_admin_api_mod::api_description::<DdmAdminApiImpl>()
 }
+
+/// Snapshot the current peer table, keyed by interface index.
+pub(crate) fn do_get_peers(
+    ctx: &Arc<Mutex<HandlerContext>>,
+) -> HashMap<u32, PeerInfo> {
+    let ctx = lock!(ctx);
+    ctx.db.peers()
+}
+
+/// Insert or replace the peer entry at `request.if_index`. Tests bypass
+/// the dropshot endpoint and call this directly; production goes through
+/// [`DdmAdminApiImpl::put_peer`].
+pub(crate) fn do_put_peer(
+    ctx: &Arc<Mutex<HandlerContext>>,
+    request: PutPeerRequest,
+) {
+    let PutPeerRequest { if_index, info } = request;
+    let ctx = lock!(ctx);
+    ctx.db.set_peer(if_index, info);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{HandlerContext, RouterStats, do_get_peers, do_put_peer};
+    use crate::db::Db;
+    use ddm_types::admin::PutPeerRequest;
+    use ddm_types::db::{PeerInfo, PeerStatus, RouterKind};
+    use slog::{Discard, Logger, o};
+    use std::sync::{Arc, Mutex};
+    use tempfile::TempDir;
+
+    fn build_context(tmpdir: &TempDir) -> Arc<Mutex<HandlerContext>> {
+        let log = Logger::root(Discard, o!());
+        let db_path = tmpdir.path().join("ddm").to_str().unwrap().to_string();
+        let db = Db::new(&db_path, log.clone()).expect("open db");
+        Arc::new(Mutex::new(HandlerContext {
+            event_channels: vec![],
+            db,
+            stats: Arc::new(RouterStats::default()),
+            peers: vec![],
+            stats_handler: Arc::new(Mutex::new(None)),
+            log,
+        }))
+    }
+
+    #[test]
+    fn put_peer_round_trips() {
+        let tmpdir = TempDir::new().expect("tempdir");
+        let ctx = build_context(&tmpdir);
+
+        let info = PeerInfo {
+            status: PeerStatus::Active,
+            addr: "fd00::1".parse().unwrap(),
+            host: "test-sled-1".to_string(),
+            kind: RouterKind::Server,
+            if_name: Some("tfportrear0_0".to_string()),
+        };
+
+        do_put_peer(
+            &ctx,
+            PutPeerRequest {
+                if_index: 7,
+                info: info.clone(),
+            },
+        );
+
+        let peers = do_get_peers(&ctx);
+        assert_eq!(peers.len(), 1);
+        let got = peers.get(&7).expect("peer at if_index 7");
+        assert_eq!(got, &info);
+
+        // Overwriting at the same `if_index` replaces the entry rather
+        // than creating a second one.
+        let info2 = PeerInfo {
+            addr: "fd00::2".parse().unwrap(),
+            host: "test-sled-1-replaced".to_string(),
+            ..info
+        };
+        do_put_peer(
+            &ctx,
+            PutPeerRequest {
+                if_index: 7,
+                info: info2.clone(),
+            },
+        );
+        let peers = do_get_peers(&ctx);
+        assert_eq!(peers.len(), 1, "overwrite at same if_index keeps map size",);
+        assert_eq!(peers[&7].addr, info2.addr);
+    }
+}

ddm/src/admin.rs

@@ -223,6 +223,34 @@
         }
       }
     },
+    "/peer": {
+      "put": {
+        "summary": "Set peer information for a given interface index, bypassing the state machine.",
+        "description": "Intended for test fixtures that run `ddmd` with `--no-state-machine`. In a normal run, discovery writes peer entries keyed by interface index whenever it processes an advertisement, so any directly-injected entry for an active interface will be overwritten the next time a peer is observed there.",
+        "operationId": "put_peer",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PutPeerRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "204": {
+            "description": "resource updated"
+          },
+          "4XX": {
+            "$ref": "#/components/responses/Error"
+          },
+          "5XX": {
+            "$ref": "#/components/responses/Error"
+          }
+        }
+      }
+    },
     "/peers": {
       "get": {
         "operationId": "get_peers",
@@ -717,6 +745,24 @@
           "Expired"
         ]
       },
+      "PutPeerRequest": {
+        "description": "Body for `PUT /peer`. Sets `info` at the slot keyed by `if_index` (interface index) in the in-memory peer map.",
+        "type": "object",
+        "properties": {
+          "if_index": {
+            "type": "integer",
+            "format": "uint32",
+            "minimum": 0
+          },
+          "info": {
+            "$ref": "#/components/schemas/PeerInfo"
+          }
+        },
+        "required": [
+          "if_index",
+          "info"
+        ]
+      },
       "RouterKind": {
         "type": "integer",
         "enum": [

…pi/ddm-admin/ddm-admin-2.0.0-8aeda2.json …pi/ddm-admin/ddm-admin-2.0.0-0cfd90.jsonopenapi/ddm-admin/ddm-admin-2.0.0-8aeda2.json renamed to openapi/ddm-admin/ddm-admin-2.0.0-0cfd90.json openapi/ddm-admin/ddm-admin-2.0.0-8aeda2.json renamed to openapi/ddm-admin/ddm-admin-2.0.0-0cfd90.json

@@ -1 +1 @@
-ddm-admin-2.0.0-8aeda2.json
+ddm-admin-2.0.0-0cfd90.json

openapi/ddm-admin/ddm-admin-latest.json

@@ -4,7 +4,10 @@
 
 use anyhow::{Result, anyhow};
 use ddm_admin_client::Client;
-use ddm_admin_client::types::{MulticastOrigin, TunnelOrigin, Vni};
+use ddm_admin_client::types::{
+    MulticastOrigin, PeerInfo, PeerStatus, PutPeerRequest, RouterKind,
+    TunnelOrigin, Vni,
+};
 use slog::{Drain, Logger};
 use std::env;
 use std::net::Ipv6Addr;
@@ -462,6 +465,31 @@ async fn run_trio_tests(
 
     println!("initial peering test passed");
 
+    // PUT /peer smoke against a running ddmd. Use an unused interface
+    // index so the live discovery handler does not race the injection
+    // on a real interface.
+    let synthetic = PeerInfo {
+        status: PeerStatus::Active,
+        addr: "fd00::dead:beef".parse().unwrap(),
+        host: "synthetic".to_string(),
+        // RouterKind is integer-encoded in the generated client schema;
+        // 0 is `Server`. See ddm-types::initial::db::RouterKind.
+        kind: RouterKind::try_from(0_i64).unwrap(),
+        if_name: Some("synthetic0".to_string()),
+    };
+
+    t1.put_peer(&PutPeerRequest {
+        if_index: 9999,
+        info: synthetic.clone(),
+    })
+    .await?;
+
+    wait_for_eq!(t1.get_peers().await.map_or(99, |x| x.len()), 3);
+    let peers = t1.get_peers().await?;
+    assert_eq!(peers["9999"].host, "synthetic");
+
+    println!("put_peer synthetic injection passed");
+
     s1.advertise_prefixes(&vec!["fd00:1::/64".parse().unwrap()])
         .await?;