hologit 0.43.2 → 0.45.0

package/lib/Studio.js

@@ -1,16 +1,54 @@
+const { spawn } = require('child_process');
 const stream = require('stream');
-const Docker = require('dockerode');
 const os = require('os');
 const exitHook = require('async-exit-hook');
 const fs = require('mz/fs');
 
-
 const logger = require('./logger');
 
-
 const studioCache = new Map();
-let hab, docker;
+let hab;
+
+/**
+ * Helper function to execute a Docker CLI command.
+ * @param {Array<string>} args - The arguments to pass to the docker command.
+ * @param {Object} options - Options for child_process.spawn.
+ * @returns {Promise<string>} - Resolves with stdout data.
+ */
+function execDocker(args, options = { }) {
+    logger.debug(`docker ${args.join(' ')}`);
+
+    return new Promise((resolve, reject) => {
+        const dockerProcess = spawn('docker', args, { stdio: 'pipe', ...options });
 
+        if (options.$relayStderr) {
+            dockerProcess.stderr.pipe(process.stderr);
+        }
+
+        if (options.$relayStdout) {
+            dockerProcess.stdout.pipe(process.stdout);
+        }
+
+        let stdout = '';
+        let stderr = '';
+
+        dockerProcess.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        dockerProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        dockerProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            } else {
+                reject(new Error(stderr.trim()));
+            }
+        });
+    });
+}
 
 /**
  * A studio session that can be used to run multiple commands, using chroot if available or docker container
@@ -23,11 +61,15 @@ class Studio {
         for (const [gitDir, studio] of studioCache) {
             const { container } = studio;
 
-            if (container && container.type != 'studio') {
+            if (container && container.type !== 'studio') {
                 logger.info(`terminating studio container: ${container.id}`);
-                await container.stop();
-                await container.remove();
-                cleanupCount++;
+                try {
+                    await execDocker(['stop', container.id]);
+                    await execDocker(['rm', container.id]);
+                    cleanupCount++;
+                } catch (err) {
+                    logger.error(`Failed to stop/remove container ${container.id}: ${err.message}`);
+                }
             }
 
             studioCache.delete(gitDir);
@@ -46,23 +88,19 @@ class Studio {
         return hab;
     }
 
-    static async getDocker () {
-        if (!docker) {
-            const { DOCKER_HOST: dockerHost } = process.env;
-            const dockerHostMatch = dockerHost && dockerHost.match(/^unix:\/\/(\/.*)$/);
-            const socketPath = dockerHostMatch ? dockerHostMatch[1] : '/var/run/docker.sock';
-
-            docker = new Docker({ socketPath });
-            logger.info(`connected to docker on: ${socketPath}`);
-        }
-
-        return docker;
-    }
-
     static async isEnvironmentStudio () {
         return Boolean(process.env.STUDIO_TYPE);
     }
 
+    /**
+     * Execute a Docker CLI command.
+     * @param {Array<string>} args - The arguments to pass to the docker command.
+     * @param {Object} options - Options for child_process.spawn.
+     * @returns {Promise<string>} - Resolves with stdout data.
+     */
+    static execDocker(args, options = {}) {
+        return execDocker(args, options);
+    }
 
     static async get (gitDir) {
         const cachedStudio = studioCache.get(gitDir);
@@ -91,39 +129,9 @@ class Studio {
         }
 
 
-        // connect with Docker API
-        const docker = await Studio.getDocker();
-
-
         // pull latest studio container
         try {
-            await new Promise((resolve, reject) => {
-                docker.pull('jarvus/hologit-studio:latest', (streamErr, stream) => {
-                    if (streamErr) {
-                        reject(streamErr);
-                        return;
-                    }
-
-                    let lastStatus;
-
-                    docker.modem.followProgress(
-                        stream,
-                        (err, output) => {
-                            if (err) {
-                                reject(err);
-                            } else {
-                                resolve(output);
-                            }
-                        },
-                        event => {
-                            if (event.status != lastStatus) {
-                                logger.info(`docker pull: ${event.status}`);
-                                lastStatus = event.status;
-                            }
-                        }
-                    );
-                });
-            });
+            await execDocker(['pull', 'jarvus/hologit-studio:latest'], { $relayStdout: true, $relayStderr: true });
         } catch (err) {
             logger.error(`failed to pull studio image via docker: ${err.message}`);
         }
@@ -157,65 +165,70 @@ class Studio {
         }
 
 
-        // start studio container
-        let container;
+        // create studio container
+        let containerId;
+        let defaultUser;
         try {
-            container = await docker.createContainer({
-                Image: 'jarvus/hologit-studio',
-                Labels: {
-                    'sh.holo.studio': 'yes'
-                },
-                AttachStdin: false,
-                AttachStdout: true,
-                AttachStderr: true,
-                Env: [
-                    'STUDIO_TYPE=holo',
-                    'GIT_DIR=/git',
-                    'GIT_WORK_TREE=/hab/cache',
-                    `DEBUG=${process.env.DEBUG||''}`,
-                    `HAB_LICENSE=accept-no-persist`
-                ],
-                WorkingDir: '/git',
-                Volumes: volumesConfig,
-                HostConfig: {
-                    Binds: bindsConfig,
-                    // ExposedPorts: {
-                    //     "9229/tcp": { }
-                    // },
-                    // PortBindings: {
-                    //     '9229/tcp': [
-                    //         {
-                    //             HostIp: '0.0.0.0',
-                    //             HostPort: '9229'
-                    //         }
-                    //     ]
-                    // }
-                }
-            });
+            // Prepare environment variables
+            const envArgs = [
+                '--env', 'STUDIO_TYPE=holo',
+                '--env', 'GIT_DIR=/git',
+                '--env', 'GIT_WORK_TREE=/hab/cache',
+                '--env', `DEBUG=${process.env.DEBUG || ''}`,
+                '--env', 'HAB_LICENSE=accept-no-persist'
+            ];
+
+            // Prepare volume bindings
+            const volumeArgs = [];
+            for (const bind of bindsConfig) {
+                volumeArgs.push('-v', bind);
+            }
+
+            // Create container
+            const createArgs = [
+                'create',
+                '--label', 'sh.holo.studio=yes',
+                '--workdir', '/git',
+                ...envArgs,
+                ...volumeArgs,
+                'jarvus/hologit-studio:latest'
+            ];
+
+            containerId = await execDocker(createArgs);
+            containerId = containerId.split('\n').pop().trim(); // Get the container ID from output
 
             logger.info('starting studio container');
-            await container.start();
+            await execDocker(['start', containerId]);
 
             const { uid, gid, username } = os.userInfo();
 
             if (uid && gid && username) {
                 logger.info(`configuring container to use user: ${username}`);
-                await containerExec(container, 'adduser', '-u', `${uid}`, '-G', 'developer', '-D', username);
-                await containerExec(container, 'mkdir', '-p', `/home/${username}/.hab`);
-                await containerExec(container, 'ln', '-sf', '/hab/cache', `/home/${username}/.hab/`);
-                container.defaultUser = `${uid}`;
+                await containerExec({ id: containerId }, 'adduser', '-u', `${uid}`, '-G', 'developer', '-D', username);
+                await containerExec({ id: containerId }, 'mkdir', '-p', `/home/${username}/.hab`);
+                await containerExec({ id: containerId }, 'ln', '-sf', '/hab/cache', `/home/${username}/.hab/`);
+                if (!artifactCachePath) await containerExec({ id: containerId }, 'chown', '-R', `${uid}:${gid}`, '/hab/cache');
+                defaultUser = `${uid}`;
             }
 
-            const studio = new Studio({ gitDir, container });
+            const studio = new Studio({ gitDir, container: { id: containerId, defaultUser } });
             studioCache.set(gitDir, studio);
             return studio;
 
         } catch (err) {
-            logger.error('container failed: %o', err);
+            logger.error(`container failed: ${err.message}`);
 
-            if (container) {
-                await container.stop();
-                await container.remove();
+            if (containerId) {
+                try {
+                    await execDocker(['stop', containerId]);
+                } catch (stopErr) {
+                    logger.error(`Failed to stop container ${containerId}: ${stopErr.message}`);
+                }
+                try {
+                    await execDocker(['rm', containerId]);
+                } catch (rmErr) {
+                    logger.error(`Failed to remove container ${containerId}: ${rmErr.message}`);
+                }
             }
         }
     }
@@ -227,14 +240,14 @@ class Studio {
     }
 
     isLocal () {
-        return this.container.type == 'studio';
+        return this.container.type === 'studio';
     }
 
     /**
      * Run a command in the studio
      */
     async habExec (...command) {
-        const options = typeof command[command.length-1] == 'object'
+        const options = typeof command[command.length-1] === 'object'
             ? command.pop()
             : {};
 
@@ -274,7 +287,7 @@ class Studio {
         //         $env: { PATH }
         //     }
         // );
-        if (logger.level == 'debug') {
+        if (logger.level === 'debug') {
             command.unshift('--debug');
         }
 
@@ -286,55 +299,66 @@ class Studio {
     }
 
     async getPackage (query, { install } = { install: false }) {
-        let packagePath = await this.habExec('pkg', 'path', query, { $nullOnError: true, $relayStderr: false });
+        let packagePath;
+        try {
+            packagePath = await this.habExec('pkg', 'path', query, { $nullOnError: true, $relayStderr: false });
+        } catch (err) {
+            packagePath = null;
+        }
 
         if (!packagePath && install) {
             await this.habExec('pkg', 'install', query);
-            packagePath = await this.habExec('pkg', 'path', query);
+            try {
+                packagePath = await this.habExec('pkg', 'path', query);
+            } catch (err) {
+                packagePath = null;
+            }
         }
 
         return packagePath ? packagePath.substr(10) : null;
     }
 }
 
-
 exitHook(callback => Studio.cleanup().then(callback));
 
-
+/**
+ * Executes a command inside the specified Docker container.
+ * @param {Object} container - The container object containing at least the `id` and optionally `defaultUser`.
+ * @param  {...string} command - The command and its arguments to execute.
+ * @returns {Promise<string>} - Resolves with the command's stdout output.
+ */
 async function containerExec (container, ...command) {
-    const options = typeof command[command.length-1] == 'object'
+    const options = typeof command[command.length-1] === 'object'
         ? command.pop()
         : {};
 
     logger.info(`studio-exec: ${command.join(' ')}`);
 
-    const env = [];
+    const execArgs = ['exec'];
+
+    if (options.$user) {
+        execArgs.push('--user', options.$user);
+    } else if (container.defaultUser) {
+        execArgs.push('--user', container.defaultUser);
+    }
+
     if (options.$env) {
-        for (const key of Object.keys(options.$env)) {
-            env.push(`${key}=${options.$env[key]}`);
+        for (const [key, value] of Object.entries(options.$env)) {
+            execArgs.push('--env', `${key}=${value}`);
         }
     }
 
-    const exec = await container.exec({
-        Cmd: command,
-        AttachStdout: true,
-        AttachStderr: options.$relayStderr !== false,
-        Env: env,
-        User: `${container.defaultUser || options.$user || ''}`
-    });
-
-    const execStream = await exec.start();
+    execArgs.push(container.id, ...command);
 
-    return new Promise((resolve, reject) => {
-        const output = [];
-        const outputStream = new stream.PassThrough();
-
-        outputStream.on('data', chunk => output.push(chunk.toString('utf8')));
-        execStream.on('end', () => resolve(output.join('').trim()));
-
-        container.modem.demuxStream(execStream, outputStream, process.stderr);
-    });
+    try {
+        const output = await execDocker(execArgs, { $relayStdout: true, $relayStderr: true });
+        return output;
+    } catch (err) {
+        if (options.$nullOnError) {
+            return null;
+        }
+        throw err;
+    }
 }
 
-
 module.exports = Studio;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hologit",
-  "version": "0.43.2",
+  "version": "0.45.0",
   "description": "Hologit automates the projection of layered composite file trees based on flat, declarative plans",
   "repository": "https://github.com/EmergencePlatform/hologit",
   "main": "lib/index.js",
@@ -12,11 +12,10 @@
     "@iarna/toml": "^2.2.5",
     "async-exit-hook": "^2.0.1",
     "axios": "^1.7.7",
-    "chokidar": "^3.5.3",
+    "chokidar": "^4.0.1",
     "debounce": "^2.0.0",
-    "dockerode": "^4.0.2",
     "fb-watchman": "^2.0.1",
-    "git-client": "^1.8.3",
+    "git-client": "^1.9.3",
     "hab-client": "^1.1.3",
     "handlebars": "^4.7.6",
     "minimatch": "^10.0.1",