@scandipwa/magento-scripts 1.16.1 → 2.0.0-alpha.2

package/lib/tasks/docker/containers/container-api.js

@@ -0,0 +1,153 @@
+/* eslint-disable max-len */
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+/**
+ * @param {import('./container-api').ContainerRunOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const run = (options, execOptions = {}) => {
+    const {
+        addHost,
+        ports = [],
+        mounts = [],
+        mountVolumes = [],
+        env,
+        image,
+        restart,
+        network,
+        name,
+        entrypoint,
+        command = '',
+        healthCheck,
+        securityOptions = [],
+        tmpfs = [],
+        expose = [],
+        detach = true,
+        rm = false,
+        user
+    } = options;
+
+    const detachArg = detach && '-d';
+    const rmArg = rm && '--rm';
+    const exposeArg = expose && expose.map((e) => `--expose=${ e }`);
+    const restartArg = !rm && restart && `--restart ${ restart }`;
+    const networkArg = network && `--network ${ network }`;
+    const portsArgs = ports.map((port) => `-p ${ port }`).join(' ');
+    const mountsArgs = mounts.map((mount) => `--mount ${ mount }`).join(' ');
+    const mountVolumesArgs = mountVolumes.map((mount) => `-v ${mount}`).join(' ');
+    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env ${ key }='${ value }'`).join(' ');
+    const nameArg = name && `--name ${name}`;
+    const entrypointArg = entrypoint && `--entrypoint "${entrypoint}"`;
+    const healthCheckArg = healthCheck && Object.entries(healthCheck).map(([key, value]) => `--health-${key} '${value}'`).join(' ');
+    const securityArg = securityOptions.length > 0 && securityOptions.map((opt) => `--security-opt ${opt}`).join(' ');
+    const tmpfsArg = tmpfs.length > 0 && tmpfs.map((t) => `--tmpfs ${t}`).join(' ');
+    const userArg = user && `--user=${user}`;
+    const addHostArg = addHost && `--add-host=${addHost}`;
+
+    const dockerCommand = [
+        'docker',
+        'run',
+        detachArg,
+        rmArg,
+        nameArg,
+        networkArg,
+        restartArg,
+        portsArgs,
+        exposeArg,
+        mountsArgs,
+        mountVolumesArgs,
+        envArgs,
+        entrypointArg,
+        healthCheckArg,
+        securityArg,
+        tmpfsArg,
+        userArg,
+        addHostArg,
+        image,
+        command
+    ].filter(Boolean).join(' ');
+
+    return execAsyncSpawn(dockerCommand, execOptions);
+};
+
+/**
+ * @param {string} command
+ * @param {string} container container id or name
+ * @param {import('./container-api').ContainerExecOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const exec = (command, container, options = {}, execOptions = {}) => {
+    const {
+        env,
+        tty,
+        user,
+        workdir
+    } = options;
+    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env ${ key }='${ value }'`).join(' ');
+    const ttyArg = tty ? '--tty' : '';
+    const userArg = user ? `--user=${user}` : '';
+    const workdirArg = workdir ? `--workdir=${workdir}` : '';
+
+    const execCommand = [
+        'docker',
+        'container',
+        'exec',
+        envArgs,
+        ttyArg,
+        userArg,
+        workdirArg,
+        container,
+        command
+    ].filter(Boolean).join(' ');
+
+    return execAsyncSpawn(execCommand, execOptions);
+};
+
+/**
+ * @param {import('./container-api').ContainerLsOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const ls = async (options = {}, execOptions = {}) => {
+    const {
+        all,
+        filter,
+        format,
+        formatToJSON = false,
+        latest,
+        noTrunc,
+        quiet
+    } = options;
+
+    const allArg = all && '--all';
+    const filterArg = filter && typeof filter === 'string'
+        ? `--filter=${filter}`
+        : filter && Array.isArray(filter) && filter.every((f) => typeof f === 'string') && filter.map((f) => `--filter=${f}`).join(' ');
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+    const latestArg = latest && '--latest';
+    const noTruncArg = noTrunc && '--no-trunc';
+    const quietArg = quiet && '--quiet';
+
+    const args = [
+        allArg,
+        filterArg,
+        formatArg,
+        latestArg,
+        noTruncArg,
+        quietArg
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker container ls ${args}`, execOptions);
+        return JSON.parse(`[${result.split('\n').join(', ')}]`);
+    }
+
+    return execAsyncSpawn(`docker container ls ${args}`, execOptions);
+};
+
+module.exports = {
+    run,
+    exec,
+    ls
+};

package/lib/tasks/docker/containers/index.js

@@ -0,0 +1,19 @@
+const {
+    startContainers,
+    stopContainers,
+    pullImages,
+    statusContainers,
+    checkContainersAreRunning,
+    getContainerStatus
+} = require('./tasks');
+const containerApi = require('./container-api');
+
+module.exports = {
+    startContainers,
+    stopContainers,
+    pullImages,
+    statusContainers,
+    checkContainersAreRunning,
+    getContainerStatus,
+    containerApi
+};

package/lib/tasks/docker/containers/tasks.js

@@ -0,0 +1,215 @@
+/* eslint-disable max-len */
+const sleep = require('../../../util/sleep');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const KnownError = require('../../../errors/known-error');
+const containerApi = require('./container-api');
+const { imageApi } = require('../image');
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+const stop = async (containers) => {
+    await execAsyncSpawn(`docker container stop ${containers.join(' ')}`);
+    await execAsyncSpawn(`docker container rm ${containers.join(' ')}`);
+};
+
+const pull = async (image) => execAsyncSpawn(`docker pull ${image}`);
+
+const remoteImageReducer = (acc, val) => {
+    if (Array.isArray(val.remoteImages) && val.remoteImages.every((image) => typeof image === 'string')) {
+        return acc.concat(val.remoteImages);
+    }
+
+    return acc.concat([val.image]);
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const pullImages = () => ({
+    title: 'Pulling container images',
+    task: async ({ config: { docker } }, task) => {
+        const containers = Object.values(docker.getContainers());
+        const imagesFilter = containers
+            .reduce(remoteImageReducer, [])
+            .map((image) => `reference='${image}'`);
+
+        const existingImages = await imageApi.ls({
+            formatToJSON: true,
+            filter: imagesFilter
+        });
+
+        const missingContainerImages = containers
+            .reduce(remoteImageReducer, [])
+            .map((image) => {
+                const [repo, tag = 'latest'] = image.split(':');
+
+                return { repo, tag };
+            })
+            .filter(
+                ({ repo, tag }) => !existingImages.some(
+                    (image) => image.Repository === repo
+                    && image.Tag === tag
+                )
+            )
+            .reduce(
+                (acc, val) => acc.concat(
+                    acc.some(
+                        (c) => c.repo === val.repo
+                        && c.tag === val.tag
+                    )
+                        ? []
+                        : val
+                ),
+                []
+            );
+
+        if (missingContainerImages.length === 0) {
+            task.skip();
+            return;
+        }
+
+        return task.newListr(
+            missingContainerImages.map(({ repo, tag }) => ({
+                title: `Pulling ${ logger.style.file(`${repo}:${tag}`) } image`,
+                task: () => pull(`${repo}:${tag}`)
+            })), {
+                concurrent: true,
+                exitOnError: true
+            }
+        );
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const startContainers = () => ({
+    title: 'Starting containers',
+    task: async ({ ports, config: { docker }, debug }, task) => {
+        const containerList = (await execAsyncSpawn('docker container ls --all --format="{{.Names}}"')).split('\n');
+
+        const missingContainers = Object.values(docker.getContainers(ports)).filter(
+            ({ name }) => !containerList.includes(name)
+        );
+
+        if (missingContainers.length === 0) {
+            task.skip();
+            return;
+        }
+
+        if (debug) {
+            await Promise.all(
+                missingContainers
+                    .map((container) => {
+                        if (container.debugImage) {
+                            container.image = container.debugImage;
+                        }
+
+                        return container;
+                    }).map((container) => containerApi.run(container).then((out) => {
+                        task.output = `From ${container._}: ${out}`;
+                    }))
+            );
+
+            return;
+        }
+
+        // TODO: we might stop containers here ?
+        await Promise.all(missingContainers.map((container) => containerApi.run(container).then((out) => {
+            task.output = `From ${container._}: ${out}`;
+        })));
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const stopContainers = () => ({
+    title: 'Stopping Docker containers',
+    task: async ({ config: { baseConfig: { prefix } } }, task) => {
+        const containerList = (await execAsyncSpawn('docker container ls --all --format="{{.Names}}"')).split('\n');
+
+        const runningContainers = containerList.filter((containerName) => containerName.startsWith(prefix));
+
+        if (runningContainers.length === 0) {
+            task.skip();
+            return;
+        }
+
+        await stop(runningContainers);
+    }
+});
+
+const getContainerStatus = async (containerName) => {
+    try {
+        return JSON.parse(await execAsyncSpawn(`docker inspect --format='{{json .State}}' ${containerName}`));
+    } catch {
+        return null;
+    }
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const checkContainersAreRunning = () => ({
+    title: 'Checking container statuses',
+    task: async (ctx, task) => {
+        const { config: { docker }, ports } = ctx;
+        const containers = Object.values(docker.getContainers(ports));
+        let tries = 0;
+        while (tries < 3) {
+            const containersWithStatus = await Promise.all(
+                containers.map(async (container) => ({
+                    ...container,
+                    status: await getContainerStatus(container.name)
+                }))
+            );
+
+            if (containersWithStatus.some((c) => c.status.Status !== 'running')) {
+                if (tries === 2) {
+                    throw new KnownError(`${containersWithStatus.filter((c) => c.status.Status !== 'running').map((c) => c._).join(', ')} containers are not running! Please check container logs for more details!`);
+                } else {
+                    task.output = `${containersWithStatus.filter((c) => c.status.Status !== 'running').map((c) => c._).join(', ')} are not running, waiting if something will change...`;
+                    await sleep(2000);
+                    tries++;
+                }
+            } else {
+                break;
+            }
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const statusContainers = () => ({
+    task: async (ctx) => {
+        const { config: { docker }, ports } = ctx;
+        const containers = Object.values(docker.getContainers(ports));
+
+        ctx.containers = await Promise.all(
+            containers.map(async (container) => ({
+                ...container,
+                status: await getContainerStatus(container.name)
+            }))
+        );
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = {
+    startContainers,
+    stopContainers,
+    pullImages,
+    statusContainers,
+    checkContainersAreRunning,
+    getContainerStatus
+};

package/lib/tasks/docker/convert-legacy-volumes.js

@@ -1,10 +1,11 @@
+/* eslint-disable no-param-reassign */
 /* eslint-disable max-len */
 const { stopServices } = require('./index');
 const { getBaseConfig, getConfigFromMagentoVersion } = require('../../config');
 const getDockerConfig = require('../../config/docker');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
 const { folderName, legacyFolderName } = require('../../util/prefix');
-const { createVolume } = require('./volumes');
+const { volumeApi } = require('./volume');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -12,24 +13,28 @@ const { createVolume } = require('./volumes');
 const convertLegacyVolumes = () => ({
     task: async (ctx, task) => {
         const { config: { overridenConfiguration } } = ctx;
-        const newDockerConfig = await getDockerConfig(overridenConfiguration, getBaseConfig(process.cwd(), folderName));
+        const newDockerConfig = await getDockerConfig(ctx, overridenConfiguration, getBaseConfig(process.cwd(), folderName));
 
-        const newVolumeNames = Object.values(newDockerConfig.volumes).filter((v) => !v.opts).map(({ name }) => name);
+        const newVolumeNames = Object.values(newDockerConfig.volumes).filter((v) => !v.opt).map(({ name }) => name);
 
-        const existingVolumes = (await execAsyncSpawn('docker volume ls -q')).split('\n');
+        const existingVolumes = await volumeApi.ls({ formatToJSON: true });
 
         if (newVolumeNames.every((v) => existingVolumes.includes(v))) {
             return;
         }
 
-        const legacyDockerConfig = await getDockerConfig(overridenConfiguration, getBaseConfig(process.cwd(), legacyFolderName));
-        const legacyVolumeNames = Object.values(legacyDockerConfig.volumes).filter((v) => !v.opts).map(({ name }) => name);
+        const legacyDockerConfig = await getDockerConfig(ctx, overridenConfiguration, getBaseConfig(process.cwd(), legacyFolderName));
+        const legacyVolumeNames = Object.values(legacyDockerConfig.volumes).filter((v) => !v.opt).map(({ name }) => name);
 
         if (
-            newVolumeNames.every((name) => !existingVolumes.includes(name))
-            && legacyVolumeNames.every((name) => existingVolumes.includes(name))
+            newVolumeNames.every((name) => !existingVolumes.some((v) => v.Name === name))
+            && legacyVolumeNames.every((name) => existingVolumes.some((v) => v.Name === name))
         ) {
-            ctx.config = await getConfigFromMagentoVersion(ctx.magentoVersion, process.cwd(), legacyFolderName);
+            ctx.config = await getConfigFromMagentoVersion(ctx, {
+                magentoVersion: ctx.magentoVersion,
+                projectPath: process.cwd(),
+                prefix: legacyFolderName
+            });
 
             return task.newListr([
                 stopServices(),
@@ -42,7 +47,7 @@ const convertLegacyVolumes = () => ({
                             const legacyVolumeConfig = legacyDockerConfig.volumes[volumeName];
 
                             subTask.output = `Creating volume ${volumeConfig.name}...`;
-                            await createVolume(volumeConfig);
+                            await volumeApi.create(volumeConfig);
                             subTask.output = `Copying data from ${legacyVolumeConfig.name} to ${volumeConfig.name}...`;
                             await execAsyncSpawn(
                                 `docker run --rm -v ${legacyVolumeConfig.name}:/from:ro -v ${volumeConfig.name}:/to alpine ash -c "cd /from; cp -av . /to"`, {