kurtosis-sdk 0.49.5

package/build/core/lib/enclaves/enclave_context.d.ts

@@ -0,0 +1,39 @@
+import { Result } from "neverthrow";
+import { ModuleContext, ModuleID } from "../modules/module_context";
+import type { ContainerConfig, FilesArtifactUUID } from "../services/container_config";
+import type { ServiceID } from "../services/service";
+import { ServiceContext } from "../services/service_context";
+import type { PartitionConnection } from "./partition_connection";
+import { TemplateAndData } from "./template_and_data";
+export declare type EnclaveID = string;
+export declare type PartitionID = string;
+export declare class EnclaveContext {
+    private readonly backend;
+    private readonly pathJoiner;
+    private readonly genericTgzArchiver;
+    private constructor();
+    static newGrpcWebEnclaveContext(ipAddress: string, apiContainerGrpcProxyPortNum: number, enclaveId: string): Promise<Result<EnclaveContext, Error>>;
+    static newGrpcNodeEnclaveContext(ipAddress: string, apiContainerGrpcPortNum: number, enclaveId: string): Promise<Result<EnclaveContext, Error>>;
+    getEnclaveId(): EnclaveID;
+    loadModule(moduleId: ModuleID, image: string, serializedParams: string): Promise<Result<ModuleContext, Error>>;
+    unloadModule(moduleId: ModuleID): Promise<Result<null, Error>>;
+    getModuleContext(moduleId: ModuleID): Promise<Result<ModuleContext, Error>>;
+    addService(serviceId: ServiceID, containerConfig: ContainerConfig): Promise<Result<ServiceContext, Error>>;
+    addServices(containerConfigs: Map<ServiceID, ContainerConfig>): Promise<Result<[Map<ServiceID, ServiceContext>, Map<ServiceID, Error>], Error>>;
+    addServiceToPartition(serviceId: ServiceID, partitionId: PartitionID, containerConfig: ContainerConfig): Promise<Result<ServiceContext, Error>>;
+    addServicesToPartition(containerConfigs: Map<ServiceID, ContainerConfig>, partitionID: PartitionID): Promise<Result<[Map<ServiceID, ServiceContext>, Map<ServiceID, Error>], Error>>;
+    getServiceContext(serviceId: ServiceID): Promise<Result<ServiceContext, Error>>;
+    removeService(serviceId: ServiceID): Promise<Result<null, Error>>;
+    repartitionNetwork(partitionServices: Map<PartitionID, Set<ServiceID>>, partitionConnections: Map<PartitionID, Map<PartitionID, PartitionConnection>>, defaultConnection: PartitionConnection): Promise<Result<null, Error>>;
+    waitForHttpGetEndpointAvailability(serviceId: ServiceID, port: number, path: string, initialDelayMilliseconds: number, retries: number, retriesDelayMilliseconds: number, bodyText: string): Promise<Result<null, Error>>;
+    waitForHttpPostEndpointAvailability(serviceId: ServiceID, port: number, path: string, requestBody: string, initialDelayMilliseconds: number, retries: number, retriesDelayMilliseconds: number, bodyText: string): Promise<Result<null, Error>>;
+    getServices(): Promise<Result<Set<ServiceID>, Error>>;
+    getModules(): Promise<Result<Set<ModuleID>, Error>>;
+    uploadFiles(pathToArchive: string): Promise<Result<FilesArtifactUUID, Error>>;
+    storeWebFiles(url: string): Promise<Result<FilesArtifactUUID, Error>>;
+    storeServiceFiles(serviceId: ServiceID, absoluteFilepathOnServiceContainer: string): Promise<Result<FilesArtifactUUID, Error>>;
+    pauseService(serviceId: string): Promise<Result<null, Error>>;
+    unpauseService(serviceId: string): Promise<Result<null, Error>>;
+    renderTemplates(templateAndDataByDestinationRelFilepath: Map<string, TemplateAndData>): Promise<Result<FilesArtifactUUID, Error>>;
+    private static convertApiPortsToServiceContextPorts;
+}

package/build/core/lib/enclaves/enclave_context.js

