dbgate-api 5.2.1 → 5.2.2-alpha.11

package/src/shell/tableReader.js

@@ -1,17 +1,18 @@
-const { quoteFullName, fullNameToString } = require('dbgate-tools');
+const { quoteFullName, fullNameToString, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
+const logger = getLogger('tableReader');
 
 async function tableReader({ connection, pureName, schemaName }) {
   const driver = requireEngineDriver(connection);
   const pool = await connectUtility(driver, connection, 'read');
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
 
   const fullName = { pureName, schemaName };
 
   if (driver.databaseEngineTypes.includes('document')) {
     // @ts-ignore
-    console.log(`Reading collection ${fullNameToString(fullName)}`);
+    logger.info(`Reading collection ${fullNameToString(fullName)}`);
     // @ts-ignore
     return await driver.readQuery(pool, JSON.stringify(fullName));
   }
@@ -20,14 +21,14 @@ async function tableReader({ connection, pureName, schemaName }) {
   const query = `select * from ${quoteFullName(driver.dialect, fullName)}`;
   if (table) {
     // @ts-ignore
-    console.log(`Reading table ${fullNameToString(table)}`);
+    logger.info(`Reading table ${fullNameToString(table)}`);
     // @ts-ignore
     return await driver.readQuery(pool, query, table);
   }
   const view = await driver.analyseSingleObject(pool, fullName, 'views');
   if (view) {
     // @ts-ignore
-    console.log(`Reading view ${fullNameToString(view)}`);
+    logger.info(`Reading view ${fullNameToString(view)}`);
     // @ts-ignore
     return await driver.readQuery(pool, query, view);
   }

package/src/shell/tableWriter.js

@@ -1,16 +1,17 @@
-const { fullNameToString } = require('dbgate-tools');
+const { fullNameToString, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
+const logger = getLogger('tableWriter');
 
 async function tableWriter({ connection, schemaName, pureName, driver, systemConnection, ...options }) {
-  console.log(`Writing table ${fullNameToString({ schemaName, pureName })}`);
+  logger.info(`Writing table ${fullNameToString({ schemaName, pureName })}`);
 
   if (!driver) {
     driver = requireEngineDriver(connection);
   }
   const pool = systemConnection || (await connectUtility(driver, connection, 'write'));
 
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
   return await driver.writeTable(pool, { schemaName, pureName }, options);
 }
 

package/src/utility/DatastoreProxy.js

@@ -2,6 +2,9 @@ const { fork } = require('child_process');
 const uuidv1 = require('uuid/v1');
 const { handleProcessCommunication } = require('./processComm');
 const processArgs = require('../utility/processArgs');
+const pipeForkLogs = require('./pipeForkLogs');
+const { getLogger } = require('dbgate-tools');
+const logger = getLogger('DatastoreProxy');
 
 class DatastoreProxy {
   constructor(file) {
@@ -30,13 +33,20 @@ class DatastoreProxy {
 
   async ensureSubprocess() {
     if (!this.subprocess) {
-      this.subprocess = fork(global['API_PACKAGE'] || process.argv[1], [
-        '--is-forked-api',
-        '--start-process',
-        'jslDatastoreProcess',
-        ...processArgs.getPassArgs(),
-        // ...process.argv.slice(3),
-      ]);
+      this.subprocess = fork(
+        global['API_PACKAGE'] || process.argv[1],
+        [
+          '--is-forked-api',
+          '--start-process',
+          'jslDatastoreProcess',
+          ...processArgs.getPassArgs(),
+          // ...process.argv.slice(3),
+        ],
+        {
+          stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        }
+      );
+      pipeForkLogs(this.subprocess);
 
       this.subprocess.on('message', message => {
         // @ts-ignore
@@ -60,7 +70,12 @@ class DatastoreProxy {
     const msgid = uuidv1();
     const promise = new Promise((resolve, reject) => {
       this.requests[msgid] = [resolve, reject];
-      this.subprocess.send({ msgtype: 'read', msgid, offset, limit });
+      try {
+        this.subprocess.send({ msgtype: 'read', msgid, offset, limit });
+      } catch (err) {
+        logger.error({ err }, 'Error getting rows');
+        this.subprocess = null;
+      }
     });
     return promise;
   }
@@ -69,7 +84,12 @@ class DatastoreProxy {
     const msgid = uuidv1();
     const promise = new Promise((resolve, reject) => {
       this.requests[msgid] = [resolve, reject];
-      this.subprocess.send({ msgtype: 'notify', msgid });
+      try {
+        this.subprocess.send({ msgtype: 'notify', msgid });
+      } catch (err) {
+        logger.error({ err }, 'Error notifying subprocess');
+        this.subprocess = null;
+      }
     });
     return promise;
   }

package/src/utility/childProcessChecker.js

@@ -1,14 +1,18 @@
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger('childProcessChecked');
+
 let counter = 0;
 
 function childProcessChecker() {
   setInterval(() => {
     try {
       process.send({ msgtype: 'ping', counter: counter++ });
-    } catch (ex) {
+    } catch (err) {
       // This will come once parent dies.
       // One way can be to check for error code ERR_IPC_CHANNEL_CLOSED
       //     and call process.exit()
-      console.log('parent died', ex.toString());
+      logger.error({ err }, 'parent died');
       process.exit(1);
     }
   }, 1000);

package/src/utility/cleanDirectory.js

@@ -2,7 +2,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const ageSeconds = 3600;
 
-async function cleanDirectory(directory) {
+async function cleanDirectory(directory, age = undefined) {
   const files = await fs.readdir(directory);
   const now = new Date().getTime();
 
@@ -10,7 +10,7 @@ async function cleanDirectory(directory) {
     const full = path.join(directory, file);
     const stat = await fs.stat(full);
     const mtime = stat.mtime.getTime();
-    const expirationTime = mtime + ageSeconds * 1000;
+    const expirationTime = mtime + (age || ageSeconds) * 1000;
     if (now > expirationTime) {
       if (stat.isDirectory()) {
         await fs.rmdir(full, { recursive: true });

package/src/utility/directories.js

@@ -1,20 +1,24 @@
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
+const _ = require('lodash');
 const cleanDirectory = require('./cleanDirectory');
 const platformInfo = require('./platformInfo');
 const processArgs = require('./processArgs');
 const consoleObjectWriter = require('../shell/consoleObjectWriter');
+const { getLogger } = require('dbgate-tools');
+
+let logsFilePath;
 
 const createDirectories = {};
 const ensureDirectory = (dir, clean) => {
   if (!createDirectories[dir]) {
     if (clean && fs.existsSync(dir) && !platformInfo.isForkedApi) {
-      console.log(`Cleaning directory ${dir}`);
-      cleanDirectory(dir);
+      getLogger('directories').info(`Cleaning directory ${dir}`);
+      cleanDirectory(dir, _.isNumber(clean) ? clean : null);
     }
     if (!fs.existsSync(dir)) {
-      console.log(`Creating directory ${dir}`);
+      getLogger('directories').info(`Creating directory ${dir}`);
       fs.mkdirSync(dir);
     }
     createDirectories[dir] = true;
@@ -38,7 +42,7 @@ function datadir() {
   return dir;
 }
 
-const dirFunc = (dirname, clean = false) => () => {
+const dirFunc = (dirname, clean) => () => {
   const dir = path.join(datadir(), dirname);
   ensureDirectory(dir, clean);
 
@@ -52,6 +56,7 @@ const pluginsdir = dirFunc('plugins');
 const archivedir = dirFunc('archive');
 const appdir = dirFunc('apps');
 const filesdir = dirFunc('files');
+const logsdir = dirFunc('logs', 3600 * 24 * 7);
 
 function packagedPluginsDir() {
   // console.log('CALL DIR FROM', new Error('xxx').stack);
@@ -127,11 +132,19 @@ function migrateDataDir() {
     if (fs.existsSync(oldDir) && !fs.existsSync(newDir)) {
       fs.renameSync(oldDir, newDir);
     }
-  } catch (e) {
-    console.log('Error migrating data dir:', e.message);
+  } catch (err) {
+    getLogger('directories').error({ err }, 'Error migrating data dir');
   }
 }
 
+function setLogsFilePath(value) {
+  logsFilePath = value;
+}
+
+function getLogsFilePath() {
+  return logsFilePath;
+}
+
 migrateDataDir();
 
 module.exports = {
@@ -144,9 +157,12 @@ module.exports = {
   ensureDirectory,
   pluginsdir,
   filesdir,
+  logsdir,
   packagedPluginsDir,
   packagedPluginList,
   getPluginBackendPath,
   resolveArchiveFolder,
   clearArchiveLinksCache,
+  getLogsFilePath,
+  setLogsFilePath,
 };

package/src/utility/pipeForkLogs.js

@@ -0,0 +1,19 @@
+const byline = require('byline');
+const { safeJsonParse, getLogger } = require('dbgate-tools');
+const logger = getLogger();
+
+const logDispatcher = method => data => {
+  const json = safeJsonParse(data.toString());
+  if (json && json.level) {
+    logger.log(json);
+  } else {
+    logger[method](json || data.toString());
+  }
+};
+
+function pipeForkLogs(subprocess) {
+  byline(subprocess.stdout).on('data', logDispatcher('info'));
+  byline(subprocess.stderr).on('data', logDispatcher('error'));
+}
+
+module.exports = pipeForkLogs;

package/src/utility/processArgs.js

@@ -11,6 +11,7 @@ const startProcess = getNamedArg('--start-process');
 const isForkedApi = process.argv.includes('--is-forked-api');
 const pluginsDir = getNamedArg('--plugins-dir');
 const workspaceDir = getNamedArg('--workspace-dir');
+const processDisplayName = getNamedArg('--process-display-name');
 const listenApi = process.argv.includes('--listen-api');
 const listenApiChild = process.argv.includes('--listen-api-child') || listenApi;
 
@@ -37,4 +38,5 @@ module.exports = {
   workspaceDir,
   listenApi,
   listenApiChild,
+  processDisplayName,
 };

package/src/utility/sshTunnel.js

@@ -5,6 +5,9 @@ const AsyncLock = require('async-lock');
 const lock = new AsyncLock();
 const { fork } = require('child_process');
 const processArgs = require('../utility/processArgs');
+const { getLogger } = require('dbgate-tools');
+const pipeForkLogs = require('./pipeForkLogs');
+const logger = getLogger('sshTunnel');
 
 const sshTunnelCache = {};
 
@@ -21,18 +24,24 @@ const CONNECTION_FIELDS = [
 const TUNNEL_FIELDS = [...CONNECTION_FIELDS, 'server', 'port'];
 
 function callForwardProcess(connection, tunnelConfig, tunnelCacheKey) {
-  let subprocess = fork(global['API_PACKAGE'] || process.argv[1], [
-    '--is-forked-api',
-    '--start-process',
-    'sshForwardProcess',
-    ...processArgs.getPassArgs(),
-  ]);
+  let subprocess = fork(
+    global['API_PACKAGE'] || process.argv[1],
+    ['--is-forked-api', '--start-process', 'sshForwardProcess', ...processArgs.getPassArgs()],
+    {
+      stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+    }
+  );
+  pipeForkLogs(subprocess);
 
-  subprocess.send({
-    msgtype: 'connect',
-    connection,
-    tunnelConfig,
-  });
+  try {
+    subprocess.send({
+      msgtype: 'connect',
+      connection,
+      tunnelConfig,
+    });
+  } catch (err) {
+    logger.error({ err }, 'Error connecting SSH');
+  }
   return new Promise((resolve, reject) => {
     subprocess.on('message', resp => {
       // @ts-ignore
@@ -45,7 +54,7 @@ function callForwardProcess(connection, tunnelConfig, tunnelCacheKey) {
       }
     });
     subprocess.on('exit', code => {
-      console.log('SSH forward process exited');
+      logger.info('SSH forward process exited');
       delete sshTunnelCache[tunnelCacheKey];
     });
   });
@@ -65,13 +74,13 @@ async function getSshTunnel(connection) {
       toHost: connection.server,
     };
     try {
-      console.log(
+      logger.info(
         `Creating SSH tunnel to ${connection.sshHost}-${connection.server}:${connection.port}, using local port ${localPort}`
       );
 
       const subprocess = await callForwardProcess(connection, tunnelConfig, tunnelCacheKey);
 
-      console.log(
+      logger.info(
         `Created SSH tunnel to ${connection.sshHost}-${connection.server}:${connection.port}, using local port ${localPort}`
       );
 

package/src/utility/sshTunnelProxy.js

@@ -1,11 +1,17 @@
+const { getLogger } = require('dbgate-tools');
 const uuidv1 = require('uuid/v1');
 const { getSshTunnel } = require('./sshTunnel');
+const logger = getLogger('sshTunnelProxy');
 
 const dispatchedMessages = {};
 
 async function handleGetSshTunnelRequest({ msgid, connection }, subprocess) {
   const response = await getSshTunnel(connection);
-  subprocess.send({ msgtype: 'getsshtunnel-response', msgid, response });
+  try {
+    subprocess.send({ msgtype: 'getsshtunnel-response', msgid, response });
+  } catch (err) {
+    logger.error({ err }, 'Error sending to SSH tunnel');
+  }
 }
 
 function handleGetSshTunnelResponse({ msgid, response }, subprocess) {

package/src/utility/useController.js

@@ -2,7 +2,9 @@ const _ = require('lodash');
 const express = require('express');
 const getExpressPath = require('./getExpressPath');
 const { MissingCredentialsError } = require('./exceptions');
+const { getLogger } = require('dbgate-tools');
 
+const logger = getLogger('useController');
 /**
  * @param {string} route
  */
@@ -10,11 +12,11 @@ module.exports = function useController(app, electron, route, controller) {
   const router = express.Router();
 
   if (controller._init) {
-    console.log(`Calling init controller for controller ${route}`);
+    logger.info(`Calling init controller for controller ${route}`);
     try {
       controller._init();
     } catch (err) {
-      console.log(`Error initializing controller, exiting application`, err);
+      logger.error({ err }, `Error initializing controller, exiting application`);
       process.exit(1);
     }
   }
@@ -75,16 +77,16 @@ module.exports = function useController(app, electron, route, controller) {
         try {
           const data = await controller[key]({ ...req.body, ...req.query }, req);
           res.json(data);
-        } catch (e) {
-          console.log(e);
-          if (e instanceof MissingCredentialsError) {
+        } catch (err) {
+          logger.error({ err }, `Error when processing route ${route}/${key}`);
+          if (err instanceof MissingCredentialsError) {
             res.json({
               missingCredentials: true,
               apiErrorMessage: 'Missing credentials',
-              detail: e.detail,
+              detail: err.detail,
             });
           } else {
-            res.status(500).json({ apiErrorMessage: e.message });
+            res.status(500).json({ apiErrorMessage: err.message });
           }
         }
       });