@norskvideo/norsk-manager-sdk 1.0.356

package/lib/src/sdk.js

@@ -0,0 +1,1423 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventStream = exports.NorskManager = exports.AwsLaunchTemplateId = exports.AwsLaunchTemplateName = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protobuf_1 = require("@bufbuild/protobuf");
+const common_pb_1 = require("@norskvideo/norsk-api/lib/shared/common_pb");
+const manager_grpc_pb_1 = require("@norskvideo/norsk-api/lib/manager_grpc_pb");
+const CommonPB = __importStar(require("@norskvideo/norsk-api/lib/shared/common_pb"));
+const ManagerPB = __importStar(require("@norskvideo/norsk-api/lib/manager_pb"));
+const utils_1 = require("./shared/utils");
+const utils = __importStar(require("./shared/utils"));
+const util = __importStar(require("util"));
+/** @internal */
+function toJobId(jobId) {
+    return (0, utils_1.provideFull)(CommonPB.JobId, { jobId: jobId });
+}
+/** @internal */
+function fromJobId(jobId) {
+    return jobId.jobId;
+}
+/** @internal */
+function toContainerUrl(url) {
+    return (0, utils_1.provideFull)(CommonPB.ContainerUrl, {
+        url,
+    });
+}
+/** @internal */
+function fromContainerUrl(containerUrl) {
+    return containerUrl.url;
+}
+/** @internal */
+function toDockerContainer(container) {
+    return (0, utils_1.provideFull)(CommonPB.DockerContainer, {
+        containerUrl: toContainerUrl(container.url),
+    });
+}
+/** @internal */
+function fromDockerContainer(container) {
+    return {
+        codeType: "docker",
+        url: fromContainerUrl(utils.mandatory(container.containerUrl)),
+    };
+}
+/** @internal */
+function toClientCode(clientCode) {
+    switch (clientCode.codeType) {
+        case "docker":
+            return utils.mkCase({ docker: toDockerContainer(clientCode) });
+    }
+}
+/** @internal */
+function fromClientCode(clientCode) {
+    switch (clientCode.case) {
+        case "docker":
+            return fromDockerContainer(clientCode.value);
+        case undefined:
+            throw new Error();
+    }
+}
+/** @internal */
+function toJobState(state) {
+    switch (state) {
+        case "pre":
+            return ManagerPB.Job_JobState.PRE;
+        case "active":
+            return ManagerPB.Job_JobState.ACTIVE;
+        case "post":
+            return ManagerPB.Job_JobState.POST;
+    }
+}
+/** @internal */
+function toPortMapping({ containerPort, protocol, hostPort, hostAddress, }) {
+    var protocolPB;
+    var hostPortPB;
+    switch (protocol) {
+        case "tcp":
+            protocolPB = CommonPB.ProtocolFamily.TCP;
+            break;
+        case "udp":
+            protocolPB = CommonPB.ProtocolFamily.UDP;
+            break;
+        case undefined:
+            protocolPB = CommonPB.ProtocolFamily.ANY;
+            break;
+    }
+    switch (hostPort.type) {
+        case "ephemeral":
+            hostPortPB = {
+                case: "ephemeral",
+                value: (0, utils_1.provideFull)(CommonPB.HostPortEphemeral, {}),
+            };
+            break;
+        case "range":
+            hostPortPB = {
+                case: "range",
+                value: (0, utils_1.provideFull)(CommonPB.HostPortRange, {
+                    minPort: hostPort.minPort,
+                    maxPort: hostPort.maxPort,
+                }),
+            };
+            break;
+        case "specific":
+            hostPortPB = {
+                case: "specific",
+                value: (0, utils_1.provideFull)(CommonPB.HostPortSpecific, {
+                    port: hostPort.port,
+                }),
+            };
+            break;
+    }
+    return (0, utils_1.provideFull)(CommonPB.PortMapping, {
+        containerPort,
+        protocol: protocolPB,
+        hostPort: hostPortPB,
+        hostAddress: hostAddress || "",
+    });
+}
+/** @internal */
+function fromPortMapping({ containerPort, protocol: protocolPB, hostPort: hostPortPB, hostAddress, }) {
+    var protocol;
+    var hostPort;
+    switch (protocolPB) {
+        case CommonPB.ProtocolFamily.TCP:
+            protocol = "tcp";
+            break;
+        case CommonPB.ProtocolFamily.UDP:
+            protocol = "udp";
+            break;
+        case CommonPB.ProtocolFamily.ANY:
+            protocol = undefined;
+            break;
+    }
+    switch (hostPortPB.case) {
+        case "ephemeral":
+            hostPort = { type: "ephemeral" };
+            break;
+        case "range":
+            hostPort = {
+                type: "range",
+                minPort: hostPortPB.value.minPort,
+                maxPort: hostPortPB.value.maxPort,
+            };
+            break;
+        case "specific":
+            hostPort = {
+                type: "specific",
+                port: hostPortPB.value.port,
+            };
+            break;
+        case undefined:
+            hostPort = { type: "ephemeral" };
+            break;
+    }
+    return {
+        containerPort,
+        protocol,
+        hostPort,
+        hostAddress: hostAddress || "",
+    };
+}
+/** @internal */
+function toEnvironmentVariable(env) {
+    return (0, utils_1.provideFull)(CommonPB.EnvironmentVariable, env);
+}
+/** @internal */
+function fromEnvironmentVariable({ name, value, }) {
+    return { name, value };
+}
+/** @internal */
+function toServiceParameters({ portMappings, environmentVariables, sharedMemorySize, cpuSet, volumeMounts, }) {
+    return (0, utils_1.provideFull)(CommonPB.ServiceParameters, {
+        portMappings: portMappings ? portMappings.map(toPortMapping) : [],
+        environmentVariables: environmentVariables
+            ? environmentVariables.map(toEnvironmentVariable)
+            : [],
+        sharedMemorySize: sharedMemorySize
+            ? (0, utils_1.provideFull)(CommonPB.OptionalInt64, { value: sharedMemorySize })
+            : undefined,
+        cpuSet: cpuSet || [],
+        volumeMounts: volumeMounts
+            ? volumeMounts.map((v) => (0, utils_1.provideFull)(CommonPB.VolumeMount, v))
+            : [],
+    });
+}
+/** @internal */
+function fromServiceParameters({ portMappings, environmentVariables, sharedMemorySize, cpuSet, volumeMounts, }) {
+    return {
+        portMappings: portMappings.map(fromPortMapping),
+        environmentVariables: environmentVariables.map(fromEnvironmentVariable),
+        sharedMemorySize: sharedMemorySize ? sharedMemorySize.value : undefined,
+        cpuSet,
+        volumeMounts,
+    };
+}
+/** @internal */
+function toService({ name, container, restart, dependsOn, configuration, restartIntensity, command, parameters, }) {
+    var restartPB;
+    switch (restart) {
+        case "never":
+            restartPB = CommonPB.Service_ServiceRestart.NEVER;
+            break;
+        case "onFailure":
+            restartPB = CommonPB.Service_ServiceRestart.ON_FAILURE;
+            break;
+        case "always":
+            restartPB = CommonPB.Service_ServiceRestart.ALWAYS;
+            break;
+        case undefined:
+            restartPB = CommonPB.Service_ServiceRestart.ALWAYS;
+            break;
+    }
+    return (0, utils_1.provideFull)(CommonPB.Service, {
+        name,
+        container: toClientCode(container),
+        restart: restartPB,
+        dependsOn: Array.from(dependsOn?.keys() || []),
+        configuration: configuration || "",
+        restartCount: restartIntensity ? restartIntensity.count : 5,
+        restartPeriod: restartIntensity ? restartIntensity.period : 1000,
+        command: command || "",
+        parameters: parameters ? toServiceParameters(parameters) : undefined,
+    });
+}
+/** @internal */
+function fromService({ name, container, restart: restartPB, dependsOn: dependsOnPB, configuration, restartCount, restartPeriod, command, parameters, }) {
+    var restart;
+    switch (restartPB) {
+        case CommonPB.Service_ServiceRestart.NEVER:
+            restart = "never";
+            break;
+        case CommonPB.Service_ServiceRestart.ON_FAILURE:
+            restart = "onFailure";
+            break;
+        case CommonPB.Service_ServiceRestart.ALWAYS:
+            restart = "always";
+            break;
+    }
+    const dependsOn = dependsOnPB.reduce((acc, val) => acc.add(val), new Set());
+    return {
+        name,
+        container: fromClientCode(container),
+        restart,
+        dependsOn,
+        configuration,
+        restartIntensity: { count: restartCount, period: restartPeriod },
+        command,
+        parameters: parameters ? fromServiceParameters(parameters) : undefined,
+    };
+}
+/** @internal */
+function toJob({ jobId, description, tags, startDateTime, currentHash = BigInt(0), services, volumes, managerConfiguration, norskMediaVersion, norskServiceParameters, state, shape, availabilityDomain, subnet, architecture, }) {
+    return (0, utils_1.provideFull)(ManagerPB.Job, {
+        jobId: toJobId(jobId),
+        description: description,
+        tags: Object.fromEntries(tags.entries()),
+        startDateTime: protobuf_1.Timestamp.fromDate(startDateTime),
+        currentHash: currentHash,
+        services: services.map(toService),
+        volumes: volumes || [],
+        managerConfiguration: managerConfiguration || "",
+        norskMediaVersion: toVersion(norskMediaVersion),
+        norskServiceParameters: norskServiceParameters
+            ? toServiceParameters(norskServiceParameters)
+            : undefined,
+        state: toJobState(state),
+        shape,
+        availabilityDomain,
+        subnet,
+        architecture
+    });
+}
+/** @internal */
+function fromJobState(state) {
+    switch (state) {
+        case ManagerPB.Job_JobState.PRE:
+            return "pre";
+        case ManagerPB.Job_JobState.ACTIVE:
+            return "active";
+        case ManagerPB.Job_JobState.POST:
+            return "post";
+    }
+}
+/** @internal */
+function fromJob(job) {
+    return {
+        jobId: fromJobId(utils.mandatory(job.jobId)),
+        cloud: job.architecture == "" ? "aws" : "oci",
+        description: job.description,
+        tags: new Map(Object.entries(job.tags)),
+        startDateTime: utils.mandatory(job.startDateTime).toDate(),
+        currentHash: job.currentHash,
+        services: job.services.map(fromService),
+        volumes: job.volumes,
+        managerConfiguration: job.managerConfiguration,
+        norskMediaVersion: fromVersion(job.norskMediaVersion),
+        norskServiceParameters: job.norskServiceParameters
+            ? fromServiceParameters(job.norskServiceParameters)
+            : undefined,
+        state: fromJobState(job.state),
+        shape: job.shape,
+        availabilityDomain: job.availabilityDomain,
+        subnet: job.subnet,
+        architecture: job.architecture
+    };
+}
+/** @internal */
+function fromJobHistoryJobCreated(entry) {
+    return {
+        event: "created",
+        timestamp: utils.mandatory(entry.timestamp).toDate(),
+    };
+}
+/** @internal */
+function fromJobHistoryJobUpdated(entry) {
+    return {
+        event: "updated",
+        timestamp: utils.mandatory(entry.timestamp).toDate(),
+        previousJob: fromJob(utils.mandatory(entry.previousJob)),
+    };
+}
+/** @internal */
+function fromJobHistoryJobProvisioned(entry) {
+    return {
+        event: "provisioned",
+        timestamp: utils.mandatory(entry.timestamp).toDate(),
+        role: entry.role,
+        nodeMetadata: fromNodeMetadata(utils.mandatory(entry.nodeMetadata)),
+    };
+}
+/** @internal */
+function fromJobHistoryJobRunning(entry) {
+    return {
+        event: "running",
+        timestamp: utils.mandatory(entry.timestamp).toDate(),
+        role: entry.role,
+        nodeMetadata: fromNodeMetadata(utils.mandatory(entry.nodeMetadata)),
+        runningNodeMetadata: fromRunningNodeMetadata(utils.mandatory(entry.runningNodeMetadata)),
+    };
+}
+/** @internal */
+function fromJobHistoryJobStopping(entry) {
+    let reason;
+    switch (entry.reason) {
+        case ManagerPB.JobHistoryJobStopping_Reason.JOB_STOPPED_NODE_STOPPED:
+            reason = "nodeStopped";
+            break;
+        case ManagerPB.JobHistoryJobStopping_Reason.JOB_STOPPED_NODE_TERMINATED:
+            reason = "nodeTerminated";
+            break;
+        case ManagerPB.JobHistoryJobStopping_Reason.JOB_STOPPED_USER_REQUESTED:
+            reason = "userRequested";
+            break;
+        case ManagerPB.JobHistoryJobStopping_Reason.JOB_STOPPED_UNKNOWN_JOB:
+            reason = "unknownJob";
+            break;
+        case ManagerPB.JobHistoryJobStopping_Reason.JOB_STOPPED_JOB_FAILED:
+            reason = "jobFailed";
+            break;
+        default: {
+            const exhaustiveCheck = entry.reason;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+        }
+    }
+    return {
+        event: "stopping",
+        timestamp: utils.mandatory(entry.timestamp).toDate(),
+        role: entry.role,
+        nodeMetadata: fromNodeMetadata(utils.mandatory(entry.nodeMetadata)),
+        runningNodeMetadata: utils.mapOptional(fromRunningNodeMetadata, entry.runningNodeMetadata),
+        reason: reason,
+    };
+}
+/** @internal */
+function fromJobHistoryJobStopped(entry) {
+    return {
+        event: "stopped",
+        timestamp: utils.mandatory(entry.timestamp).toDate(),
+        role: entry.role,
+        nodeMetadata: fromNodeMetadata(utils.mandatory(entry.nodeMetadata)),
+        runningNodeMetadata: utils.mapOptional(fromRunningNodeMetadata, entry.runningNodeMetadata),
+    };
+}
+/** @internal */
+function fromJobHistoryJobCompleted(entry) {
+    return {
+        event: "completed",
+        timestamp: utils.mandatory(entry.timestamp).toDate(),
+    };
+}
+/** @internal */
+function fromJobHistoryEntry(historyEntry) {
+    const event = historyEntry.historyEntry.case;
+    switch (event) {
+        case undefined:
+            throw Error();
+        case "jobCreated":
+            return fromJobHistoryJobCreated(historyEntry.historyEntry.value);
+        case "jobUpdated":
+            return fromJobHistoryJobUpdated(historyEntry.historyEntry.value);
+        case "jobProvisioned":
+            return fromJobHistoryJobProvisioned(historyEntry.historyEntry.value);
+        case "jobRunning":
+            return fromJobHistoryJobRunning(historyEntry.historyEntry.value);
+        case "jobStopping":
+            return fromJobHistoryJobStopping(historyEntry.historyEntry.value);
+        case "jobStopped":
+            return fromJobHistoryJobStopped(historyEntry.historyEntry.value);
+        case "jobCompleted":
+            return fromJobHistoryJobCompleted(historyEntry.historyEntry.value);
+        default: {
+            const exhaustiveCheck = event;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+        }
+    }
+}
+/** @internal */
+function fromJobWithHistory(jobWithHistory) {
+    return {
+        job: fromJob(utils.mandatory(jobWithHistory.job)),
+        history: jobWithHistory.historyEntry.map(fromJobHistoryEntry),
+    };
+}
+/** @internal */
+function toNodeId(nodeId) {
+    return (0, utils_1.provideFull)(CommonPB.NodeId, { nodeId: nodeId });
+}
+/** @internal */
+function fromNodeId(nodeId) {
+    return nodeId.nodeId;
+}
+/**  @public */
+class AwsLaunchTemplateName {
+}
+exports.AwsLaunchTemplateName = AwsLaunchTemplateName;
+/**  @public */
+class AwsLaunchTemplateId {
+}
+exports.AwsLaunchTemplateId = AwsLaunchTemplateId;
+function toVersion(version) {
+    switch (version) {
+        case "latest":
+            return ManagerPB.Version.LATEST;
+        case "recommended":
+            return ManagerPB.Version.RECOMMENDED;
+        case "previousRecommended":
+            return ManagerPB.Version.PREVIOUS_RECOMMENDED;
+        case "LTS":
+            return ManagerPB.Version.LTS;
+    }
+}
+function fromVersion(version) {
+    switch (version) {
+        case ManagerPB.Version.LATEST:
+            return "latest";
+        case ManagerPB.Version.RECOMMENDED:
+            return "recommended";
+        case ManagerPB.Version.PREVIOUS_RECOMMENDED:
+            return "previousRecommended";
+        case ManagerPB.Version.LTS:
+            return "LTS";
+    }
+}
+function toAwsLaunchTemplate(template) {
+    if (template instanceof AwsLaunchTemplateName) {
+        return (0, utils_1.provideFull)(ManagerPB.AwsLaunchTemplate, {
+            template: { value: template.name, case: "name" },
+            version: template.version || "",
+        });
+    }
+    else {
+        return (0, utils_1.provideFull)(ManagerPB.AwsLaunchTemplate, {
+            template: { value: template.id, case: "id" },
+            version: template.version || "",
+        });
+    }
+}
+function toAwsNodeCreate(node) {
+    return (0, utils_1.provideFull)(ManagerPB.CreateAwsNodeRequest, {
+        nodeId: toNodeId(node.nodeId),
+        tags: Object.fromEntries(node.tags.entries()),
+        region: node.region,
+        instanceType: node.instanceType,
+        workerImageVersion: toVersion(node.workerImageVersion || "recommended"),
+        workerDaemonVersion: toVersion(node.workerDaemonVersion || "recommended"),
+        template: utils.mapOptional(toAwsLaunchTemplate, node.template),
+    });
+}
+function toOciNodeCreate(node) {
+    return (0, utils_1.provideFull)(ManagerPB.CreateOciNodeRequest, {
+        nodeId: toNodeId(node.nodeId),
+        tags: Object.fromEntries(node.tags.entries()),
+        workerImageVersion: toVersion(node.workerImageVersion || "recommended"),
+        workerDaemonVersion: toVersion(node.workerDaemonVersion || "recommended"),
+        availabilityDomain: node.availabilityDomain,
+        architecture: node.architecture,
+        shape: node.shape,
+        subnet: node.subnet,
+    });
+}
+/** @internal */
+function fromNodeMetadata(nodeMetadata) {
+    return {
+        nodeId: fromNodeId(utils.mandatory(nodeMetadata.nodeId)),
+        tags: new Map(Object.entries(nodeMetadata.tags)),
+        createdAt: nodeMetadata.createdAt?.toDate(),
+        providerMetadata: fromProviderMetadata(utils.mandatory(nodeMetadata.providerMetadata)),
+        //    daemonVersion: awsNode.daemonVersion,
+    };
+}
+function fromAwsMetadata(nodeDetails) {
+    return {
+        provider: "aws",
+        instanceType: nodeDetails.instanceType,
+        region: nodeDetails.region,
+    };
+}
+function fromOciMetadata(_nodeDetails) {
+    return {
+        provider: "oci",
+    };
+}
+function fromProviderMetadata(provider) {
+    const providerType = provider.metadata.case;
+    switch (providerType) {
+        case undefined:
+            throw Error();
+        case "aws":
+            return fromAwsMetadata(provider.metadata.value);
+        case "oci":
+            return fromOciMetadata(provider.metadata.value);
+        case "test":
+            throw Error();
+        default: {
+            const exhaustiveCheck = providerType;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+        }
+    }
+}
+function fromRunningAwsMetadata(metadata) {
+    return { provider: "aws", instanceId: metadata.instanceId };
+}
+function fromRunningOciMetadata(_metadata) {
+    return { provider: "oci" };
+}
+function fromRunningNodeProviderMetadata(provider) {
+    const providerType = provider.instance.case;
+    switch (providerType) {
+        case undefined:
+            throw Error();
+        case "aws":
+            return fromRunningAwsMetadata(provider.instance.value);
+        case "oci":
+            return fromRunningOciMetadata(provider.instance.value);
+        case "test":
+            throw Error();
+        default: {
+            const exhaustiveCheck = providerType;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+        }
+    }
+}
+function fromRunningNodeMetadata(runningNodeMetadata) {
+    return {
+        publicDnsName: runningNodeMetadata.publicDnsName,
+        privateDnsName: runningNodeMetadata.privateDnsName,
+        privateIpAddress: runningNodeMetadata.privateIpAddress,
+        providerMetadata: fromRunningNodeProviderMetadata(utils.mandatory(runningNodeMetadata.providerMetadata)),
+    };
+}
+/** @internal */
+function fromPhysicalNode(physicalNode) {
+    return {
+        nodeType: "physical",
+        id: physicalNode.id,
+        tags: new Map(Object.entries(physicalNode.tags)),
+        ipAddress: physicalNode.ipAddress,
+    };
+}
+/** @internal */
+function fromRunningJob(runningJob) {
+    const key = utils.mandatory(runningJob.jobKey);
+    return {
+        jobId: fromJobId(utils.mandatory(key.jobId)),
+        role: key.role,
+        nodeId: fromNodeId(utils.mandatory(runningJob.nodeId)),
+    };
+}
+/** @internal */
+function fromJobPending(event) {
+    return utils.mapOptional((jobWithHistory) => ({
+        event: "jobPending",
+        jobWithHistory: fromJobWithHistory(jobWithHistory),
+    }), event.jobWithHistory);
+}
+/** @internal */
+function fromJobUpdated(event) {
+    return utils.mapOptional((jobWithHistory) => ({
+        event: "jobUpdated",
+        jobWithHistory: fromJobWithHistory(jobWithHistory),
+    }), event.jobWithHistory);
+}
+/** @internal */
+function fromJobOutOfWindow(event) {
+    return utils.mapOptional((jobWithHistory) => ({
+        event: "jobOutOfWindow",
+        jobWithHistory: fromJobWithHistory(jobWithHistory),
+    }), event.jobWithHistory);
+}
+/** @internal */
+function fromJobInfo(event) {
+    var message;
+    switch (event.message.case) {
+        case "serviceStarted":
+            message = {
+                type: "serviceStarted",
+                serviceName: event.message.value.serviceName,
+            };
+            break;
+        case "serviceRestarting":
+            message = {
+                type: "serviceRestarting",
+                serviceName: event.message.value.serviceName,
+            };
+            break;
+        case "containerEvent":
+            message = {
+                type: "containerEvent",
+                serviceName: event.message.value.serviceName,
+                text: event.message.value.text,
+            };
+            break;
+        case "composeMessage": {
+            var stage;
+            switch (event.message.value.stage) {
+                case CommonPB.JobInfoComponseMessage_Stage.BUILD:
+                    stage = "build";
+                    break;
+                case CommonPB.JobInfoComponseMessage_Stage.CREATE:
+                    stage = "create";
+                    break;
+                case CommonPB.JobInfoComponseMessage_Stage.START:
+                    stage = "start";
+                    break;
+                case CommonPB.JobInfoComponseMessage_Stage.STOP:
+                    stage = "stop";
+                    break;
+                case CommonPB.JobInfoComponseMessage_Stage.DOWN:
+                    stage = "down";
+                    break;
+            }
+            message = {
+                type: "composeMessage",
+                stage,
+                text: event.message.value.text,
+            };
+            break;
+        }
+        case undefined:
+            return undefined;
+    }
+    return {
+        event: "jobInfo",
+        jobId: fromJobId(utils.mandatory(event.jobKey?.jobId)),
+        role: utils.mandatory(event.jobKey).role,
+        timestamp: utils.mandatory(event.timestamp).toDate(),
+        message,
+    };
+}
+/** @internal */
+function fromJobDeleted(event) {
+    return utils.mapOptional((jobId) => ({
+        event: "jobDeleted",
+        jobId: fromJobId(jobId),
+    }), event.jobId);
+}
+/** @internal */
+function fromNodeStarting(event) {
+    return utils.mapOptional((nodeMetadata) => ({
+        event: "nodeStarting",
+        nodeMetadata: fromNodeMetadata(nodeMetadata),
+    }), event.nodeMetadata);
+}
+/** @internal */
+function fromNodeStarted(event) {
+    if (event.nodeMetadata && event.runningNodeMetadata) {
+        return {
+            event: "nodeStarted",
+            nodeMetadata: fromNodeMetadata(event.nodeMetadata),
+            runningNodeMetadata: fromRunningNodeMetadata(event.runningNodeMetadata),
+        };
+    }
+    return undefined;
+}
+/** @internal */
+function fromNodeStopping(event) {
+    let reason;
+    switch (event.reason) {
+        case ManagerPB.NodeStopping_Reason.CREATE_FAILED:
+            reason = "createFailed";
+            break;
+        case ManagerPB.NodeStopping_Reason.PENDING_TIME_EXCEEDED:
+            reason = "pendingTimeExceeded";
+            break;
+        case ManagerPB.NodeStopping_Reason.STARTUP_TIME_EXCEEDED:
+            reason = "startupTimeExceeded";
+            break;
+        case ManagerPB.NodeStopping_Reason.INITIALISATION_HEALTH_PING_TIME_EXCEEDED:
+            reason = "initialisationHealthPingTimeExceeded";
+            break;
+        case ManagerPB.NodeStopping_Reason.HEALTH_PING_TIME_EXCEEDED:
+            reason = "healthPingTimeExceeded";
+            break;
+        case ManagerPB.NodeStopping_Reason.DUPLICATE_JOB:
+            reason = "duplicateJob";
+            break;
+        case ManagerPB.NodeStopping_Reason.PROVIDER_STOP:
+            reason = "providerStop";
+            break;
+        case ManagerPB.NodeStopping_Reason.PROVIDER_TERMINATE:
+            reason = "providerTerminate";
+            break;
+        case ManagerPB.NodeStopping_Reason.USER_REQUESTED:
+            reason = "userRequested";
+            break;
+        case ManagerPB.NodeStopping_Reason.UNKNOWN_NODE:
+            reason = "unknownNode";
+            break;
+        default: {
+            const exhaustiveCheck = event.reason;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+        }
+    }
+    return utils.mapOptional((nodeId) => ({
+        event: "nodeStopping",
+        nodeId: fromNodeId(nodeId),
+        reason: reason,
+    }), event.nodeId);
+}
+/** @internal */
+function fromNodeStopped(event) {
+    return utils.mapOptional((nodeId) => ({
+        event: "nodeStopped",
+        nodeId: fromNodeId(nodeId),
+    }), event.nodeId);
+}
+/** @internal */
+function fromNodeRunning(event) {
+    if (event.nodeMetadata && event.runningNodeMetadata) {
+        return {
+            event: "nodeRunning",
+            nodeMetadata: fromNodeMetadata(event.nodeMetadata),
+            runningNodeMetadata: fromRunningNodeMetadata(event.runningNodeMetadata),
+            instances: event.instances.map(fromRunningJob),
+        };
+    }
+    return undefined;
+}
+/** @internal */
+function fromPhysicalNodeConnected(event) {
+    return utils.mapOptional((node) => ({
+        event: "physicalNodeConnected",
+        node: fromPhysicalNode(node),
+        instances: event.instances.map(fromRunningJob),
+    }), event.node);
+}
+/** internal */
+function toTagFilter(filter) {
+    let comparison;
+    switch (filter.comparison.comparison) {
+        case "eq":
+            comparison = utils.mkCase({ eq: filter.comparison.value });
+            break;
+        case "neq":
+            comparison = utils.mkCase({ neq: filter.comparison.value });
+            break;
+        case "re":
+            comparison = utils.mkCase({ re: filter.comparison.value });
+            break;
+        case "exists":
+            comparison = utils.mkCase({ exists: filter.comparison.value });
+            break;
+    }
+    return (0, utils_1.provideFull)(ManagerPB.TagFilter, {
+        tagName: filter.tagName,
+        comparison: comparison,
+    });
+}
+/** internal */
+function toIdFilter(filter) {
+    let comparison;
+    switch (filter.comparison.comparison) {
+        case "eq":
+            comparison = utils.mkCase({ eq: filter.comparison.value });
+            break;
+        case "neq":
+            comparison = utils.mkCase({ neq: filter.comparison.value });
+            break;
+        case "re":
+            comparison = utils.mkCase({ re: filter.comparison.value });
+            break;
+    }
+    return (0, utils_1.provideFull)(ManagerPB.IdFilter, {
+        comparison: comparison,
+    });
+}
+/** internal */
+function toDateFilter(filter) {
+    let comparison;
+    switch (filter.comparison.comparison) {
+        case "eq":
+            comparison = utils.mkCase({
+                eq: protobuf_1.Timestamp.fromDate(filter.comparison.value),
+            });
+            break;
+        case "lt":
+            comparison = utils.mkCase({
+                lt: protobuf_1.Timestamp.fromDate(filter.comparison.value),
+            });
+            break;
+        case "lte":
+            comparison = utils.mkCase({
+                lte: protobuf_1.Timestamp.fromDate(filter.comparison.value),
+            });
+            break;
+        case "gt":
+            comparison = utils.mkCase({
+                gt: protobuf_1.Timestamp.fromDate(filter.comparison.value),
+            });
+            break;
+        case "gte":
+            comparison = utils.mkCase({
+                gte: protobuf_1.Timestamp.fromDate(filter.comparison.value),
+            });
+            break;
+        case "between":
+            comparison = utils.mkCase({
+                within: (0, utils_1.provideFull)(ManagerPB.DateFilter_Within, {
+                    startDate: protobuf_1.Timestamp.fromDate(filter.comparison.from),
+                    endDate: protobuf_1.Timestamp.fromDate(filter.comparison.to),
+                }),
+            });
+            break;
+    }
+    return (0, utils_1.provideFull)(ManagerPB.DateFilter, {
+        comparison: comparison,
+    });
+}
+/** internal */
+function toJobFilter(jobFilter) {
+    switch (jobFilter.filterType) {
+        case "tag":
+            return (0, utils_1.provideFull)(ManagerPB.JobFilter, {
+                jobFilter: utils.mkCase({ tagFilter: toTagFilter(jobFilter) }),
+            });
+        case "id":
+            return (0, utils_1.provideFull)(ManagerPB.JobFilter, {
+                jobFilter: utils.mkCase({ idFilter: toIdFilter(jobFilter) }),
+            });
+        case "date":
+            return (0, utils_1.provideFull)(ManagerPB.JobFilter, {
+                jobFilter: utils.mkCase({ dateFilter: toDateFilter(jobFilter) }),
+            });
+    }
+}
+/** @internal */
+function fromCurrentJob(event) {
+    return utils.mapOptional((job) => ({
+        job: fromJob(job),
+        instances: event.instances.map(fromRunningJob),
+    }), event.job);
+}
+/** @internal */
+function fromHealth(health) {
+    switch (health) {
+        case ManagerPB.Health.HEALTHY:
+            return "healthy";
+        case ManagerPB.Health.UNSTABLE:
+            return "unstable";
+        case ManagerPB.Health.FAILED:
+            return "failed";
+    }
+}
+/** @internal */
+function fromAwsHealth(health) {
+    const map = new Map();
+    health.regionHealth.forEach((regionHealth) => map.set(regionHealth.region, fromHealth(regionHealth.health)));
+    return { provider: "aws", regions: map };
+}
+/** @internal */
+function fromOciHealth(_health) {
+    return { provider: "oci" };
+}
+/** @internal */
+function fromProviderHealth(health) {
+    const healthType = health.health.case;
+    switch (healthType) {
+        case undefined:
+            throw Error();
+        case "aws":
+            return fromAwsHealth(health.health.value);
+        case "oci":
+            return fromOciHealth(health.health.value);
+        case "test":
+            throw Error();
+        default: {
+            const exhaustiveCheck = healthType;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+        }
+    }
+}
+/**
+ * @public
+ * The entrypoint for all Norsk Manager applications
+ *
+ * @example
+ * ```ts
+ * const norsk = await Norsk.connect({ url: "localhost:6790" });
+ * ```
+ */
+class NorskManager {
+    /** @internal */
+    constructor(norskSettings) {
+        /** @internal */
+        this.closed = false;
+        /** @internal */
+        this.managerActivityStreams = [];
+        this.nextEventStreamId = 0;
+        this.connectivityState = 0;
+        this.client = new manager_grpc_pb_1.ManagerClient(norskSettings.url ? norskSettings.url : norskHost() + ":" + norskPort(), grpc.credentials.createInsecure());
+        this.settings = norskSettings;
+        this.connectivityStateWatcher();
+        this.initialised = new Promise((resolve, _reject) => {
+            this.resolveInitialised = resolve;
+        });
+    }
+    /** @public */
+    static async connect(settings) {
+        const norsk = new NorskManager(settings);
+        await norsk.initialised;
+        return norsk;
+    }
+    /**
+     * @public
+     * Close down the Norsk connection
+     */
+    close() {
+        this.statusStream?.cancel();
+        for (const stream of this.managerActivityStreams) {
+            stream.cancel();
+        }
+        try {
+            this.client.close();
+        }
+        catch { }
+        this.closed = true;
+    }
+    /**
+     * @public - TODO - this can fail (duplicate id etc)
+     */
+    async createJob(job) {
+        const fn = safeBind(promisifyUnary(this.client.createJob), this.client);
+        const jobFull = { ...job, state: "pre", currentHash: BigInt(0) };
+        const newHash = await fn(toJob(jobFull));
+        jobFull.currentHash = newHash.hash;
+        return jobFull;
+    }
+    /**
+     * @public - TODO - this can fail (version check etc)
+     */
+    async updateJob(job) {
+        const fn = safeBind(promisifyUnary(this.client.updateJob), this.client);
+        const newHash = await fn(toJob(job));
+        job.currentHash = newHash.hash;
+        return job;
+    }
+    /**
+     * @public - TODO - can it fail?
+     */
+    async deleteJob(jobId) {
+        const fn = safeBind(promisifyUnary(this.client.deleteJob), this.client);
+        await fn(toJobId(jobId));
+    }
+    /**
+     * @public - TODO - can it fail?
+     */
+    async completeJob(jobId) {
+        const fn = safeBind(promisifyUnary(this.client.completeJob), this.client);
+        await fn(toJobId(jobId));
+    }
+    /**
+     * @public - TODO
+     */
+    async createAwsNode(node) {
+        const fn = safeBind(promisifyUnary(this.client.createAwsNode), this.client);
+        await fn(toAwsNodeCreate(node));
+        return;
+    }
+    /**
+   * @public - TODO
+   */
+    async createOciNode(node) {
+        const fn = safeBind(promisifyUnary(this.client.createOciNode), this.client);
+        await fn(toOciNodeCreate(node));
+        return;
+    }
+    /**
+     * @public - TODO
+     */
+    async updatePhysicalNode(nodeId, daemonVersion) {
+        const fn = safeBind(promisifyUnary(this.client.updatePhysicalNode), this.client);
+        await fn((0, utils_1.provideFull)(ManagerPB.UpdatePhysicalNodeRequest, {
+            id: nodeId,
+            daemonVersion: daemonVersion,
+        }));
+    }
+    /**
+     * @public - TODO
+     */
+    async terminateNode(nodeId) {
+        const fn = safeBind(promisifyUnary(this.client.terminateNode), this.client);
+        await fn(toNodeId(nodeId));
+    }
+    /**
+     * @public - TODO
+     */
+    async startJob(jobId, role, nodeId) {
+        const fn = safeBind(promisifyUnary(this.client.startJob), this.client);
+        await fn((0, utils_1.provideFull)(ManagerPB.StartJobRequest, {
+            jobId: toJobId(jobId),
+            role: role,
+            nodeId: toNodeId(nodeId),
+        }));
+    }
+    /**
+     * @public - TODO
+     */
+    async stopJob(jobId, role, nodeId) {
+        const fn = safeBind(promisifyUnary(this.client.stopJob), this.client);
+        await fn((0, utils_1.provideFull)(ManagerPB.StopJobRequest, {
+            jobId: toJobId(jobId),
+            role: role,
+            nodeId: toNodeId(nodeId),
+        }));
+    }
+    /**
+     * @public - TODO - check name
+     * provides a stream of activity that is essential for the creation of client-side
+     * management logic.
+     */
+    async eventStream(settings) {
+        const stream = this.client.eventStream((0, utils_1.provideFull)(ManagerPB.EventStreamRequest, {
+            pendingWindowS: settings.pendingWindow,
+        }));
+        this.managerActivityStreams[this.nextEventStreamId] = stream;
+        const stop = () => {
+            this.managerActivityStreams[this.nextEventStreamId]?.cancel;
+            delete this.managerActivityStreams[this.nextEventStreamId];
+        };
+        this.nextEventStreamId++;
+        return new Promise((resolve, reject) => {
+            let resolved = false;
+            const nodesStarting = [];
+            const nodesRunning = [];
+            const activeJobs = [];
+            stream.on("close", () => {
+                if (resolved) {
+                    settings.onEvent({ event: "eventStreamClosed" });
+                }
+                else {
+                    reject();
+                }
+            });
+            stream.on("error", (err) => {
+                if (err.code == grpc.status.CANCELLED) {
+                    // close will get called next...
+                    return;
+                }
+                if (resolved) {
+                    settings.onEvent({ event: "eventStreamClosed", error: err });
+                }
+                else {
+                    reject();
+                }
+            });
+            stream.on("data", (data) => {
+                const messageCase = data.event.case;
+                switch (messageCase) {
+                    case undefined:
+                        break;
+                    case "initialDataComplete":
+                        resolve([
+                            {
+                                nodesRunning,
+                                nodesStarting,
+                                activeJobs,
+                                health: data.event.value.health.map(fromProviderHealth),
+                                closeStream: () => {
+                                    stream.cancel();
+                                },
+                            },
+                            stop,
+                        ]);
+                        resolved = true;
+                        break;
+                    case "jobActive":
+                        // should only get jobActive prior to initialDataLoad completing
+                        if (!resolved && data.event.value.jobWithHistory) {
+                            const jobWithHistory = fromJobWithHistory(data.event.value.jobWithHistory);
+                            if (jobWithHistory !== undefined) {
+                                activeJobs.push(jobWithHistory);
+                            }
+                        }
+                        break;
+                    case "jobUpdated":
+                        utils.mapOptional(settings.onEvent, fromJobUpdated(data.event.value));
+                        break;
+                    case "jobPending":
+                        utils.mapOptional(settings.onEvent, fromJobPending(data.event.value));
+                        break;
+                    case "jobDeleted":
+                        utils.mapOptional(settings.onEvent, fromJobDeleted(data.event.value));
+                        break;
+                    case "jobOutOfWindow":
+                        utils.mapOptional(settings.onEvent, fromJobOutOfWindow(data.event.value));
+                        break;
+                    case "nodeRunning":
+                        // should only get nodeRunning prior to initialDataLoad completing
+                        if (!resolved) {
+                            const nodeRunningEvent = fromNodeRunning(data.event.value);
+                            if (nodeRunningEvent !== undefined) {
+                                nodesRunning.push(nodeRunningEvent);
+                            }
+                        }
+                        break;
+                    case "nodeStarting":
+                        {
+                            const nodeStartingEvent = fromNodeStarting(data.event.value);
+                            if (nodeStartingEvent) {
+                                if (resolved) {
+                                    settings.onEvent(nodeStartingEvent);
+                                }
+                                else {
+                                    nodesStarting.push(nodeStartingEvent);
+                                }
+                            }
+                        }
+                        break;
+                    case "nodeStarted":
+                        utils.mapOptional(settings.onEvent, fromNodeStarted(data.event.value));
+                        break;
+                    case "nodeStopping":
+                        utils.mapOptional(settings.onEvent, fromNodeStopping(data.event.value));
+                        break;
+                    case "nodeStopped":
+                        utils.mapOptional(settings.onEvent, fromNodeStopped(data.event.value));
+                        break;
+                    case "physicalNodeConnected":
+                        utils.mapOptional(settings.onEvent, fromPhysicalNodeConnected(data.event.value));
+                        break;
+                    case "providerHealthChange":
+                        utils.mapOptional(settings.onEvent, {
+                            event: "providerHealthChange",
+                            health: fromProviderHealth(data.event.value),
+                        });
+                        break;
+                    case "jobInfo":
+                        utils.mapOptional(settings.onEvent, fromJobInfo(data.event.value));
+                        break;
+                    default:
+                        utils.exhaustiveCheck(messageCase);
+                }
+            });
+        });
+    }
+    /**
+     * @public
+     * search for jobs by id
+     */
+    async jobById(id) {
+        const jobSearchResults = await this.jobSearch({
+            filter: [
+                { filterType: "id", comparison: { comparison: "eq", value: id } },
+            ],
+        });
+        if (jobSearchResults.length != 1) {
+            return undefined;
+        }
+        else {
+            return jobSearchResults[0];
+        }
+    }
+    /**
+     * @public
+     * search for jobs by tag / date etc
+     */
+    async jobSearch(settings) {
+        const stream = this.client.jobSearch((0, utils_1.provideFull)(ManagerPB.JobSearchRequest, {
+            jobFilter: settings.filter.map(toJobFilter),
+        }));
+        return new Promise((resolve, reject) => {
+            const jobs = [];
+            // TODO - handle stream errors...
+            stream.on("data", (data) => {
+                const job = fromCurrentJob(data);
+                if (job !== undefined) {
+                    jobs.push(job);
+                }
+            });
+            stream.on("close", () => resolve(jobs));
+            stream.on("error", (err) => reject(err));
+        });
+    }
+    /** @internal */
+    handleStatusEvent(data) {
+        const messageCase = data.message.case;
+        switch (messageCase) {
+            case undefined:
+                break;
+            case "hello": {
+                (0, utils_1.debuglog)("Norsk status channel connected: %s", data.message.value.version);
+                if (data.message.value.version === undefined) {
+                    throw new Error("Norsk version is undefined");
+                }
+                else {
+                    this.version = data.message.value.version;
+                }
+                this.resolveInitialised();
+                this.settings.onHello &&
+                    data.message.value.version &&
+                    this.settings.onHello(data.message.value.version);
+                break;
+            }
+            case "logEvent": {
+                let level;
+                switch (data.message.value.level) {
+                    case common_pb_1.Log_Level.EMERGENCY:
+                        level = "emergency";
+                        break;
+                    case common_pb_1.Log_Level.ALERT:
+                        level = "alert";
+                        break;
+                    case common_pb_1.Log_Level.CRITICAL:
+                        level = "critical";
+                        break;
+                    case common_pb_1.Log_Level.ERROR:
+                        level = "error";
+                        break;
+                    case common_pb_1.Log_Level.WARNING:
+                        level = "warning";
+                        break;
+                    case common_pb_1.Log_Level.NOTICE:
+                        level = "notice";
+                        break;
+                    case common_pb_1.Log_Level.INFO:
+                        level = "info";
+                        break;
+                    case common_pb_1.Log_Level.DEBUG:
+                        level = "debug";
+                        break;
+                }
+                const log = {
+                    level: level,
+                    message: data.message.value.msg,
+                    timestamp: new Date(Number(data.message.value.timestamp) / 1000),
+                };
+                if (this.settings.onLogEvent) {
+                    this.settings.onLogEvent(log);
+                }
+                else {
+                    (0, utils_1.debuglog)("Norsk log event: %o", log);
+                }
+                break;
+            }
+            default: {
+                const exhaustiveCheck = messageCase;
+                throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+            }
+        }
+    }
+    /** @internal */
+    connectivityStateWatcher() {
+        if (this.closed) {
+            return;
+        }
+        const channel = this.client.getChannel();
+        const connectivityState = channel.getConnectivityState(true);
+        let stateStr = connectivityState.toString();
+        switch (connectivityState) {
+            case 0: {
+                if (this.connectivityState == 1 || this.connectivityState == 2) {
+                    this.settings.onShutdown && this.settings.onShutdown();
+                }
+                // Idle
+                stateStr = "idle";
+                this.settings.onAttemptingToConnect &&
+                    this.settings.onAttemptingToConnect();
+                break;
+            }
+            case 1: {
+                // Connecting
+                stateStr = "connecting";
+                this.settings.onConnecting && this.settings.onConnecting();
+                break;
+            }
+            case 2: {
+                // Ready
+                stateStr = "ready";
+                this.settings.onReady && this.settings.onReady();
+                this.statusStream = this.client.createStatusChannel(new protobuf_1.Empty());
+                this.statusStream.on("data", this.handleStatusEvent.bind(this));
+                this.statusStream.on("error", () => {
+                    return;
+                });
+                break;
+            }
+            case 3: {
+                // Transient failure
+                stateStr = "transient failure";
+                this.settings.onFailedToConnect && this.settings.onFailedToConnect();
+                break;
+            }
+            case 4: {
+                // Shutdown
+                stateStr = "shutdown";
+                this.settings.onShutdown && this.settings.onShutdown();
+                break;
+            }
+        }
+        (0, utils_1.debuglog)("Channel connectivity state change: %d / %s", connectivityState, stateStr);
+        this.connectivityState = connectivityState;
+        channel.watchConnectivityState(connectivityState, Infinity, () => {
+            this.connectivityStateWatcher();
+        });
+    }
+}
+exports.NorskManager = NorskManager;
+async function eventStream(norsk, options) {
+    let nextEventToReturn = 0;
+    let nextEventToArrive = 0;
+    const resolves = [];
+    const promises = [];
+    const iter = {
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    const mPromise = promises[nextEventToReturn];
+                    if (mPromise) {
+                        // If we have a promise available, then just return it
+                        delete promises[nextEventToReturn];
+                        nextEventToReturn++;
+                        return mPromise;
+                    }
+                    else {
+                        const promise = new Promise((r) => (resolves[nextEventToReturn] = r));
+                        nextEventToReturn++;
+                        return promise;
+                    }
+                },
+            };
+        },
+    };
+    const [initialState, _stop] = await norsk.eventStream({
+        pendingWindow: options.pendingWindow,
+        onEvent: (event) => {
+            const done = event.event == "eventStreamClosed";
+            if (resolves[nextEventToArrive]) {
+                resolves[nextEventToArrive]({ value: event, done: done });
+                delete resolves[nextEventToArrive];
+                nextEventToArrive++;
+            }
+            else {
+                promises[nextEventToArrive] = new Promise((r) => r({ value: event, done: done }));
+                nextEventToArrive++;
+            }
+        },
+    });
+    return [initialState, iter];
+}
+exports.eventStream = eventStream;
+/** @private */
+function norskHost() {
+    if (process.env.NORSK_HOST)
+        return process.env.NORSK_HOST;
+    return "localhost";
+}
+/** @private */
+function norskPort() {
+    if (process.env.NORSK_PORT)
+        return process.env.NORSK_PORT;
+    return "6789";
+}
+/** @private */
+function promisifyUnary(requestFn) {
+    return util.promisify(requestFn);
+}
+/** @private */
+function safeBind(fn, obj) {
+    return fn.bind(obj);
+}
+//# sourceMappingURL=sdk.js.map