@@ -0,0 +1,501 @@
+"use strict";
+/*
+ * Copyright (c) 2020 - present Kurtosis Technologies LLC.
+ * All Rights Reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnclaveContext = void 0;
+const neverthrow_1 = require("neverthrow");
+const loglevel_1 = require("loglevel");
+const browser_or_node_1 = require("browser-or-node");
+const grpc_node_api_container_client_1 = require("./grpc_node_api_container_client");
+const grpc_web_api_container_client_1 = require("./grpc_web_api_container_client");
+const module_context_1 = require("../modules/module_context");
+const constructor_calls_1 = require("../constructor_calls");
+const service_context_1 = require("../services/service_context");
+const port_spec_1 = require("../services/port_spec");
+// This will always resolve to the default partition ID (regardless of whether such a partition exists in the enclave,
+//  or it was repartitioned away)
+const DEFAULT_PARTITION_ID = "";
+// Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+class EnclaveContext {
+    constructor(backend, pathJoiner, genericTgzArchiver) {
+        this.backend = backend;
+        this.pathJoiner = pathJoiner;
+        this.genericTgzArchiver = genericTgzArchiver;
+    }
+    static newGrpcWebEnclaveContext(ipAddress, apiContainerGrpcProxyPortNum, enclaveId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (browser_or_node_1.isNode) {
+                return (0, neverthrow_1.err)(new Error("It seems you're trying to create Enclave Context from Node environment. Please consider the 'newGrpcNodeEnclaveContext()' method instead."));
+            }
+            let genericApiContainerClient;
+            let genericTgzArchiver;
+            let pathJoiner;
+            try {
+                pathJoiner = yield Promise.resolve().then(() => require("path-browserify"));
+                const apiContainerServiceWeb = yield Promise.resolve().then(() => require("../../kurtosis_core_rpc_api_bindings/api_container_service_grpc_web_pb"));
+                const apiContainerGrpcProxyUrl = `${ipAddress}:${apiContainerGrpcProxyPortNum}`;
+                const apiContainerClient = new apiContainerServiceWeb.ApiContainerServiceClient(apiContainerGrpcProxyUrl);
+                genericApiContainerClient = new grpc_web_api_container_client_1.GrpcWebApiContainerClient(apiContainerClient, enclaveId);
+                const webFileArchiver = yield Promise.resolve().then(() => require("./web_tgz_archiver"));
+                genericTgzArchiver = new webFileArchiver.WebTgzArchiver();
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    return (0, neverthrow_1.err)(error);
+                }
+                return (0, neverthrow_1.err)(new Error("An unknown exception value was thrown during creation of the API container client that wasn't an error: " + error));
+            }
+            const enclaveContext = new EnclaveContext(genericApiContainerClient, pathJoiner, genericTgzArchiver);
+            return (0, neverthrow_1.ok)(enclaveContext);
+        });
+    }
+    static newGrpcNodeEnclaveContext(ipAddress, apiContainerGrpcPortNum, enclaveId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!browser_or_node_1.isNode) {
+                return (0, neverthrow_1.err)(new Error("It seems you're trying to create Enclave Context from Web environment. Please consider the 'newGrpcWebEnclaveContext()' method instead."));
+            }
+            let genericApiContainerClient;
+            let genericTgzArchiver;
+            let pathJoiner;
+            //TODO Pull things that can't throw an error out of try statement.
+            try {
+                pathJoiner = yield Promise.resolve().then(() => require(/* webpackIgnore: true */ "path"));
+                const grpc_node = yield Promise.resolve().then(() => require(/* webpackIgnore: true */ "@grpc/grpc-js"));
+                const apiContainerServiceNode = yield Promise.resolve().then(() => require(/* webpackIgnore: true */ "../../kurtosis_core_rpc_api_bindings/api_container_service_grpc_pb"));
+                const apiContainerGrpcUrl = `${ipAddress}:${apiContainerGrpcPortNum}`;
+                const apiContainerClient = new apiContainerServiceNode.ApiContainerServiceClient(apiContainerGrpcUrl, grpc_node.credentials.createInsecure());
+                genericApiContainerClient = new grpc_node_api_container_client_1.GrpcNodeApiContainerClient(apiContainerClient, enclaveId);
+                const nodeTgzArchiver = yield Promise.resolve().then(() => require(/* webpackIgnore: true */ "./node_tgz_archiver"));
+                genericTgzArchiver = new nodeTgzArchiver.NodeTgzArchiver();
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    return (0, neverthrow_1.err)(error);
+                }
+                return (0, neverthrow_1.err)(new Error("An unknown exception value was thrown during creation of the API container client that wasn't an error: " + error));
+            }
+            const enclaveContext = new EnclaveContext(genericApiContainerClient, pathJoiner, genericTgzArchiver);
+            return (0, neverthrow_1.ok)(enclaveContext);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getEnclaveId() {
+        return this.backend.getEnclaveId();
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    loadModule(moduleId, image, serializedParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadModuleArgs = (0, constructor_calls_1.newLoadModuleArgs)(moduleId, image, serializedParams);
+            const loadModuleResult = yield this.backend.loadModule(loadModuleArgs);
+            if (loadModuleResult.isErr()) {
+                return (0, neverthrow_1.err)(loadModuleResult.error);
+            }
+            const moduleContext = new module_context_1.ModuleContext(this.backend, moduleId);
+            return (0, neverthrow_1.ok)(moduleContext);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    unloadModule(moduleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unloadModuleArgs = (0, constructor_calls_1.newUnloadModuleArgs)(moduleId);
+            const unloadModuleResult = yield this.backend.unloadModule(unloadModuleArgs);
+            if (unloadModuleResult.isErr()) {
+                return (0, neverthrow_1.err)(unloadModuleResult.error);
+            }
+            // We discard the module GUID
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getModuleContext(moduleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const moduleMapForArgs = new Map();
+            moduleMapForArgs.set(moduleId, true);
+            const args = (0, constructor_calls_1.newGetModulesArgs)(moduleMapForArgs);
+            const getModuleInfoResult = yield this.backend.getModules(args);
+            if (getModuleInfoResult.isErr()) {
+                return (0, neverthrow_1.err)(getModuleInfoResult.error);
+            }
+            const resp = getModuleInfoResult.value;
+            if (!resp.getModuleInfoMap().has(moduleId)) {
+                return (0, neverthrow_1.err)(new Error(`Module '${moduleId}' does not exist`));
+            }
+            const moduleCtx = new module_context_1.ModuleContext(this.backend, moduleId);
+            return (0, neverthrow_1.ok)(moduleCtx);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    addService(serviceId, containerConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const containerConfigs = new Map();
+            containerConfigs.set(serviceId, containerConfig);
+            const resultAddServiceToPartition = yield this.addServicesToPartition(containerConfigs, DEFAULT_PARTITION_ID);
+            if (resultAddServiceToPartition.isErr()) {
+                return (0, neverthrow_1.err)(resultAddServiceToPartition.error);
+            }
+            const [successfulServices, failedService] = resultAddServiceToPartition.value;
+            const serviceErr = failedService.get(serviceId);
+            if (serviceErr != undefined) {
+                return (0, neverthrow_1.err)(new Error(`An error occurred adding service '${serviceId}' to the enclave in the default partition:\n${serviceErr}`));
+            }
+            const serviceCtx = successfulServices.get(serviceId);
+            if (serviceCtx == undefined) {
+                return (0, neverthrow_1.err)(new Error(`An error occurred retrieving the service context of service with ID ${serviceId} from result of adding service to partition. This should not happen and is a bug in Kurtosis.`));
+            }
+            return (0, neverthrow_1.ok)(serviceCtx);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    addServices(containerConfigs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resultAddServicesToPartition = yield this.addServicesToPartition(containerConfigs, DEFAULT_PARTITION_ID);
+            if (resultAddServicesToPartition.isErr()) {
+                return (0, neverthrow_1.err)(resultAddServicesToPartition.error);
+            }
+            return (0, neverthrow_1.ok)(resultAddServicesToPartition.value);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    addServiceToPartition(serviceId, partitionId, containerConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const containerConfigs = new Map();
+            containerConfigs.set(serviceId, containerConfig);
+            const resultAddServiceToPartition = yield this.addServicesToPartition(containerConfigs, partitionId);
+            if (resultAddServiceToPartition.isErr()) {
+                return (0, neverthrow_1.err)(resultAddServiceToPartition.error);
+            }
+            const [successfulServices, failedService] = resultAddServiceToPartition.value;
+            const serviceErr = failedService.get(serviceId);
+            if (serviceErr != undefined) {
+                return (0, neverthrow_1.err)(new Error(`An error occurred adding service '${serviceId}' to the enclave in the default partition:\n${serviceErr}`));
+            }
+            const serviceCtx = successfulServices.get(serviceId);
+            if (serviceCtx == undefined) {
+                return (0, neverthrow_1.err)(new Error(`An error occurred retrieving the service context of service with ID ${serviceId} from result of adding service to partition. This should not happen and is a bug in Kurtosis.`));
+            }
+            return (0, neverthrow_1.ok)(serviceCtx);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    addServicesToPartition(containerConfigs, partitionID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const failedServicesPool = new Map();
+            const successfulServices = new Map();
+            const serviceConfigs = new Map();
+            for (const [serviceID, containerConfig] of containerConfigs.entries()) {
+                loglevel_1.default.trace(`Creating files artifact ID str -> mount dirpaths map for service with Id '${serviceID}'...`);
+                const artifactIdStrToMountDirpath = new Map();
+                for (const [filesArtifactId, mountDirpath] of containerConfig.filesArtifactMountpoints) {
+                    artifactIdStrToMountDirpath.set(filesArtifactId, mountDirpath);
+                }
+                loglevel_1.default.trace(`Successfully created files artifact ID str -> mount dirpaths map for service with Id '${serviceID}'`);
+                const privatePorts = containerConfig.usedPorts;
+                const privatePortsForApi = new Map();
+                for (const [portId, portSpec] of privatePorts.entries()) {
+                    const portSpecForApi = (0, constructor_calls_1.newPort)(portSpec.number, portSpec.protocol);
+                    privatePortsForApi.set(portId, portSpecForApi);
+                }
+                //TODO this is a huge hack to temporarily enable static ports for NEAR until we have a more productized solution
+                const publicPorts = containerConfig.publicPorts;
+                const publicPortsForApi = new Map();
+                for (const [portId, portSpec] of publicPorts.entries()) {
+                    const portSpecForApi = (0, constructor_calls_1.newPort)(portSpec.number, portSpec.protocol);
+                    publicPortsForApi.set(portId, portSpecForApi);
+                }
+                //TODO finish the hack
+                const serviceConfig = (0, constructor_calls_1.newServiceConfig)(containerConfig.image, privatePortsForApi, publicPortsForApi, containerConfig.entrypointOverrideArgs, containerConfig.cmdOverrideArgs, containerConfig.environmentVariableOverrides, artifactIdStrToMountDirpath, containerConfig.cpuAllocationMillicpus, containerConfig.memoryAllocationMegabytes, containerConfig.privateIPAddrPlaceholder);
+                serviceConfigs.set(serviceID, serviceConfig);
+            }
+            loglevel_1.default.trace("Starting new services with Kurtosis API...");
+            const startServicesArgs = (0, constructor_calls_1.newStartServicesArgs)(serviceConfigs, partitionID);
+            const startServicesResponseResult = yield this.backend.startServices(startServicesArgs);
+            if (startServicesResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(startServicesResponseResult.error);
+            }
+            const startServicesResponse = startServicesResponseResult.value;
+            const successfulServicesInfo = startServicesResponse.getSuccessfulServiceIdsToServiceInfoMap();
+            if (successfulServicesInfo === undefined) {
+                return (0, neverthrow_1.err)(new Error("Expected StartServicesResponse to contain a field that does not exist."));
+            }
+            // defer-undo removes all successfully started services in case of errors in the future phases
+            const shouldRemoveServices = new Map();
+            for (const [serviceIdStr, _] of successfulServicesInfo.entries()) {
+                shouldRemoveServices.set(serviceIdStr, true);
+            }
+            try {
+                // Add services that failed to start to failed services pool
+                const failedServices = startServicesResponse.getFailedServiceIdsToErrorMap();
+                if (failedServices === undefined) {
+                    return (0, neverthrow_1.err)(new Error("Expected StartServicesResponse to contain a field that does not exist."));
+                }
+                for (const [serviceIdStr, serviceErrStr] of failedServices.entries()) {
+                    const serviceId = serviceIdStr;
+                    failedServicesPool.set(serviceId, new Error(serviceErrStr));
+                }
+                for (const [serviceIdStr, serviceInfo] of successfulServicesInfo.entries()) {
+                    const serviceId = serviceIdStr;
+                    const serviceCtxPrivatePorts = EnclaveContext.convertApiPortsToServiceContextPorts(serviceInfo.getPrivatePortsMap());
+                    const serviceCtxPublicPorts = EnclaveContext.convertApiPortsToServiceContextPorts(serviceInfo.getMaybePublicPortsMap());
+                    const serviceContext = new service_context_1.ServiceContext(this.backend, serviceId, serviceInfo.getPrivateIpAddr(), serviceCtxPrivatePorts, serviceInfo.getMaybePublicIpAddr(), serviceCtxPublicPorts);
+                    successfulServices.set(serviceId, serviceContext);
+                    loglevel_1.default.trace(`Successfully started service with ID '${serviceId}' with Kurtosis API`);
+                }
+                // Do not remove resources for successful services
+                for (const [serviceId, _] of successfulServices) {
+                    shouldRemoveServices.delete(serviceId);
+                }
+            }
+            finally {
+                for (const [serviceId, _] of shouldRemoveServices) {
+                    // Do a best effort attempt to remove resources for this object to clean up after it failed
+                    // TODO: Migrate this to a bulk remove services call
+                    const removeServiceArgs = (0, constructor_calls_1.newRemoveServiceArgs)(serviceId);
+                    const removeServiceResult = yield this.backend.removeService(removeServiceArgs);
+                    if (removeServiceResult.isErr()) {
+                        const errMsg = `"Attempted to remove service '${serviceId}' to delete its resources after it failed to start, but the following error occurred " +
+                    "while attempting to remove the service:\n ${removeServiceResult.error}`;
+                        failedServicesPool.set(serviceId, new Error(errMsg));
+                    }
+                }
+            }
+            return (0, neverthrow_1.ok)([successfulServices, failedServicesPool]);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getServiceContext(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const serviceArgMap = new Map();
+            serviceArgMap.set(serviceId, true);
+            const getServiceInfoArgs = (0, constructor_calls_1.newGetServicesArgs)(serviceArgMap);
+            const getServicesResult = yield this.backend.getServices(getServiceInfoArgs);
+            if (getServicesResult.isErr()) {
+                return (0, neverthrow_1.err)(getServicesResult.error);
+            }
+            const serviceInfo = getServicesResult.value.getServiceInfoMap().get(serviceId);
+            if (!serviceInfo) {
+                return (0, neverthrow_1.err)(new Error("Failed to retrieve service information for service " + serviceId));
+            }
+            if (serviceInfo.getPrivateIpAddr() === "") {
+                return (0, neverthrow_1.err)(new Error("Kurtosis API reported an empty private IP address for service " + serviceId + " - this should never happen, and is a bug with Kurtosis!"));
+            }
+            if (serviceInfo.getMaybePublicIpAddr() === "") {
+                return (0, neverthrow_1.err)(new Error("Kurtosis API reported an empty public IP address for service " + serviceId + " - this should never happen, and is a bug with Kurtosis!"));
+            }
+            const serviceCtxPrivatePorts = EnclaveContext.convertApiPortsToServiceContextPorts(serviceInfo.getPrivatePortsMap());
+            const serviceCtxPublicPorts = EnclaveContext.convertApiPortsToServiceContextPorts(serviceInfo.getMaybePublicPortsMap());
+            const serviceContext = new service_context_1.ServiceContext(this.backend, serviceId, serviceInfo.getPrivateIpAddr(), serviceCtxPrivatePorts, serviceInfo.getMaybePublicIpAddr(), serviceCtxPublicPorts);
+            return (0, neverthrow_1.ok)(serviceContext);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    removeService(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            loglevel_1.default.debug("Removing service '" + serviceId + "'...");
+            const removeServiceArgs = (0, constructor_calls_1.newRemoveServiceArgs)(serviceId);
+            const removeServiceResult = yield this.backend.removeService(removeServiceArgs);
+            if (removeServiceResult.isErr()) {
+                return (0, neverthrow_1.err)(removeServiceResult.error);
+            }
+            loglevel_1.default.debug("Successfully removed service ID " + serviceId);
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    repartitionNetwork(partitionServices, partitionConnections, defaultConnection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (partitionServices === null) {
+                return (0, neverthrow_1.err)(new Error("Partition services map cannot be null"));
+            }
+            if (defaultConnection === null) {
+                return (0, neverthrow_1.err)(new Error("Default connection cannot be null"));
+            }
+            // Cover for lazy/confused users
+            if (partitionConnections === null) {
+                partitionConnections = new Map();
+            }
+            const reqPartitionServices = new Map();
+            for (const [partitionId, serviceIdSet] of partitionServices.entries()) {
+                const partitionIdStr = String(partitionId);
+                reqPartitionServices.set(partitionIdStr, (0, constructor_calls_1.newPartitionServices)(serviceIdSet));
+            }
+            const reqPartitionConns = new Map();
+            for (const [partitionAId, partitionAConnsMap] of partitionConnections.entries()) {
+                const partitionAConnsStrMap = new Map();
+                for (const [partitionBId, conn] of partitionAConnsMap.entries()) {
+                    const partitionBIdStr = String(partitionBId);
+                    partitionAConnsStrMap.set(partitionBIdStr, conn.getPartitionConnectionInfo());
+                }
+                const partitionAConns = (0, constructor_calls_1.newPartitionConnections)(partitionAConnsStrMap);
+                const partitionAIdStr = String(partitionAId);
+                reqPartitionConns.set(partitionAIdStr, partitionAConns);
+            }
+            const reqDefaultConnection = defaultConnection.getPartitionConnectionInfo();
+            const repartitionArgs = (0, constructor_calls_1.newRepartitionArgs)(reqPartitionServices, reqPartitionConns, reqDefaultConnection);
+            const repartitionNetworkResult = yield this.backend.repartitionNetwork(repartitionArgs);
+            if (repartitionNetworkResult.isErr()) {
+                return (0, neverthrow_1.err)(repartitionNetworkResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    waitForHttpGetEndpointAvailability(serviceId, port, path, initialDelayMilliseconds, retries, retriesDelayMilliseconds, bodyText) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availabilityArgs = (0, constructor_calls_1.newWaitForHttpGetEndpointAvailabilityArgs)(serviceId, port, path, initialDelayMilliseconds, retries, retriesDelayMilliseconds, bodyText);
+            const waitForHttpGetEndpointAvailabilityResult = yield this.backend.waitForHttpGetEndpointAvailability(availabilityArgs);
+            if (waitForHttpGetEndpointAvailabilityResult.isErr()) {
+                return (0, neverthrow_1.err)(waitForHttpGetEndpointAvailabilityResult.error);
+            }
+            const result = waitForHttpGetEndpointAvailabilityResult.value;
+            return (0, neverthrow_1.ok)(result);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    waitForHttpPostEndpointAvailability(serviceId, port, path, requestBody, initialDelayMilliseconds, retries, retriesDelayMilliseconds, bodyText) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availabilityArgs = (0, constructor_calls_1.newWaitForHttpPostEndpointAvailabilityArgs)(serviceId, port, path, requestBody, initialDelayMilliseconds, retries, retriesDelayMilliseconds, bodyText);
+            return this.backend.waitForHttpPostEndpointAvailability(availabilityArgs);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getServices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getAllServicesArgMap = new Map();
+            const emptyGetServicesArg = (0, constructor_calls_1.newGetServicesArgs)(getAllServicesArgMap);
+            const getServicesResponseResult = yield this.backend.getServices(emptyGetServicesArg);
+            if (getServicesResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(getServicesResponseResult.error);
+            }
+            const getServicesResponse = getServicesResponseResult.value;
+            const serviceIDs = new Set();
+            getServicesResponse.getServiceInfoMap().forEach((value, key) => {
+                serviceIDs.add(key);
+            });
+            return (0, neverthrow_1.ok)(serviceIDs);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getModules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getAllModulesArgMap = new Map();
+            const emptyGetModulesArg = (0, constructor_calls_1.newGetModulesArgs)(getAllModulesArgMap);
+            const getModulesResponseResult = yield this.backend.getModules(emptyGetModulesArg);
+            if (getModulesResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(getModulesResponseResult.error);
+            }
+            const modulesResponse = getModulesResponseResult.value;
+            const moduleIds = new Set();
+            modulesResponse.getModuleInfoMap().forEach((value, key) => {
+                moduleIds.add(key);
+            });
+            return (0, neverthrow_1.ok)(moduleIds);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    uploadFiles(pathToArchive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const archiverResponse = yield this.genericTgzArchiver.createTgzByteArray(pathToArchive);
+            if (archiverResponse.isErr()) {
+                return (0, neverthrow_1.err)(archiverResponse.error);
+            }
+            const args = (0, constructor_calls_1.newUploadFilesArtifactArgs)(archiverResponse.value);
+            const uploadResult = yield this.backend.uploadFiles(args);
+            if (uploadResult.isErr()) {
+                return (0, neverthrow_1.err)(uploadResult.error);
+            }
+            return (0, neverthrow_1.ok)(uploadResult.value.getUuid());
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    storeWebFiles(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = (0, constructor_calls_1.newStoreWebFilesArtifactArgs)(url);
+            const storeWebFilesArtifactResponseResult = yield this.backend.storeWebFilesArtifact(args);
+            if (storeWebFilesArtifactResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(storeWebFilesArtifactResponseResult.error);
+            }
+            const storeWebFilesArtifactResponse = storeWebFilesArtifactResponseResult.value;
+            return (0, neverthrow_1.ok)(storeWebFilesArtifactResponse.getUuid());
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    storeServiceFiles(serviceId, absoluteFilepathOnServiceContainer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = (0, constructor_calls_1.newStoreFilesArtifactFromServiceArgs)(serviceId, absoluteFilepathOnServiceContainer);
+            const storeFilesArtifactFromServiceResponseResult = yield this.backend.storeFilesArtifactFromService(args);
+            if (storeFilesArtifactFromServiceResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(storeFilesArtifactFromServiceResponseResult.error);
+            }
+            const storeFilesArtifactFromServiceResponse = storeFilesArtifactFromServiceResponseResult.value;
+            return (0, neverthrow_1.ok)(storeFilesArtifactFromServiceResponse.getUuid());
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    pauseService(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pauseServiceArgs = (0, constructor_calls_1.newPauseServiceArgs)(serviceId);
+            const pauseServiceResult = yield this.backend.pauseService(pauseServiceArgs);
+            if (pauseServiceResult.isErr()) {
+                return (0, neverthrow_1.err)(pauseServiceResult.error);
+            }
+            const pauseServiceResponse = pauseServiceResult.value;
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    unpauseService(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unpauseServiceArgs = (0, constructor_calls_1.newUnpauseServiceArgs)(serviceId);
+            const unpauseServiceResult = yield this.backend.unpauseService(unpauseServiceArgs);
+            if (unpauseServiceResult.isErr()) {
+                return (0, neverthrow_1.err)(unpauseServiceResult.error);
+            }
+            const pauseServiceResponse = unpauseServiceResult.value;
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    renderTemplates(templateAndDataByDestinationRelFilepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (templateAndDataByDestinationRelFilepath.size === 0) {
+                return (0, neverthrow_1.err)(new Error("Expected at least one template got 0"));
+            }
+            let renderTemplatesToFilesArtifactArgs = (0, constructor_calls_1.newRenderTemplatesToFilesArtifactArgs)();
+            let templateAndDataByRelDestinationFilepath = renderTemplatesToFilesArtifactArgs.getTemplatesAndDataByDestinationRelFilepathMap();
+            for (let [destinationRelFilepath, templateAndData] of templateAndDataByDestinationRelFilepath) {
+                const templateDataAsJsonString = JSON.stringify(templateAndData.templateData);
+                const templateAndDataAsJson = (0, constructor_calls_1.newTemplateAndData)(templateAndData.template, templateDataAsJsonString);
+                templateAndDataByRelDestinationFilepath.set(destinationRelFilepath, templateAndDataAsJson);
+            }
+            const renderTemplatesToFilesArtifactResult = yield this.backend.renderTemplatesToFilesArtifact(renderTemplatesToFilesArtifactArgs);
+            if (renderTemplatesToFilesArtifactResult.isErr()) {
+                return (0, neverthrow_1.err)(renderTemplatesToFilesArtifactResult.error);
+            }
+            return (0, neverthrow_1.ok)(renderTemplatesToFilesArtifactResult.value.getUuid());
+        });
+    }
+    // ====================================================================================================
+    //                                       Private helper functions
+    // ====================================================================================================
+    static convertApiPortsToServiceContextPorts(apiPorts) {
+        const result = new Map();
+        for (const [portId, apiPortSpec] of apiPorts.entries()) {
+            const portProtocol = apiPortSpec.getProtocol();
+            const portNum = apiPortSpec.getNumber();
+            result.set(portId, new port_spec_1.PortSpec(portNum, portProtocol));
+        }
+        return result;
+    }
+}
+exports.EnclaveContext = EnclaveContext;

package/build/core/lib/enclaves/generic_api_container_client.d.ts

@@ -0,0 +1,23 @@
+import { Result } from "neverthrow";
+import { ExecCommandArgs, ExecCommandResponse, ExecuteModuleArgs, ExecuteModuleResponse, GetModulesArgs, GetModulesResponse, GetServicesArgs, GetServicesResponse, LoadModuleArgs, PauseServiceArgs, RemoveServiceArgs, RemoveServiceResponse, RenderTemplatesToFilesArtifactArgs, RenderTemplatesToFilesArtifactResponse, RepartitionArgs, StartServicesArgs, StartServicesResponse, StoreFilesArtifactFromServiceArgs, StoreWebFilesArtifactArgs, StoreWebFilesArtifactResponse, UnloadModuleArgs, UnloadModuleResponse, UnpauseServiceArgs, UploadFilesArtifactArgs, UploadFilesArtifactResponse, WaitForHttpGetEndpointAvailabilityArgs, WaitForHttpPostEndpointAvailabilityArgs } from "../../kurtosis_core_rpc_api_bindings/api_container_service_pb";
+import { EnclaveID } from "./enclave_context";
+export interface GenericApiContainerClient {
+    getEnclaveId(): EnclaveID;
+    loadModule(loadModuleArgs: LoadModuleArgs): Promise<Result<null, Error>>;
+    unloadModule(unloadModuleArgs: UnloadModuleArgs): Promise<Result<UnloadModuleResponse, Error>>;
+    startServices(startServicesArgs: StartServicesArgs): Promise<Result<StartServicesResponse, Error>>;
+    removeService(args: RemoveServiceArgs): Promise<Result<RemoveServiceResponse, Error>>;
+    repartitionNetwork(repartitionArgs: RepartitionArgs): Promise<Result<null, Error>>;
+    waitForHttpGetEndpointAvailability(availabilityArgs: WaitForHttpGetEndpointAvailabilityArgs): Promise<Result<null, Error>>;
+    waitForHttpPostEndpointAvailability(availabilityArgs: WaitForHttpPostEndpointAvailabilityArgs): Promise<Result<null, Error>>;
+    getServices(getServicesArgs: GetServicesArgs): Promise<Result<GetServicesResponse, Error>>;
+    getModules(getModulesArgs: GetModulesArgs): Promise<Result<GetModulesResponse, Error>>;
+    executeModule(executeModuleArgs: ExecuteModuleArgs): Promise<Result<ExecuteModuleResponse, Error>>;
+    execCommand(execCommandArgs: ExecCommandArgs): Promise<Result<ExecCommandResponse, Error>>;
+    pauseService(pauseServiceArgs: PauseServiceArgs): Promise<Result<null, Error>>;
+    unpauseService(unpauseServiceArgs: UnpauseServiceArgs): Promise<Result<null, Error>>;
+    uploadFiles(uploadFilesArtifactArgs: UploadFilesArtifactArgs): Promise<Result<UploadFilesArtifactResponse, Error>>;
+    storeWebFilesArtifact(storeWebFilesArtifactArgs: StoreWebFilesArtifactArgs): Promise<Result<StoreWebFilesArtifactResponse, Error>>;
+    storeFilesArtifactFromService(storeFilesArtifactFromServiceArgs: StoreFilesArtifactFromServiceArgs): Promise<Result<StoreWebFilesArtifactResponse, Error>>;
+    renderTemplatesToFilesArtifact(renderTemplatesToFilesArtifactArgs: RenderTemplatesToFilesArtifactArgs): Promise<Result<RenderTemplatesToFilesArtifactResponse, Error>>;
+}

package/build/core/lib/enclaves/generic_api_container_client.js

@@ -0,0 +1,6 @@
+"use strict";
+/*
+ * Copyright (c) 2022 - present Kurtosis Technologies Inc.
+ * All Rights Reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/core/lib/enclaves/generic_path_joiner.d.ts

@@ -0,0 +1,3 @@
+export interface GenericPathJoiner {
+    join(firstPath: string, secondPath: string): string;
+}

package/build/core/lib/enclaves/generic_path_joiner.js

@@ -0,0 +1,6 @@
+"use strict";
+/*
+ * Copyright (c) 2022 - present Kurtosis Technologies Inc.
+ * All Rights Reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/core/lib/enclaves/generic_tgz_archiver.d.ts

@@ -0,0 +1,4 @@
+import { Result } from "neverthrow";
+export interface GenericTgzArchiver {
+    createTgzByteArray(pathToArchive: string): Promise<Result<Uint8Array, Error>>;
+}

package/build/core/lib/enclaves/generic_tgz_archiver.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/core/lib/enclaves/grpc_node_api_container_client.d.ts

@@ -0,0 +1,29 @@
+import { Result } from "neverthrow";
+import { StartServicesArgs, StartServicesResponse, RemoveServiceArgs, RepartitionArgs, WaitForHttpGetEndpointAvailabilityArgs, WaitForHttpPostEndpointAvailabilityArgs, GetServicesResponse, LoadModuleArgs, UnloadModuleArgs, GetModulesResponse, ExecuteModuleResponse, ExecuteModuleArgs, ExecCommandArgs, ExecCommandResponse, PauseServiceArgs, UnpauseServiceArgs, UploadFilesArtifactArgs, UploadFilesArtifactResponse, StoreWebFilesArtifactArgs, StoreWebFilesArtifactResponse, StoreFilesArtifactFromServiceArgs, GetServicesArgs, GetModulesArgs, UnloadModuleResponse, RenderTemplatesToFilesArtifactArgs, RenderTemplatesToFilesArtifactResponse } from "../../kurtosis_core_rpc_api_bindings/api_container_service_pb";
+import type { ApiContainerServiceClient as ApiContainerServiceClientNode } from "../../kurtosis_core_rpc_api_bindings/api_container_service_grpc_pb";
+import { GenericApiContainerClient } from "./generic_api_container_client";
+import { EnclaveID } from "./enclave_context";
+import { RemoveServiceResponse } from "../../kurtosis_core_rpc_api_bindings/api_container_service_pb";
+export declare class GrpcNodeApiContainerClient implements GenericApiContainerClient {
+    private readonly client;
+    private readonly enclaveId;
+    constructor(client: ApiContainerServiceClientNode, enclaveId: EnclaveID);
+    getEnclaveId(): EnclaveID;
+    loadModule(loadModuleArgs: LoadModuleArgs): Promise<Result<null, Error>>;
+    unloadModule(unloadModuleArgs: UnloadModuleArgs): Promise<Result<UnloadModuleResponse, Error>>;
+    startServices(startServicesArgs: StartServicesArgs): Promise<Result<StartServicesResponse, Error>>;
+    removeService(args: RemoveServiceArgs): Promise<Result<RemoveServiceResponse, Error>>;
+    repartitionNetwork(repartitionArgs: RepartitionArgs): Promise<Result<null, Error>>;
+    waitForHttpGetEndpointAvailability(availabilityArgs: WaitForHttpGetEndpointAvailabilityArgs): Promise<Result<null, Error>>;
+    waitForHttpPostEndpointAvailability(availabilityArgs: WaitForHttpPostEndpointAvailabilityArgs): Promise<Result<null, Error>>;
+    getServices(getServicesArgs: GetServicesArgs): Promise<Result<GetServicesResponse, Error>>;
+    getModules(getModulesArgs: GetModulesArgs): Promise<Result<GetModulesResponse, Error>>;
+    executeModule(executeModuleArgs: ExecuteModuleArgs): Promise<Result<ExecuteModuleResponse, Error>>;
+    execCommand(execCommandArgs: ExecCommandArgs): Promise<Result<ExecCommandResponse, Error>>;
+    pauseService(pauseServiceArgs: PauseServiceArgs): Promise<Result<null, Error>>;
+    unpauseService(unpauseServiceArgs: UnpauseServiceArgs): Promise<Result<null, Error>>;
+    uploadFiles(uploadFilesArtifactArgs: UploadFilesArtifactArgs): Promise<Result<UploadFilesArtifactResponse, Error>>;
+    storeWebFilesArtifact(storeWebFilesArtifactArgs: StoreWebFilesArtifactArgs): Promise<Result<StoreWebFilesArtifactResponse, Error>>;
+    storeFilesArtifactFromService(storeFilesArtifactFromServiceArgs: StoreFilesArtifactFromServiceArgs): Promise<Result<StoreWebFilesArtifactResponse, Error>>;
+    renderTemplatesToFilesArtifact(renderTemplatesToFilesArtifactArgs: RenderTemplatesToFilesArtifactArgs): Promise<Result<RenderTemplatesToFilesArtifactResponse, Error>>;
+}