jschoubben
97707480d6
lavinmq becomes a provider of a user-facing amqp interface: a consumer
that requires a message queue is given its OWN broker — a scoped vhost
and user on a lavinmq provider — not an account on the mesh's own
control-plane broker (ADR 0048). Vhost-per-login is the isolation model,
the exact analog of postgres's database-per-login: the provider names a
vhost after the consumer's login and a user with full rights on that
vhost and none elsewhere, so a login is a broker the consumer alone can
reach.
The provider drives lavinmq through its HTTP management API (client.ts,
the module's one impure seam), with a run-once bootstrap that computes
the RabbitMQ-compatible password hash lavinmq's config wants from the
plain admin secret the mesh mints — the value no ${secret:...}
placeholder can produce and the reason the bootstrap exists (ADR 0052).
serves.amqp carries the port so consumers reference ${bound:amqp:port}.
amqp-ping is a demo consumer: it contributes nothing (the vhost is the
login), reads its grant from an env-file the mesh fills, and uses
${bound:amqp:as} for BOTH its username and its vhost — the db-name
lesson applied to AMQP. It speaks AMQP 0-9-1 over a raw socket with no
npm dependency (the way redis speaks RESP) and round-trips one message.
It carries a slug so its identity fits the 20-char backend bound
(ADR 0049).
Claude-Session: https://claude.ai/code/session_01LrgweAeERJYBg88c5cKDzF
51 lines
2.2 KiB
TypeScript
51 lines
2.2 KiB
TypeScript
// amqp-ping — a tiny demo consumer of the mesh `amqp` interface, run as a long-lived container by
|
|
// `mesh-tools run` (it never returns, so the container stays up). It exists to PROVE the grant end to
|
|
// end: the mesh gave it a scoped login and a vhost of that name on the lavinmq provider, and this
|
|
// connects with exactly those and round-trips a message.
|
|
//
|
|
// The connection facts arrive the way every consumer's do — the mesh writes them into an env-file the
|
|
// container reads (novox/hq ADR 0048): MESH_AMQP_HOST/PORT from the binding, MESH_AMQP_USER and
|
|
// MESH_AMQP_VHOST both from `${bound:amqp:as}` (the provider named the vhost after the login, so the
|
|
// consumer uses the login for both — the db-name lesson applied to AMQP), and MESH_AMQP_PASSWORD from
|
|
// `${secret:amqp}`.
|
|
//
|
|
// It retries: on first boot the provider may not have provisioned this consumer yet (the reconcile is
|
|
// asynchronous and cross-container), so a refused or unreachable connection is a "not yet", not a
|
|
// failure — it waits and tries again until the round-trip succeeds, then holds the connection idle
|
|
// and re-pings on a slow cadence so the container is a stable, running proof.
|
|
|
|
import { connFromEnv, roundTrip } from "./client.js";
|
|
|
|
async function sleep(ms: number): Promise<void> {
|
|
await new Promise((r) => setTimeout(r, ms));
|
|
}
|
|
|
|
async function pingOnce(): Promise<boolean> {
|
|
try {
|
|
const conn = connFromEnv();
|
|
const sent = `ping-${Date.now()}`;
|
|
const got = await roundTrip(conn, "amqp-ping", sent);
|
|
if (got === sent) {
|
|
console.log(`[amqp-ping] round-trip ok as ${conn.user} on vhost ${conn.vhost} (${conn.host}:${conn.port})`);
|
|
return true;
|
|
}
|
|
console.error(`[amqp-ping] round-trip mismatch: sent ${sent}, got ${got}`);
|
|
return false;
|
|
} catch (err) {
|
|
console.error(`[amqp-ping] not ready yet: ${err instanceof Error ? err.message : err}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Wait for the first successful round-trip — the proof this consumer's grant works — then stay up.
|
|
let first = false;
|
|
for (let i = 0; !first; i++) {
|
|
first = await pingOnce();
|
|
if (!first) await sleep(3000);
|
|
}
|
|
console.log("[amqp-ping] connected and round-tripped; holding steady");
|
|
for (;;) {
|
|
await sleep(30000);
|
|
await pingOnce();
|
|
}
|