@omnitron-dev/omnitron 0.2.0 → 0.3.0

package/dist/services/infrastructure.rpc-service.d.ts

@@ -5,14 +5,309 @@
  * (Docker-based PostgreSQL, Redis, MinIO, etc.).
  */
 import type { InfrastructureService } from '../infrastructure/infrastructure.service.js';
+import type { InfrastructureConfig, IServiceRequirement } from '../infrastructure/types.js';
 import type { InfrastructureState, ContainerState } from '../infrastructure/types.js';
-export declare class InfrastructureRpcService {
+import type { IOmnitronInfraService } from '../shared/dto/services.js';
+export declare class InfrastructureRpcService implements IOmnitronInfraService {
     private readonly getInfra;
-    constructor(getInfra: () => InfrastructureService | null);
+    /**
+     * How this daemon builds and adopts an infrastructure it is asked for.
+     *
+     * The daemon does it, not this service: it holds the logger the node
+     * logs through, and it is what has to remember the result — the same
+     * field `getState`, the health indicator and the shutdown path read.
+     *
+     * Absent on a daemon that will not host one, and the call is then
+     * refused by name rather than silently doing nothing, which is the
+     * difference between "this node does not do that" and "it worked".
+     */
+    private readonly hostInfra?;
+    /**
+     * This node's secret store.
+     *
+     * A GETTER, resolved per call. Captured once at boot, a resolution that
+     * failed during startup — a container not yet ready, a token registered
+     * later — left credential generation off for the life of the daemon,
+     * and nothing said so: the absence looks exactly like a daemon that
+     * hosts no infrastructure. `getInfra` above is a getter for the same
+     * reason.
+     *
+     * Absent on a daemon that hosts no stack infrastructure, in which case
+     * nothing is generated — there is nothing to generate it for.
+     */
+    private readonly getVault?;
+    /**
+     * Where this service says what only it knows.
+     *
+     * Optional in the type and required in practice: the one thing
+     * `provisionStack` reports on its own — that a deployment is running on
+     * a default credential — is said at error level, and an absent logger
+     * turns a safety mechanism into a silent one. It was absent, and the
+     * mechanism worked and said nothing.
+     */
+    /**
+     * Narrowed to what this service actually says. It was `error` alone, when
+     * the only thing it reported was a deployment running on a default
+     * credential; writing a node's config files is worth an `info` and a
+     * partial payload a `warn`.
+     */
+    private readonly logger?;
+    constructor(getInfra: () => InfrastructureService | null, 
+    /**
+     * How this daemon builds and adopts an infrastructure it is asked for.
+     *
+     * The daemon does it, not this service: it holds the logger the node
+     * logs through, and it is what has to remember the result — the same
+     * field `getState`, the health indicator and the shutdown path read.
+     *
+     * Absent on a daemon that will not host one, and the call is then
+     * refused by name rather than silently doing nothing, which is the
+     * difference between "this node does not do that" and "it worked".
+     */
+    hostInfra?: ((config: InfrastructureConfig, services: Record<string, IServiceRequirement>, registry: import('../infrastructure/presets/registry.js').PresetRegistry, overrides: Record<string, import('../infrastructure/types.js').IServiceOverride>) => InfrastructureService) | undefined, 
+    /**
+     * This node's secret store.
+     *
+     * A GETTER, resolved per call. Captured once at boot, a resolution that
+     * failed during startup — a container not yet ready, a token registered
+     * later — left credential generation off for the life of the daemon,
+     * and nothing said so: the absence looks exactly like a daemon that
+     * hosts no infrastructure. `getInfra` above is a getter for the same
+     * reason.
+     *
+     * Absent on a daemon that hosts no stack infrastructure, in which case
+     * nothing is generated — there is nothing to generate it for.
+     */
+    getVault?: (() => import('../infrastructure/service-credentials.js').CredentialStore | undefined) | undefined, 
+    /**
+     * Where this service says what only it knows.
+     *
+     * Optional in the type and required in practice: the one thing
+     * `provisionStack` reports on its own — that a deployment is running on
+     * a default credential — is said at error level, and an absent logger
+     * turns a safety mechanism into a silent one. It was absent, and the
+     * mechanism worked and said nothing.
+     */
+    /**
+     * Narrowed to what this service actually says. It was `error` alone, when
+     * the only thing it reported was a deployment running on a default
+     * credential; writing a node's config files is worth an `info` and a
+     * partial payload a `warn`.
+     */
+    logger?: {
+        error(obj: object, msg?: string, ...args: any[]): void;
+        warn?(obj: object, msg?: string, ...args: any[]): void;
+        info?(obj: object, msg?: string, ...args: any[]): void;
+    } | undefined);
+    /**
+     * Bring up the infrastructure a stack needs, here, on this node.
+     *
+     * A node deployed to by `omnitron stack start` received its applications
+     * and nothing for them to connect to. `startRemoteStack` provisioned the
+     * daemon, shipped the artifacts and opened the mesh connection; the
+     * stack's `infrastructure` block — its Postgres, its Redis, its MinIO —
+     * was read by the master and never left it. Worse, a provisioned slave is
+     * started with `--no-infra`, and the boot path is guarded by
+     * `config.infrastructure && !isSlave`, so a node would not have acted on
+     * one even if it had been given one.
+     *
+     * Everything needed was already here. `InfrastructureService` reconciles
+     * containers against a desired set, waits on health, and keeps a janitor
+     * for stale endpoints; it runs against the `docker` CLI directly, which is
+     * what a provisioned node has. The only thing missing was a way to ask.
+     *
+     * The master orchestrates and the node executes, which is the same
+     * division the mesh already uses: a node that loses its master keeps
+     * supervising what it was given.
+     *
+     * Idempotent, because reconciliation is: calling it twice with the same
+     * config leaves the containers alone and returns the same report.
+     */
+    provisionStack(data: {
+        config: InfrastructureConfig;
+        /**
+         * What the stack's APPLICATIONS declare they need — a chain daemon, a
+         * cache, anything an app names in `omnitron.infrastructure`.
+         *
+         * Sent by the master rather than read here: the node does not have the
+         * application definitions when it is asked, and parsing them again on
+         * this side would be a second implementation of variant selection and
+         * override merging, on the side with less information.
+         */
+        services?: Record<string, IServiceRequirement> | undefined;
+        /**
+         * Which stack this is, so the node names its containers the way a local
+         * deployment of the same stack would.
+         *
+         * Without it a node prefixes everything `omnitron-`, which is fine for
+         * one stack and a collision for two: the second stack's Postgres would
+         * find the first one's container already running under the name it
+         * wants, and reconcile it towards its own spec. It also makes the names
+         * unpredictable from the master's side, and a hidden service that has to
+         * name the gateway container cannot guess.
+         */
+        project?: string | undefined;
+        stack?: string | undefined;
+        /**
+         * The stack's service overrides — `disabled`, `external`, per-service
+         * docker changes. Sent, because a node that does not receive them
+         * provisions what the operator asked it not to.
+         */
+        overrides?: Record<string, import('../infrastructure/types.js').IServiceOverride> | undefined;
+        /**
+         * Config files the services need, keyed by service name.
+         *
+         * A gateway is configured by files, and the resolver mounts them from the
+         * MASTER's project root — a path this node does not have. Without them the
+         * container comes up as bare openresty: measured on the test server, an
+         * empty `Mounts` array, a null entrypoint, zero UPSTREAM variables, and an
+         * onion answering `Welcome to OpenResty!` over Tor.
+         *
+         * Validated here rather than trusted: the sender is another daemon, and an
+         * older or tampered one is exactly the case a receiving check exists for.
+         */
+        configFiles?: import('../infrastructure/config-payload.js').ConfigPayload | undefined;
+        /**
+         * Where each service's static content already is ON THIS NODE, by service
+         * name — delivered by SSH before this call, because a build is 32 MB and
+         * an RPC argument is the wrong shape for that.
+         *
+         * A path, not content: this node checks that it exists and mounts it, and
+         * refuses one that is not under the directory this daemon owns.
+         */
+        staticRoots?: Record<string, string> | undefined;
+        /**
+         * The static ROOT of each service whose gateway serves through a link —
+         * `/opt/omnitron/stack-static/gateway`, the directory that holds the build
+         * directories and `current-<project>-<stack>`.
+         *
+         * ADDITIVE and optional on purpose. A node's omni must equal the
+         * release's, while the master's may legitimately be newer, so the two ends
+         * of this call differ by design: an old node ignores a field it does not
+         * know, and a new node that is sent none does exactly what it did before.
+         * Changing the type of `staticRoots` instead would break both directions.
+         */
+        staticLinkRoots?: Record<string, string> | undefined;
+    }): Promise<{
+        ready: boolean;
+        detail: string;
+        running: string[];
+        failed: Array<{
+            name: string;
+            status: string;
+            error: string | null;
+        }>;
+        missing: string[];
+    }>;
+    /** `provisionStack`'s work. Not an RPC method: it carries no `@Public`. */
+    private provisionStackNow;
+    /**
+     * Bring every declared host service to what the stack says it should be.
+     *
+     * Driven from the SAME normalized requirements the container path uses, so
+     * one declaration describes one service and the operator's choice of which
+     * block to fill in is what decides how it runs.
+     */
+    /**
+       * Write the master's config files under this node's own root.
+       *
+       * Returns service name → the directory its files landed in, so the
+       * resolver can mount paths that exist HERE instead of paths that exist on
+       * the machine that sent them.
+       */
+    /**
+       * Accept the static directories a master says it delivered.
+       *
+       * Two checks, and neither is a formality. The path arrives over RPC from
+       * another daemon, so it is confined to the directory this node keeps such
+       * things in — a mount source is a path with root's reach, and `/etc` is a
+       * directory too. And it must EXIST: a mount of a missing path creates an
+       * empty directory and the gateway then serves nothing from it, which looks
+       * exactly like a gateway serving a broken build.
+       */
+    private acceptStaticRoots;
+    private writeStackConfigs;
+    private reconcileHostServices;
+    /**
+     * What `provisionStack` would find and do on this host for the services a
+     * stack declares — asked, not done (`host-inspection.ts`).
+     *
+     * It reads this machine's units, paths and addresses, and is asked by the
+     * master that drives it: the roles that may provision here, no wider.
+     */
+    inspectHostServices(data: import('../infrastructure/host-inspection.js').HostInspectionRequest): Promise<import('../infrastructure/host-inspection.js').HostInspection>;
     getState(): Promise<InfrastructureState | null>;
+    /**
+     * Containers this Omnitron manages, read from the container runtime.
+     *
+     * This used to return `Object.values(infra.getState().services)` — the
+     * daemon's in-memory bookkeeping, which is populated only when THIS daemon
+     * process provisioned them. Containers outlive the daemon, so after any
+     * restart the map is empty while the containers keep running: `omnitron
+     * infra status` listed eleven and the console's containers page listed
+     * none, and said "No containers found. Infrastructure containers will
+     * appear here when Docker is running" — an empty state indistinguishable
+     * from a broken query, which is why it went unnoticed.
+     *
+     * `listManagedContainers` asks the runtime and filters on the
+     * `omnitron.managed` label, so it answers the same in a fresh daemon as in
+     * one that did the provisioning — and it is the same call the CLI makes,
+     * which is what stops the two from disagreeing again.
+     *
+     * A runtime that cannot be asked is an error, not an empty list. Asked
+     * without `orThrow`, a Docker that did not answer came back as `[]` — the
+     * same empty state this comment describes, one layer down: the console's
+     * containers page said «No containers found» with 0 running, and the
+     * topology read no container's health, while every container ran.
+     */
     listContainers(): Promise<ContainerState[]>;
+    /**
+     * The credentials a service was provisioned with.
+     *
+     * `CONTROL_PLANE_ROLES`, not `VIEWER_ROLES`, and the change is a
+     * tightening as well as a widening. This method returns `password`,
+     * `accessKey` and `secretKey` — the platform's own database password among
+     * them — and it sat in the READ-ONLY HUMAN tier, so any account that could
+     * look at a dashboard could read them. A viewer is someone allowed to see
+     * that a service is healthy, not someone allowed to connect to it as its
+     * owner.
+     *
+     * `service_role` is in the set because a master needs this about the nodes
+     * it drives: the credentials are generated ON the node, by its own vault,
+     * so the node is the only place the answer exists. Without it the master
+     * could tell a node to provision a database and could not learn the
+     * password to give the applications it then deployed there — which is
+     * exactly what happened: six apps handed `postgres:postgres` against a
+     * 43-character generated secret.
+     */
     getConnectionInfo(data: {
         service: string;
     }): Promise<Record<string, unknown> | null>;
+    /**
+     * @throws when the container is not one this daemon manages.
+     */
+    private assertManaged;
+    startContainer(data: {
+        name: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    stopContainer(data: {
+        name: string;
+        timeout?: number;
+    }): Promise<{
+        success: boolean;
+    }>;
+    removeContainer(data: {
+        name: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    getContainerLogs(data: {
+        name: string;
+        tail?: number;
+    }): Promise<{
+        logs: string;
+    }>;
 }
 //# sourceMappingURL=infrastructure.rpc-service.d.ts.map

package/dist/services/infrastructure.rpc-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"infrastructure.rpc-service.d.ts","sourceRoot":"","sources":["../../src/services/infrastructure.rpc-service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEtF,qBACa,wBAAwB;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,MAAM,qBAAqB,GAAG,IAAI;IAGnE,QAAQ,IAAI,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAM/C,cAAc,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAQ3C,iBAAiB,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAK5F"}
+{"version":3,"file":"infrastructure.rpc-service.d.ts","sourceRoot":"","sources":["../../src/services/infrastructure.rpc-service.ts"],"names":[],"mappings":"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"}