@yamf/services-deploy-router 0.1.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@yamf/services-deploy-router",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Registry plugin: deploy-plan + deploy-bundle (slice C3)",
+  "main": "service.js",
+  "files": [
+    "service.js",
+    "placement.js"
+  ],
+  "devDependencies": {
+    "@yamf/test": "0.1.4"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@yamf/core": "0.8.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mcbrumagin/yamf"
+  },
+  "scripts": {
+    "test": "yamf test -d ."
+  }
+}

package/placement.js

@@ -0,0 +1,26 @@
+import { HttpError } from '@yamf/core'
+
+/**
+ * C4: least-loaded pm3 node by `replicaMetadata.node` tallies.
+ * @param {{ _state?: { replicaMetadata: Map<unknown, { node?: string }> }, listHealthyLocations?: (name: string) => string[] }} registry
+ * @param {string} pm3ServiceName
+ * @param {{ excludeNodes?: string[] }} [opts]
+ */
+export function pickNode (registry, pm3ServiceName, { excludeNodes = [] } = {}) {
+  const nodes = (registry.listHealthyLocations?.(pm3ServiceName) || [])
+    .filter((n) => !excludeNodes.includes(n))
+  if (!nodes.length) {
+    throw new HttpError(503, 'no-placement')
+  }
+  const meta = registry._state?.replicaMetadata
+  if (meta) {
+    const load = new Map(nodes.map((n) => [n, 0]))
+    for (const [, row] of meta) {
+      if (row?.node && load.has(row.node)) {
+        load.set(row.node, (load.get(row.node) || 0) + 1)
+      }
+    }
+    return [...load.entries()].sort((a, b) => a[1] - b[1])[0][0]
+  }
+  return nodes[0]
+}

package/service.js

@@ -0,0 +1,106 @@
+import {
+  deployDecisionFromReplicas,
+  HEADERS,
+  HttpError,
+  publishMessage,
+  streamBundleToFileWithHashCheck,
+  enforceDeployBundleEd25519Policy
+} from '@yamf/core'
+import { existsSync } from 'node:fs'
+import { pickNode } from './placement.js'
+
+const PLUGIN_SERVICE = 'yamf-deploy-router'
+
+/**
+ * @param {object} registry - server from `registryServer()`; must expose `registerCommand`, `getReplicasFor`, optional `_bundleStore`
+ * @param {{ bundleStore?: object, location: string, pm3ServiceName?: string }} options
+ * @param {string} options.location - own URL (used for `registerCommand` cleanup key; often `YAMF_REGISTRY_URL`)
+ */
+export function attachDeployRouter (registry, { bundleStore, location, pm3ServiceName = 'pm3-service' } = {}) {
+  if (!location) {
+    throw new Error('attachDeployRouter: `location` (registry public URL) is required')
+  }
+  if (!bundleStore && !registry?._bundleStore) {
+    throw new Error('attachDeployRouter: pass bundleStore or start registry with a bundle store')
+  }
+  const store = bundleStore || registry._bundleStore
+
+  // Server-side plan (auth: deploy token). The `yamf deploy` CLI still uses REGISTRY_PULL + planAndApply
+  // client-side for parity; keep this for HTTP API consumers and future "registry as source of truth" flows.
+  registry.registerCommand(
+    'deploy-plan',
+    async ({ body, headers }) => {
+      const out = { decisions: [] }
+      for (const s of body?.services || []) {
+        if (!s?.name || !s?.hash) {
+          throw new HttpError(400, 'Each service needs name and hash')
+        }
+        const reps = registry.getReplicasFor(s.name) || []
+        const { decision } = deployDecisionFromReplicas(reps, s.hash, s.replicas ?? 1)
+        out.decisions.push({ service: s.name, hash: s.hash, decision })
+        const fromH = (reps || []).map((r) => r.sourceHash).filter(Boolean).join(',') || null
+        try {
+          await publishMessage('yamf:deploy', {
+            service: s.name,
+            fromHash: fromH,
+            toHash: s.hash,
+            decision,
+            at: Date.now(),
+            deployer: headers[HEADERS.DEPLOYER] || null
+          })
+        } catch {
+          /* no pub */
+        }
+      }
+      return out
+    },
+    {
+      service: PLUGIN_SERVICE,
+      location,
+      requireDeployToken: true,
+      requireRegistryToken: false,
+      parseJsonBody: true
+    }
+  )
+
+  registry.registerCommand(
+    'deploy-bundle',
+    async ({ request, headers }) => {
+      const hash = (headers[HEADERS.DEPLOY_HASH] || headers['yamf-deploy-hash'] || '').trim()
+      if (!hash) {
+        throw new HttpError(400, 'yamf-deploy-hash required')
+      }
+      const out = store.pathFor(hash)
+      if (existsSync(out)) {
+        return { stored: hash, deduped: true }
+      }
+      try {
+        await streamBundleToFileWithHashCheck(request, hash, out)
+      } catch (e) {
+        if (e?.code === 'BUNDLE_HASH_MISMATCH' || e?.status === 422) {
+          const err = new HttpError(422, e.message || 'bundle-hash-mismatch')
+          err.code = 'bundle-hash-mismatch'
+          throw err
+        }
+        throw e
+      }
+      const policy = enforceDeployBundleEd25519Policy({
+        hash,
+        headers: request?.headers || {}
+      })
+      if (policy && 'status' in policy) {
+        throw new HttpError(policy.status, policy.message)
+      }
+      return { stored: hash }
+    },
+    {
+      service: PLUGIN_SERVICE,
+      location,
+      requireDeployToken: true,
+      requireRegistryToken: false,
+      parseJsonBody: false
+    }
+  )
+
+  return { pickNode: (o) => pickNode(registry, pm3ServiceName, o) }
+}