@platforma-sdk/bootstrap 3.5.21 → 5.0.0

package/dist/core.js

@@ -1,4 +1,4 @@
-import fs from 'node:fs';
+import fs__default from 'node:fs';
 import os__default from 'node:os';
 import path from 'node:path';
 import { assets, plImageTag } from './package.js';
@@ -116,23 +116,23 @@ class Core {
         }
         this.logger.debug('  creating pl state directories...');
         for (const dir of storageDirs) {
-            if (!fs.existsSync(dir)) {
+            if (!fs__default.existsSync(dir)) {
                 this.logger.debug(`    '${dir}'`);
-                fs.mkdirSync(dir, { recursive: true });
+                fs__default.mkdirSync(dir, { recursive: true });
             }
         }
         for (const drv of configOptions.core.auth.drivers) {
             if (drv.driver === 'htpasswd') {
-                if (!fs.existsSync(drv.path)) {
+                if (!fs__default.existsSync(drv.path)) {
                     this.logger.debug(`  installing default 'users.htpasswd' to ${drv.path}...`);
-                    fs.copyFileSync(assets('users.htpasswd'), drv.path);
+                    fs__default.copyFileSync(assets('users.htpasswd'), drv.path);
                 }
             }
         }
         if (!configPath) {
             configPath = path.join(configOptions.localRoot, 'config.yaml');
             this.logger.debug(`  rendering configuration '${configPath}'...`);
-            fs.writeFileSync(configPath, render(configOptions));
+            fs__default.writeFileSync(configPath, render(configOptions));
         }
         const upCommands = [];
         if (options?.sourcesPath) {
@@ -159,6 +159,29 @@ class Core {
                 GOMAXPROCS: String(options?.configOptions?.numCpu),
             };
         }
+        // Process additional environment variables from CLI options
+        if (options?.backendCommands) {
+            if (!runBinary.runOpts.env) {
+                runBinary.runOpts.env = {};
+            }
+            for (const cmd of options.backendCommands) {
+                const equalIndex = cmd.indexOf('=');
+                if (equalIndex > 0) {
+                    const key = cmd.substring(0, equalIndex);
+                    const value = cmd.substring(equalIndex + 1);
+                    runBinary.runOpts.env[key] = value;
+                }
+                else {
+                    this.logger.warn(`Invalid environment variable format: ${cmd}. Expected format: KEY=VALUE`);
+                }
+            }
+        }
+        // Process additional backend commands
+        if (options?.backendCommands && options.backendCommands.length > 0) {
+            this.logger.debug(`Adding backend commands: ${options.backendCommands.join(' ')}`);
+            // Add commands as arguments to the binary
+            runBinary.args = [...runBinary.args, ...options.backendCommands];
+        }
         upCommands.push(runBinary);
         state.setInstanceInfo(instanceName, {
             type: 'process',
@@ -182,8 +205,8 @@ class Core {
         const minioPort = options?.minioPort ?? 9000;
         const instance = this.createLocal(instanceName, {
             ...options,
-            primaryURL: options?.primaryURL ?? `s3e://testuser:testpassword@localhost:${minioPort}/main-bucket/?region=no-region`,
-            libraryURL: options?.libraryURL ?? `s3e://testuser:testpassword@localhost:${minioPort}/library-bucket/?region=no-region`,
+            primaryURL: options?.primaryURL ?? `s3e://testuser:testpassword@localhost:${minioPort}/platforma-primary-bucket/?region=no-region`,
+            libraryURL: options?.libraryURL ?? `s3e://testuser:testpassword@localhost:${minioPort}/platforma-library-bucket/?region=no-region`,
         });
         const localRoot = options?.configOptions?.localRoot;
         const minioRunCmd = this.createMinio(instanceName, {
@@ -263,20 +286,20 @@ class Core {
             return p;
         };
         const logFilePath = storagePath('logs', 'platforma.log');
-        if (!fs.existsSync(logFilePath)) {
-            fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
-            fs.writeFileSync(logFilePath, '');
+        if (!fs__default.existsSync(logFilePath)) {
+            fs__default.mkdirSync(path.dirname(logFilePath), { recursive: true });
+            fs__default.writeFileSync(logFilePath, '');
         }
         const presignHost = options?.presignHost ?? 'localhost';
         const presignPort = options?.s3Port ?? 9000;
-        const primary = storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/main-bucket`);
+        const primary = storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/platforma-primary-bucket`);
         if (primary.type !== 'S3') {
             throw new Error('primary storage must have \'S3\' type in \'docker s3\' configuration');
         }
         else {
             primary.presignEndpoint = `http://${presignHost}:${presignPort}`;
         }
-        const library = storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/library-bucket`);
+        const library = storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/platforma-library-bucket`);
         if (library.type !== 'S3') {
             throw new Error(`${library.type} storage type is not supported for library storage`);
         }
@@ -286,11 +309,11 @@ class Core {
         const dbFSPath = storageDir('db');
         const workFSPath = storageDir('work');
         const usersFSPath = storagePath('users.htpasswd');
-        if (!fs.existsSync(usersFSPath)) {
-            fs.copyFileSync(assets('users.htpasswd'), usersFSPath);
+        if (!fs__default.existsSync(usersFSPath)) {
+            fs__default.copyFileSync(assets('users.htpasswd'), usersFSPath);
         }
         const composeDstPath = storagePath('compose.yaml');
-        if (fs.existsSync(composeDstPath)) {
+        if (fs__default.existsSync(composeDstPath)) {
             this.logger.info(`replacing docker compose file ${composeDstPath}`);
         }
         const backendMounts = [];
@@ -305,13 +328,14 @@ class Core {
             ['backend', {
                     platform: options?.platformOverride,
                     mounts: backendMounts,
+                    commands: options?.backendCommands,
                 }],
         ]));
         const envs = {
             MINIO_IMAGE: 'quay.io/minio/minio',
             MINIO_STORAGE: storageDir('minio'),
             PL_IMAGE: image,
-            PL_AUTH_HTPASSWD_PATH: usersFSPath,
+            PL_AUTH_HTPASSWD: usersFSPath,
             PL_LICENSE: options?.license,
             PL_LICENSE_FILE: options?.licenseFile,
             PL_LOG_LEVEL: options?.logLevel ?? 'info',
@@ -327,36 +351,70 @@ class Core {
             ...this.configureDockerStorage('primary', primary),
             ...this.configureDockerStorage('library', library),
         };
-        if (options?.grpcAddr)
-            envs.PL_GRPC_ADDR = options.grpcAddr;
-        if (options?.grpcPort)
-            envs.PL_GRPC_PORT = options.grpcPort.toString();
-        if (options?.monitoringAddr)
-            envs.PL_MONITORING_ADDR = options.monitoringAddr;
-        if (options?.monitoringPort)
+        if (options?.grpcAddr) {
+            const addrParts = options.grpcAddr.split(':');
+            if (addrParts.length === 2) {
+                envs.PL_LISTEN_ADDRESS = addrParts[0];
+                envs.PL_LISTEN_PORT = addrParts[1];
+            }
+            else {
+                envs.PL_LISTEN_ADDRESS = options.grpcAddr;
+            }
+        }
+        else if (options?.grpcPort) {
+            envs.PL_LISTEN_PORT = options.grpcPort.toString();
+        }
+        if (options?.monitoringAddr) {
+            const addrParts = options.monitoringAddr.split(':');
+            if (addrParts.length === 2) {
+                envs.PL_MONITORING_IP = addrParts[0];
+                envs.PL_MONITORING_PORT = addrParts[1];
+            }
+            else {
+                envs.PL_MONITORING_IP = options.monitoringAddr;
+            }
+        }
+        else if (options?.monitoringPort) {
             envs.PL_MONITORING_PORT = options.monitoringPort.toString();
-        if (options?.debugAddr)
-            envs.PL_DEBUG_ADDR = options.debugAddr;
-        if (options?.debugPort)
+        }
+        if (options?.debugAddr) {
+            const addrParts = options.debugAddr.split(':');
+            if (addrParts.length === 2) {
+                envs.PL_DEBUG_IP = addrParts[0];
+                envs.PL_DEBUG_PORT = addrParts[1];
+            }
+            else {
+                envs.PL_DEBUG_IP = options.debugAddr;
+            }
+        }
+        else if (options?.debugPort) {
             envs.PL_DEBUG_PORT = options.debugPort.toString();
+        }
         if (options?.s3Port)
             envs.MINIO_PORT = options.s3Port.toString();
         if (options?.s3ConsolePort)
             envs.MINIO_CONSOLE_PORT = options.s3ConsolePort.toString();
         if (options?.auth) {
             if (options.auth.enabled) {
-                envs['PL_AUTH_ENABLED'] = 'true';
+                envs['PL_NO_AUTH'] = 'false';
+            }
+            else {
+                envs['PL_NO_AUTH'] = 'true';
             }
             if (options.auth.drivers) {
                 for (const drv of options.auth.drivers) {
                     if (drv.driver === 'htpasswd') {
-                        envs['PL_AUTH_HTPASSWD_PATH'] = path.resolve(drv.path);
+                        envs['PL_AUTH_HTPASSWD'] = path.resolve(drv.path);
                         drv.path = '/etc/platforma/users.htpasswd';
                     }
                 }
                 envs['PL_AUTH_DRIVERS'] = JSON.stringify(options.auth.drivers);
             }
         }
+        // Process additional backend commands
+        if (options?.backendCommands && options.backendCommands.length > 0) {
+            this.logger.debug(`Adding backend commands: ${options.backendCommands.join(' ')}`);
+        }
         state.setInstanceInfo(instanceName, {
             type: 'docker',
             upCommands: [{
@@ -401,20 +459,20 @@ class Core {
             return p;
         };
         const logFilePath = storagePath('logs', 'platforma.log');
-        if (!fs.existsSync(logFilePath)) {
-            fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
-            fs.writeFileSync(logFilePath, '');
+        if (!fs__default.existsSync(logFilePath)) {
+            fs__default.mkdirSync(path.dirname(logFilePath), { recursive: true });
+            fs__default.writeFileSync(logFilePath, '');
         }
         const dbFSPath = storageDir('db');
         const primaryFSPath = storageDir('primary');
         const libraryFSPath = storageDir('library');
         const workFSPath = storageDir('work');
         const usersFSPath = storagePath('users.htpasswd');
-        if (!fs.existsSync(usersFSPath)) {
-            fs.copyFileSync(assets('users.htpasswd'), usersFSPath);
+        if (!fs__default.existsSync(usersFSPath)) {
+            fs__default.copyFileSync(assets('users.htpasswd'), usersFSPath);
         }
         const composeDstPath = storagePath('compose.yaml');
-        if (fs.existsSync(composeDstPath)) {
+        if (fs__default.existsSync(composeDstPath)) {
             this.logger.info(`replacing docker compose file ${composeDstPath}`);
         }
         const backendMounts = [];
@@ -429,16 +487,17 @@ class Core {
             ['backend', {
                     platform: options?.platformOverride,
                     mounts: backendMounts,
+                    commands: options?.backendCommands,
                 }],
         ]));
         const primary = storageSettingsFromURL(options?.primaryStorageURL ?? `file:${primaryFSPath}`, '.');
         const library = storageSettingsFromURL(options?.libraryStorageURL ?? `file:${libraryFSPath}`, '.');
         const envs = {
             PL_IMAGE: image,
-            PL_AUTH_HTPASSWD_PATH: usersFSPath,
+            PL_AUTH_HTPASSWD: usersFSPath,
             PL_LICENSE: options?.license,
             PL_LICENSE_FILE: options?.licenseFile,
-            PL_LOG_LEVEL: 'info',
+            PL_LOG_LEVEL: options?.logLevel ?? 'info',
             PL_LOG_DIR: path.dirname(logFilePath),
             PL_LOG_ROTATION_ENABLED: 'true',
             PL_RUNNER_WD_CACHE_ON_FAILURE: '1h',
@@ -450,32 +509,66 @@ class Core {
             ...this.configureDockerStorage('primary', primary),
             ...this.configureDockerStorage('library', library),
         };
-        if (options?.grpcAddr)
-            envs.PL_GRPC_ADDR = options.grpcAddr;
-        if (options?.grpcPort)
-            envs.PL_GRPC_PORT = options.grpcPort.toString();
-        if (options?.monitoringAddr)
-            envs.PL_MONITORING_ADDR = options.monitoringAddr;
-        if (options?.monitoringPort)
+        if (options?.grpcAddr) {
+            const addrParts = options.grpcAddr.split(':');
+            if (addrParts.length === 2) {
+                envs.PL_LISTEN_ADDRESS = addrParts[0];
+                envs.PL_LISTEN_PORT = addrParts[1];
+            }
+            else {
+                envs.PL_LISTEN_ADDRESS = options.grpcAddr;
+            }
+        }
+        else if (options?.grpcPort) {
+            envs.PL_LISTEN_PORT = options.grpcPort.toString();
+        }
+        if (options?.monitoringAddr) {
+            const addrParts = options.monitoringAddr.split(':');
+            if (addrParts.length === 2) {
+                envs.PL_MONITORING_IP = addrParts[0];
+                envs.PL_MONITORING_PORT = addrParts[1];
+            }
+            else {
+                envs.PL_MONITORING_IP = options.monitoringAddr;
+            }
+        }
+        else if (options?.monitoringPort) {
             envs.PL_MONITORING_PORT = options.monitoringPort.toString();
-        if (options?.debugAddr)
-            envs.PL_DEBUG_ADDR = options.debugAddr;
-        if (options?.debugPort)
+        }
+        if (options?.debugAddr) {
+            const addrParts = options.debugAddr.split(':');
+            if (addrParts.length === 2) {
+                envs.PL_DEBUG_IP = addrParts[0];
+                envs.PL_DEBUG_PORT = addrParts[1];
+            }
+            else {
+                envs.PL_DEBUG_IP = options.debugAddr;
+            }
+        }
+        else if (options?.debugPort) {
             envs.PL_DEBUG_PORT = options.debugPort.toString();
+        }
         if (options?.auth) {
             if (options.auth.enabled) {
-                envs['PL_AUTH_ENABLED'] = 'true';
+                envs['PL_NO_AUTH'] = 'false';
+            }
+            else {
+                envs['PL_NO_AUTH'] = 'true';
             }
             if (options.auth.drivers) {
                 for (const drv of options.auth.drivers) {
                     if (drv.driver === 'htpasswd') {
-                        envs['PL_AUTH_HTPASSWD_PATH'] = path.resolve(drv.path);
+                        envs['PL_AUTH_HTPASSWD'] = path.resolve(drv.path);
                         drv.path = '/etc/platforma/users.htpasswd';
                     }
                 }
                 envs['PL_AUTH_DRIVERS'] = JSON.stringify(options.auth.drivers);
             }
         }
+        // Process additional backend commands
+        if (options?.backendCommands && options.backendCommands.length > 0) {
+            this.logger.debug(`Adding backend commands: ${options.backendCommands.join(' ')}`);
+        }
         state.setInstanceInfo(instanceName, {
             type: 'docker',
             upCommands: [{
@@ -561,11 +654,11 @@ You are going to reset the state of all platforma services configured with pl-bo
                 checkRunError(result.executed, `failed to wipe instance ${name} services`);
             }
             this.logger.info(`Destroying instance '${name}' data directory`);
-            fs.rmSync(state.instanceDir(name), { recursive: true, force: true });
+            fs__default.rmSync(state.instanceDir(name), { recursive: true, force: true });
         }
         if (!instanceName) {
             this.logger.info(`Destroying state dir '${state.path()}'`);
-            fs.rmSync(state.path(), { recursive: true, force: true });
+            fs__default.rmSync(state.path(), { recursive: true, force: true });
         }
         this.logger.info(`\nIf you want to remove all downloaded platforma binaries, delete '${state.binaries()}' dir manually\n`);
     }
@@ -582,7 +675,7 @@ You are going to reset the state of all platforma services configured with pl-bo
                 flags['license-file'] = process.env.MI_LICENSE_FILE;
             else if ((process.env.PL_LICENSE_FILE ?? '') != '')
                 flags['license-file'] = process.env.PL_LICENSE_FILE;
-            else if (fs.existsSync(path.resolve(os__default.homedir(), '.pl.license')))
+            else if (fs__default.existsSync(path.resolve(os__default.homedir(), '.pl.license')))
                 flags['license-file'] = path.resolve(os__default.homedir(), '.pl.license');
         }
     }
@@ -614,12 +707,12 @@ You are going to reset the state of all platforma services configured with pl-bo
         const jwtFile = state.path('auth.jwt');
         const encoding = 'utf-8';
         let lastJwt = '';
-        if (fs.existsSync(jwtFile)) {
-            lastJwt = fs.readFileSync(jwtFile, { encoding });
+        if (fs__default.existsSync(jwtFile)) {
+            lastJwt = fs__default.readFileSync(jwtFile, { encoding });
         }
         if (lastJwt == '') {
             lastJwt = randomStr(64);
-            fs.writeFileSync(jwtFile, lastJwt, { encoding });
+            fs__default.writeFileSync(jwtFile, lastJwt, { encoding });
         }
         return lastJwt;
     }
@@ -647,21 +740,58 @@ You can obtain the license from "https://licensing.milaboratories.com".`);
         storageID = storageID.toUpperCase();
         switch (sType) {
             case 'S3':
-                envs[`PL_DATA_${storageID}_TYPE`] = 'S3';
-                envs[`PL_DATA_${storageID}_S3_BUCKET`] = storage.bucketName;
-                if (storage.endpoint)
-                    envs[`PL_DATA_${storageID}_S3_ENDPOINT`] = storage.endpoint;
-                if (storage.presignEndpoint)
-                    envs[`PL_DATA_${storageID}_S3_PRESIGN_ENDPOINT`] = storage.presignEndpoint;
-                if (storage.region)
-                    envs[`PL_DATA_${storageID}_S3_REGION`] = storage.region;
-                if (storage.key)
-                    envs[`PL_DATA_${storageID}_S3_KEY`] = storage.key;
-                if (storage.secret)
-                    envs[`PL_DATA_${storageID}_S3_SECRET`] = storage.secret;
+                switch (storageID) {
+                    case 'PRIMARY': {
+                        // Construct the S3 URL for primary storage
+                        if (storage.endpoint && storage.bucketName) {
+                            envs['PL_DATA_LIBRARY_S3_URL'] = `${storage.endpoint}${storage.bucketName}`;
+                        }
+                        if (storage.endpoint)
+                            envs['PL_PRIMARY_STORAGE_S3_ENDPOINT'] = storage.endpoint;
+                        if (storage.presignEndpoint)
+                            envs['PL_PRIMARY_STORAGE_S3_EXTERNAL_ENDPOINT'] = storage.presignEndpoint;
+                        if (storage.region)
+                            envs['PL_PRIMARY_STORAGE_S3_REGION'] = storage.region;
+                        if (storage.key)
+                            envs['PL_PRIMARY_STORAGE_S3_KEY'] = storage.key;
+                        if (storage.secret)
+                            envs['PL_PRIMARY_STORAGE_S3_SECRET'] = storage.secret;
+                        break;
+                    }
+                    case 'LIBRARY': {
+                        // Construct the S3 URL for library storage
+                        if (storage.endpoint && storage.bucketName) {
+                            envs['PL_DATA_LIBRARY_S3_URL'] = `library=${storage.endpoint}${storage.bucketName}`;
+                        }
+                        if (storage.endpoint)
+                            envs['PL_DATA_LIBRARY_S3_ENDPOINT'] = `library=${storage.endpoint}`;
+                        if (storage.presignEndpoint)
+                            envs['PL_DATA_LIBRARY_S3_EXTERNAL_ENDPOINT'] = `library=${storage.presignEndpoint}`;
+                        if (storage.region)
+                            envs['PL_DATA_LIBRARY_S3_REGION'] = `library=${storage.region}`;
+                        if (storage.key)
+                            envs['PL_DATA_LIBRARY_S3_KEY'] = `library=${storage.key}`;
+                        if (storage.secret)
+                            envs['PL_DATA_LIBRARY_S3_SECRET'] = `library=${storage.secret}`;
+                        break;
+                    }
+                    default:
+                        throw new Error(`Unknown storage ID: ${storageID}`);
+                }
                 return envs;
             case 'FS':
-                envs[`PL_DATA_${storageID}_TYPE`] = 'FS';
+                switch (storageID) {
+                    case 'PRIMARY':
+                        if (storage.rootPath)
+                            envs['PL_PRIMARY_STORAGE_FS'] = storage.rootPath;
+                        break;
+                    case 'LIBRARY':
+                        if (storage.rootPath)
+                            envs['PL_DATA_LIBRARY_FS_PATH'] = storage.rootPath;
+                        break;
+                    default:
+                        throw new Error(`Unknown storage ID: ${storageID}`);
+                }
                 return envs;
             default:
                 assertNever();