chore: reduce examples size

Author: gmelodie

cbind/examples/README.md

@@ -7,9 +7,9 @@ The bindings are a header-only C API over a C ABI. Every generated method is asy
 - `echo.c` — two TCP nodes; the server mounts a custom `/cbind/echo/1.0.0` protocol and echoes the bytes it reads, the client dials it and verifies the round-trip. The incoming-stream handler only hands the stream id to `main`, which serves it inline, since calling back into the library from the dispatch thread would deadlock.
 - `gossipsub.c` — two TCP nodes join a shared topic and exchange one message, delivered to the subscriber through its pub/sub-message listener.
 - `kad.c` — two TCP nodes form a Kademlia DHT (a server, and a client that lists the server as its bootstrap node), then round-trip a value (`kad_put_value` / `kad_get_value`) and a provider record (`create_cid`, `kad_start_providing` / `kad_get_providers`) over the wire.
-- `relay.c` — three TCP nodes: a relay, a destination and a source. The destination reserves a slot on the relay (`circuit_relay_reserve`); the source reaches it over a `/p2p-circuit` address (`dial_circuit_relay`) and runs the echo exchange relayed instead of direct.
-- `peerstore.c` — drives one node's peerstore directly from a second node's PeerInfo: `peerstore_add_peer`, `peerstore_get_peers`, `peerstore_get_peer_info`, `peerstore_set_peer_protocols`, then `peerstore_delete_peer`. No dialing required.
-- `metrics.c` — two TCP nodes connect, then one dumps the process-wide Prometheus registry as JSON via `collect_metrics`.
+- `relay.c` — three TCP nodes: a relay, a destination and a source. The destination reserves a slot on the relay (`circuit_relay_reserve`); the source reaches it over a `/p2p-circuit` address (`dial_circuit_relay`) and sends a message the destination reads off its relayed stream.
+- `peerstore.c` — drives one node's peerstore directly from a second node's PeerInfo: `peerstore_add_peer`, `peerstore_get_peers`, `peerstore_get_peer_info`, then `peerstore_delete_peer`. No dialing required.
+- `metrics.c` — a running node dumps the process-wide Prometheus registry as JSON via `collect_metrics`.
 
 ## Build
 

cbind/examples/metrics.c

@@ -1,35 +1,29 @@
-// Metrics: two TCP nodes connect, then one dumps the process-wide Prometheus
-// registry as JSON via libp2p_ctx_collect_metrics. The registry is global (it
-// belongs to the `metrics` module, not a single node), so a running node with a
-// live connection is enough to populate real counters. The generated bindings
-// are asynchronous, so every call is wrapped with the blocking helpers in
+// Metrics: a running node dumps the process-wide Prometheus registry as JSON
+// via libp2p_ctx_collect_metrics. The registry is global, so one started node
+// is enough to populate it. Calls are made blocking with the helpers in
 // common.h.
 #include "common.h"
 
 // TransportType / MuxerType ordinals, mirrored from libp2p_ffi/config.nim.
 static const int64_t TransportTcp = 1;
 static const int64_t MuxerMplex = 0;
 
