@scandipwa/magento-scripts 1.14.1-alpha.2 → 1.14.1-alpha.5

package/lib/tasks/requirements/docker/install.js

@@ -3,13 +3,16 @@ const { execCommandTask } = require('../../../util/exec-async-command');
 const installDependenciesTask = require('../../../util/install-dependencies-task');
 const executeSudoCommand = require('../../../util/execute-sudo-command');
 
+const downloadDockerInstallScriptCommand = () => execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh');
+const runDockerInstallScriptCommand = () => executeSudoCommand('sudo sh get-docker.sh');
+const enableAndStartDockerCommand = () => executeSudoCommand('sudo systemctl enable docker --now');
+
 const postInstallSteps = [
     executeSudoCommand('[ $(getent group docker) ] && sudo groupadd docker', {
         withCode: true
     }),
     executeSudoCommand(`sudo usermod -aG docker ${process.env.USER}`)
 ];
-
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
@@ -24,26 +27,23 @@ const installDocker = () => ({
                     platform: 'Arch Linux',
                     dependenciesToInstall: ['docker']
                 }),
-                executeSudoCommand('sudo systemctl start docker.service'),
-                executeSudoCommand('sudo systemctl enable docker.service'),
+                enableAndStartDockerCommand(),
                 ...postInstallSteps
             ]);
         }
         case 'Fedora':
         case 'CentOS': {
             return task.newListr([
-                execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh'),
-                executeSudoCommand('sudo sh get-docker.sh'),
-                executeSudoCommand('sudo systemctl start docker'),
-                executeSudoCommand('sudo systemctl enable docker')
+                downloadDockerInstallScriptCommand(),
+                runDockerInstallScriptCommand(),
+                enableAndStartDockerCommand()
             ]);
         }
         case 'Ubuntu': {
             return task.newListr([
-                execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh'),
-                executeSudoCommand('sudo sh get-docker.sh'),
-                executeSudoCommand('sudo service docker start'),
-                executeSudoCommand('sudo systemctl enable docker.service'),
+                downloadDockerInstallScriptCommand(),
+                runDockerInstallScriptCommand(),
+                enableAndStartDockerCommand(),
                 ...postInstallSteps
             ]);
         }

package/lib/tasks/requirements/docker/running-status.js

