kurtosis-sdk 0.49.5

package/build/engine/lib/constructor_calls.d.ts

@@ -0,0 +1,5 @@
+import { CleanArgs, CreateEnclaveArgs, DestroyEnclaveArgs } from "../kurtosis_engine_rpc_api_bindings/engine_service_pb";
+export declare function newCreateEnclaveArgs(enclaveId: string, apiContainerImageVersionTag: string, apiContainerLogLevel: string, isPartitioningEnabled: boolean): CreateEnclaveArgs;
+export declare function newStopEnclaveArgs(enclaveId: string): DestroyEnclaveArgs;
+export declare function newDestroyEnclaveArgs(enclaveId: string): DestroyEnclaveArgs;
+export declare function newCleanArgs(shouldCleanAll: boolean): CleanArgs;

package/build/engine/lib/constructor_calls.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newCleanArgs = exports.newDestroyEnclaveArgs = exports.newStopEnclaveArgs = exports.newCreateEnclaveArgs = void 0;
+const engine_service_pb_1 = require("../kurtosis_engine_rpc_api_bindings/engine_service_pb");
+// ====================================================================================================
+//                                    Kurtosis Context
+// ====================================================================================================
+function newCreateEnclaveArgs(enclaveId, apiContainerImageVersionTag, apiContainerLogLevel, isPartitioningEnabled) {
+    const result = new engine_service_pb_1.CreateEnclaveArgs();
+    result.setEnclaveId(enclaveId);
+    result.setApiContainerVersionTag(apiContainerImageVersionTag);
+    result.setApiContainerLogLevel(apiContainerLogLevel);
+    result.setIsPartitioningEnabled(isPartitioningEnabled);
+    return result;
+}
+exports.newCreateEnclaveArgs = newCreateEnclaveArgs;
+function newStopEnclaveArgs(enclaveId) {
+    const result = new engine_service_pb_1.StopEnclaveArgs();
+    result.setEnclaveId(enclaveId);
+    return result;
+}
+exports.newStopEnclaveArgs = newStopEnclaveArgs;
+function newDestroyEnclaveArgs(enclaveId) {
+    const result = new engine_service_pb_1.DestroyEnclaveArgs();
+    result.setEnclaveId(enclaveId);
+    return result;
+}
+exports.newDestroyEnclaveArgs = newDestroyEnclaveArgs;
+function newCleanArgs(shouldCleanAll) {
+    const result = new engine_service_pb_1.CleanArgs();
+    result.setShouldCleanAll(shouldCleanAll);
+    return result;
+}
+exports.newCleanArgs = newCleanArgs;

package/build/engine/lib/kurtosis_context/generic_engine_client.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "neverthrow";
+import { CleanArgs, CleanResponse, CreateEnclaveArgs, CreateEnclaveResponse, DestroyEnclaveArgs, GetEnclavesResponse, GetEngineInfoResponse, StopEnclaveArgs } from "../../kurtosis_engine_rpc_api_bindings/engine_service_pb";
+export interface GenericEngineClient {
+    getEngineInfo(): Promise<Result<GetEngineInfoResponse, Error>>;
+    createEnclaveResponse(args: CreateEnclaveArgs): Promise<Result<CreateEnclaveResponse, Error>>;
+    getEnclavesResponse(): Promise<Result<GetEnclavesResponse, Error>>;
+    stopEnclave(stopEnclaveArgs: StopEnclaveArgs): Promise<Result<null, Error>>;
+    destroyEnclave(destroyEnclaveArgs: DestroyEnclaveArgs): Promise<Result<null, Error>>;
+    clean(cleanArgs: CleanArgs): Promise<Result<CleanResponse, Error>>;
+}

package/build/engine/lib/kurtosis_context/generic_engine_client.js

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

package/build/engine/lib/kurtosis_context/grpc_node_engine_client.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "neverthrow";
+import type { EngineServiceClient as EngineServiceClientNode } from "../../kurtosis_engine_rpc_api_bindings/engine_service_grpc_pb";
+import type { GenericEngineClient } from "./generic_engine_client";
+import type { CleanArgs, CleanResponse, CreateEnclaveArgs, CreateEnclaveResponse, DestroyEnclaveArgs, GetEnclavesResponse, GetEngineInfoResponse, StopEnclaveArgs } from "../../kurtosis_engine_rpc_api_bindings/engine_service_pb";
+export declare class GrpcNodeEngineClient implements GenericEngineClient {
+    private readonly client;
+    constructor(client: EngineServiceClientNode);
+    getEngineInfo(): Promise<Result<GetEngineInfoResponse, Error>>;
+    createEnclaveResponse(args: CreateEnclaveArgs): Promise<Result<CreateEnclaveResponse, Error>>;
+    stopEnclave(stopEnclaveArgs: StopEnclaveArgs): Promise<Result<null, Error>>;
+    destroyEnclave(destroyEnclaveArgs: DestroyEnclaveArgs): Promise<Result<null, Error>>;
+    clean(cleanArgs: CleanArgs): Promise<Result<CleanResponse, Error>>;
+    getEnclavesResponse(): Promise<Result<GetEnclavesResponse, Error>>;
+}

