kurtosis-sdk 0.84.4 → 0.84.6

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

@@ -35,4 +35,7 @@ export declare class EnclaveContext {
     getStarlarkRun(): Promise<Result<GetStarlarkRunResponse, Error>>;
     private static convertApiPortsToServiceContextPorts;
     private assembleRunStarlarkPackageArg;
+    private getKurtosisYaml;
+    private uploadLocalStarlarkPackageDependencies;
+    private isLocalDependencyReplace;
 }

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

@@ -25,6 +25,8 @@ const kurtosis_yaml_1 = require("./kurtosis_yaml");
 const starlark_run_blocking_1 = require("./starlark_run_blocking");
 const service_identifiers_1 = require("../services/service_identifiers");
 exports.KURTOSIS_YAML_FILENAME = "kurtosis.yml";
+const OS_PATH_SEPARATOR_STRING = "/";
+const DOT_RELATIVE_PATH_INDICATOR_STRING = ".";
 // Docs available at https://docs.kurtosis.com/sdk/#enclavecontext
 class EnclaveContext {
     constructor(backend, pathJoiner, genericTgzArchiver) {
@@ -98,10 +100,31 @@ class EnclaveContext {
     // Docs available at https://docs.kurtosis.com/sdk/#runstarlarkpackagestring-packagerootpath-string-serializedparams-boolean-dryrun---streamstarlarkrunresponseline-responselines-error-error
     runStarlarkPackage(packageRootPath, runConfig) {
         return __awaiter(this, void 0, void 0, function* () {
-            const args = yield this.assembleRunStarlarkPackageArg(packageRootPath, runConfig.relativePathToMainFile, runConfig.mainFunctionName, runConfig.serializedParams, runConfig.dryRun, runConfig.cloudInstanceId, runConfig.cloudUserId);
+            const kurtosisYmlResult = yield this.getKurtosisYaml(packageRootPath);
+            if (kurtosisYmlResult.isErr()) {
+                return (0, neverthrow_1.err)(new Error(`Unexpected error while getting the Kurtosis yaml file from path '${packageRootPath}'`));
+            }
+            const kurtosisYaml = kurtosisYmlResult.value;
+            const packageId = kurtosisYaml.name;
+            const packageReplaceOptions = kurtosisYaml.packageReplaceOptions;
+            const args = yield this.assembleRunStarlarkPackageArg(kurtosisYaml, runConfig.relativePathToMainFile, runConfig.mainFunctionName, runConfig.serializedParams, runConfig.dryRun, runConfig.cloudInstanceId, runConfig.cloudUserId);
             if (args.isErr()) {
                 return (0, neverthrow_1.err)(new Error(`Unexpected error while assembling arguments to pass to the Starlark executor \n${args.error}`));
             }
+            const archiverResponse = yield this.genericTgzArchiver.createTgzByteArray(packageRootPath);
+            if (archiverResponse.isErr()) {
+                return (0, neverthrow_1.err)(new Error(`Unexpected error while creating the package's tgs file from '${packageRootPath}'\n${archiverResponse.error}`));
+            }
+            const uploadStarlarkPackageResponse = yield this.backend.uploadStarlarkPackage(packageId, archiverResponse.value);
+            if (uploadStarlarkPackageResponse.isErr()) {
+                return (0, neverthrow_1.err)(new Error(`Unexpected error while uploading Starlark package '${packageId}'\n${uploadStarlarkPackageResponse.error}`));
+            }
+            if (packageReplaceOptions !== undefined && packageReplaceOptions.size > 0) {
+                const uploadLocalStarlarkPackageDependenciesResponse = yield this.uploadLocalStarlarkPackageDependencies(packageRootPath, packageReplaceOptions);
+                if (uploadLocalStarlarkPackageDependenciesResponse.isErr()) {
+                    return (0, neverthrow_1.err)(new Error(`Unexpected error while uploading local Starlark package dependencies '${packageReplaceOptions}' from '${packageRootPath}' \n${uploadLocalStarlarkPackageDependenciesResponse.error}`));
+                }
+            }
             const packageRunResult = yield this.backend.runStarlarkPackage(args.value);
             if (packageRunResult.isErr()) {
                 return (0, neverthrow_1.err)(new Error(`Unexpected error happened executing Starlark package \n${packageRunResult.error}`));
@@ -306,20 +329,9 @@ class EnclaveContext {
         }
         return (0, neverthrow_1.ok)(result);
     }
-    assembleRunStarlarkPackageArg(packageRootPath, relativePathToMainFile, mainFunctionName, serializedParams, dryRun, cloudInstanceId, cloudUserId) {
+    assembleRunStarlarkPackageArg(kurtosisYaml, relativePathToMainFile, mainFunctionName, serializedParams, dryRun, cloudInstanceId, cloudUserId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const kurtosisYamlFilepath = path.join(packageRootPath, exports.KURTOSIS_YAML_FILENAME);
-            const resultParseKurtosisYaml = yield (0, kurtosis_yaml_1.parseKurtosisYaml)(kurtosisYamlFilepath);
-            if (resultParseKurtosisYaml.isErr()) {
-                return (0, neverthrow_1.err)(resultParseKurtosisYaml.error);
-            }
-            const kurtosisYaml = resultParseKurtosisYaml.value;
-            const archiverResponse = yield this.genericTgzArchiver.createTgzByteArray(packageRootPath);
-            if (archiverResponse.isErr()) {
-                return (0, neverthrow_1.err)(archiverResponse.error);
-            }
             const args = new api_container_service_pb_1.RunStarlarkPackageArgs;
-            args.setLocal(archiverResponse.value);
             args.setPackageId(kurtosisYaml.name);
             args.setSerializedParams(serializedParams);
             args.setDryRun(dryRun);
@@ -330,5 +342,41 @@ class EnclaveContext {
             return (0, neverthrow_1.ok)(args);
         });
     }
+    getKurtosisYaml(packageRootPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const kurtosisYamlFilepath = path.join(packageRootPath, exports.KURTOSIS_YAML_FILENAME);
+            const resultParseKurtosisYaml = yield (0, kurtosis_yaml_1.parseKurtosisYaml)(kurtosisYamlFilepath);
+            if (resultParseKurtosisYaml.isErr()) {
+                return (0, neverthrow_1.err)(resultParseKurtosisYaml.error);
+            }
+            const kurtosisYaml = resultParseKurtosisYaml.value;
+            return (0, neverthrow_1.ok)(kurtosisYaml);
+        });
+    }
+    uploadLocalStarlarkPackageDependencies(packageRootPath, packageReplaceOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [dependencyPackageId, replaceOption] of packageReplaceOptions.entries()) {
+                if (this.isLocalDependencyReplace(replaceOption)) {
+                    const localPackagePath = path.join(packageRootPath, replaceOption);
+                    const archiverResponse = yield this.genericTgzArchiver.createTgzByteArray(localPackagePath);
+                    if (archiverResponse.isErr()) {
+                        return (0, neverthrow_1.err)(archiverResponse.error);
+                    }
+                    const uploadStarlarkPackageResponse = yield this.backend.uploadStarlarkPackage(dependencyPackageId, archiverResponse.value);
+                    if (uploadStarlarkPackageResponse.isErr()) {
+                        return (0, neverthrow_1.err)(uploadStarlarkPackageResponse.error);
+                    }
+                    return (0, neverthrow_1.ok)(null);
+                }
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    isLocalDependencyReplace(replace) {
+        if (replace.startsWith(OS_PATH_SEPARATOR_STRING) || replace.startsWith(DOT_RELATIVE_PATH_INDICATOR_STRING)) {
+            return true;
+        }
+        return false;
+    }
 }
 exports.EnclaveContext = EnclaveContext;

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

@@ -13,6 +13,7 @@ export interface GenericApiContainerClient {
     getServices(getServicesArgs: GetServicesArgs): Promise<Result<GetServicesResponse, Error>>;
     execCommand(execCommandArgs: ExecCommandArgs): Promise<Result<ExecCommandResponse, Error>>;
     uploadFiles(name: string, payload: Uint8Array): Promise<Result<UploadFilesArtifactResponse, Error>>;
+    uploadStarlarkPackage(packageId: string, payload: Uint8Array): Promise<Result<null, Error>>;
     storeWebFilesArtifact(storeWebFilesArtifactArgs: StoreWebFilesArtifactArgs): Promise<Result<StoreWebFilesArtifactResponse, Error>>;
     downloadFilesArtifact(downloadFilesArtifactArgs: DownloadFilesArtifactArgs): Promise<Result<Uint8Array, Error>>;
     getExistingAndHistoricalServiceIdentifiers(): Promise<Result<GetExistingAndHistoricalServiceIdentifiersResponse, Error>>;

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

@@ -19,6 +19,7 @@ export declare class GrpcNodeApiContainerClient implements GenericApiContainerCl
     getServices(getServicesArgs: GetServicesArgs): Promise<Result<GetServicesResponse, Error>>;
     execCommand(execCommandArgs: ExecCommandArgs): Promise<Result<ExecCommandResponse, Error>>;
     uploadFiles(name: string, payload: Uint8Array): Promise<Result<UploadFilesArtifactResponse, Error>>;
+    uploadStarlarkPackage(packageId: string, payload: Uint8Array): Promise<Result<null, Error>>;
     storeWebFilesArtifact(storeWebFilesArtifactArgs: StoreWebFilesArtifactArgs): Promise<Result<StoreWebFilesArtifactResponse, Error>>;
     downloadFilesArtifact(downloadFilesArtifactArgs: DownloadFilesArtifactArgs): Promise<Result<Uint8Array, Error>>;
     getExistingAndHistoricalServiceIdentifiers(): Promise<Result<GetExistingAndHistoricalServiceIdentifiersResponse, Error>>;

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

@@ -183,6 +183,48 @@ class GrpcNodeApiContainerClient {
             return (0, neverthrow_1.ok)(uploadFilesArtifactResponse);
         });
     }
+    uploadStarlarkPackage(packageId, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uploadStarlarkPackagePromise = new Promise((resolve, _unusedReject) => {
+                const clientStream = this.client.uploadStarlarkPackage((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)(null));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+                const constantChunkMetadata = new api_container_service_pb_1.DataChunkMetadata()
+                    .setName(packageId);
+                let previousChunkHash = "";
+                for (let idx = 0; idx < payload.length; idx += DATA_STREAM_CHUNK_SIZE) {
+                    const currentChunk = payload.subarray(idx, Math.min(idx + DATA_STREAM_CHUNK_SIZE, payload.length));
+                    const dataChunk = new api_container_service_pb_1.StreamedDataChunk()
+                        .setData(currentChunk)
+                        .setPreviousChunkHash(previousChunkHash)
+                        .setMetadata(constantChunkMetadata);
+                    clientStream.write(dataChunk, (streamErr) => {
+                        if (streamErr != undefined) {
+                            resolve((0, neverthrow_1.err)(new Error(`An error occurred sending data through the stream:\n${streamErr.message}`)));
+                        }
+                    });
+                    previousChunkHash = this.computeHexHash(currentChunk);
+                }
+                clientStream.end(); // close the stream, no more data will be sent
+            });
+            const uploadStarlarkPackageResponseResult = yield uploadStarlarkPackagePromise;
+            if (uploadStarlarkPackageResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(uploadStarlarkPackageResponseResult.error);
+            }
+            const uploadStarlarkPackageResponse = uploadStarlarkPackageResponseResult.value;
+            return (0, neverthrow_1.ok)(uploadStarlarkPackageResponse);
+        });
+    }
     storeWebFilesArtifact(storeWebFilesArtifactArgs) {
         return __awaiter(this, void 0, void 0, function* () {
             const storeWebFilesArtifactPromise = new Promise((resolve, _unusedReject) => {

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

@@ -1,6 +1,8 @@
 import { Result } from "neverthrow";
 export declare class KurtosisYaml {
     readonly name: string;
-    constructor(name: string);
+    readonly description: string;
+    readonly packageReplaceOptions: Map<string, string>;
+    constructor(name: string, description: string, packageReplaceOptions: Map<string, string>);
 }
 export declare function parseKurtosisYaml(kurtosisYamlFilepath: string): Promise<Result<KurtosisYaml, Error>>;

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

@@ -16,8 +16,10 @@ const yaml = require("js-yaml");
 const enclave_context_1 = require("./enclave_context");
 const PACKAGES_URL = "https://docs.kurtosis.com/concepts-reference/packages";
 class KurtosisYaml {
-    constructor(name) {
+    constructor(name, description, packageReplaceOptions) {
         this.name = name;
+        this.description = description;
+        this.packageReplaceOptions = packageReplaceOptions;
     }
 }
 exports.KurtosisYaml = KurtosisYaml;

package/build/kurtosis_version/kurtosis_version.js

@@ -4,5 +4,5 @@ exports.KURTOSIS_VERSION = void 0;
 // !!!!!!!!!!! DO NOT UPDATE! WILL BE MANUALLY UPDATED DURING THE RELEASE PROCESS !!!!!!!!!!!!!!!!!!!!!!
 // This is necessary so that Kurt Core consumers (e.g. modules) will know if they're compatible with the currently-running
 //  API container
-exports.KURTOSIS_VERSION = "0.84.4";
+exports.KURTOSIS_VERSION = "0.84.6";
 // !!!!!!!!!!! DO NOT UPDATE! WILL BE MANUALLY UPDATED DURING THE RELEASE PROCESS !!!!!!!!!!!!!!!!!!!!!!

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "kurtosis-sdk",
     "//": "NOTE: DO NOT UPDATE THIS VERSION MANUALLY - IT WILL BE UPDATED DURING THE RELEASE PROCESS!",
-    "version": "0.84.4",
+    "version": "0.84.6",
     "main": "./build/index",
     "description": "This repo contains a Typescript client for communicating with the Kurtosis Engine server, which is responsible for creating, managing and destroying Kurtosis Enclaves.",
     "types": "./build/index",