@@ -0,0 +1,137 @@
+const os = require('os');
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const getIsWsl = require('../../../util/is-wsl');
+const pathExists = require('../../../util/path-exists');
+const sleep = require('../../../util/sleep');
+const { systemctlControl } = require('../../../util/systemctl');
+
+const pathToDockerApplication = '/Applications/Docker.app';
+
+const getDockerVersion = () => execAsyncSpawn('docker version --format {{.Server.Version}}', {
+    withCode: true
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatusMacOS = () => ({
+    title: 'Checking Docker status on MacOS',
+    task: async (ctx, task) => {
+        const { result, code } = await getDockerVersion();
+
+        if (code !== 0 && result.includes('Is the docker daemon running?')) {
+            const dockerOpenAppConfirmation = await task.prompt({
+                type: 'Confirm',
+                message: 'Looks like Docker is not running, would you like us to open a Docker for Mac application and wait for it to start up?'
+            });
+
+            if (dockerOpenAppConfirmation && await pathExists(pathToDockerApplication)) {
+                await execAsyncSpawn(`open ${pathToDockerApplication}`);
+                let ready = false;
+                let attempts = 0;
+                while (!ready) {
+                    if (attempts > 24 && !ready) {
+                        throw new Error('Docker haven\'t started in 2 mins, exiting...');
+                    }
+                    try {
+                        const { code: startupCode } = await getDockerVersion();
+                        if (startupCode !== 0) {
+                            task.output = `Waiting for Docker to startup for ${attempts * 5} seconds...`;
+                            attempts++;
+                            await sleep(5000);
+                        } else {
+                            ready = true;
+                        }
+                    } catch (e) {
+                        //
+                    }
+                }
+
+                return;
+            }
+
+            task.skip('User skipped running Docker');
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatusWSL = () => ({
+    title: 'Checking Docker status on Windows WSL',
+    task: async () => {
+        const { result, code } = await getDockerVersion();
+
+        if (code !== 0 && result.includes('Is the docker daemon running?')) {
+            throw new Error(`Docker is not running!
+
+Please open Docker Desktop application for Windows and make sure that Docker is running. Then you can try again!`);
+        }
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatusLinux = () => ({
+    title: 'Checking Docker status on Linux',
+    task: async (ctx, task) => {
+        const dockerService = systemctlControl('docker');
+
+        const isRunning = await dockerService.isRunning();
+        const isEnabled = await dockerService.isEnabled();
+
+        if (!isEnabled && !isRunning) {
+            const dockerStartConfirmation = await task.prompt({
+                type: 'Confirm',
+                message: `Looks like Docker is not enabled and not running, would you like to enable and run it?
+
+This action requires root privileges.`
+            });
+
+            if (dockerStartConfirmation) {
+                await dockerService.enableAndStart();
+
+                return;
+            }
+            task.skip('User skipped running Docker');
+        } else if (!isRunning) {
+            const dockerStartConfirmation = await task.prompt({
+                type: 'Confirm',
+                message: `Looks like Docker is not running, would you like to run it?
+
+This action requires root privileges.`
+            });
+
+            if (dockerStartConfirmation) {
+                await dockerService.start();
+
+                return;
+            }
+            task.skip('User skipped running Docker');
+        }
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatus = () => ({
+    title: 'Checking Docker status',
+    task: async (ctx, task) => {
+        if (os.platform() === 'darwin') {
+            return task.newListr(checkDockerStatusMacOS());
+        }
+        if (!await getIsWsl()) {
+            return task.newListr(checkDockerStatusLinux());
+        }
+
+        return task.newListr(checkDockerStatusWSL());
+    }
+});
+
+module.exports = checkDockerStatus;

package/lib/tasks/requirements/docker/version.js

@@ -13,6 +13,8 @@ const getDockerVersion = () => ({
             const dockerVersion = result.split('').filter((c) => /[\d.]/i.test(c)).join('') || result;
 
             ctx.dockerVersion = dockerVersion;
+        } else {
+            throw new Error(`Got unexpected result during Docker version retrieval!\n\n${ result }`);
         }
     }
 });

package/lib/tasks/requirements/index.js

@@ -13,17 +13,17 @@ const checkRequirements = () => ({
     task: (ctx, task) => task.newListr([
         // checking if user is on supported platform
         checkPlatform(),
+        // check the Docker installation
+        checkDocker(),
+        // check for Node.js version
+        checkNodeVersion(),
         // check the PHPBrew installation
         checkPHPbrew(),
         // check installed PHP version
         checkPHPVersion(),
-        // check the Docker installation
-        checkDocker(),
         // check for COMPOSER_AUTH or auth.json
         // localAuthJson(),
-        checkComposer(),
-        // check for Node.js version
-        checkNodeVersion()
+        checkComposer()
     ], {
         concurrent: false,
         exitOnError: true,

package/lib/tasks/requirements/php-version.js

@@ -99,7 +99,7 @@ const checkPHPVersion = () => ({
     task: async (ctx, task) => {
         const phpVersionResponse = await execAsyncSpawn('php --version');
 
-        const phpVersionResponseResult = phpVersionResponse.match(/PHP\s(\d\.\d\.\d)/i);
+        const phpVersionResponseResult = phpVersionResponse.match(/PHP\s(\d+\.\d+\.\d+)/i);
 
         if (phpVersionResponseResult && phpVersionResponseResult.length > 0) {
             const phpVersion = phpVersionResponseResult[1];
@@ -123,6 +123,8 @@ To fix that we will build special PHP version that will be used by PHPBrew, plea
                     );
                 }
             }
+
+            task.title = `Using PHP version ${phpVersion} in system`;
         }
     }
 });

package/lib/tasks/start.js

@@ -29,7 +29,6 @@ const convertLegacyVolumes = require('./docker/convert-legacy-volumes');
 const enableMagentoComposerPlugins = require('./magento/enable-magento-composer-plugins');
 const getIsWsl = require('../util/is-wsl');
 const checkForXDGOpen = require('../util/xdg-open-exists');
-const { getInstanceMetadata, constants: { WEB_LOCATION_TITLE } } = require('../util/instance-metadata');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
@@ -127,6 +126,7 @@ const configureProject = () => ({
  */
 const finishProjectConfiguration = () => ({
     title: 'Finishing project configuration',
+    skip: ({ skipSetup }) => skipSetup,
     task: (ctx, task) => task.newListr([
         {
             skip: (ctx) => !ctx.importDb,
@@ -144,16 +144,10 @@ const finishProjectConfiguration = () => ({
                 });
             }
         },
-        {
-            title: 'Setting up themes',
-            skip: (ctx) => !ctx.magentoFirstInstall,
-            task: (subCtx, subTask) => subTask.newListr(
-                setupThemes()
-            )
-        }
+        setupThemes()
     ], {
         rendererOptions: {
-            collapse: true
+            collapse: false
         }
     })
 });
@@ -190,11 +184,8 @@ const start = () => ({
 
                     return false;
                 },
-                task: (ctx) => {
-                    const instanceMetadata = getInstanceMetadata(ctx);
-                    const locationOnTheWeb = instanceMetadata.frontend.find(({ title }) => title === WEB_LOCATION_TITLE);
-
-                    openBrowser(locationOnTheWeb.text);
+                task: ({ ports, config: { overridenConfiguration: { host, ssl } } }) => {
+                    openBrowser(`${ssl.enabled ? 'https' : 'http'}://${host}${ssl.enabled || ports.app === 80 ? '' : `:${ports.app}`}/`);
                 },
                 options: {
                     showTimer: false

package/lib/tasks/status/index.js

@@ -91,7 +91,7 @@ const prettyStatus = async (ctx) => {
             .addLine(`Image: ${logger.style.file(container.image)}`)
             .addLine(`Network: ${logger.style.link(container.network)}`);
 
-        if (container.ports.length > 0) {
+        if (container.ports && container.ports.length > 0) {
             block.addLine('Port forwarding:');
             container.ports.forEach((port) => {
                 const { host, hostPort, containerPort } = parsePort(port);

package/lib/tasks/theme/build-theme.js

@@ -1,7 +1,8 @@
 const path = require('path');
 const pathExists = require('../../util/path-exists');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
-const shouldUseYarn = require('@scandipwa/scandipwa-dev-utils/should-use-yarn');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const matchFilesystem = require('../../util/match-filesystem');
 
 /**
  * @type {(theme: import('../../../typings/theme').Theme) => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -13,15 +14,32 @@ const buildTheme = ({ themePath }) => ({
 
         if (!await pathExists(path.join(themePath, 'node_modules'))) {
             task.output = 'Installing theme dependencies';
-            await execAsyncSpawn(shouldUseYarn() ? 'yarn' : 'npm i', {
-                cwd: path.join(process.cwd(), themePath),
-                callback: !verbose ? undefined : (t) => {
-                    task.output = t;
-                }
-            });
+            const commandToInstallDependencies = await pathExists(path.join(themePath, 'package-lock.json'))
+                ? 'npm ci'
+                : 'npm i';
+
+            try {
+                await execAsyncSpawn(commandToInstallDependencies, {
+                    cwd: path.join(process.cwd(), themePath),
+                    callback: !verbose ? undefined : (t) => {
+                        task.output = t;
+                    }
+                });
+            } catch (e) {
+                throw new Error(`We were unable to install theme dependencies in ${themePath} using ${logger.style.code(commandToInstallDependencies)} command!
+If you have ${logger.style.file('package-lock.json')} in theme directory make sure it's up to date with ${logger.style.file('package.json')} file content.`);
+            }
         }
 
-        if (await pathExists(path.join(themePath, 'magento', 'Magento_Theme'))) {
+        const magentoThemeDirPath = path.join(themePath, 'magento', 'Magento_Theme');
+        const isMagentoThemeDirMatching = await matchFilesystem(magentoThemeDirPath, {
+            templates: true,
+            web: [
+                'static'
+            ]
+        });
+
+        if (isMagentoThemeDirMatching) {
             task.skip();
             return;
         }

package/lib/tasks/theme/install-theme.js

@@ -1,13 +1,23 @@
+const path = require('path');
+const getJsonfileData = require('../../util/get-jsonfile-data');
 const runComposerCommand = require('../../util/run-composer');
 
 /**
  * @type {(theme: import('../../../typings/theme').Theme) => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const installTheme = ({ composerData }) => ({
+const installTheme = (theme) => ({
     title: 'Installing theme in composer.json',
-    task: async ({ magentoVersion, verbose = false }, task) => {
+    task: async (ctx, task) => {
+        const { magentoVersion, verbose = false } = ctx;
+        const composerJsonData = await getJsonfileData(path.join(process.cwd(), 'composer.json'));
+
+        if (composerJsonData.require[theme.composerData.name]) {
+            task.skip();
+            return;
+        }
+
         try {
-            await runComposerCommand(`require ${composerData.name}`, {
+            await runComposerCommand(`require ${theme.composerData.name}`, {
                 magentoVersion,
                 callback: !verbose ? undefined : (t) => {
                     task.output = t;
@@ -16,9 +26,11 @@ const installTheme = ({ composerData }) => ({
         } catch (e) {
             throw new Error(
                 `Unexpected error while installing theme.
-                See ERROR log below.\n\n${e}`
+See ERROR log below.\n\n${e}`
             );
         }
+
+        ctx.isSetupUpgradeNeeded = true;
     },
     options: {
         bottomBar: 10

package/lib/tasks/theme/link-theme.js

@@ -1,6 +1,6 @@
 const symlinkTheme = require('./symlink-theme');
 const installTheme = require('./install-theme');
-const disablePageCache = require('../magento/setup-magento/disable-page-cache');
+const disableFullPageCache = require('../magento/setup-magento/disable-full-page-cache');
 const disablePageBuilder = require('../magento/setup-magento/disable-page-builder');
 const buildTheme = require('./build-theme');
 const upgradeMagento = require('../magento/setup-magento/upgrade-magento');
@@ -53,7 +53,7 @@ const linkTheme = () => ({
             updateEnvPHP(),
             setupPersistedQuery(),
             upgradeMagento(),
-            disablePageCache(),
+            disableFullPageCache(),
             ...(isPageBuilderInstalled && Number(isPagebuilderEnabled) ? [disablePageBuilder()] : []),
             buildTheme(theme)
         ]);

package/lib/tasks/theme/setup-persisted-query.js

@@ -8,7 +8,7 @@ const runMagentoCommand = require('../../util/run-magento');
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const persistedQuerySetup = () => ({
-    title: 'Setting up redis configuration for persisted queries',
+    title: 'Setting up Redis configuration for persisted queries',
     task: async (ctx, task) => {
         const { ports, magentoVersion, verbose = false } = ctx;
         const composerLockData = await getJsonfileData(path.join(process.cwd(), 'composer.lock'));
@@ -29,8 +29,8 @@ const persistedQuerySetup = () => ({
         if (
             persistedQueryConfig
             && persistedQueryConfig.redis
-            && persistedQueryConfig.redis.port === ports.redis
-            && persistedQueryConfig.redis.localhost === 'localhost'
+            && persistedQueryConfig.redis.port === `${ ports.redis }`
+            && persistedQueryConfig.redis.host === 'localhost'
         ) {
             task.skip();
             return;

package/lib/tasks/theme/setup-themes.js

@@ -5,13 +5,14 @@ const symlinkTheme = require('./symlink-theme');
 const installTheme = require('./install-theme');
 const setupPersistedQuery = require('./setup-persisted-query');
 const upgradeMagento = require('../magento/setup-magento/upgrade-magento');
-const disablePageCache = require('../magento/setup-magento/disable-page-cache');
+const disableFullPageCache = require('../magento/setup-magento/disable-full-page-cache');
 const buildTheme = require('./build-theme');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const setupThemes = () => ({
+    title: 'Setting up themes',
     task: async (ctx, task) => {
         const { config: { baseConfig } } = ctx;
         const composerData = await getJsonfileData(path.join(baseConfig.magentoDir, 'composer.json'));
@@ -80,7 +81,7 @@ const setupThemes = () => ({
                 ])
             })).concat([
                 upgradeMagento(),
-                disablePageCache(),
+                disableFullPageCache(),
                 setupPersistedQuery()
             ])
         );

package/lib/tasks/theme/symlink-theme.js

@@ -1,13 +1,26 @@
+const path = require('path');
+const getJsonfileData = require('../../util/get-jsonfile-data');
 const runComposerCommand = require('../../util/run-composer');
 
 /**
  * @type {(theme: import('../../../typings/theme').Theme) => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const symlinkTheme = ({ absoluteThemePath }) => ({
+const symlinkTheme = (theme) => ({
     title: 'Setting symbolic link for theme in composer.json',
-    task: async ({ magentoVersion, verbose = false }, task) => {
+    task: async (ctx, task) => {
+        const { magentoVersion, verbose = false } = ctx;
+        const composerJsonData = await getJsonfileData(path.join(process.cwd(), 'composer.json'));
+        const repositories = Array.isArray(composerJsonData.repositories)
+            ? composerJsonData.repositories.reduce((acc, repo, index) => ({ ...acc, [`${index}`]: repo }), {})
+            : composerJsonData.repositories;
+
+        if (Object.values(repositories).some((value) => value.url === theme.themePath)) {
+            task.skip();
+            return;
+        }
+
         try {
-            await runComposerCommand(`config repo.scandipwa path ${absoluteThemePath}`, {
+            await runComposerCommand(`config repo.scandipwa path ${theme.absoluteThemePath}`, {
                 magentoVersion,
                 callback: !verbose ? undefined : (t) => {
                     task.output = t;
@@ -19,6 +32,8 @@ const symlinkTheme = ({ absoluteThemePath }) => ({
                 See ERROR log above.\n\n${e}`
             );
         }
+
+        ctx.isSetupUpgradeNeeded = true;
     }
 });
 

package/lib/util/config-file-validator.js

@@ -72,6 +72,15 @@ const nginxConfigurationSchema = Joi.object({
     configTemplate: Joi.string().optional().custom(fileExistsValidator)
 });
 
+/**
+ * @type {Joi.ObjectSchema<import('../../typings').NginxConfiguration>}
+ */
+const varnishConfigurationSchema = Joi.object({
+    enabled: Joi.boolean().optional(),
+    version: Joi.string().optional(),
+    configTemplate: Joi.string().optional().custom(fileExistsValidator)
+});
+
 /**
  * @type {Joi.ObjectSchema<import('../../typings').ServiceWithVersion>}
  */
@@ -101,7 +110,8 @@ const configurationSchema = Joi.object({
     mysql: serviceConfigurationSchema.optional(),
     elasticsearch: serviceConfigurationSchema.optional(),
     redis: serviceConfigurationSchema.optional(),
-    composer: composerConfigurationSchema.optional()
+    composer: composerConfigurationSchema.optional(),
+    varnish: varnishConfigurationSchema.optional()
 });
 
 /**

package/lib/util/config-php-json.js

@@ -0,0 +1,19 @@
+const path = require('path');
+const runPhpCode = require('./run-php');
+
+const configPhpToJson = async (projectPath = process.cwd(), { magentoVersion }) => {
+    const { code, result } = await runPhpCode(`-r "echo json_encode(require '${path.join(projectPath, 'app', 'etc', 'config.php')}');"`, {
+        magentoVersion
+    });
+
+    if (code !== 0) {
+        throw new Error(result);
+    }
+    try {
+        return JSON.parse(result);
+    } catch (e) {
+        throw new Error(`Ooops! Something went wrong when trying to parse app/etc/config.php file!\n\n${e}\n\nFile result: ${result}`);
+    }
+};
+
+module.exports = configPhpToJson;

package/lib/util/instance-metadata.js

@@ -70,11 +70,5 @@ const getInstanceMetadata = (ctx) => {
 };
 
 module.exports = {
-    getInstanceMetadata,
-    constants: {
-        WEB_LOCAL_LOCATION_TITLE,
-        WEB_LOCATION_TITLE,
-        WEB_ADMIN_LOCATION_TITLE,
-        WEB_ADMIN_CREDENTIALS_TITLE
-    }
+    getInstanceMetadata
 };

package/lib/util/is-running-root.js

@@ -0,0 +1,3 @@
+const isRunningRoot = () => process.getuid() === 0; // UID 0 is always root
+
+module.exports = isRunningRoot;

package/lib/util/match-filesystem.js

@@ -13,7 +13,8 @@ const matchFilesystem = async (cwd, structure) => {
             .every((value) => value === true);
 
         return ok;
-    } if (typeof structure === 'object') {
+    }
+    if (typeof structure === 'object') {
         const ok = (await Promise.all(Object.entries(structure).map(([key, value]) => {
             if (typeof value === 'boolean') {
                 return pathExists(path.join(cwd, key));

package/lib/util/php-task.js

@@ -1,7 +1,10 @@
 const runPhpCode = require('./run-php');
 
 /**
- * @type {(command: string, options: { noTitle: boolean }) => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
+ * @type {(
+ * command: string,
+ * options: { noTitle: boolean, env: Record<string, string> }
+ * ) => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const phpTask = (command, options = {}) => ({
     title: !options.noTitle ? `Running command 'php ${command}` : undefined,
@@ -10,7 +13,8 @@ const phpTask = (command, options = {}) => ({
             task.output = t;
         },
         throwNonZeroCode: true,
-        magentoVersion
+        magentoVersion,
+        env: options.env
     })
 });
 

package/lib/util/run-php.js

@@ -10,6 +10,7 @@ const { getConfigFromMagentoVersion, defaultConfiguration } = require('../config
  * @param {() => {}} options.callback
  * @param {Boolean} options.throwNonZeroCode Throw if command return non 0 code.
  * @param {String} options.magentoVersion Magento version for config
+ * @param {Record<string, string>} options.env Environment variables
  */
 const runPhpCode = async (command, options = {}) => {
     const {
@@ -17,7 +18,12 @@ const runPhpCode = async (command, options = {}) => {
         magentoVersion = defaultConfiguration.magentoVersion
     } = options;
     const { php } = await getConfigFromMagentoVersion(magentoVersion);
-    const { code, result } = await execAsyncSpawn(`${php.binPath} -c ${php.iniPath} ${command}`, {
+    let spawnCommand = `${php.binPath} -c ${php.iniPath} ${command}`;
+    if (options.env && Object.keys(options.env).length > 0) {
+        const env = Object.entries(options.env).map(([key, value]) => `${key}=${value}`).join(' ');
+        spawnCommand = `${env} ${spawnCommand}`;
+    }
+    const { code, result } = await execAsyncSpawn(spawnCommand, {
         ...options,
         withCode: true
     });

package/lib/util/systemctl.js

@@ -0,0 +1,46 @@
+const { execAsyncSpawn } = require('./exec-async-command');
+
+/**
+ * @param {String} cmd
+ * @param {String} serviceName
+ * @param {{ now: boolean }} options
+ */
+const run = (cmd, serviceName, options = {}) => execAsyncSpawn(
+    `systemctl ${ cmd }${ serviceName ? ` ${ serviceName }` : '' }${ options.now ? ' --now' : ''}`,
+    {
+        withCode: true
+    }
+);
+
+const daemonReload = () => run('daemon-reload');
+
+const systemctlControl = (serviceName) => ({
+    disable: () => run('disable', serviceName),
+    enable: () => run('enable', serviceName),
+    enableAndStart: () => run('enable', serviceName, { now: true }),
+    restart: () => run('restart', serviceName),
+    start: () => run('start', serviceName),
+    stop: () => run('stop', serviceName),
+    isEnabled: async () => {
+        try {
+            const { result } = await run('is-enabled', serviceName);
+            return result.includes('enabled');
+        } catch (e) {
+            return false;
+        }
+    },
+    isRunning: async () => {
+        try {
+            const { result } = await run('status', serviceName);
+
+            return result.includes('active (running)');
+        } catch (e) {
+            return false;
+        }
+    }
+});
+
+module.exports = {
+    systemctlControl,
+    daemonReload
+};