clever-tools 2.9.0 → 2.10.0-beta.1

package/src/commands/networkgroups/members.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const ngApi = require('@clevercloud/client/cjs/api/v4/network-group.js');
+
+const { sendToApi } = require('../../models/send-to-api.js');
+
+const Logger = require('../../logger.js');
+const NetworkGroup = require('../../models/networkgroup.js');
+const Formatter = require('../../models/format-string.js');
+const TableFormatter = require('../../models/format-ng-table.js');
+
+async function listMembers(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'natural-name': naturalName, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Listing members from Network Group '${networkGroupId}'`);
+  const result = await ngApi.listNetworkGroupMembers({ ownerId, networkGroupId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    if (result.length === 0) {
+      Logger.println(`No member found. You can add one with ${Formatter.formatCommand('clever networkgroups members add')}.`);
+    }
+    else {
+      await TableFormatter.printMembersTableHeader(naturalName);
+      for (const ng of result) {
+        Logger.println(await TableFormatter.formatMembersLine(ng, naturalName));
+      }
+    }
+  }
+}
+
+async function getMember(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'member-id': memberId, 'natural-name': naturalName, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);;
+
+  Logger.info(`Getting details for member ${Formatter.formatString(memberId)} in Network Group ${Formatter.formatString(networkGroupId)}`);
+  const result = await ngApi.getNetworkGroupMember({ ownerId, networkGroupId, memberId: memberId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    await TableFormatter.printMembersTableHeader(naturalName);
+    Logger.println(await TableFormatter.formatMembersLine(result, naturalName));
+  }
+}
+
+async function addMember(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'member-id': memberId, type, 'domain-name': domainName, label } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  const body = { id: memberId, label, domain_name: domainName, type };
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  await ngApi.createNetworkGroupMember({ ownerId, networkGroupId }, body).then(sendToApi);
+
+  Logger.println(`Successfully added member ${Formatter.formatString(memberId)} to Network Group ${Formatter.formatString(networkGroupId)}.`);
+}
+
+async function removeMember(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'member-id': memberId } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  await ngApi.deleteNetworkGroupMember({ ownerId, networkGroupId, memberId }).then(sendToApi);
+
+  Logger.println(`Successfully removed member ${Formatter.formatString(memberId)} from Network Group ${Formatter.formatString(networkGroupId)}.`);
+}
+
+module.exports = {
+  listMembers,
+  getMember,
+  addMember,
+  removeMember,
+};

package/src/commands/networkgroups/peers.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const ngApi = require('@clevercloud/client/cjs/api/v4/network-group.js');
+
+const { sendToApi } = require('../../models/send-to-api.js');
+
+const Logger = require('../../logger.js');
+const NetworkGroup = require('../../models/networkgroup.js');
+const Formatter = require('../../models/format-string.js');
+const TableFormatter = require('../../models/format-ng-table.js');
+
+async function listPeers(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Listing peers from Network Group ${Formatter.formatString(networkGroupId)}`);
+  const result = await ngApi.listNetworkGroupPeers({ ownerId, networkGroupId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    if (result.length === 0) {
+      Logger.println(`No peer found. You can add an external one with ${Formatter.formatCommand('clever networkgroups peers add-external')}.`);
+    }
+    else {
+      TableFormatter.printPeersTableHeader();
+      result.forEach((peer) => {
+        Logger.println(TableFormatter.formatPeersLine(peer));
+      });
+    }
+  }
+}
+
+async function getPeer(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'peer-id': peerId, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Getting details for peer ${Formatter.formatString(peerId)} in Network Group ${Formatter.formatString(networkGroupId)}`);
+  const peer = await ngApi.getNetworkGroupPeer({ ownerId, networkGroupId, peerId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(peer, null, 2));
+  }
+  else {
+    TableFormatter.printPeersTableHeader();
+    Logger.println(TableFormatter.formatPeersLine(peer));
+  }
+}
+
+async function addExternalPeer(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, role, 'public-key': publicKey, label, parent, ip, port } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  const body = { peer_role: role, public_key: publicKey, label, parent_member: parent, ip, port };
+  Logger.info(`Adding external peer to Network Group ${Formatter.formatString(networkGroupId)}`);
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  const { id: peerId } = await ngApi.createNetworkGroupExternalPeer({ ownerId, networkGroupId }, body).then(sendToApi);
+
+  Logger.println(`External peer ${Formatter.formatString(peerId)} must have been added to Network Group ${Formatter.formatString(networkGroupId)}.`);
+  return peerId;
+}
+
+async function removeExternalPeer(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'peer-id': peerId } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Removing external peer ${Formatter.formatString(peerId)} from Network Group ${Formatter.formatString(networkGroupId)}`);
+  await ngApi.deleteNetworkGroupExternalPeer({ ownerId, networkGroupId, peerId }).then(sendToApi);
+
+  Logger.println(`External peer ${Formatter.formatString(peerId)} must have been removed from Network Group ${Formatter.formatString(networkGroupId)}.`);
+}
+
+module.exports = {
+  listPeers,
+  getPeer,
+  addExternalPeer,
+  removeExternalPeer,
+};

