bdy 1.7.46-dev

package/src/agent/system.js

@@ -0,0 +1,205 @@
+const {
+  writeFileSync,
+  readFileSync,
+  mkdirSync,
+  createWriteStream,
+  rmSync,
+  writeFile
+} = require('fs');
+const https = require('https');
+const path = require('path');
+
+const {
+  getVersionEnv,
+  getVersionWithoutEnv,
+  getHomeDirectory
+} = require('../utils');
+const logger = require('../logger');
+const {
+  LOG_SAVING_AGENT_SYSTEM_CONFIG,
+  LOG_ERROR_SAVING_AGENT_SYSTEM_CONFIG,
+  LOG_SAVING_AGENT_LOCAL_CONFIG,
+  LOG_ERROR_SAVING_AGENT_LOCAL_CONFIG
+} = require('../texts');
+
+class AgentSystem {
+  // extend
+  isEnabled() {
+    return Promise.resolve(false);
+  }
+
+  // extend
+  enable() {
+    return Promise.reject();
+  }
+
+  // extend
+  update() {
+    return Promise.reject();
+  }
+
+  // extend
+  disable() {
+    return Promise.reject();
+  }
+
+  // extend
+  getSystemConfigPath() {
+    return '';
+  }
+
+  // extend
+  getSystemConfigDir() {
+    return '';
+  }
+
+  getAgentConfigDir() {
+    return getHomeDirectory();
+  }
+
+  getAgentConfigPath() {
+    return path.join(this.getAgentConfigDir(), 'agent.json');
+  }
+
+  // extend
+  hasAdminRights() {
+    return Promise.resolve(false);
+  }
+
+  // extend
+  isSupported() {
+    return Promise.resolve(false);
+  }
+
+  // extend
+  getBinaryArchive() {
+    return '';
+  }
+
+  extractArchive(source, dest) {
+    return new Promise((resolve, reject) => {
+      import('@xhmikosr/decompress').then(({ default: decompress }) => {
+        decompress(source, dest).then(() => {
+          rmSync(source, { force: true });
+          resolve();
+        }).catch((err) => {
+          rmSync(source, { force: true });
+          reject(err);
+        });
+      }).catch(reject);
+    });
+  }
+
+  extractBinaryArchive() {
+    return this.extractArchive(this.getBinaryArchivePath(), this.getSystemConfigDir());
+  }
+
+  loadSystemConfig() {
+    const str = readFileSync(this.getSystemConfigPath(), 'utf-8');
+    return JSON.parse(str);
+  }
+
+  loadAgentConfig() {
+    const str = readFileSync(this.getAgentConfigPath(), 'utf-8');
+    return JSON.parse(str);
+  }
+
+  clearSystemFiles() {
+    rmSync(this.getSystemBinaryPath(), { force: true });
+    rmSync(this.getSystemConfigPath(), { force: true });
+  }
+
+  clearAgentFiles() {
+    rmSync(this.getAgentConfigPath(),  { force: true });
+  }
+
+  ensureSystemConfigDir() {
+    mkdirSync(this.getSystemConfigDir(), { recursive: true });
+  }
+
+  saveFile(p, c) {
+    return new Promise((resolve, reject) => {
+      writeFile(p, c, 'utf-8', (err) => {
+        if (!err) resolve();
+        else reject(err);
+      });
+    });
+  }
+
+  getSystemBinaryPath() {
+    return path.join(this.getSystemConfigDir(), 'bdy');
+  }
+
+  getBinaryArchivePath() {
+    return path.join(this.getSystemConfigDir(), this.getBinaryArchive());
+  }
+
+  downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+      const file = createWriteStream(dest);
+      const request = https.get(url, (response) => {
+        if (response.statusCode !== 200) {
+          file.close();
+          rmSync(dest);
+          reject(new Error('File not found'));
+          return;
+        }
+        response.pipe(file);
+        file.once('finish', () => {
+          file.close((err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+      });
+      request.once('error', (err) => {
+        file.close();
+        rmSync(dest);
+        reject(err);
+      });
+    });
+  }
+
+  downloadBinaryArchive() {
+    const archivePath = this.getBinaryArchivePath();
+    const env = getVersionEnv();
+    const version = getVersionWithoutEnv();
+    const archive = this.getBinaryArchive();
+    return this.downloadFile(`https://es.buddy.works/tunnel/${env}/${version}/${archive}`, archivePath);
+  }
+
+  saveSystemConfig(id, host, token, port) {
+    try {
+      logger.info(LOG_SAVING_AGENT_SYSTEM_CONFIG);
+      this.ensureSystemConfigDir();
+      writeFileSync(this.getSystemConfigPath(), JSON.stringify({
+        id,
+        host,
+        token,
+        port
+      }), 'utf-8');
+      return true;
+    } catch (err) {
+      logger.error(LOG_ERROR_SAVING_AGENT_SYSTEM_CONFIG);
+      logger.error(err);
+      return false;
+    }
+  }
+
+  saveAgentConfig(shouldStart, sshHostKey) {
+    try {
+      logger.info(LOG_SAVING_AGENT_LOCAL_CONFIG);
+      writeFileSync(this.getAgentConfigPath(), JSON.stringify({
+        shouldStart,
+        sshHostKey
+      }), 'utf-8');
+      return true;
+    } catch (err) {
+      logger.error(LOG_ERROR_SAVING_AGENT_LOCAL_CONFIG);
+      logger.error(err);
+      return false;
+    }
+  }
+}
+
+module.exports = AgentSystem;

package/src/agent/wait.js

@@ -0,0 +1,20 @@
+const { sleep } = require('../utils.js');
+
+const waitUntilAgentEnabled = async (api, timeout, onTimeout, onSuccess) => {
+  let s;
+  try {
+    s = await api.fetchStatus();
+  } catch (err) {
+    s = {};
+  }
+  if (s.enabled) {
+    onSuccess();
+  } else if (timeout < 1000) {
+    onTimeout();
+  } else {
+    await sleep(1000);
+    return waitUntilAgentEnabled(api,timeout - 1000, onTimeout, onSuccess);
+  }
+};
+
+module.exports = waitUntilAgentEnabled;

package/src/agent/windows.js

@@ -0,0 +1,168 @@
+const AgentSystem = require('./system');
+const { exec } = require('child_process');
+const path = require('path');
+const { rmSync } = require('fs');
+const logger = require('../logger');
+const { LOG_AGENT_SYSTEM_DIR,
+  LOG_AGENT_DOWNLOADING_ARCHIVE,
+  LOG_AGENT_EXTRACTING_ARCHIVE,
+  LOG_AGENT_ENABLING_SYSTEM,
+  LOG_AGENT_ENABLED,
+  LOG_AGENT_NSSM_DOWNLOADING,
+  LOG_AGENT_NSSM_EXTRACTING,
+  LOG_AGENT_NSSM_CLEARING,
+  LOG_AGENT_STOPPING_SYSTEM,
+  LOG_AGENT_STARTING_SYSTEM
+} = require('../texts');
+
+class AgentWindows extends AgentSystem {
+
+  hasAdminRights() {
+    return new Promise((resolve) => {
+      exec('net session', (err) => {
+        resolve(!err);
+      });
+    });
+  }
+
+  isSupported() {
+    return Promise.resolve(process.arch === 'x64');
+  }
+
+  isEnabled() {
+    return new Promise((resolve) => {
+      this.sc('query bdy').then(() => {
+        resolve(true);
+      }).catch(() => {
+        resolve(false);
+      });
+    });
+  }
+
+  getBinaryArchive() {
+    return 'win-x64.zip';
+  }
+
+  getSystemConfigDir() {
+    return 'C:\\ProgramData\\bdy';
+  }
+
+  getSystemConfigPath() {
+    return path.join(this.getSystemConfigDir(), 'agent.json');
+  }
+
+  getNssmArchivePath() {
+    return path.join(this.getSystemConfigDir(), 'nssm.zip');
+  }
+
+  downloadNssm() {
+    return this.downloadFile('https://es.buddy.works/tunnel/nssm.zip', this.getNssmArchivePath());
+  }
+
+  extractNssm() {
+    return this.extractArchive(this.getNssmArchivePath(), this.getSystemConfigDir());
+  }
+
+  clearNssmExtract() {
+    rmSync(path.join(this.getSystemConfigDir(), '__MACOSX'), { force: true, recursive: true });
+  }
+
+  getNssmBinaryPath() {
+    return path.join(this.getSystemConfigDir(), 'nssm', 'win64', 'nssm.exe');
+  }
+
+  getSystemBinaryPath() {
+    return path.join(this.getSystemConfigDir(), 'bdy.exe');
+  }
+
+  clearSystemFiles() {
+    rmSync(this.getSystemBinaryPath(), { force: true });
+    rmSync(this.getSystemConfigPath(), { force: true });
+    rmSync(path.join(this.getSystemConfigDir(), 'nssm'), { force: true, recursive: true });
+  }
+
+  async update() {
+    try {
+      logger.info(LOG_AGENT_STOPPING_SYSTEM);
+      await this.nssm('stop bdy');
+      logger.info(LOG_AGENT_SYSTEM_DIR);
+      await this.ensureSystemConfigDir();
+      logger.info(LOG_AGENT_DOWNLOADING_ARCHIVE);
+      await this.downloadBinaryArchive();
+      logger.info(LOG_AGENT_EXTRACTING_ARCHIVE);
+      await this.extractBinaryArchive();
+      try {
+        logger.info(LOG_AGENT_STARTING_SYSTEM);
+        await this.nssm('start bdy');
+      } catch {
+        // do nothing, it will throw operation pending
+      }
+    } catch (err) {
+      logger.error(err);
+      throw err;
+    }
+  }
+
+  async enable(id, host, token, port, start, user, pass, debug) {
+    try {
+      logger.info(LOG_AGENT_SYSTEM_DIR);
+      await this.ensureSystemConfigDir();
+      logger.info(LOG_AGENT_NSSM_DOWNLOADING);
+      await this.downloadNssm();
+      logger.info(LOG_AGENT_NSSM_EXTRACTING);
+      await this.extractNssm();
+      logger.info(LOG_AGENT_NSSM_CLEARING);
+      this.clearNssmExtract();
+      logger.info(LOG_AGENT_DOWNLOADING_ARCHIVE);
+      await this.downloadBinaryArchive();
+      logger.info(LOG_AGENT_EXTRACTING_ARCHIVE);
+      await this.extractBinaryArchive();
+      logger.info(LOG_AGENT_ENABLING_SYSTEM);
+      await this.nssm(`install bdy ${this.getSystemBinaryPath()}`);
+      await this.nssm(`set bdy AppParameters agent run --id="${id}" --host="${host}" --token="${token}" --port=${port} --start=${!!start}`);
+      await this.nssm('set bdy DisplayName Buddy Tunnel Agent');
+      await this.nssm('set bdy AppThrottle 5000');
+      await this.nssm('set bdy AppRestartDelay 0');
+      await this.nssm('set bdy AppExit Default Restart');
+      await this.nssm('set bdy Start SERVICE_AUTO_START');
+      await this.nssm(`set bdy AppEnvironmentExtra DEBUG=${debug ? 1 : 0}`);
+      if (user && pass) {
+        await this.nssm(`set bdy ObjectName ${user} ${pass}`);
+      }
+      this.nssm('start bdy').then().catch();
+      logger.info(LOG_AGENT_ENABLED);
+    } catch (err) {
+      logger.info(err);
+      throw err;
+    }
+  }
+
+  async disable() {
+    try{
+      await this.nssm('stop bdy');
+    } catch {
+      // do nothing
+    }
+    await this.nssm('remove bdy confirm');
+  }
+
+  nssm(cmd) {
+    return new Promise((resolve, reject) => {
+      exec(`${this.getNssmBinaryPath()} ${cmd}`, (err, stdout, stderr) => {
+        if (!err) resolve(stdout, stderr);
+        else reject(err, stderr);
+      });
+    });
+  }
+
+  sc(cmd) {
+    return new Promise((resolve, reject) => {
+      exec(`sc ${cmd}`, (err, stdout, stderr) => {
+        if (!err) resolve(stdout, stderr);
+        else reject(err, stderr);
+      });
+    });
+  }
+}
+
+module.exports = AgentWindows;

package/src/agent.js

@@ -0,0 +1,248 @@
+const EventEmitter = require('events');
+const logger = require('./logger.js');
+const {
+  ERR_AGENT_REMOVED,
+  ERR_TUNNEL_REMOVED,
+  LOG_ERROR_WHILE_REFRESHING_AGENT
+} = require('./texts.js');
+const {
+  AGENT_ACTION_DELETE,
+  AGENT_ACTION_RESTART,
+  AGENT_ACTION_START,
+  AGENT_ACTION_STOP,
+  TUNNEL_OPEN
+} = require('./utils.js');
+const Tunnel = require('./tunnel.js');
+const Output = require('./output.js');
+const {
+  ApiErrorAgentNotFound,
+  SOCKET_IO_EVENT_FETCH_SUCCESS,
+  SOCKET_IO_EVENT_FETCH_FAILED,
+  TUNNEL_EVENT_OPEN,
+  TUNNEL_EVENT_CLOSED,
+  TUNNEL_EVENT_TCP_OPEN,
+  TUNNEL_EVENT_TCP_CLOSED,
+  TUNNEL_EVENT_TLS_OPEN,
+  TUNNEL_EVENT_TLS_CLOSED,
+  TUNNEL_EVENT_HTTP_IDENTIFIED,
+  TUNNEL_EVENT_HTTP_OPEN,
+  TUNNEL_EVENT_HTTP_CLOSED,
+  TUNNEL_EVENT_STOPPED,
+  SOCKET_IO_EVENT_CONNECTED,
+  SOCKET_IO_EVENT_DISCONNECTED,
+  TUNNEL_EVENT_HTTP_REQUEST,
+  SOCKET_IO_EVENT_TUNNEL,
+  SOCKET_IO_EVENT_AGENT,
+} = require('./utils');
+const ApiSocketClass = require('./api/socket');
+
+class Agent extends EventEmitter {
+  constructor(id, host, token, service, api) {
+    super();
+    this.id = id;
+    this.host = host;
+    this.token = token;
+    this.service = service;
+    this.tunnels = [];
+    this.started = false;
+    this.api = api;
+    this.manager = null;
+    this.onRefresh = null;
+    this.socket = new ApiSocketClass(host, id, token);
+    this.socket.on(SOCKET_IO_EVENT_FETCH_SUCCESS, (data) => this._onSocketFetch(data));
+    this.socket.on(SOCKET_IO_EVENT_FETCH_FAILED, (err) => this._onSocketFetchFailed(err));
+    this.socket.on(SOCKET_IO_EVENT_CONNECTED, () => this._onSocketConnected());
+    this.socket.on(SOCKET_IO_EVENT_DISCONNECTED, () => this._onSocketDisconnected());
+    this.socket.on(SOCKET_IO_EVENT_TUNNEL, (tunnel, action) => this._onSocketTunnel(tunnel, action));
+    this.socket.on(SOCKET_IO_EVENT_AGENT, (agent, action) => this._onSocketAgent(agent, action));
+  }
+
+  _onSocketTunnel(data, action) {
+    if (action === 'DEL') {
+      this.destroyTunnel(data.id);
+      if (!this.service && this.tunnels.length <= 0) Output.exitError(ERR_TUNNEL_REMOVED);
+    } else {
+      this.socket.fetch(this.started, null, false, []);
+    }
+  }
+
+  _onSocketAgent(_, action) {
+    if (action === 'DEL') {
+      if (this.manager) return this.manager.disableAgentAndExit(ERR_AGENT_REMOVED);
+      Output.exitError(ERR_AGENT_REMOVED);
+    }
+  }
+
+  _onSocketConnected() {
+    if (this.onRefresh) this.onRefresh(true);
+  }
+
+  _onSocketDisconnected() {
+    if (this.onRefresh) this.onRefresh(false);
+  }
+
+  async _onSocketFetch(data) {
+    try {
+      if (data.agent.action) await this.makeAction(data.agent.action);
+      this.refreshTunnels(data.tunnels || []);
+    } catch (err) {
+      logger.error('fetch error');
+      logger.error(err);
+    }
+  }
+
+  _onSocketFetchFailed(err) {
+    if (err instanceof ApiErrorAgentNotFound) {
+      if (this.manager) return this.manager.disableAgentAndExit(ERR_AGENT_REMOVED);
+      Output.exitError(ERR_AGENT_REMOVED);
+    } else {
+      logger.error(LOG_ERROR_WHILE_REFRESHING_AGENT);
+      logger.error(err);
+    }
+  }
+
+  startRefreshingConfiguration(onRefresh) {
+    this.onRefresh = onRefresh;
+    if (this.onRefresh) this.onRefresh(this.socket.connected);
+    this.refreshIn15();
+  }
+
+  async start() {
+    this.started = true;
+    this.tunnels.forEach((t) => {
+      t.start();
+    });
+    this.socket.fetch(this.started, '', true, this.getTunnelsUpdate());
+  }
+
+  async stop(clearAction = true) {
+    this.started = false;
+    this.tunnels.forEach((t) => {
+      t.stop();
+    });
+    this.socket.fetch(this.started, clearAction ? '' : null, false, this.getTunnelsUpdate());
+  }
+
+  async restart() {
+    await this.stop(false);
+    await this.start();
+  }
+
+  async delete() {
+    try {
+      await this.api.unregister(this.id, this.host, this.token);
+    } catch {
+      // do nothing
+    }
+    process.exit(0);
+  }
+
+  refreshIn15(fetch = true) {
+    setTimeout(async () => {
+      if (fetch) this.socket.fetch(this.started, null, false, this.getTunnelsUpdate());
+      else this.update();
+      this.refreshIn15(false);
+    }, 15000);
+  }
+
+  httpRequest(tunnelId, logRequest) {
+    this.socket.request(tunnelId, logRequest);
+  }
+
+  update(force = false) {
+    this.socket.update(this.started, this.getTunnelsUpdate(), force);
+  }
+
+  async makeAction(action) {
+    if (action === AGENT_ACTION_STOP) {
+      if (this.manager) return this.manager.agentStop();
+      else return this.stop();
+    }
+    if (action === AGENT_ACTION_START) {
+      if (this.manager) return this.manager.agentStart();
+      else return this.start();
+    }
+    if (action === AGENT_ACTION_RESTART) {
+      if (this.manager) return this.manager.agentRestart();
+      else return this.restart();
+    }
+    if (action === AGENT_ACTION_DELETE) {
+      if (this.manager) return this.manager.disableAgentAndExit(ERR_AGENT_REMOVED);
+      else return this.delete();
+    }
+  }
+
+  refreshTunnels(tunnels) {
+    const tt = this.tunnels;
+    const hasTunnels = tt.length > 0;
+    const haveTunnels = tunnels.length > 0;
+    if (hasTunnels) {
+      tt.forEach((tunnel) => {
+        if (!tunnels.find((t) => t.id === tunnel.id)) {
+          this.destroyTunnel(tunnel.id);
+        }
+      });
+    }
+    if (haveTunnels) {
+      tunnels.forEach((data) => {
+        let sshHostKey;
+        if (this.manager) sshHostKey = this.manager.sshHostKey;
+        const tunnel = tt.find((tunnel) => data.id === tunnel.id);
+        if (!tunnel) {
+          this.addTunnel(new Tunnel({
+            ...data,
+            sshHostKey
+          }));
+        } else if (tunnel.hasChanged(data)) {
+          tunnel.recreate(data);
+        }
+      });
+    }
+    if (!this.service && hasTunnels && !haveTunnels) {
+      Output.exitError(ERR_TUNNEL_REMOVED);
+    }
+  }
+
+  getTunnelsUpdate() {
+    const update = [];
+    this.tunnels.forEach((t) => {
+      update.push({
+        id: t.id,
+        active: t.status === TUNNEL_OPEN,
+        regionLatency: t.regionLatency ? t.regionLatency.latency : -1,
+        targetLatency: t.targetLatency ? t.targetLatency.latency : -1,
+        totalConnections: t.totalConnections,
+        currentConnections: Object.keys(t.connections).length,
+        httpIdentified: t.identify ? t.identify.type : '',
+      });
+    });
+    return update;
+  }
+
+  addTunnel(tunnel) {
+    this.tunnels.push(tunnel);
+    if (this.started) tunnel.start();
+    tunnel.on(TUNNEL_EVENT_OPEN, () => this.update(true));
+    tunnel.on(TUNNEL_EVENT_CLOSED, () => this.update());
+    tunnel.on(TUNNEL_EVENT_TCP_OPEN, () => this.update());
+    tunnel.on(TUNNEL_EVENT_TCP_CLOSED, () => this.update());
+    tunnel.on(TUNNEL_EVENT_TLS_OPEN, () => this.update());
+    tunnel.on(TUNNEL_EVENT_TLS_CLOSED, () => this.update());
+    tunnel.on(TUNNEL_EVENT_HTTP_IDENTIFIED, () => this.update());
+    tunnel.on(TUNNEL_EVENT_HTTP_OPEN, () => this.update());
+    tunnel.on(TUNNEL_EVENT_HTTP_CLOSED, () => this.update());
+    tunnel.on(TUNNEL_EVENT_STOPPED, () => this.update());
+    tunnel.on(TUNNEL_EVENT_HTTP_REQUEST, (t, logRequest) => this.httpRequest(t.id, logRequest));
+  }
+
+  destroyTunnel(id) {
+    let tunnel = this.tunnels.find((t) => t.id === id);
+    if (!tunnel) return null;
+    this.tunnels = this.tunnels.filter((t) => t.id !== tunnel.id);
+    tunnel.stop();
+    tunnel.removeAllListeners();
+    return tunnel;
+  }
+}
+
+module.exports = Agent;