package/build/engine/lib/kurtosis_context/grpc_node_engine_client.js

@@ -0,0 +1,165 @@
+"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.GrpcNodeEngineClient = void 0;
+const neverthrow_1 = require("neverthrow");
+const google_protobuf_empty_pb = require("google-protobuf/google/protobuf/empty_pb");
+class GrpcNodeEngineClient {
+    constructor(client) {
+        this.client = client;
+    }
+    getEngineInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const grpc_node = yield Promise.resolve().then(() => require(/* webpackIgnore: true */ "@grpc/grpc-js"));
+            const emptyArg = new google_protobuf_empty_pb.Empty();
+            const getEngineInfoPromise = new Promise((resolve, _unusedReject) => {
+                this.client.getEngineInfo(emptyArg, (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 {
+                        if (error.code === grpc_node.status.UNAVAILABLE) {
+                            resolve((0, neverthrow_1.err)(new Error("The Kurtosis Engine Server is unavailable and is probably not running; you " +
+                                "will need to start it using the Kurtosis CLI before you can create a connection to it")));
+                        }
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const getEngineInfoResult = yield getEngineInfoPromise;
+            if (getEngineInfoResult.isErr()) {
+                return (0, neverthrow_1.err)(getEngineInfoResult.error);
+            }
+            const engineInfoResponse = getEngineInfoResult.value;
+            return (0, neverthrow_1.ok)(engineInfoResponse);
+        });
+    }
+    createEnclaveResponse(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const createEnclavePromise = new Promise((resolve, _unusedReject) => {
+                this.client.createEnclave(args, {}, (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 createEnclaveResult = yield createEnclavePromise;
+            if (createEnclaveResult.isErr()) {
+                return (0, neverthrow_1.err)(createEnclaveResult.error);
+            }
+            const enclaveResponse = createEnclaveResult.value;
+            return (0, neverthrow_1.ok)(enclaveResponse);
+        });
+    }
+    stopEnclave(stopEnclaveArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stopEnclavePromise = new Promise((resolve, _unusedReject) => {
+                this.client.stopEnclave(stopEnclaveArgs, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const stopEnclaveResult = yield stopEnclavePromise;
+            if (stopEnclaveResult.isErr()) {
+                return (0, neverthrow_1.err)(stopEnclaveResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    destroyEnclave(destroyEnclaveArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const destroyEnclavePromise = new Promise((resolve, _unusedReject) => {
+                this.client.destroyEnclave(destroyEnclaveArgs, {}, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const destroyEnclaveResult = yield destroyEnclavePromise;
+            if (destroyEnclaveResult.isErr()) {
+                return (0, neverthrow_1.err)(destroyEnclaveResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    clean(cleanArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanPromise = new Promise((resolve, _unusedReject) => {
+                this.client.clean(cleanArgs, (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 cleanResult = yield cleanPromise;
+            if (cleanResult.isErr()) {
+                return (0, neverthrow_1.err)(cleanResult.error);
+            }
+            const cleanResponse = cleanResult.value;
+            return (0, neverthrow_1.ok)(cleanResponse);
+        });
+    }
+    getEnclavesResponse() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emptyArg = new google_protobuf_empty_pb.Empty();
+            const getEnclavesPromise = new Promise((resolve, _unusedReject) => {
+                this.client.getEnclaves(emptyArg, (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 getEnclavesResponseResult = yield getEnclavesPromise;
+            if (!getEnclavesResponseResult.isOk()) {
+                return (0, neverthrow_1.err)(getEnclavesResponseResult.error);
+            }
+            return (0, neverthrow_1.ok)(getEnclavesResponseResult.value);
+        });
+    }
+}
+exports.GrpcNodeEngineClient = GrpcNodeEngineClient;

package/build/engine/lib/kurtosis_context/grpc_web_engine_client.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "neverthrow";
+import type { EngineServiceClient as EngineServiceClientWeb } from "../../kurtosis_engine_rpc_api_bindings/engine_service_grpc_web_pb";
+import type { GenericEngineClient } from "./generic_engine_client";
+import type { CleanArgs, CleanResponse, CreateEnclaveArgs, CreateEnclaveResponse, DestroyEnclaveArgs, GetEnclavesResponse, GetEngineInfoResponse, StopEnclaveArgs } from "../../kurtosis_engine_rpc_api_bindings/engine_service_pb";
+export declare class GrpcWebEngineClient implements GenericEngineClient {
+    private readonly client;
+    constructor(client: EngineServiceClientWeb);
+    getEngineInfo(): Promise<Result<GetEngineInfoResponse, Error>>;
+    createEnclaveResponse(createEnclaveArgs: CreateEnclaveArgs): Promise<Result<CreateEnclaveResponse, Error>>;
+    stopEnclave(stopEnclaveArgs: StopEnclaveArgs): Promise<Result<null, Error>>;
+    destroyEnclave(destroyEnclaveArgs: DestroyEnclaveArgs): Promise<Result<null, Error>>;
+    clean(cleanArgs: CleanArgs): Promise<Result<CleanResponse, Error>>;
+    getEnclavesResponse(): Promise<Result<GetEnclavesResponse, Error>>;
+}

package/build/engine/lib/kurtosis_context/grpc_web_engine_client.js

@@ -0,0 +1,165 @@
+"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.GrpcWebEngineClient = void 0;
+const grpc_web = require("grpc-web");
+const google_protobuf_empty_pb = require("google-protobuf/google/protobuf/empty_pb");
+const neverthrow_1 = require("neverthrow");
+class GrpcWebEngineClient {
+    constructor(client) {
+        this.client = client;
+    }
+    getEngineInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emptyArg = new google_protobuf_empty_pb.Empty();
+            const getEngineInfoPromise = new Promise((resolve, _unusedReject) => {
+                this.client.getEngineInfo(emptyArg, {}, (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 {
+                        if (error.code === grpc_web.StatusCode.UNAVAILABLE) {
+                            resolve((0, neverthrow_1.err)(new Error("The Kurtosis Engine Server is unavailable and is probably not running; you " +
+                                "will need to start it using the Kurtosis CLI before you can create a connection to it")));
+                        }
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const getEngineInfoResult = yield getEngineInfoPromise;
+            if (getEngineInfoResult.isErr()) {
+                return (0, neverthrow_1.err)(getEngineInfoResult.error);
+            }
+            const engineInfoResponse = getEngineInfoResult.value;
+            return (0, neverthrow_1.ok)(engineInfoResponse);
+        });
+    }
+    createEnclaveResponse(createEnclaveArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const createEnclavePromise = new Promise((resolve, _unusedReject) => {
+                this.client.createEnclave(createEnclaveArgs, {}, (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 createEnclaveResult = yield createEnclavePromise;
+            if (createEnclaveResult.isErr()) {
+                return (0, neverthrow_1.err)(createEnclaveResult.error);
+            }
+            const enclaveResponse = createEnclaveResult.value;
+            return (0, neverthrow_1.ok)(enclaveResponse);
+        });
+    }
+    stopEnclave(stopEnclaveArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stopEnclavePromise = new Promise((resolve, _unusedReject) => {
+                this.client.stopEnclave(stopEnclaveArgs, {}, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const stopEnclaveResult = yield stopEnclavePromise;
+            if (stopEnclaveResult.isErr()) {
+                return (0, neverthrow_1.err)(stopEnclaveResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    destroyEnclave(destroyEnclaveArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const destroyEnclavePromise = new Promise((resolve, _unusedReject) => {
+                this.client.destroyEnclave(destroyEnclaveArgs, {}, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const destroyEnclaveResult = yield destroyEnclavePromise;
+            if (destroyEnclaveResult.isErr()) {
+                return (0, neverthrow_1.err)(destroyEnclaveResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    clean(cleanArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanPromise = new Promise((resolve, _unusedReject) => {
+                this.client.clean(cleanArgs, {}, (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 cleanResult = yield cleanPromise;
+            if (cleanResult.isErr()) {
+                return (0, neverthrow_1.err)(cleanResult.error);
+            }
+            const cleanResponse = cleanResult.value;
+            return (0, neverthrow_1.ok)(cleanResponse);
+        });
+    }
+    getEnclavesResponse() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emptyArg = new google_protobuf_empty_pb.Empty();
+            const getEnclavesPromise = new Promise((resolve, _unusedReject) => {
+                this.client.getEnclaves(emptyArg, {}, (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 getEnclavesResponseResult = yield getEnclavesPromise;
+            if (getEnclavesResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(getEnclavesResponseResult.error);
+            }
+            return (0, neverthrow_1.ok)(getEnclavesResponseResult.value);
+        });
+    }
+}
+exports.GrpcWebEngineClient = GrpcWebEngineClient;

package/build/engine/lib/kurtosis_context/kurtosis_context.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "neverthrow";
+import { EnclaveContext, EnclaveID } from "../../../index";
+import { GenericEngineClient } from "./generic_engine_client";
+export declare const DEFAULT_GRPC_ENGINE_SERVER_PORT_NUM: number;
+export declare const DEFAULT_GRPC_PROXY_ENGINE_SERVER_PORT_NUM: number;
+export declare const DEFAULT_HTTP_LOGS_COLLECTOR_PORT_NUM: number;
+export declare class KurtosisContext {
+    private readonly client;
+    constructor(client: GenericEngineClient);
+    static newKurtosisContextFromLocalEngine(): Promise<Result<KurtosisContext, Error>>;
+    createEnclave(enclaveId: string, isPartitioningEnabled: boolean): Promise<Result<EnclaveContext, Error>>;
+    getEnclaveContext(enclaveId: EnclaveID): Promise<Result<EnclaveContext, Error>>;
+    getEnclaves(): Promise<Result<Set<EnclaveID>, Error>>;
+    stopEnclave(enclaveId: EnclaveID): Promise<Result<null, Error>>;
+    destroyEnclave(enclaveId: EnclaveID): Promise<Result<null, Error>>;
+    clean(shouldCleanAll: boolean): Promise<Result<Set<string>, Error>>;
+    private newEnclaveContextFromEnclaveInfo;
+    private static validateEngineApiVersion;
+}