kurtosis-sdk 0.49.5

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

@@ -0,0 +1,415 @@
+"use strict";
+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.GrpcNodeApiContainerClient = void 0;
+const neverthrow_1 = require("neverthrow");
+class GrpcNodeApiContainerClient {
+    constructor(client, enclaveId) {
+        this.client = client;
+        this.enclaveId = enclaveId;
+    }
+    getEnclaveId() {
+        return this.enclaveId;
+    }
+    loadModule(loadModuleArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadModulePromise = new Promise((resolve, _unusedReject) => {
+                this.client.loadModule(loadModuleArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const loadModulePromiseResult = yield loadModulePromise;
+            if (loadModulePromiseResult.isErr()) {
+                return (0, neverthrow_1.err)(loadModulePromiseResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    unloadModule(unloadModuleArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unloadModulePromise = new Promise((resolve, _unusedReject) => {
+                this.client.unloadModule(unloadModuleArgs, (error, unloadModuleResponse) => {
+                    if (error === null) {
+                        if (!unloadModuleResponse) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(unloadModuleResponse));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const unloadModuleResult = yield unloadModulePromise;
+            if (unloadModuleResult.isErr()) {
+                return (0, neverthrow_1.err)(unloadModuleResult.error);
+            }
+            return (0, neverthrow_1.ok)(unloadModuleResult.value);
+        });
+    }
+    startServices(startServicesArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseStartServices = new Promise((resolve, _unusedReject) => {
+                this.client.startServices(startServicesArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultStartServices = yield promiseStartServices;
+            if (resultStartServices.isErr()) {
+                return (0, neverthrow_1.err)(resultStartServices.error);
+            }
+            const startServicesResponse = resultStartServices.value;
+            return (0, neverthrow_1.ok)(startServicesResponse);
+        });
+    }
+    removeService(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const removeServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.removeService(args, (error, removeServiceResponse) => {
+                    if (error === null) {
+                        if (!removeServiceResponse) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(removeServiceResponse));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultRemoveService = yield removeServicePromise;
+            if (resultRemoveService.isErr()) {
+                return (0, neverthrow_1.err)(resultRemoveService.error);
+            }
+            return (0, neverthrow_1.ok)(resultRemoveService.value);
+        });
+    }
+    repartitionNetwork(repartitionArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseRepartition = new Promise((resolve, _unusedReject) => {
+                this.client.repartition(repartitionArgs, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultRepartition = yield promiseRepartition;
+            if (resultRepartition.isErr()) {
+                return (0, neverthrow_1.err)(resultRepartition.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    waitForHttpGetEndpointAvailability(availabilityArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseWaitForHttpGetEndpointAvailability = new Promise((resolve, _unusedReject) => {
+                this.client.waitForHttpGetEndpointAvailability(availabilityArgs, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultWaitForHttpGetEndpointAvailability = yield promiseWaitForHttpGetEndpointAvailability;
+            if (resultWaitForHttpGetEndpointAvailability.isErr()) {
+                return (0, neverthrow_1.err)(resultWaitForHttpGetEndpointAvailability.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    waitForHttpPostEndpointAvailability(availabilityArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseWaitForHttpPostEndpointAvailability = new Promise((resolve, _unusedReject) => {
+                this.client.waitForHttpPostEndpointAvailability(availabilityArgs, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultWaitForHttpPostEndpointAvailability = yield promiseWaitForHttpPostEndpointAvailability;
+            if (resultWaitForHttpPostEndpointAvailability.isErr()) {
+                return (0, neverthrow_1.err)(resultWaitForHttpPostEndpointAvailability.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    getServices(getServicesArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseGetServices = new Promise((resolve, _unusedReject) => {
+                this.client.getServices(getServicesArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultGetServices = yield promiseGetServices;
+            if (resultGetServices.isErr()) {
+                return (0, neverthrow_1.err)(resultGetServices.error);
+            }
+            const getServicesResponse = resultGetServices.value;
+            return (0, neverthrow_1.ok)(getServicesResponse);
+        });
+    }
+    getModules(getModulesArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getModulesPromise = new Promise((resolve, _unusedReject) => {
+                this.client.getModules(getModulesArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const getModulesResult = yield getModulesPromise;
+            if (getModulesResult.isErr()) {
+                return (0, neverthrow_1.err)(getModulesResult.error);
+            }
+            const getModulesResponse = getModulesResult.value;
+            return (0, neverthrow_1.ok)(getModulesResponse);
+        });
+    }
+    executeModule(executeModuleArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const executeModulePromise = new Promise((resolve, _unusedReject) => {
+                this.client.executeModule(executeModuleArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const executeModuleResult = yield executeModulePromise;
+            if (executeModuleResult.isErr()) {
+                return (0, neverthrow_1.err)(executeModuleResult.error);
+            }
+            const executeModuleResponse = executeModuleResult.value;
+            return (0, neverthrow_1.ok)(executeModuleResponse);
+        });
+    }
+    execCommand(execCommandArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const execCommandPromise = new Promise((resolve, _unusedReject) => {
+                this.client.execCommand(execCommandArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const execCommandResponseResult = yield execCommandPromise;
+            if (execCommandResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(execCommandResponseResult.error);
+            }
+            const execCommandResponse = execCommandResponseResult.value;
+            return (0, neverthrow_1.ok)(execCommandResponse);
+        });
+    }
+    pauseService(pauseServiceArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pauseServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.pauseService(pauseServiceArgs, (error) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const pauseServiceResult = yield pauseServicePromise;
+            if (pauseServiceResult.isErr()) {
+                return (0, neverthrow_1.err)(pauseServiceResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    unpauseService(unpauseServiceArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unpauseServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.unpauseService(unpauseServiceArgs, (error) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const unpauseServiceResult = yield unpauseServicePromise;
+            if (unpauseServiceResult.isErr()) {
+                return (0, neverthrow_1.err)(unpauseServiceResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    uploadFiles(uploadFilesArtifactArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uploadFilesArtifactPromise = new Promise((resolve, _unusedReject) => {
+                this.client.uploadFilesArtifact(uploadFilesArtifactArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const uploadFilesArtifactResponseResult = yield uploadFilesArtifactPromise;
+            if (uploadFilesArtifactResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(uploadFilesArtifactResponseResult.error);
+            }
+            const uploadFilesArtifactResponse = uploadFilesArtifactResponseResult.value;
+            return (0, neverthrow_1.ok)(uploadFilesArtifactResponse);
+        });
+    }
+    storeWebFilesArtifact(storeWebFilesArtifactArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storeWebFilesArtifactPromise = new Promise((resolve, _unusedReject) => {
+                this.client.storeWebFilesArtifact(storeWebFilesArtifactArgs, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const storeWebFilesArtifactResponseResult = yield storeWebFilesArtifactPromise;
+            if (storeWebFilesArtifactResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(storeWebFilesArtifactResponseResult.error);
+            }
+            const storeWebFilesArtifactResponse = storeWebFilesArtifactResponseResult.value;
+            return (0, neverthrow_1.ok)(storeWebFilesArtifactResponse);
+        });
+    }
+    storeFilesArtifactFromService(storeFilesArtifactFromServiceArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storeFilesArtifactFromServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.storeFilesArtifactFromService(storeFilesArtifactFromServiceArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const storeFilesArtifactFromServiceResponseResult = yield storeFilesArtifactFromServicePromise;
+            if (storeFilesArtifactFromServiceResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(storeFilesArtifactFromServiceResponseResult.error);
+            }
+            const storeFilesArtifactFromServiceResponse = storeFilesArtifactFromServiceResponseResult.value;
+            return (0, neverthrow_1.ok)(storeFilesArtifactFromServiceResponse);
+        });
+    }
+    renderTemplatesToFilesArtifact(renderTemplatesToFilesArtifactArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const renderTemplatesToFilesArtifactPromise = new Promise((resolve, _unusedReject) => {
+                this.client.renderTemplatesToFilesArtifact(renderTemplatesToFilesArtifactArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const renderTemplatesToFilesArtifactResponseResult = yield renderTemplatesToFilesArtifactPromise;
+            if (renderTemplatesToFilesArtifactResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(renderTemplatesToFilesArtifactResponseResult.error);
+            }
+            const renderTemplatesToFilesArtifactResponse = renderTemplatesToFilesArtifactResponseResult.value;
+            return (0, neverthrow_1.ok)(renderTemplatesToFilesArtifactResponse);
+        });
+    }
+}
+exports.GrpcNodeApiContainerClient = GrpcNodeApiContainerClient;

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

@@ -0,0 +1,28 @@
+import { Result } from "neverthrow";
+import { StartServicesArgs, StartServicesResponse, RemoveServiceArgs, RepartitionArgs, WaitForHttpGetEndpointAvailabilityArgs, WaitForHttpPostEndpointAvailabilityArgs, GetServicesResponse, LoadModuleArgs, UnloadModuleArgs, GetModulesResponse, ExecuteModuleArgs, ExecuteModuleResponse, ExecCommandArgs, ExecCommandResponse, PauseServiceArgs, UnpauseServiceArgs, UploadFilesArtifactArgs, UploadFilesArtifactResponse, StoreWebFilesArtifactResponse, StoreWebFilesArtifactArgs, StoreFilesArtifactFromServiceArgs, GetServicesArgs, GetModulesArgs, UnloadModuleResponse, RemoveServiceResponse, RenderTemplatesToFilesArtifactArgs, RenderTemplatesToFilesArtifactResponse } from "../../kurtosis_core_rpc_api_bindings/api_container_service_pb";
+import { ApiContainerServiceClient as ApiContainerServiceClientWeb } from "../../kurtosis_core_rpc_api_bindings/api_container_service_grpc_web_pb";
+import { GenericApiContainerClient } from "./generic_api_container_client";
+import { EnclaveID } from "./enclave_context";
+export declare class GrpcWebApiContainerClient implements GenericApiContainerClient {
+    private readonly client;
+    private readonly enclaveId;
+    constructor(client: ApiContainerServiceClientWeb, 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>>;
+}