-// collect_metrics replies with a JSON string (Result[string]), so it needs its
-// own waiter. The document can be large, so keep a generous buffer and record
-// whether it was truncated for display.
+// collect_metrics replies with a JSON string (Result[string]).
 typedef struct {
   atomic_int done;
   int err_code;
   char err[256];
   char json[1 << 16];
   size_t len;
-  bool truncated;
 } MetricsWaiter;
 
 static void on_metrics(int ec, const NimFfiStr *reply, const char *em,
                        void *ud) {
   MetricsWaiter *w = (MetricsWaiter *)ud;
   w->err_code = ec;
   if (reply && reply->data) {
-    size_t cap = sizeof(w->json) - 1;
-    w->truncated = reply->len > cap;
-    w->len = w->truncated ? cap : reply->len;
+    w->len =
+        reply->len < sizeof(w->json) - 1 ? reply->len : sizeof(w->json) - 1;
     memcpy(w->json, reply->data, w->len);
     w->json[w->len] = '\0';
   }
@@ -38,72 +32,44 @@ static void on_metrics(int ec, const NimFfiStr *reply, const char *em,
   atomic_store(&w->done, 1);
 }
 
-static LibP2PCtx *createNode(const char *listenAddr, const char *label) {
-  NimFfiStr addrSlot = nimffi_str(listenAddr);
+int main(void) {
+  NimFfiStr addr = nimffi_str("/ip4/127.0.0.1/tcp/5041");
   Libp2pConfig cfg;
   memset(&cfg, 0, sizeof(cfg));
-  cfg.addrs.data = &addrSlot;
+  cfg.addrs.data = &addr;
   cfg.addrs.len = 1;
   cfg.muxer = MuxerMplex;
   cfg.transport = TransportTcp;
-  return await_create(&cfg, label);
-}
 
-int main(void) {
-  LibP2PCtx *server = createNode("/ip4/127.0.0.1/tcp/5041", "server");
-  LibP2PCtx *client = createNode("/ip4/127.0.0.1/tcp/5042", "client");
-  if (!server || !client) {
-    libp2p_ctx_destroy(server);
-    libp2p_ctx_destroy(client);
+  LibP2PCtx *node = await_create(&cfg, "node");
+  if (!node)
     return 1;
-  }
 
   int status = 1;
   BoolWaiter bw;
-  if (!AWAIT_BOOL(bw, libp2p_ctx_start(server, on_bool, &bw), "start server") ||
-      !AWAIT_BOOL(bw, libp2p_ctx_start(client, on_bool, &bw), "start client"))
+  if (!AWAIT_BOOL(bw, libp2p_ctx_start(node, on_bool, &bw), "start"))
     goto cleanup;
 
-  PeerInfoWaiter pw;
-  if (!await_peerinfo(server, &pw, "peerinfo"))
-    goto cleanup;
-
-  NimFfiStr connAddrs[MAX_ADDRS];
-  for (size_t i = 0; i < pw.naddrs; i++)
-    connAddrs[i] = nimffi_str(pw.addrs[i]);
-  ConnectRequest connReq = {nimffi_str(pw.peerId), {connAddrs, pw.naddrs}, 0};
-  if (!AWAIT_BOOL(bw, libp2p_ctx_connect(client, &connReq, on_bool, &bw),
-                  "connect"))
-    goto cleanup;
-
-  // Let identify and the muxer settle so their counters are non-zero.
-  sleep_ms(500);
-
   MetricsWaiter mw;
   memset(&mw, 0, sizeof(mw));
-  libp2p_ctx_collect_metrics(server, on_metrics, &mw);
+  libp2p_ctx_collect_metrics(node, on_metrics, &mw);
   if (!wait_done(&mw.done) || mw.err_code != 0) {
     fprintf(stderr, "collect_metrics: %s\n", mw.err[0] ? mw.err : "unknown");
     goto cleanup;
   }
 
-  // The payload is a JSON array of {name,type,help,labels,value,timestamp}
-  // objects. Print a short prefix rather than the whole document.
-  printf("Collected %zu bytes of metrics%s\n", mw.len,
-         mw.truncated ? " (truncated)" : "");
-  printf("%.512s%s\n", mw.json, mw.len > 512 ? " ..." : "");
+  // A JSON array of {name,type,help,labels,value,timestamp} objects; print a
+  // prefix rather than the whole document.
+  printf("Collected %zu bytes of metrics\n", mw.len);
+  printf("%.400s%s\n", mw.json, mw.len > 400 ? " ..." : "");
 
-  // A running node always registers libp2p collectors, so a well-formed,
-  // non-empty JSON array with at least one named metric is the success signal.
-  if (mw.len > 2 && mw.json[0] == '[' && strstr(mw.json, "\"name\""))
+  if (mw.json[0] == '[' && strstr(mw.json, "\"name\""))
     status = 0;
   else
     fprintf(stderr, "Error: metrics payload was empty or malformed\n");
 
 cleanup:
-  AWAIT_BOOL(bw, libp2p_ctx_stop(client, on_bool, &bw), "stop client");
-  AWAIT_BOOL(bw, libp2p_ctx_stop(server, on_bool, &bw), "stop server");
-  libp2p_ctx_destroy(client);
-  libp2p_ctx_destroy(server);
+  AWAIT_BOOL(bw, libp2p_ctx_stop(node, on_bool, &bw), "stop");
+  libp2p_ctx_destroy(node);
   return status;
 }

cbind/examples/peerstore.c

@@ -1,15 +1,13 @@
-// Peerstore: a node's local book of what it knows about other peers. This
-// example drives the store directly — no dialing required — by taking a second
-// node's real PeerInfo and then adding, inspecting, updating and removing it
-// through the peerstore API. The generated bindings are asynchronous, so every
-// call is wrapped with the blocking helpers in common.h.
+// Peerstore: a node's local record of other peers. This drives the store
+// directly — no dialing — using a second node's real PeerInfo: add the peer,
+// list it, read it back, then delete it. Calls are made blocking via common.h.
 #include "common.h"
 
 // TransportType / MuxerType ordinals, mirrored from libp2p_ffi/config.nim.
 static const int64_t TransportTcp = 1;
 static const int64_t MuxerMplex = 0;
 
-static const char *CustomProto = "/cbind/peerstore/1.0.0";
+static const char *Proto = "/cbind/peerstore/1.0.0";
 
 // get_peers replies with a PeersResponse of peer-id strings.
 #define MAX_PEERS 16
@@ -37,61 +35,49 @@ static void on_peers(int ec, const PeersResponse *reply, const char *em,
   atomic_store(&w->done, 1);
 }
 
-// get_peer_info replies with the full PeerStoreEntryResponse for one peer.
+static bool get_peers(LibP2PCtx *ctx, PeersWaiter *w) {
+  memset(w, 0, sizeof(*w));
+  libp2p_ctx_peerstore_get_peers(ctx, on_peers, w);
+  if (!wait_done(&w->done) || w->err_code != 0) {
+    fprintf(stderr, "get_peers: %s\n", w->err[0] ? w->err : "unknown");
+    return false;
+  }
+  return true;
+}
+
+static bool holds(const PeersWaiter *w, const char *peerId) {
+  for (size_t i = 0; i < w->n; i++)
+    if (strcmp(w->peerIds[i], peerId) == 0)
+      return true;
+  return false;
+}
+
+// get_peer_info replies with the full entry; we only report its counts here.
 typedef struct {
   atomic_int done;
   int err_code;
   char err[256];
-  char addrs[MAX_ADDRS][256];
-  size_t naddrs;
-  char protocols[MAX_ADDRS][128];
-  size_t nprotocols;
-} PeerEntryWaiter;
-
-static void on_peer_entry(int ec, const PeerStoreEntryResponse *reply,
-                          const char *em, void *ud) {
-  PeerEntryWaiter *w = (PeerEntryWaiter *)ud;
+  size_t naddrs, nprotocols;
+} EntryWaiter;
+
+static void on_entry(int ec, const PeerStoreEntryResponse *reply,
+                     const char *em, void *ud) {
+  EntryWaiter *w = (EntryWaiter *)ud;
   w->err_code = ec;
   if (reply) {
-    w->naddrs = reply->addrs.len < MAX_ADDRS ? reply->addrs.len : MAX_ADDRS;
-    for (size_t i = 0; i < w->naddrs; i++)
-      if (reply->addrs.data[i].data)
-        snprintf(w->addrs[i], sizeof(w->addrs[i]), "%s",
-                 reply->addrs.data[i].data);
-    w->nprotocols =
-        reply->protocols.len < MAX_ADDRS ? reply->protocols.len : MAX_ADDRS;
-    for (size_t i = 0; i < w->nprotocols; i++)
-      if (reply->protocols.data[i].data)
-        snprintf(w->protocols[i], sizeof(w->protocols[i]), "%s",
-                 reply->protocols.data[i].data);
+    w->naddrs = reply->addrs.len;
+    w->nprotocols = reply->protocols.len;
   }
   if (em)
     snprintf(w->err, sizeof(w->err), "%s", em);
   atomic_store(&w->done, 1);
 }
 
-static bool get_entry(LibP2PCtx *ctx, const char *peerId, PeerEntryWaiter *w) {
-  memset(w, 0, sizeof(*w));
-  libp2p_ctx_peerstore_get_peer_info(ctx, nimffi_str(peerId), on_peer_entry, w);
-  if (!wait_done(&w->done) || w->err_code != 0) {
-    fprintf(stderr, "get_peer_info: %s\n", w->err[0] ? w->err : "unknown");
-    return false;
-  }
-  return true;
-}
-
-static bool has_protocol(const PeerEntryWaiter *w, const char *proto) {
-  for (size_t i = 0; i < w->nprotocols; i++)
-    if (strcmp(w->protocols[i], proto) == 0)
-      return true;
-  return false;
-}
-
-static LibP2PCtx *createNode(const char *listenAddr, const char *label) {
-  NimFfiStr addrSlot = nimffi_str(listenAddr);
+static LibP2PCtx *createNode(const char *addr, const char *label) {
+  NimFfiStr slot = nimffi_str(addr);
   Libp2pConfig cfg;
   memset(&cfg, 0, sizeof(cfg));
-  cfg.addrs.data = &addrSlot;
+  cfg.addrs.data = &slot;
   cfg.addrs.len = 1;
   cfg.muxer = MuxerMplex;
   cfg.transport = TransportTcp;
@@ -102,8 +88,8 @@ int main(void) {
   int status = 1;
   BoolWaiter bw;
 
-  // The "local" node owns the peerstore we drive. The "other" node only exists
-  // to hand us a real peer id and listen addresses to store.
+  // `local` owns the peerstore we drive; `other` just hands us a real peer id
+  // and listen addresses to store.
   LibP2PCtx *local = createNode("/ip4/127.0.0.1/tcp/5051", "local");
   LibP2PCtx *other = createNode("/ip4/127.0.0.1/tcp/5052", "other");
   if (!local || !other) {
@@ -115,96 +101,56 @@ int main(void) {
   // Start `other` so its listen addresses are bound and reported by peer_info.
   if (!AWAIT_BOOL(bw, libp2p_ctx_start(other, on_bool, &bw), "start other"))
     goto cleanup;
-
-  PeerInfoWaiter other_info;
-  if (!await_peerinfo(other, &other_info, "other peerinfo"))
+  PeerInfoWaiter oi;
+  if (!await_peerinfo(other, &oi, "other peerinfo"))
     goto cleanup;
-  printf("Peer to store: %s\n", other_info.peerId);
+  printf("Peer to store: %s\n", oi.peerId);
 
-  // ── add_peer: merge addresses (and a protocol) into the address book ───────
+  // add_peer: merge the peer's addresses and a protocol into the store.
   NimFfiStr addrs[MAX_ADDRS];
-  for (size_t i = 0; i < other_info.naddrs; i++)
-    addrs[i] = nimffi_str(other_info.addrs[i]);
-  NimFfiStr protoSlot = nimffi_str(CustomProto);
-  AddPeerRequest addReq = {nimffi_str(other_info.peerId),
-                           {addrs, other_info.naddrs},
-                           {&protoSlot, 1}};
+  for (size_t i = 0; i < oi.naddrs; i++)
+    addrs[i] = nimffi_str(oi.addrs[i]);
+  NimFfiStr proto = nimffi_str(Proto);
+  AddPeerRequest addReq = {
+      nimffi_str(oi.peerId), {addrs, oi.naddrs}, {&proto, 1}};
   if (!AWAIT_BOOL(bw,
                   libp2p_ctx_peerstore_add_peer(local, &addReq, on_bool, &bw),
                   "add_peer"))
     goto cleanup;
-  printf("Added %s with %zu address(es) and protocol %s\n", other_info.peerId,
-         other_info.naddrs, CustomProto);
 
-  // ── get_peers: the stored peer should now be listed ───────────────────────
+  // get_peers + get_peer_info: the peer is now listed and readable.
   PeersWaiter peers;
-  memset(&peers, 0, sizeof(peers));
-  libp2p_ctx_peerstore_get_peers(local, on_peers, &peers);
-  if (!wait_done(&peers.done) || peers.err_code != 0) {
-    fprintf(stderr, "get_peers: %s\n", peers.err[0] ? peers.err : "unknown");
+  if (!get_peers(local, &peers))
     goto cleanup;
-  }
-  bool listed = false;
-  printf("Peerstore holds %zu peer(s):\n", peers.n);
-  for (size_t i = 0; i < peers.n; i++) {
-    printf("  %s\n", peers.peerIds[i]);
-    if (strcmp(peers.peerIds[i], other_info.peerId) == 0)
-      listed = true;
-  }
-  if (!listed) {
-    fprintf(stderr, "Error: stored peer not found in get_peers\n");
+  EntryWaiter entry;
+  memset(&entry, 0, sizeof(entry));
+  libp2p_ctx_peerstore_get_peer_info(local, nimffi_str(oi.peerId), on_entry,
+                                     &entry);
+  if (!wait_done(&entry.done) || entry.err_code != 0) {
+    fprintf(stderr, "get_peer_info: %s\n",
+            entry.err[0] ? entry.err : "unknown");
     goto cleanup;
   }
-
-  // ── get_peer_info: read back the stored addresses and protocols ───────────
-  PeerEntryWaiter entry;
-  if (!get_entry(local, other_info.peerId, &entry))
-    goto cleanup;
-  printf("Stored entry: %zu address(es), %zu protocol(s)\n", entry.naddrs,
-         entry.nprotocols);
-  if (entry.naddrs == 0 || !has_protocol(&entry, CustomProto)) {
-    fprintf(stderr, "Error: stored entry is missing its address or protocol\n");
-    goto cleanup;
-  }
-
-  // ── set_peer_protocols: replace the protocol set, then verify the change ──
-  const char *NewProto = "/cbind/peerstore/2.0.0";
-  NimFfiStr newProtoSlot = nimffi_str(NewProto);
-  SetProtocolsRequest setReq = {nimffi_str(other_info.peerId),
-                                {&newProtoSlot, 1}};
-  if (!AWAIT_BOOL(
-          bw,
-          libp2p_ctx_peerstore_set_peer_protocols(local, &setReq, on_bool, &bw),
-          "set_peer_protocols"))
-    goto cleanup;
-  if (!get_entry(local, other_info.peerId, &entry))
-    goto cleanup;
-  if (has_protocol(&entry, CustomProto) || !has_protocol(&entry, NewProto)) {
-    fprintf(stderr,
-            "Error: set_peer_protocols did not replace the protocols\n");
+  printf("Stored: %zu peer(s), entry has %zu address(es) and %zu protocol(s)\n",
+         peers.n, entry.naddrs, entry.nprotocols);
+  if (!holds(&peers, oi.peerId) || entry.naddrs == 0 || entry.nprotocols == 0) {
+    fprintf(stderr, "Error: peer was not stored correctly\n");
     goto cleanup;
   }
-  printf("Protocols replaced with %s\n", NewProto);
 
-  // ── delete_peer: the store should be empty of it afterwards ───────────────
+  // delete_peer: the store no longer holds it.
   if (!AWAIT_BOOL(bw,
-                  libp2p_ctx_peerstore_delete_peer(
-                      local, nimffi_str(other_info.peerId), on_bool, &bw),
+                  libp2p_ctx_peerstore_delete_peer(local, nimffi_str(oi.peerId),
+                                                   on_bool, &bw),
                   "delete_peer"))
     goto cleanup;
-  memset(&peers, 0, sizeof(peers));
-  libp2p_ctx_peerstore_get_peers(local, on_peers, &peers);
-  if (!wait_done(&peers.done) || peers.err_code != 0) {
-    fprintf(stderr, "get_peers: %s\n", peers.err[0] ? peers.err : "unknown");
+  if (!get_peers(local, &peers))
+    goto cleanup;
+  if (holds(&peers, oi.peerId)) {
+    fprintf(stderr, "Error: peer still present after delete_peer\n");
     goto cleanup;
   }
-  for (size_t i = 0; i < peers.n; i++) {
-    if (strcmp(peers.peerIds[i], other_info.peerId) == 0) {
-      fprintf(stderr, "Error: peer still present after delete_peer\n");
-      goto cleanup;
-    }
-  }
-  printf("Deleted %s from the peerstore\n", other_info.peerId);
+  printf("Deleted %s\n", oi.peerId);
   status = 0;
 
 cleanup: