@brutalsystems/dray 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brutalsystems/dray",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Convention-driven multi-repo deploy orchestrator (forge for shipping)",
   "bin": {
     "dray": "bin/dray.js"

package/src/cli/commands/add.js

@@ -1,7 +1,20 @@
+const fs = require('node:fs'); const path = require('node:path');
 const { loadRepoConfig } = require('../../config/repo'); const { addRepo } = require('../../config/registry');
+
+// The registry is consulted from arbitrary working directories, so a stored path
+// MUST be absolute. `dray add .` used to store "." verbatim, which then resolved
+// against whatever cwd dray ran in later -- two repos added that way both pointed
+// at "the current directory", and `dray ship <a>` from repo b deployed b under a's
+// name. realpath so symlinked checkouts land on one canonical path.
+function resolveRepoPath(repoPath) {
+  const p = path.resolve(repoPath || process.cwd());
+  try { return fs.realpathSync(p); } catch { return p; }
+}
+
 module.exports = function registerAdd(program) {
   program.command('add [repoPath]').description('Register a repo').action((repoPath) => {
-    const p = repoPath || process.cwd(); const config = loadRepoConfig(p);
+    const p = resolveRepoPath(repoPath); const config = loadRepoConfig(p);
     addRepo(undefined, { name: config.name, path: p, config }); console.log(`registered ${config.name} → ${p}`);
   });
 };
+module.exports.resolveRepoPath = resolveRepoPath;

package/src/config/registry.js

@@ -10,16 +10,22 @@ function removeRepo(file, name) { const r = loadRegistry(file); delete r[name];
 // without a manual `dray reload`. Falls back to the snapshot when the repo
 // isn't checked out here (stat throws) or its config is momentarily invalid
 // (loadRepoConfig throws) — a broken repo must not break `list`/`--all`.
-function refreshEntry(entry) {
+function refreshEntry(entry, name) {
   try {
     const mtime = Math.floor(fs.statSync(path.join(entry.path, '.dray', 'config.json')).mtimeMs);
     if (mtime <= (Date.parse(entry.addedAt) || 0)) return entry;
-    return { ...entry, config: loadRepoConfig(entry.path), addedAt: new Date(mtime).toISOString() };
+    const config = loadRepoConfig(entry.path);
+    // Only adopt a config that still belongs to this entry. A path pointing at a
+    // different project (a relative path left by an old `dray add .`, or a moved
+    // checkout) would otherwise have its config silently written into this key and
+    // PERSISTED -- turning `dray ship <name>` into a deploy of someone else's repo.
+    if (name !== undefined && config.name !== name) return entry;
+    return { ...entry, config, addedAt: new Date(mtime).toISOString() };
   } catch { return entry; }
 }
 function allRepos(file = REGISTRY) {
   const reg = loadRegistry(file); let changed = false;
-  for (const [n, e] of Object.entries(reg)) { const f = refreshEntry(e); if (f !== e) { reg[n] = f; changed = true; } }
+  for (const [n, e] of Object.entries(reg)) { const f = refreshEntry(e, n); if (f !== e) { reg[n] = f; changed = true; } }
   if (changed) saveRegistry(file, reg);
   return reg;
 }

package/src/core/engine.js

@@ -52,9 +52,25 @@ async function execute(steps, { dryRun = false, allowDirty = false, deps } = {})
         const vars = {}; for (const s of u.stamp) vars[s.var] = `${s.repoUri}:${sha}`;
         const files = d.render.renderManifests(u.manifests, vars, u.repoPath, { dryRun });
         if (files[0]) renderDirs.push(path.dirname(files[0]));
+        // Read the running image BEFORE applying. If it differs from what we
+        // are about to stamp, this apply changes the pod template and the
+        // Deployment controller starts a rollout on its own — so the rollout
+        // step that follows must wait rather than restart, or every ship
+        // produces two ReplicaSets and replaces the pod twice.
+        //
+        // Deliberately conservative: any doubt (dry run, cronjob, unreadable
+        // deployment) leaves the restart in place, which is the previous
+        // behaviour.
+        u._applyStartsRollout = false;
+        if (!dryRun && u.workload && u.kind !== 'cronjob') {
+          try {
+            const before = await d.kubectl.runningImage({ workload: u.workload, kind: u.kind, context: u.defaults.context, namespace: u.defaults.namespace });
+            u._applyStartsRollout = before !== `${u.repoUri}:${sha}`;
+          } catch { u._applyStartsRollout = false; }
+        }
         for (const f of files) await d.kubectl.applyFile({ file: f, context: u.defaults.context, namespace: u.defaults.namespace, dryRun });
       } else if (step.kind === 'rollout') {
-        try { await d.kubectl.rollout({ deployment: u.workload, context: u.defaults.context, namespace: u.defaults.namespace, dryRun }); }
+        try { await d.kubectl.rollout({ deployment: u.workload, context: u.defaults.context, namespace: u.defaults.namespace, dryRun, restart: !u._applyStartsRollout }); }
         catch (err) { await d.kubectl.rolloutUndo({ deployment: u.workload, context: u.defaults.context, namespace: u.defaults.namespace, dryRun }); throw err; }
       }
     }

package/src/primitives/kubectl.js

@@ -1,8 +1,12 @@
 let _run = require('./exec').run; function _withRun(fn) { _run = fn; }
 const ns = (c, n) => ['-n', n, '--context', c];
 function applyFile({ file, context, namespace, dryRun }) { return _run('kubectl', ['apply', '-f', file, ...ns(context, namespace)], { dryRun }); }
-async function rollout({ deployment, context, namespace, dryRun }) {
-  await _run('kubectl', ['rollout', 'restart', `deployment/${deployment}`, ...ns(context, namespace)], { dryRun });
+// `restart: false` waits without restarting. Used when the preceding apply
+// stamped a new image SHA and therefore already started a rollout — issuing
+// `rollout restart` on top of that produces a SECOND ReplicaSet and a second
+// pod replacement, doubling the disruption window on every deploy.
+async function rollout({ deployment, context, namespace, dryRun, restart = true }) {
+  if (restart) await _run('kubectl', ['rollout', 'restart', `deployment/${deployment}`, ...ns(context, namespace)], { dryRun });
   return _run('kubectl', ['rollout', 'status', `deployment/${deployment}`, '--timeout=180s', ...ns(context, namespace)], { dryRun });
 }
 function rolloutUndo({ deployment, context, namespace, dryRun }) { return _run('kubectl', ['rollout', 'undo', `deployment/${deployment}`, ...ns(context, namespace)], { dryRun }); }