@automattic/vip 2.27.0-dev2 → 2.27.0-dev4

package/dist/lib/dev-environment/dev-environment-cli.js

@@ -37,6 +37,7 @@ var _devEnvironment = require("../constants/dev-environment");
 var _devEnvironmentCore = require("./dev-environment-core");
 var _devEnvironmentLando = require("./dev-environment-lando");
 var _userError = _interopRequireDefault(require("../user-error"));
+var _devEnvironmentConfigurationFile = require("./dev-environment-configuration-file");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * 
@@ -128,13 +129,13 @@ const verifyDNSResolution = async slug => {
 };
 const VALIDATION_STEPS = [{
   id: 'docker',
-  name: 'Check for docker installation'
+  name: 'Check for Docker installation'
 }, {
   id: 'compose',
   name: 'Check for docker-compose installation'
 }, {
   id: 'access',
-  name: 'Check access to docker for current user'
+  name: 'Check Docker connectivity'
 }, {
   id: 'dns',
   name: 'Check DNS resolution'
@@ -181,7 +182,7 @@ const validateDependencies = async (lando, slug, quiet) => {
   debug('Validation checks completed in %d ms', duration);
 };
 exports.validateDependencies = validateDependencies;
-function getEnvironmentName(options) {
+async function getEnvironmentName(options) {
   if (options.slug) {
     return options.slug;
   }
@@ -194,6 +195,12 @@ function getEnvironmentName(options) {
     const message = `This command does not support @app.env notation. Use '--slug=${appName}' to target the local environment.`;
     throw new _userError.default(message);
   }
+  const configurationFileOptions = await (0, _devEnvironmentConfigurationFile.getConfigurationFileOptions)();
+  if (configurationFileOptions.slug) {
+    const slug = configurationFileOptions.slug;
+    console.log(`Using environment ${_chalk.default.blue.bold(slug)} from ${_chalk.default.gray(_devEnvironmentConfigurationFile.CONFIGURATION_FILE_NAME)}\n`);
+    return slug;
+  }
   const envs = (0, _devEnvironmentCore.getAllEnvironmentNames)();
   if (envs.length === 1) {
     return envs[0];
@@ -205,8 +212,9 @@ function getEnvironmentName(options) {
   return DEFAULT_SLUG; // Fall back to the default slug if we don't have any, e.g. during the env creation purpose
 }
 
-function getEnvironmentStartCommand(slug) {
-  if (!slug) {
+function getEnvironmentStartCommand(slug, configurationFileOptions) {
+  const isUsingConfigurationFileSlug = Object.keys(configurationFileOptions).length > 0 && configurationFileOptions.slug === slug;
+  if (!slug || isUsingConfigurationFileSlug) {
     return `${_devEnvironment.DEV_ENVIRONMENT_FULL_COMMAND} start`;
   }
   return `${_devEnvironment.DEV_ENVIRONMENT_FULL_COMMAND} start --slug ${slug}`;
@@ -272,7 +280,7 @@ async function promptForArguments(preselectedOptions, defaultOptions, suppressPr
   }
   const instanceData = {
     wpTitle: preselectedOptions.title || (await promptForText('WordPress site title', defaultOptions.title || _devEnvironment.DEV_ENVIRONMENT_DEFAULTS.title)),
-    multisite: 'multisite' in preselectedOptions ? preselectedOptions.multisite : await promptForBoolean(multisiteText, !!multisiteDefault),
+    multisite: preselectedOptions.multisite !== undefined ? preselectedOptions.multisite : await promptForBoolean(multisiteText, !!multisiteDefault),
     elasticsearch: false,
     php: preselectedOptions.php ? resolvePhpVersion(preselectedOptions.php) : await promptForPhpVersion(resolvePhpVersion(defaultOptions.php || _devEnvironment.DEV_ENVIRONMENT_DEFAULTS.phpVersion)),
     mariadb: preselectedOptions.mariadb || defaultOptions.mariadb,
@@ -312,7 +320,7 @@ async function promptForArguments(preselectedOptions, defaultOptions, suppressPr
     const defaultValue = ((_defaultOptions$compo = defaultOptions[component]) !== null && _defaultOptions$compo !== void 0 ? _defaultOptions$compo : '').toString();
 
     // eslint-disable-next-line no-await-in-loop
-    const result = await processComponent(component, option, defaultValue);
+    const result = await processComponent(component, option, defaultValue, suppressPrompts);
     if (null === result) {
       throw new Error('processComponent() returned null');
     }
@@ -337,14 +345,14 @@ async function promptForArguments(preselectedOptions, defaultOptions, suppressPr
   debug('Instance data after prompts', instanceData);
   return instanceData;
 }
-async function processComponent(component, preselectedValue, defaultValue) {
+async function processComponent(component, preselectedValue, defaultValue, suppressPrompts = false) {
   debug(`processing a component '${component}', with preselected/default - ${preselectedValue}/${defaultValue}`);
   let result = null;
   const allowLocal = component !== 'wordpress';
   const defaultObject = defaultValue ? processComponentOptionInput(defaultValue, allowLocal) : null;
   if (preselectedValue) {
     result = processComponentOptionInput(preselectedValue, allowLocal);
-    if (allowLocal) {
+    if (allowLocal && suppressPrompts === false) {
       console.log(`${_chalk.default.green('✓')} Path to your local ${componentDisplayNames[component]}: ${preselectedValue}`);
     }
   } else {

package/dist/lib/dev-environment/dev-environment-configuration-file.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CONFIGURATION_FILE_NAME = void 0;
+exports.getConfigurationFileOptions = getConfigurationFileOptions;
+exports.mergeConfigurationFileOptions = mergeConfigurationFileOptions;
+exports.printConfigurationFile = printConfigurationFile;
+var _debug = _interopRequireDefault(require("debug"));
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _jsYaml = _interopRequireWildcard(require("js-yaml"));
+var exit = _interopRequireWildcard(require("../cli/exit"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+
+const debug = (0, _debug.default)('@automattic/vip:bin:dev-environment');
+const CONFIGURATION_FILE_NAME = '.vip-dev-env.yml';
+exports.CONFIGURATION_FILE_NAME = CONFIGURATION_FILE_NAME;
+async function getConfigurationFileOptions() {
+  const configurationFilePath = _path.default.join(process.cwd(), CONFIGURATION_FILE_NAME);
+  let configurationFileContents = '';
+  const fileExists = await _fs.default.promises.access(configurationFilePath, _fs.default.R_OK).then(() => true).catch(() => false);
+  if (fileExists) {
+    debug('Reading configuration file from:', configurationFilePath);
+    configurationFileContents = await _fs.default.promises.readFile(configurationFilePath, 'utf8');
+  } else {
+    return {};
+  }
+  let configurationFromFile = {};
+  try {
+    configurationFromFile = _jsYaml.default.load(configurationFileContents, {
+      // Only allow strings, arrays, and objects to be parsed from configuration file
+      // This causes number-looking values like `php: 8.1` to be parsed directly into strings
+      schema: _jsYaml.FAILSAFE_SCHEMA
+    });
+  } catch (err) {
+    const messageToShow = `Configuration file ${_chalk.default.grey(CONFIGURATION_FILE_NAME)} could not be loaded:\n` + err.toString();
+    exit.withError(messageToShow);
+  }
+  const configuration = await sanitizeConfiguration(configurationFromFile).catch(async ({
+    message
+  }) => {
+    exit.withError(message);
+    return {};
+  });
+  debug('Sanitized configuration from file:', configuration);
+  return configuration;
+}
+async function sanitizeConfiguration(configuration) {
+  const genericConfigurationError = `Configuration file ${_chalk.default.grey(CONFIGURATION_FILE_NAME)} is available but ` + `couldn't be loaded. Ensure there is a ${_chalk.default.cyan('configuration-version')} and ${_chalk.default.cyan('slug')} ` + `configured. For example:\n\n${_chalk.default.grey(getConfigurationFileExample())}`;
+  if (Array.isArray(configuration) || typeof configuration !== 'object') {
+    throw new Error(genericConfigurationError);
+  } else if (configuration['configuration-version'] === undefined || configuration.slug === undefined) {
+    throw new Error(genericConfigurationError);
+  }
+  const validVersions = getAllConfigurationFileVersions().map(version => _chalk.default.cyan(version)).join(', ');
+  if (!isValidConfigurationFileVersion(configuration['configuration-version'])) {
+    throw new Error(`Configuration file ${_chalk.default.grey(CONFIGURATION_FILE_NAME)} has an invalid ` + `${_chalk.default.cyan('configuration-version')} key. Update to a supported version. For example:\n\n` + _chalk.default.grey(getConfigurationFileExample()) + `\nSupported configuration versions: ${validVersions}.\n`);
+  }
+  const stringToBooleanIfDefined = value => {
+    if (value === undefined || !['true', 'false'].includes(value)) {
+      return undefined;
+    }
+    return value === 'true';
+  };
+  const sanitizedConfiguration = {
+    'configuration-version': configuration['configuration-version'],
+    slug: configuration.slug,
+    title: configuration.title,
+    multisite: stringToBooleanIfDefined(configuration.multisite),
+    php: configuration.php,
+    wordpress: configuration.wordpress,
+    'mu-plugins': configuration['mu-plugins'],
+    'app-code': configuration['app-code'],
+    elasticsearch: stringToBooleanIfDefined(configuration.elasticsearch),
+    phpmyadmin: stringToBooleanIfDefined(configuration.phpmyadmin),
+    xdebug: stringToBooleanIfDefined(configuration.xdebug),
+    mailhog: stringToBooleanIfDefined(configuration.mailhog)
+  };
+
+  // Remove undefined values
+  Object.keys(sanitizedConfiguration).forEach(key => sanitizedConfiguration[key] === undefined && delete sanitizedConfiguration[key]);
+  return sanitizedConfiguration;
+}
+function mergeConfigurationFileOptions(preselectedOptions, configurationFileOptions) {
+  // configurationFileOptions holds different parameters than present in
+  // preselectedOptions like "slug", and friendly-named parameters (e.g.
+  // 'app-code' vs 'appCode'). Selectively merge configurationFileOptions
+  // parameters into preselectedOptions.
+  const configurationFileInstanceOptions = {
+    title: configurationFileOptions.title,
+    multisite: configurationFileOptions.multisite,
+    php: configurationFileOptions.php,
+    wordpress: configurationFileOptions.wordpress,
+    muPlugins: configurationFileOptions['mu-plugins'],
+    appCode: configurationFileOptions['app-code'],
+    elasticsearch: configurationFileOptions.elasticsearch,
+    phpmyadmin: configurationFileOptions.phpmyadmin,
+    xdebug: configurationFileOptions.xdebug,
+    mailhog: configurationFileOptions.mailhog
+  };
+  const mergedOptions = {};
+  Object.keys(configurationFileInstanceOptions).forEach(key => {
+    // preselectedOptions (supplied from command-line) override configurationFileOptions
+    if (preselectedOptions[key] !== undefined) {
+      mergedOptions[key] = preselectedOptions[key];
+    } else if (configurationFileInstanceOptions[key] !== undefined) {
+      mergedOptions[key] = configurationFileInstanceOptions[key];
+    }
+  });
+  return mergedOptions;
+}
+function printConfigurationFile(configurationOptions) {
+  const isConfigurationFileEmpty = Object.keys(configurationOptions).length === 0;
+  if (isConfigurationFileEmpty) {
+    return;
+  }
+
+  // Customized formatter because Lando's printTable() automatically uppercases keys
+  // which may be confusing for YAML configuration
+  const settingLines = [];
+  for (const [key, value] of Object.entries(configurationOptions)) {
+    settingLines.push(`${_chalk.default.cyan(key)}: ${String(value)}`);
+  }
+  console.log(settingLines.join('\n') + '\n');
+}
+const CONFIGURATION_FILE_VERSIONS = ['0.preview-unstable'];
+function getAllConfigurationFileVersions() {
+  return CONFIGURATION_FILE_VERSIONS;
+}
+function getLatestConfigurationFileVersion() {
+  return CONFIGURATION_FILE_VERSIONS[CONFIGURATION_FILE_VERSIONS.length - 1];
+}
+function isValidConfigurationFileVersion(version) {
+  return CONFIGURATION_FILE_VERSIONS.includes(version);
+}
+function getConfigurationFileExample() {
+  return `configuration-version: ${getLatestConfigurationFileVersion()}
+slug: dev-site
+php: 8.0
+wordpress: 6.0
+app-code: ./site-code
+mu-plugins: image
+multisite: false
+phpmyadmin: true
+elasticsearch: true
+xdebug: true
+`;
+}

package/dist/lib/dev-environment/dev-environment-core.js

@@ -17,6 +17,7 @@ exports.printAllEnvironmentsInfo = printAllEnvironmentsInfo;
 exports.printEnvironmentInfo = printEnvironmentInfo;
 exports.readEnvironmentData = readEnvironmentData;
 exports.resolveImportPath = resolveImportPath;
+exports.showLogs = showLogs;
 exports.startEnvironment = startEnvironment;
 exports.stopEnvironment = stopEnvironment;
 exports.updateEnvironment = updateEnvironment;
@@ -200,6 +201,18 @@ function parseComponentForInfo(component) {
   }
   return component.tag || '[demo-image]';
 }
+async function showLogs(lando, slug, options = {}) {
+  debug('Will display logs command on env', slug, 'with options', options);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+  if (options.service) {
+    const appInfo = await (0, _devEnvironmentLando.landoInfo)(lando, instancePath);
+    if (!appInfo.services.includes(options.service)) {
+      throw new _userError.default(`Service '${options.service}' not found. Please choose from one: ${appInfo.services}`);
+    }
+  }
+  return (0, _devEnvironmentLando.landoLogs)(lando, instancePath, options);
+}
 async function printEnvironmentInfo(lando, slug, options) {
   debug('Will get info for an environment', slug);
   const instancePath = getEnvironmentPath(slug);

package/dist/lib/dev-environment/dev-environment-lando.js

@@ -9,7 +9,9 @@ exports.isEnvUp = isEnvUp;
 exports.landoDestroy = landoDestroy;
 exports.landoExec = landoExec;
 exports.landoInfo = landoInfo;
+exports.landoLogs = landoLogs;
 exports.landoRebuild = landoRebuild;
+exports.landoShell = landoShell;
 exports.landoStart = landoStart;
 exports.landoStop = landoStop;
 exports.validateDockerAccess = validateDockerAccess;
@@ -42,7 +44,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  */
 const DEBUG_KEY = '@automattic/vip:bin:dev-environment';
 const debug = (0, _debug.default)(DEBUG_KEY);
-
 /**
  * @return {Promise<object>} Lando configuration
  */
@@ -124,7 +125,6 @@ async function landoRecovery(lando, instancePath, error) {
   console.error(_chalk.default.green('Recovery successful, trying to initialize again...'));
   try {
     const app = lando.getApp(instancePath);
-    addHooks(app, lando);
     await app.init();
     return app;
   } catch (initError) {
@@ -142,7 +142,6 @@ async function getLandoApplication(lando, instancePath) {
   let app;
   try {
     app = lando.getApp(instancePath);
-    await addHooks(app, lando);
     await app.init();
   } catch (error) {
     app = await landoRecovery(lando, instancePath, error);
@@ -152,24 +151,8 @@ async function getLandoApplication(lando, instancePath) {
 }
 async function bootstrapLando() {
   const lando = new _lando.default(await getLandoConfig());
-  await lando.bootstrap();
-  return lando;
-}
-async function landoStart(lando, instancePath) {
-  debug('Will start lando app on path:', instancePath);
-  const app = await getLandoApplication(lando, instancePath);
-  await app.start();
-}
-async function landoRebuild(lando, instancePath) {
-  debug('Will rebuild lando app on path:', instancePath);
-  const app = await getLandoApplication(lando, instancePath);
-  await ensureNoOrphantProxyContainer(lando);
-  await app.rebuild();
-}
-async function addHooks(app, lando) {
-  app.events.on('post-start', 1, () => healthcheckHook(app, lando));
   lando.events.once('pre-engine-build', async data => {
-    const instanceData = (0, _devEnvironmentCore.readEnvironmentData)(app._name);
+    const instanceData = (0, _devEnvironmentCore.readEnvironmentData)(data.name);
     let registryResolvable = false;
     try {
       registryResolvable = (await _dns.default.promises.lookup('ghcr.io')).address || false;
@@ -178,70 +161,42 @@ async function addHooks(app, lando) {
       debug('Registry ghcr.io is not resolvable, image pull might be broken.');
       registryResolvable = false;
     }
-    data.opts.pull = registryResolvable && instanceData.pullAfter < Date.now();
-    if (Array.isArray(data.opts.pullable) && Array.isArray(data.opts.local) && data.opts.local.length === 0 && !data.opts.pull) {
+    const pull = registryResolvable && (instanceData.pullAfter || 0) < Date.now();
+    if (Array.isArray(data.opts.pullable) && Array.isArray(data.opts.local) && data.opts.local.length === 0 && !pull) {
+      // Setting `data.opts.pullable` to an empty array prevents Lando from pulling images with `docker pull`.
+      // Note that if some of the images are not available, they will still be pulled by `docker-compose`.
       data.opts.local = data.opts.pullable;
       data.opts.pullable = [];
     }
-    if (data.opts.pull || !instanceData.pullAfter) {
+    if (pull || !instanceData.pullAfter) {
       instanceData.pullAfter = Date.now() + 7 * 24 * 60 * 60 * 1000;
-      (0, _devEnvironmentCore.writeEnvironmentData)(app._name, instanceData);
+      (0, _devEnvironmentCore.writeEnvironmentData)(data.name, instanceData);
     }
   });
+  await lando.bootstrap();
+  return lando;
 }
-const healthChecks = {
-  database: 'mysql -uroot --silent --execute "SHOW DATABASES;"',
-  elasticsearch: "curl -s --noproxy '*' -XGET localhost:9200",
-  php: '[[ -f /wp/wp-includes/pomo/mo.php ]]'
-};
-async function healthcheckHook(app, lando) {
-  const now = new Date();
-  try {
-    await lando.Promise.retry(async () => {
-      const list = await lando.engine.list({
-        project: app.project
-      });
-      const notHealthyContainers = [];
-      const checkPromises = [];
-      const containerOrder = [];
-      for (const container of list) {
-        if (healthChecks[container.service]) {
-          debug(`Testing ${container.service}: ${healthChecks[container.service]}`);
-          containerOrder.push(container);
-          checkPromises.push(app.engine.run({
-            id: container.id,
-            cmd: healthChecks[container.service],
-            compose: app.compose,
-            project: app.project,
-            opts: {
-              silent: true,
-              noTTY: true,
-              cstdio: 'pipe',
-              services: [container.service]
-            }
-          }));
-        }
-      }
-      const results = await Promise.allSettled(checkPromises);
-      results.forEach((result, index) => {
-        if (result.status === 'rejected') {
-          debug(`${containerOrder[index].service} Health check failed`);
-          notHealthyContainers.push(containerOrder[index]);
-        }
-      });
-      if (notHealthyContainers.length) {
-        notHealthyContainers.forEach(container => console.log(`Waiting for service ${container.service} ...`));
-        return Promise.reject(notHealthyContainers);
-      }
-    }, {
-      max: 20,
-      backoff: 1000
-    });
-  } catch (containersWithFailingHealthCheck) {
-    containersWithFailingHealthCheck.forEach(container => console.log(_chalk.default.yellow('WARNING:') + ` Service ${container.service} failed healthcheck`));
-  }
-  const duration = new Date().getTime() - now.getTime();
-  debug(`Healthcheck completed in ${duration}ms`);
+async function landoStart(lando, instancePath) {
+  debug('Will start lando app on path:', instancePath);
+  const app = await getLandoApplication(lando, instancePath);
+  await app.start();
+}
+async function landoLogs(lando, instancePath, options) {
+  debug('Will show lando logs on path:', instancePath, ' with options: ', options);
+  const app = await getLandoApplication(lando, instancePath);
+  const logTask = lando.tasks.find(task => task.command === 'logs');
+  await logTask.run({
+    follow: options.follow,
+    service: options.service,
+    timestamps: options.timestamps,
+    _app: app
+  });
+}
+async function landoRebuild(lando, instancePath) {
+  debug('Will rebuild lando app on path:', instancePath);
+  const app = await getLandoApplication(lando, instancePath);
+  await ensureNoOrphantProxyContainer(lando);
+  await app.rebuild();
 }
 async function landoStop(lando, instancePath) {
   debug('Will stop lando app on path:', instancePath);
@@ -404,6 +359,21 @@ async function landoExec(lando, instancePath, toolName, args, options) {
     process.argv = savedArgv;
   }
 }
+async function landoShell(lando, instancePath, service, user, command) {
+  const app = await getLandoApplication(lando, instancePath);
+  const shellTask = lando.tasks.find(task => task.command === 'ssh');
+  if (!command.length) {
+    const interactive = process.stdin.isTTY ? '-i' : '';
+    command = ['/bin/sh', '-c', `if [ -x /bin/bash ]; then /bin/bash ${interactive}; else /bin/sh ${interactive}; fi; exit 0`];
+  }
+  debug('Running command "%o" in service "%s" as user "%s"', command, service, user);
+  await shellTask.run({
+    command,
+    service,
+    user,
+    _app: app
+  });
+}
 
 /**
  * Sometimes the proxy network seems to disapper leaving only orphant stopped proxy container.
@@ -445,10 +415,10 @@ async function validateDockerInstalled(lando) {
 }
 async function validateDockerAccess(lando) {
   const docker = lando.engine.docker;
-  lando.log.verbose('Fetching docker info to verify user is in docker group');
+  lando.log.verbose('Fetching docker info to verify Docker connection');
   try {
     await docker.info();
   } catch (error) {
-    throw Error('Failed to connect to docker. Please verify that the current user is part of docker group and has access to docker commands.');
+    throw Error('Failed to connect to Docker. Please verify that Docker engine (service) is running and follow the troubleshooting instructions for your platform.');
   }
 }