@norskvideo/ctl-sdk 0.1.19 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/ctl-sdk",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "type": "module",
   "exports": {
     ".": {

package/product-service.d.ts

@@ -11,6 +11,22 @@ export interface AddProductResult {
     registration: ProductRegistration;
     warnings: string[];
 }
+/** Result of `reload`. `containerRestarted` is false for dev products, which
+ *  are externally owned. `productTemplates` reports the manifest-declared
+ *  default templates handed to the host's refresh callback: `skipped` carries
+ *  the host's reason (typically "in use"), and every skip is also a warning. */
+export interface ReloadProductResult {
+    registration: ProductRegistration;
+    warnings: string[];
+    containerRestarted: boolean;
+    productTemplates: {
+        refreshed: string[];
+        skipped: Array<{
+            name: string;
+            reason: string;
+        }>;
+    };
+}
 export interface AddProductOpts {
     /** Per-product license stored on the registration record (#313). Callers
      *  typically seed this from their global license setting when the operator
@@ -49,6 +65,13 @@ export type ImportProductTemplateBytesFn = (opts: {
         kind: "product-default";
     }>;
 }) => Promise<void>;
+/** `reload`'s counterpart to ImportProductTemplateBytesFn: re-render the
+ *  stored snapshot of a product-default template from fresh bytes, or store
+ *  it if the product only started declaring it. The host owns the refusal
+ *  rules (a template an instance is using, one that is not product-default);
+ *  it throws, and the SDK reports the message as a skip rather than failing
+ *  the reload. */
+export type RefreshProductTemplateBytesFn = ImportProductTemplateBytesFn;
 /** Every container operation this service performs, behind an interface so
  *  tests can drive them without shelling out to Docker. Defaults wire straight
  *  to docker-runner + the readiness probe. Reach for these rather than the
@@ -71,6 +94,9 @@ export interface ProductServiceOptions {
      *  registration time. Omit on hosts that don't store product templates
      *  (defaultProductTemplates is then silently skipped). */
     importProductTemplateBytes?: ImportProductTemplateBytesFn;
+    /** Optional: called once per `manifest.defaultProductTemplates` entry by
+     *  `reload`. Omit on hosts that don't store product templates. */
+    refreshProductTemplateBytes?: RefreshProductTemplateBytesFn;
     /** Optional: copy a byol licence somewhere the host owns, so the path
      *  recorded in the registry outlives whatever the operator passed in.
      *  Omit on hosts that don't stage (the operator's path is then recorded). */
@@ -101,6 +127,7 @@ export declare class ProductService {
     private readonly store;
     private readonly allocatePort;
     private readonly importProductTemplateBytes?;
+    private readonly refreshProductTemplateBytes?;
     private readonly stageLicense?;
     private readonly isDevUrlAlive;
     private readonly containerOps;
@@ -119,7 +146,15 @@ export declare class ProductService {
     private addSerialised;
     remove(name: string): Promise<void>;
     private removeSerialised;
-    reload(name: string): Promise<ProductRegistration>;
+    /** Bring a registration up to date with what its image now serves. For a
+     *  container product: pull the tag (digests cannot move), re-run the
+     *  control plane on its recorded port, re-read the manifest, then hand every
+     *  manifest-declared default template to the host to re-render. Dev products
+     *  are externally owned, so only the manifest is re-read. This is the verb
+     *  the per-product "remove template, remove product, add again" scripts
+     *  stood in for. Like restart, the new container id is persisted before the
+     *  readiness wait so a timed-out reload leaves a tracked container. */
+    reload(name: string): Promise<ReloadProductResult>;
     private reloadSerialised;
     /** Stop every running container-kind product and clear its tracked
      *  containerId (model B: the daemon owns container lifecycle, so it reaps

package/product-service.js

@@ -52,6 +52,7 @@ export class ProductService {
     store;
     allocatePort;
     importProductTemplateBytes;
+    refreshProductTemplateBytes;
     stageLicense;
     isDevUrlAlive;
     containerOps;
@@ -59,6 +60,7 @@ export class ProductService {
         this.store = opts.store;
         this.allocatePort = opts.allocatePort;
         this.importProductTemplateBytes = opts.importProductTemplateBytes;
+        this.refreshProductTemplateBytes = opts.refreshProductTemplateBytes;
         this.stageLicense = opts.stageLicense;
         this.isDevUrlAlive = opts.isDevUrlAlive ?? isDevUrlAlive;
         this.containerOps = opts.containerOps ?? defaultProductContainerOps;
@@ -272,23 +274,76 @@ export class ProductService {
         await this.store.update((products) => products.filter((p) => p.name !== name));
         logger.info(`Product '${name}' removed`);
     }
+    /** Bring a registration up to date with what its image now serves. For a
+     *  container product: pull the tag (digests cannot move), re-run the
+     *  control plane on its recorded port, re-read the manifest, then hand every
+     *  manifest-declared default template to the host to re-render. Dev products
+     *  are externally owned, so only the manifest is re-read. This is the verb
+     *  the per-product "remove template, remove product, add again" scripts
+     *  stood in for. Like restart, the new container id is persisted before the
+     *  readiness wait so a timed-out reload leaves a tracked container. */
     async reload(name) {
         return this.mutations.run(() => this.reloadSerialised(name));
     }
     async reloadSerialised(name) {
-        const existing = this.store.read();
-        const target = existing.find((p) => p.name === name);
+        const target = this.store.read().find((p) => p.name === name);
         if (!target)
             throw new ProductError("NOT_FOUND", `product '${name}' not registered`);
+        let containerRestarted = false;
+        if (target.spec.kind === "container") {
+            if (target.port === undefined) {
+                throw new ProductError("NOT_RESTARTABLE", `product '${name}' has no recorded port — cannot reload`);
+            }
+            await this.refreshImage(target.spec.image);
+            if (target.containerId) {
+                try {
+                    await this.containerOps.remove(target.containerId);
+                }
+                catch {
+                    // Already gone (crashed / --rm reaped) — nothing to stop.
+                }
+            }
+            const containerId = await this.containerOps.run(target.spec.image, target.port);
+            await this.store.update((products) => products.map((p) => (p.name === name ? withContainerId(p, containerId) : p)));
+            await this.containerOps.waitForReady(specBaseUrl(target.spec, target.port));
+            await this.containerOps.rename(containerId, productContainerName(name));
+            containerRestarted = true;
+        }
         const baseUrl = specBaseUrl(target.spec, target.port);
         const manifest = await fetchManifest(baseUrl);
         if (manifest.name !== target.name) {
             throw new ProductError("NAME_CONFLICT", `manifest now reports name '${manifest.name}', was '${target.name}' — use remove + add`);
         }
-        const next = { ...target, manifest };
-        await this.store.update((products) => products.map((p) => (p.name === name ? next : p)));
-        logger.info(`Product '${name}' manifest reloaded`);
-        return next;
+        const updated = await this.store.update((products) => products.map((p) => (p.name === name ? { ...p, manifest } : p)));
+        const registration = updated.find((p) => p.name === name);
+        logger.info(`Product '${name}' reloaded${containerRestarted ? " (container re-run)" : ""}`);
+        // Same downgrade as add's default-template import: the product itself is
+        // healthy, so a template the host refuses (in use, foreign) or a fetch
+        // that fails is a warning the operator acts on, not a failed reload.
+        const warnings = [];
+        const productTemplates = { refreshed: [], skipped: [] };
+        if (this.refreshProductTemplateBytes) {
+            for (const entry of manifest.defaultProductTemplates) {
+                try {
+                    const bytes = await fetchProductTemplateBytes(baseUrl, entry.url);
+                    await this.refreshProductTemplateBytes({
+                        name: entry.name,
+                        bytes,
+                        source: { kind: "product-default", productName: manifest.name, url: entry.url },
+                    });
+                    productTemplates.refreshed.push(entry.name);
+                    logger.info(`Product '${name}': refreshed default product template '${entry.name}' from ${entry.url}`);
+                }
+                catch (e) {
+                    const reason = e instanceof Error ? e.message : String(e);
+                    productTemplates.skipped.push({ name: entry.name, reason });
+                    warnings.push(`default product template '${entry.name}' not refreshed: ${reason}`);
+                }
+            }
+        }
+        for (const w of warnings)
+            logger.warn(`[product:${name}] ${w}`);
+        return { registration, warnings, containerRestarted, productTemplates };
     }
     /** Stop every running container-kind product and clear its tracked
      *  containerId (model B: the daemon owns container lifecycle, so it reaps