@wpelevator/tug 0.1.0 → 0.2.0

package/dist/compose.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import yaml from 'js-yaml';
 import crypto from 'node:crypto';
+import { isDuration } from "./util.js";
 export async function readCompose(file = 'docker-compose.yml') {
     return yaml.load(await fs.readFile(file, 'utf8'));
 }
@@ -56,6 +57,51 @@ function validateIngress(name, svc, seen, errors) {
     if (tls === 'custom' && (!ingress.cert || !ingress.key))
         errors.push(`${name}: ingress.tls custom requires cert and key (names of project secrets holding the PEM certificate and private key)`);
 }
+/** True when the service opted in to `x-tug.rollout.strategy: rolling`. */
+export function isRolling(svc) { return svc?.['x-tug']?.rollout?.strategy === 'rolling'; }
+function validateRollout(name, svc, errors) {
+    const rollout = svc['x-tug']?.rollout;
+    if (rollout === undefined)
+        return;
+    if (!rollout || typeof rollout !== 'object' || Array.isArray(rollout)) {
+        errors.push(`${name}: x-tug.rollout must be an object`);
+        return;
+    }
+    for (const key of Object.keys(rollout))
+        if (key !== 'strategy' && key !== 'drain')
+            errors.push(`${name}: x-tug.rollout.${key} is not supported (supported: strategy, drain)`);
+    const strategy = rollout.strategy ?? 'recreate';
+    if (!['recreate', 'rolling'].includes(strategy)) {
+        errors.push(`${name}: rollout.strategy must be recreate or rolling`);
+        return;
+    }
+    if (rollout.drain !== undefined && !isDuration(rollout.drain))
+        errors.push(`${name}: rollout.drain must be a duration such as 30s, 500ms or 1m`);
+    if (strategy !== 'rolling')
+        return;
+    const lp = svc['x-tug'];
+    if (!lp.ingress)
+        errors.push(`${name}: rollout.strategy rolling requires x-tug.ingress (the edge is what switches traffic between revisions)`);
+    if (!lp.health)
+        errors.push(`${name}: rollout.strategy rolling requires x-tug.health (a new revision only takes over once it is healthy)`);
+    const ports = svc.ports || [];
+    if (ports.length !== 1)
+        errors.push(`${name}: rollout.strategy rolling requires exactly one entry in ports (the ingress port); each revision gets its own host port`);
+}
+function validateProjectExtension(compose, errors) {
+    const ext = compose['x-tug'];
+    if (ext === undefined)
+        return;
+    if (!ext || typeof ext !== 'object' || Array.isArray(ext)) {
+        errors.push('x-tug must be an object');
+        return;
+    }
+    for (const key of Object.keys(ext))
+        if (key !== 'rollback')
+            errors.push(`x-tug.${key} is not supported (supported: rollback)`);
+    if (ext.rollback !== undefined && !['auto', 'manual'].includes(ext.rollback))
+        errors.push('x-tug.rollback must be auto or manual');
+}
 export function validateCompose(compose, nodes = []) {
     if (!compose?.services || typeof compose.services !== 'object')
         throw new Error('compose file must define services');
@@ -73,19 +119,21 @@ export function validateCompose(compose, nodes = []) {
         if (lp.replicas && selected.length && lp.replicas !== selected.length)
             errors.push(`${name}: replicas must match placement node count in v1`);
         validateIngress(name, svc, ingressHosts, errors);
+        validateRollout(name, svc, errors);
     }
+    validateProjectExtension(compose, errors);
     if (errors.length)
         throw new Error(errors.join('; '));
 }