package/src/commands/open.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const openPage = require('opn');
+const openPage = require('open');
 
 const AppConfig = require('../models/app_configuration.js');
 const Domain = require('../models/domain.js');

package/src/models/app_configuration.js

@@ -79,6 +79,14 @@ function findApp (config, alias) {
     return appByAlias;
   }
 
+  return findDefaultApp(config);
+}
+
+function findDefaultApp (config) {
+  if (_.isEmpty(config.apps)) {
+    throw new Error('There are no applications linked. You can add one with `clever link`');
+  }
+
   if (config.default != null) {
     const defaultApp = _.find(config.apps, { app_id: config.default });
     if (defaultApp == null) {
@@ -95,6 +103,25 @@ function findApp (config, alias) {
   throw new Error(`Several applications are linked. You can specify one with the "--alias" option. Run "clever applications" to list linked applications. Available aliases: ${aliases}`);
 }
 
+async function getAppDetailsForId (appId) {
+  const config = await loadApplicationConf();
+
+  if (_.isEmpty(config.apps)) {
+    throw new Error('There are no applications linked. You can add one with `clever link`');
+  }
+
+  const [appById, secondAppById] = _.filter(config.apps, { app_id: appId });
+  if (appById == null) {
+    throw new Error(`There are no applications matching id '${appId}'`);
+  }
+  if (secondAppById != null) {
+    throw new Error(`There are several applications matching id '${appId}'.`
+                  + 'This should not happen, your `.clever.json` should be fixed.');
+  }
+
+  return appById;
+}
+
 async function getAppDetails ({ alias }) {
   const config = await loadApplicationConf();
   const app = findApp(config, alias);
@@ -110,6 +137,16 @@ async function getAppDetails ({ alias }) {
   };
 };
 
+async function getMostNaturalName (appId) {
+  try {
+    const details = await getAppDetailsForId(appId);
+    return details.alias || details.name || appId;
+  }
+  catch {
+    return appId;
+  }
+}
+
 function persistConfig (modifiedConfig) {
   const jsonContents = JSON.stringify(modifiedConfig, null, 2);
   return fs.writeFile(conf.APP_CONFIGURATION_FILE, jsonContents);
@@ -128,5 +165,6 @@ module.exports = {
   removeLinkedApplication,
   findApp,
   getAppDetails,
+  getMostNaturalName,
   setDefault,
 };

package/src/models/format-ng-table.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const formatNgTable = require('../format-table.js');
+const colors = require('colors/safe');
+
+const AppConfig = require('./app_configuration.js');
+const Logger = require('../logger.js');
+const Formatter = require('./format-string.js');
+
+function printSeparator (columnLengths) {
+  Logger.println('─'.repeat(columnLengths.reduce((a, b) => a + b + 2)));
+}
+
+// We use examples of maximum width text to have a clean display
+const networkGroupsTableColumnLengths = [
+  39, /* id length */
+  48, /* label length */
+  7, /* members length */
+  5, /* peers length */
+  48, /* description */
+];
+const formatNetworkGroupsTable = formatNgTable(networkGroupsTableColumnLengths);
+function formatNetworkGroupsLine (ng) {
+  return formatNetworkGroupsTable([
+    [
+      Formatter.formatId(ng.id),
+      Formatter.formatString(ng.label, false),
+      Formatter.formatNumber(ng.members.length),
+      Formatter.formatNumber(ng.peers.length),
+      Formatter.formatString(ng.description || ' ', false),
+    ],
+  ]);
+};
+function printNetworkGroupsTableHeader () {
+  Logger.println(colors.bold(formatNetworkGroupsTable([
+    ['Network Group ID', 'Label', 'Members', 'Peers', 'Description'],
+  ])));
+  printSeparator(networkGroupsTableColumnLengths);
+}
+
+const membersTableColumnLengths = [
+  48, /* id length */
+  12, /* type length */
+  48, /* label length */
+  24, /* domain-name length */
+];
+const formatMembersTable = formatNgTable(membersTableColumnLengths);
+async function formatMembersLine (member, showAliases = false) {
+  return formatMembersTable([
+    [
+      showAliases
+        ? Formatter.formatString(await AppConfig.getMostNaturalName(member.id), false)
+        : Formatter.formatId(member.id),
+      Formatter.formatString(member.type, false),
+      Formatter.formatString(member.label, false),
+      Formatter.formatString(member.domain_name || ' ', false),
+    ],
+  ]);
+};
+async function printMembersTableHeader (naturalName = false) {
+  Logger.println(colors.bold(formatMembersTable([
+    [
+      naturalName ? 'Member' : 'Member ID',
+      'Member Type',
+      'Label',
+      'Domain Name',
+    ],
+  ])));
+  printSeparator(membersTableColumnLengths);
+}
+
+const peersTableColumnLengths = [
+  45, /* id length */
+  12, /* type length */
+  14, /* endpoint type length */
+  48, /* label length */
+  24, /* hostname */
+  15, /* ip */
+];
+const formatPeersTable = formatNgTable(peersTableColumnLengths);
+function formatPeersLine (peer) {
+  const ip = (peer.endpoint.type === 'ServerEndpoint') ? peer.endpoint.ng_term.ip : peer.endpoint.ng_ip;
+  return formatPeersTable([
+    [
+      Formatter.formatId(peer.id),
+      Formatter.formatString(peer.type, false),
+      Formatter.formatString(peer.endpoint.type, false),
+      Formatter.formatString(peer.label, false),
+      Formatter.formatString(peer.hostname, false),
+      Formatter.formatIp(ip),
+    ],
+  ]);
+};
+function printPeersTableHeader () {
+  Logger.println(colors.bold(formatPeersTable([
+    [
+      'Peer ID',
+      'Peer Type',
+      'Endpoint Type',
+      'Label',
+      'Hostname',
+      'IP Address',
+    ],
+  ])));
+  printSeparator(peersTableColumnLengths);
+}
+
+module.exports = {
+  formatNetworkGroupsLine,
+  printNetworkGroupsTableHeader,
+  formatMembersLine,
+  printMembersTableHeader,
+  formatPeersLine,
+  printPeersTableHeader,
+};

package/src/models/format-string.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const colors = require('colors/safe');
+
+function formatId (id) {
+  return colors.dim(id);
+}
+
+function formatString (str, decorated = true) {
+  const string = decorated ? `'${str}'` : str;
+  return colors.green(string);
+}
+
+function formatNumber (number) {
+  return colors.yellow(number);
+}
+
+function formatIp (ip) {
+  return colors.cyan(ip);
+}
+
+function formatUrl (url, decorated = true) {
+  const string = decorated ? `<${url}>` : url;
+  return colors.cyan(string);
+}
+
+function formatCommand (command, decorated = true) {
+  const string = decorated ? `\`${command}\`` : command;
+  return colors.magenta(string);
+}
+
+function formatCode (code, decorated = true) {
+  return formatCommand(code, decorated);
+}
+
+module.exports = {
+  formatId,
+  formatString,
+  formatNumber,
+  formatIp,
+  formatUrl,
+  formatCommand,
+  formatCode,
+};

package/src/models/networkgroup.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const autocomplete = require('cliparse').autocomplete;
+const Organisation = require('../models/organisation.js');
+const User = require('../models/user.js');
+const AppConfig = require('./app_configuration.js');
+const ngApi = require('@clevercloud/client/cjs/api/v4/network-group.js');
+const { sendToApi } = require('./send-to-api.js');
+
+async function getOwnerId(orgaIdOrName, alias) {
+  if (orgaIdOrName == null) {
+    try {
+      return (await AppConfig.getAppDetails({alias})).ownerId;
+    } catch (error) {
+      return (await User.getCurrentId())
+    }
+  } else {
+    return (await Organisation.getId(orgaIdOrName));
+  }
+}
+
+async function getId(ownerId, ngIdOrLabel) {
+  if (ngIdOrLabel == null) {
+    return null;
+  }
+
+  if (ngIdOrLabel.ng_id != null) {
+    return ngIdOrLabel.ng_id;
+  }
+
+  return getByLabel(ownerId, ngIdOrLabel.ng_label)
+    .then((ng) => ng.id);
+}
+
+async function getByLabel(owner_id, label) {
+  const networkGroups = await ngApi.get({ owner_id }).then(sendToApi);
+  const filteredNgs = networkGroups.filter((ng) => ng.label === label);
+
+  if (filteredNgs.length === 0) {
+    throw new Error('Network Group not found');
+  }
+  if (filteredNgs.length > 1) {
+    throw new Error('Ambiguous Network Group label');
+  }
+
+  return filteredNgs[0];
+}
+
+function listAvailablePeerRoles() {
+  return autocomplete.words(['client', 'server']);
+}
+
+function listAvailableMemberTypes() {
+  return autocomplete.words(['application', 'addon', 'external']);
+}
+
+module.exports = {
+  getOwnerId,
+  getId,
+  listAvailablePeerRoles,
+  listAvailableMemberTypes,
+};

package/src/models/wireguard-conf.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const os = require('os');
+const { promises: fs, existsSync } = require('fs');
+const path = require('path');
+
+const Logger = require('../logger.js');
+const Formatter = require('./format-string.js');
+
+function getWgConfFolder () {
+  // TODO: See if we can use runtime dirs
+  return path.join(os.tmpdir(), 'com.clever-cloud.networkgroups');
+}
+
+async function createWgConfFolderIfNeeded () {
+  const confFolder = getWgConfFolder();
+  if (!existsSync(confFolder)) {
+    await fs.mkdir(confFolder);
+  }
+}
+
+function getWgConfInformation (ngId) {
+  const confName = `wgcc${ngId.slice(-8)}`;
+  const confPath = path.join(getWgConfFolder(), `${confName}.conf`);
+
+  return { confName, confPath };
+}
+
+function getPeerIdPath (confName) {
+  return path.join(getWgConfFolder(), `${confName}.id`);
+}
+
+async function storePeerId (peerId, confName) {
+  const filePath = getPeerIdPath(confName);
+
+  try {
+    await fs.writeFile(filePath, peerId, { mode: 0o600, flag: 'wx' });
+    Logger.info(`Saved peer ID file to ${Formatter.formatUrl(filePath)}`);
+  }
+  catch (error) {
+    throw new Error(`Error saving peer ID: ${error}`);
+  }
+}
+
+async function getPeerId (ngId) {
+  const { confName } = getWgConfInformation(ngId);
+  const filePath = getPeerIdPath(confName);
+  if (existsSync(filePath)) {
+    Logger.debug(`Reading peer ID from ${Formatter.formatUrl(filePath)}`);
+    return (await fs.readFile(filePath, { encoding: 'utf-8' })).trim();
+  }
+  else {
+    Logger.debug(`No file found at ${Formatter.formatUrl(filePath)}`);
+    return null;
+  }
+}
+
+async function deletePeerIdFile (ngId) {
+  const { confName } = getWgConfInformation(ngId);
+  const filePath = getPeerIdPath(confName);
+  // We need `force: true` to avoid errors if file doesn't exist
+  await fs.rm(filePath, { force: true });
+  Logger.info(`Deleted peer ID from ${Formatter.formatUrl(filePath)}`);
+}
+
+async function getInterfaceName (confName) {
+  // This file is created by WireGuard®, hence the file path (`/var/run/…`)
+  // TODO: Handle Windows (not yet supported by `wg-quick` anyway)
+  const interfaceNameFile = path.join('/var', 'run', 'wireguard', `${confName}.name`);
+
+  Logger.debug(`Reading WireGuard® interface name in ${Formatter.formatUrl(interfaceNameFile)}…`);
+  const interfaceName = (await fs.readFile(interfaceNameFile, { encoding: 'utf-8' })).trim();
+  Logger.debug(`Found WireGuard® interface name ${Formatter.formatString(interfaceName)} for ${Formatter.formatString(confName)}`);
+  return interfaceName;
+}
+
+function confWithoutPlaceholders (conf, { privateKey }) {
+  conf = conf.replace('<%PrivateKey%>', privateKey);
+
+  // TODO: This just removes leading and trailing new lines in the configuration file
+  //       It should be better formatted on the API's side
+  conf = conf.trim();
+
+  return conf;
+}
+
+module.exports = {
+  createWgConfFolderIfNeeded,
+  getWgConfInformation,
+  storePeerId,
+  getPeerId,
+  deletePeerIdFile,
+  getInterfaceName,
+  confWithoutPlaceholders,
+};

package/src/models/wireguard.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+const Logger = require('../logger.js');
+
+function privateKey () {
+  return execSync('wg genkey', { encoding: 'utf-8' }).trim();
+}
+
+function publicKey (privateKey) {
+  return execSync(`echo '${privateKey}' | wg pubkey`, { encoding: 'utf-8' }).trim();
+}
+
+function up (confPath) {
+  // We must use `spawn` with `detached: true` instead of `exec`
+  // because `wg-quick up` starts a `wireguard-go` used by `wg-quick down`
+  const { stdout, stderr } = spawnSync('wg-quick', ['up', confPath], { detached: true, encoding: 'utf-8' });
+  if (stdout.length > 0) {
+    Logger.debug(stdout.trim());
+  }
+  if (stderr.length > 0) {
+    Logger.debug(stderr.trim());
+  }
+  Logger.println('Activated WireGuard® tunnel');
+}
+
+function update (confPath, interfaceName) {
+  try {
+    // Update WireGuard® configuration
+    execSync(`wg-quick strip ${confPath} | wg syncconf ${interfaceName} /dev/stdin`);
+    Logger.info('Updated WireGuard® tunnel configuration');
+  }
+  catch (error) {
+    throw new Error(`Error updating WireGuard® tunnel configuration: ${error}`);
+  }
+}
+
+function down (confPath) {
+  const { stdout, stderr } = spawnSync('wg-quick', ['down', confPath], { encoding: 'utf-8' });
+  if (stdout.length > 0) {
+    Logger.debug(stdout.trim());
+  }
+  if (stderr.length > 0) {
+    Logger.debug(stderr.trim());
+  }
+}
+
+/**
+ * Check that `wg` and `wg-quick` are installed
+ */
+function checkAvailable () {
+  try {
+    // The redirect to `/dev/null` ensures that your program does not produce the output of these commands.
+    execSync('which wg > /dev/null 2>&1');
+    execSync('which wg-quick > /dev/null 2>&1');
+
+    // TODO: Handle Windows
+    //        - Those checks won't work on Windows, and wg-quick doesn't exist anyway.
+    //          - We need to wait for a Windows version of wg-quick to support the rest of the operations
+    //          - Or we could use vanilla wg on Windows, and wg-quick on other OSs
+    return true;
+  }
+  catch {
+    return false;
+  }
+}
+
+module.exports = {
+  privateKey,
+  publicKey,
+  up,
+  update,
+  down,
+  checkAvailable,
+};