@automattic/vip 2.9.5 → 2.11.2

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

@@ -0,0 +1,620 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startEnvironment = startEnvironment;
+exports.stopEnvironment = stopEnvironment;
+exports.createEnvironment = createEnvironment;
+exports.updateEnvironment = updateEnvironment;
+exports.destroyEnvironment = destroyEnvironment;
+exports.printAllEnvironmentsInfo = printAllEnvironmentsInfo;
+exports.printEnvironmentInfo = printEnvironmentInfo;
+exports.exec = exec;
+exports.doesEnvironmentExist = doesEnvironmentExist;
+exports.readEnvironmentData = readEnvironmentData;
+exports.getEnvironmentPath = getEnvironmentPath;
+exports.getApplicationInformation = getApplicationInformation;
+exports.resolveImportPath = resolveImportPath;
+exports.importMediaPath = importMediaPath;
+exports.fetchVersionList = fetchVersionList;
+exports.getVersionList = getVersionList;
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _xdgBasedir = _interopRequireDefault(require("xdg-basedir"));
+
+var _nodeFetch = _interopRequireDefault(require("node-fetch"));
+
+var _os = _interopRequireDefault(require("os"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _ejs = _interopRequireDefault(require("ejs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _enquirer = require("enquirer");
+
+var _copyDir = _interopRequireDefault(require("copy-dir"));
+
+var _devEnvironmentLando = require("./dev-environment-lando");
+
+var _searchAndReplace = require("../search-and-replace");
+
+var _devEnvironmentCli = require("./dev-environment-cli");
+
+var _app = _interopRequireDefault(require("../api/app"));
+
+var _devEnvironment = require("../constants/dev-environment");
+
+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 landoFileTemplatePath = _path.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.lando.template.yml.ejs');
+
+const nginxFileTemplatePath = _path.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.nginx.template.conf.ejs');
+
+const landoFileName = '.lando.yml';
+const nginxFileName = 'extra.conf';
+const instanceDataFileName = 'instance_data.json';
+const homeDirPathInsideContainers = '/user';
+const uploadPathString = 'uploads';
+const nginxPathString = 'nginx';
+
+async function startEnvironment(slug, options) {
+  debug('Will start an environment', slug);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+
+  const environmentExists = _fs.default.existsSync(instancePath);
+
+  if (!environmentExists) {
+    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
+  }
+
+  const updated = await updateWordPressImage(slug);
+
+  if (options.skipRebuild && !updated) {
+    await (0, _devEnvironmentLando.landoStart)(instancePath);
+  } else {
+    await (0, _devEnvironmentLando.landoRebuild)(instancePath);
+  }
+
+  await printEnvironmentInfo(slug);
+}
+
+async function stopEnvironment(slug) {
+  debug('Will stop an environment', slug);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+
+  const environmentExists = _fs.default.existsSync(instancePath);
+
+  if (!environmentExists) {
+    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
+  }
+
+  await (0, _devEnvironmentLando.landoStop)(instancePath);
+}
+
+async function createEnvironment(instanceData) {
+  const slug = instanceData.siteSlug;
+  debug('Will create an environment', slug, 'with instanceData: ', instanceData);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+
+  const alreadyExists = _fs.default.existsSync(instancePath);
+
+  if (alreadyExists) {
+    throw new Error('Environment already exists.');
+  }
+
+  const preProcessedInstanceData = preProcessInstanceData(instanceData);
+  await prepareLandoEnv(preProcessedInstanceData, instancePath);
+}
+
+async function updateEnvironment(instanceData) {
+  const slug = instanceData.siteSlug;
+  debug('Will update an environment', slug, 'with instanceData: ', instanceData);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+
+  const alreadyExists = _fs.default.existsSync(instancePath);
+
+  if (!alreadyExists) {
+    throw new Error('Environment doesn\'t exist.');
+  }
+
+  const preProcessedInstanceData = preProcessInstanceData(instanceData);
+  await prepareLandoEnv(preProcessedInstanceData, instancePath);
+}
+
+function preProcessInstanceData(instanceData) {
+  const newInstanceData = { ...instanceData
+  };
+
+  if (instanceData.mediaRedirectDomain && !instanceData.mediaRedirectDomain.match(/^http/)) {
+    // We need to make sure the redirect is an absolute path
+    newInstanceData.mediaRedirectDomain = `https://${instanceData.mediaRedirectDomain}`;
+  }
+
+  newInstanceData.enterpriseSearchEnabled = instanceData.enterpriseSearchEnabled || false;
+  newInstanceData.php = instanceData.php || _devEnvironment.DEV_ENVIRONMENT_PHP_VERSIONS.default;
+  return newInstanceData;
+}
+
+async function destroyEnvironment(slug, removeFiles) {
+  debug('Will destroy an environment', slug);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+
+  const environmentExists = _fs.default.existsSync(instancePath);
+
+  if (!environmentExists) {
+    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
+  }
+
+  const landoFilePath = _path.default.join(instancePath, landoFileName);
+
+  if (_fs.default.existsSync(landoFilePath)) {
+    debug('Lando file exists, will lando destroy.');
+    await (0, _devEnvironmentLando.landoDestroy)(instancePath);
+  } else {
+    debug("Lando file doesn't exist, skipping lando destroy.");
+  }
+
+  if (removeFiles) {
+    await _fs.default.promises.rm(instancePath, {
+      recursive: true
+    });
+    console.log(`${_chalk.default.green('✓')} Environment files deleted successfully.`);
+  }
+}
+
+async function printAllEnvironmentsInfo() {
+  const allEnvNames = getAllEnvironmentNames();
+  debug('Will print info for all environments. Names found: ', allEnvNames);
+  console.log('Found ' + _chalk.default.bold(allEnvNames.length) + ' environments' + (allEnvNames.length ? ':' : '.'));
+
+  for (const envName of allEnvNames) {
+    console.log('\n');
+    await printEnvironmentInfo(envName);
+  }
+}
+
+async function printEnvironmentInfo(slug) {
+  debug('Will get info for an environment', slug);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+
+  const environmentExists = _fs.default.existsSync(instancePath);
+
+  if (!environmentExists) {
+    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
+  }
+
+  const appInfo = await (0, _devEnvironmentLando.landoInfo)(instancePath);
+  (0, _devEnvironmentCli.printTable)(appInfo);
+}
+
+async function exec(slug, args) {
+  debug('Will run a wp command on env', slug, 'with args', args);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+
+  const environmentExists = _fs.default.existsSync(instancePath);
+
+  if (!environmentExists) {
+    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
+  }
+
+  const command = args.shift();
+  let commandArgs = [...args];
+
+  if ('add-site' === command) {
+    commandArgs = [...args.map(argument => argument.replace('--new-site-', '--'))];
+  }
+
+  await (0, _devEnvironmentLando.landoExec)(instancePath, command, commandArgs);
+}
+
+function doesEnvironmentExist(slug) {
+  debug('Will check for environment', slug);
+  const instancePath = getEnvironmentPath(slug);
+  debug('Instance path for', slug, 'is:', instancePath);
+  return _fs.default.existsSync(instancePath);
+}
+
+function readEnvironmentData(slug) {
+  debug('Will try to get instance data for environment', slug);
+  const instancePath = getEnvironmentPath(slug);
+
+  const instanceDataTargetPath = _path.default.join(instancePath, instanceDataFileName);
+
+  const instanceDataString = _fs.default.readFileSync(instanceDataTargetPath, 'utf8');
+
+  return JSON.parse(instanceDataString);
+}
+
+async function prepareLandoEnv(instanceData, instancePath) {
+  const landoFile = await _ejs.default.renderFile(landoFileTemplatePath, instanceData);
+  const nginxFile = await _ejs.default.renderFile(nginxFileTemplatePath, instanceData);
+  const instanceDataFile = JSON.stringify(instanceData);
+
+  const landoFileTargetPath = _path.default.join(instancePath, landoFileName);
+
+  const nginxFolderPath = _path.default.join(instancePath, nginxPathString);
+
+  const nginxFileTargetPath = _path.default.join(nginxFolderPath, nginxFileName);
+
+  const instanceDataTargetPath = _path.default.join(instancePath, instanceDataFileName);
+
+  _fs.default.mkdirSync(instancePath, {
+    recursive: true
+  });
+
+  _fs.default.mkdirSync(nginxFolderPath, {
+    recursive: true
+  });
+
+  _fs.default.writeFileSync(landoFileTargetPath, landoFile);
+
+  _fs.default.writeFileSync(nginxFileTargetPath, nginxFile);
+
+  _fs.default.writeFileSync(instanceDataTargetPath, instanceDataFile);
+
+  debug(`Lando file created in ${landoFileTargetPath}`);
+  debug(`Nginx file created in ${nginxFileTargetPath}`);
+  debug(`Instance data file created in ${instanceDataTargetPath}`);
+}
+
+function getAllEnvironmentNames() {
+  const mainEnvironmentPath = _xdgBasedir.default.data || _os.default.tmpdir();
+
+  const baseDir = _path.default.join(mainEnvironmentPath, 'vip', 'dev-environment');
+
+  const doWeHaveAnyEnvironment = _fs.default.existsSync(baseDir);
+
+  let envNames = [];
+
+  if (doWeHaveAnyEnvironment) {
+    const files = _fs.default.readdirSync(baseDir);
+
+    envNames = files.filter(file => {
+      const fullPath = _path.default.join(baseDir, file);
+
+      return _fs.default.lstatSync(fullPath).isDirectory();
+    });
+  }
+
+  return envNames;
+}
+
+function getEnvironmentPath(name) {
+  if (!name) {
+    throw new Error('Name was not provided');
+  }
+
+  const mainEnvironmentPath = _xdgBasedir.default.data || _os.default.tmpdir();
+
+  return _path.default.join(mainEnvironmentPath, 'vip', 'dev-environment', name + '');
+}
+
+async function getApplicationInformation(appId, envType) {
+  // $FlowFixMe: gql template is not supported by flow
+  const fieldsQuery = `
+		id,
+		name,
+		repository {
+			htmlUrl,
+			fullName
+		},
+		environments {
+			id,
+			name,
+			type,
+			branch,
+			isMultisite,
+			primaryDomain {
+				name
+			}
+		}`;
+  const queryResult = await (0, _app.default)(appId, fieldsQuery);
+  const appData = {};
+
+  if (queryResult) {
+    var _queryResult$reposito;
+
+    appData.id = queryResult.id;
+    appData.name = queryResult.name;
+    appData.repository = (_queryResult$reposito = queryResult.repository) === null || _queryResult$reposito === void 0 ? void 0 : _queryResult$reposito.htmlUrl;
+    const environments = queryResult.environments || [];
+    let envData;
+
+    if (envType) {
+      envData = environments.find(candidateEnv => candidateEnv.type === envType);
+    } else if (1 === environments.length) {
+      envData = environments[0];
+    } else {
+      const choices = environments.map(candidateEnv => candidateEnv.type);
+      const {
+        env
+      } = await (0, _enquirer.prompt)({
+        type: 'select',
+        name: 'env',
+        message: 'Which environment?',
+        choices
+      });
+      envData = environments.find(candidateEnv => candidateEnv.type === env);
+    }
+
+    if (envData) {
+      var _envData$primaryDomai;
+
+      appData.environment = {
+        name: envData.name,
+        branch: envData.branch,
+        type: envData.type,
+        isMultisite: envData.isMultisite,
+        primaryDomain: ((_envData$primaryDomai = envData.primaryDomain) === null || _envData$primaryDomai === void 0 ? void 0 : _envData$primaryDomai.name) || ''
+      };
+    }
+  }
+
+  return appData;
+}
+
+async function resolveImportPath(slug, fileName, searchReplace, inPlace) {
+  let resolvedPath = (0, _devEnvironmentCli.resolvePath)(fileName);
+
+  if (!_fs.default.existsSync(resolvedPath)) {
+    throw new Error('The provided file does not exist or it is not valid (see "--help" for examples)');
+  } // Run Search and Replace if the --search-replace flag was provided
+
+
+  if (searchReplace && searchReplace.length) {
+    const {
+      outputFileName
+    } = await (0, _searchAndReplace.searchAndReplace)(resolvedPath, searchReplace, {
+      isImport: true,
+      output: true,
+      inPlace
+    });
+
+    if (typeof outputFileName !== 'string') {
+      throw new Error('Unable to determine location of the intermediate search & replace file.');
+    }
+
+    const environmentPath = getEnvironmentPath(slug);
+
+    const baseName = _path.default.basename(outputFileName);
+
+    resolvedPath = _path.default.join(environmentPath, baseName);
+
+    _fs.default.renameSync(outputFileName, resolvedPath);
+  }
+  /**
+   * Docker container does not have acces to the host filesystem.
+   * However lando maps os.homedir() to /user in the container. So if we replace the path in the same way
+   * in the Docker container will get the file from within the mapped volume under /user.
+   */
+
+
+  let inContainerPath = resolvedPath.replace(_os.default.homedir(), homeDirPathInsideContainers);
+
+  if (_path.default.sep === '\\') {
+    // Because the file path generated for windows will have \ instead of / we need to replace that as well so that the path inside the container (unix) still works.
+    inContainerPath = inContainerPath.replace(/\\/g, '/');
+  }
+
+  debug(`Import file path ${resolvedPath} will be mapped to ${inContainerPath}`);
+  return {
+    resolvedPath,
+    inContainerPath
+  };
+}
+
+async function importMediaPath(slug, filePath) {
+  const resolvedPath = (0, _devEnvironmentCli.resolvePath)(filePath);
+
+  if (!_fs.default.existsSync(resolvedPath) || !_fs.default.lstatSync(resolvedPath).isDirectory()) {
+    throw new Error('The provided path does not exist or it is not valid (see "--help" for examples)');
+  }
+
+  const files = _fs.default.readdirSync(resolvedPath);
+
+  if (files.indexOf(uploadPathString) > -1) {
+    const confirm = await (0, _enquirer.prompt)({
+      type: 'confirm',
+      name: 'continue',
+      message: 'The provided path contains an uploads folder inside. Do you want to continue?'
+    });
+
+    if (!confirm.continue) {
+      return;
+    }
+  }
+
+  const environmentPath = getEnvironmentPath(slug);
+
+  const uploadsPath = _path.default.join(environmentPath, uploadPathString);
+
+  console.log(`${_chalk.default.yellow('-')} Started copying files`);
+
+  _copyDir.default.sync(resolvedPath, uploadsPath);
+
+  console.log(`${_chalk.default.green('✓')} Files successfully copied to ${uploadsPath}.`);
+}
+/**
+ * Uses the WordPress versions manifest on github.com
+ * Informs the user several things:
+ *   - If the WordPress image their env uses is no longer available
+ *   - If there is a newer version of the WordPress version currently used
+ *   - A choice to use a different image
+ *
+ * @param  {Object=} slug slug
+ * @return {boolean} boolean
+ */
+
+
+async function updateWordPressImage(slug) {
+  const versions = await getVersionList();
+  let message, envData, currentWordPressTag; // Get the current environment configuration
+
+  try {
+    envData = readEnvironmentData(slug);
+    currentWordPressTag = envData.wordpress.tag;
+  } catch (error) {
+    // This can throw an exception if the env is build with older vip version
+    if ('ENOENT' === error.code) {
+      message = 'Environment was created before update was supported.\n\n';
+      message += 'To update environment please destroy it and create a new one.';
+    } else {
+      message = `An error prevented reading the configuration of: ${slug}\n\n ${error}`;
+    }
+
+    (0, _devEnvironmentCli.handleCLIException)(new Error(message));
+    return false;
+  } // sort
+
+
+  versions.sort((before, after) => before.tag < after.tag ? 1 : -1); // Newest WordPress Image but that is not trunk
+
+  const newestWordPressImage = versions.find(({
+    tag
+  }) => tag !== 'trunk');
+  console.log('The most recent WordPress version available is: ' + _chalk.default.green(newestWordPressImage.tag)); // If the currently used version is the most up to date: exit.
+
+  if (currentWordPressTag === newestWordPressImage.tag) {
+    console.log('Environment WordPress version is: ' + _chalk.default.green(currentWordPressTag) + '  ... 😎 nice! ');
+    return false;
+  } // Determine if there is an image available for the current WordPress version
+
+
+  const match = versions.find(({
+    tag
+  }) => tag === currentWordPressTag); // If there is no available image for the currently installed version, give user a path to change
+
+  if (typeof match === 'undefined') {
+    console.log(`Installed WordPress: ${currentWordPressTag} has no available container image in repository. `);
+    console.log('You must select a new WordPress image to continue... ');
+  } else {
+    console.log('Environment WordPress version is: ' + _chalk.default.yellow(`${match.tag} (${match.ref})`));
+
+    if (envData.wordpress.doNotUpgrade || false) {
+      return false;
+    }
+  } // Prompt the user to select a new WordPress Version
+
+
+  const confirm = await (0, _enquirer.prompt)({
+    type: 'select',
+    name: 'upgrade',
+    message: 'Would You like to change the WordPress version? ',
+    choices: ['yes', 'no', "no (don't ask anymore)"]
+  }); // If the user takes the new WP version path
+
+  if (confirm.upgrade === 'yes') {
+    console.log('Upgrading from: ' + _chalk.default.yellow(currentWordPressTag) + ' to:'); // Select a new image
+
+    const choice = await (0, _devEnvironmentCli.promptForComponent)('wordpress');
+    const version = versions.find(({
+      tag
+    }) => tag.trim() === choice.tag.trim()); // Write new data and stage for rebuild
+
+    envData.wordpress.tag = version.tag;
+    envData.wordpress.ref = version.ref;
+    await updateEnvironment(envData);
+    return true;
+  }
+
+  if (confirm.upgrade === "no (don't ask anymore)") {
+    envData.wordpress.doNotUpgrade = true;
+    console.log("We won't ask about upgrading this environment anymore.");
+    console.log('To manually upgrade please run:' + `${_chalk.default.yellow(`vip dev-env update --slug=${slug}`)}`);
+    await updateEnvironment(envData);
+  }
+
+  return false;
+}
+/**
+ * Makes a web call to raw.githubusercontent.com
+ */
+
+
+async function fetchVersionList() {
+  const url = `https://${_devEnvironment.DEV_ENVIRONMENT_RAW_GITHUB_HOST}${_devEnvironment.DEV_ENVIRONMENT_WORDPRESS_VERSIONS_URI}`;
+  return (0, _nodeFetch.default)(url).then(res => res.text());
+}
+/**
+ * Encapsulates the logic for determining if a file is expired by an arbitrary TTL
+ * @param  {string} cacheFile uri of cache file
+ * @param  {number} ttl time to live in seconds
+ * @returns {boolean} version list expired true/false
+ */
+
+
+function isVersionListExpired(cacheFile, ttl) {
+  const stats = _fs.default.statSync(cacheFile);
+
+  const expire = new Date(stats.mtime);
+  expire.setSeconds(expire.getSeconds() + ttl);
+  return +new Date() > expire;
+}
+/**
+ * Uses a cache file to keep the version list in tow until it is ultimately outdated
+ */
+
+
+async function getVersionList() {
+  let res;
+
+  const mainEnvironmentPath = _xdgBasedir.default.data || _os.default.tmpdir();
+
+  const cacheFile = _path.default.join(mainEnvironmentPath, 'vip', _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_CACHE_KEY); // Handle from cache
+
+
+  try {
+    // If the cache doesn't exist, create it
+    if (!_fs.default.existsSync(cacheFile)) {
+      res = await fetchVersionList();
+
+      _fs.default.writeFileSync(cacheFile, res);
+    } // If the cache is expired, refresh it
+
+
+    if (isVersionListExpired(cacheFile, _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_VERSION_TTL)) {
+      res = await fetchVersionList();
+
+      _fs.default.writeFileSync(cacheFile, res);
+    }
+  } catch (err) {
+    // Soft error handling here, since it's still possible to use a previously cached file.
+    console.log(_chalk.default.yellow('fetchWordPressVersionList failed to retrieve an updated version list'));
+    debug(err);
+  } // Try to parse the cached file if it exists.
+
+
+  try {
+    return JSON.parse(_fs.default.readFileSync(cacheFile));
+  } catch (err) {
+    debug(err);
+    return [];
+  }
+}