-export function buildDesiredState({ project, version, compose, registry, defaultNode = null }) {
+export function buildDesiredState({ project, version, compose, registry, revision, defaultNode = null }) {
     const services = {};
     for (const [name, src] of Object.entries(compose.services || {})) {
         const lp = src['x-tug'] || {};
         const placement = lp.placement || (defaultNode ? { nodes: [defaultNode] } : {});
-        const image = src.build ? `${registry}/${project}/${name}:${version}` : src.image;
+        const image = src.build ? `${registry ? `${registry}/` : "tug-build/"}${project}/${name}:${revision || version}` : src.image;
         services[name] = { image, build: src.build || null, placement, replicas: lp.replicas || placement.nodes?.length || 1, health: lp.health || null };
     }
-    return { project, version, services, compose };
+    return { project, version, ...(revision ? { revision } : {}), services, compose };
 }
 /** `extra_hosts` entries (`name:ip`) for services that run on other nodes, from health-aware endpoints. */
 export function crossNodeHosts(project, endpoints, local) {
@@ -98,25 +146,53 @@ export function crossNodeHosts(project, endpoints, local) {
     }
     return hosts;
 }
+/** Removes `depends_on` references to `names` (services that live in another Compose project). */
+export function dropDependsOn(svc, names) {
+    const deps = svc.depends_on;
+    if (Array.isArray(deps)) {
+        const kept = deps.filter(d => !names.has(String(d)));
+        if (kept.length)
+            svc.depends_on = kept;
+        else
+            delete svc.depends_on;
+    }
+    else if (deps && typeof deps === 'object') {
+        const kept = Object.fromEntries(Object.entries(deps).filter(([dep]) => !names.has(dep)));
+        if (Object.keys(kept).length)
+            svc.depends_on = kept;
+        else
+            delete svc.depends_on;
+    }
+}
 function extraHostsList(value) {
     if (!value)
         return [];
     return Array.isArray(value) ? value.map(String) : Object.entries(value).map(([k, v]) => `${k}:${v}`);
 }
-export function composeForNode(desiredState, nodeName, secrets = {}, endpoints = {}) {
+/**
+ * The Compose file for one node. `exclude` names services placed here that are managed outside the
+ * node's main project (rolling services run in their own revision projects); they still count as
+ * local, so they get no cross-node `extra_hosts` entry, and `depends_on` references to them are dropped.
+ */
+export function composeForNode(desiredState, nodeName, secrets = {}, endpoints = {}, exclude = new Set()) {
     const out = { services: {}, volumes: {} };
     const outVolumes = out.volumes;
     const usedVolumes = new Set();
+    const placed = new Set();
     for (const [name, src] of Object.entries(desiredState.compose.services || {})) {
-        const lp = src['x-tug'] || {};
-        const nodes = lp.placement?.nodes || [];
+        const nodes = desiredState.services[name].placement?.nodes || [];
         if (nodes.length && !nodes.includes(nodeName))
             continue;
+        placed.add(name);
+        if (exclude.has(name))
+            continue;
         const svc = { ...src, image: desiredState.services[name].image };
         delete svc.build;
         delete svc['x-tug'];
         delete svc.deploy;
         delete svc.container_name;
+        if (desiredState.services[name].artifact)
+            svc.pull_policy = 'never';
         if (Object.keys(secrets).length)
             svc.env_file = Array.from(new Set([...(Array.isArray(svc.env_file) ? svc.env_file : svc.env_file ? [svc.env_file] : []), '.env']));
         for (const vol of svc.volumes || []) {
@@ -124,9 +200,11 @@ export function composeForNode(desiredState, nodeName, secrets = {}, endpoints =
             if (source && desiredState.compose?.volumes?.[source])
                 usedVolumes.add(source);
         }
+        if (exclude.size)
+            dropDependsOn(svc, exclude);
         out.services[name] = svc;
     }
-    const hosts = crossNodeHosts(desiredState.project, endpoints, new Set(Object.keys(out.services)));
+    const hosts = crossNodeHosts(desiredState.project, endpoints, placed);
     if (hosts.length) {
         for (const svc of Object.values(out.services)) {
             const existing = extraHostsList(svc.extra_hosts);

package/dist/control.d.ts

@@ -1,11 +1,24 @@
 #!/usr/bin/env node
 import express from 'express';
+import { saveImageArchive, inspectImage, validateImageArchive } from './artifacts.ts';
 import https from 'node:https';
+import { openDb } from './db.ts';
 import type { NodeRow } from './db.ts';
+import { buildAndPush, run as runCommand } from './build.ts';
 declare module 'express-serve-static-core' {
     interface Request {
         node?: NodeRow;
     }
 }
-export declare function createApp(): Promise<import("express-serve-static-core").Express>;
+export interface ControlImageOperations {
+    build: typeof buildAndPush;
+    save: typeof saveImageArchive;
+    inspect: typeof inspectImage;
+    validate: typeof validateImageArchive;
+    run: typeof runCommand;
+}
+export declare function createApp(options?: {
+    images?: Partial<ControlImageOperations>;
+    openDatabase?: typeof openDb;
+}): Promise<import("express-serve-static-core").Express>;
 export declare function listen(app: express.Express, port?: number): Promise<import('node:http').Server | https.Server>;