Haraka 2.8.28 → 3.0.1

package/logger.js

@@ -87,14 +87,13 @@ logger._init = function () {
 }
 
 logger.load_log_ini = function () {
-    const self = this;
-    self.cfg = config.get('log.ini', {
+    this.cfg = config.get('log.ini', {
         booleans: [
             '+main.timestamps',
         ]
     },
     () => {
-        self.load_log_ini();
+        this.load_log_ini();
     });
 
     this.set_loglevel(this.cfg.main.level);
@@ -135,8 +134,7 @@ logger.log = (level, data, logobj) => {
     if (level === 'PROTOCOL') {
         data = data.replace(/\n/g, '\\n');
     }
-    data = data.replace(/\r/g, '\\r')
-        .replace(/\n$/, '');
+    data = data.replace(/\r/g, '\\r').replace(/\n$/, '');
 
     const item = { level, data, obj: logobj};
 
@@ -159,18 +157,19 @@ logger.log = (level, data, logobj) => {
 
 logger.log_respond = (retval, msg, data) => {
     // any other return code is irrelevant
-    if (retval !== constants.cont) { return false; }
+    if (retval !== constants.cont) return false;
+
     let timestamp_string = '';
-    if (logger.timestamps) {
-        timestamp_string = `${new Date().toISOString()} `;
-    }
+    if (logger.timestamps) timestamp_string = `${new Date().toISOString()} `;
+
     const color = logger.colors[data.level];
     if (color && stdout_is_tty) {
         process.stdout.write(`${timestamp_string}${logger.colorize(color,data.data)}\n`);
-        return true;
+    }
+    else {
+        process.stdout.write(`${timestamp_string}${data.data}\n`);
     }
 
-    process.stdout.write(`${timestamp_string}${data.data}\n`);
     return true;
 }
 
@@ -207,17 +206,16 @@ logger.set_format = function (format) {
 }
 
 logger._init_loglevel = function () {
-    const self = this;
 
     const _loglevel = config.get('loglevel', 'value', () => {
-        self._init_loglevel();
+        this._init_loglevel();
     });
 
-    self.set_loglevel(_loglevel);
+    this.set_loglevel(_loglevel);
 }
 
 logger.would_log = level => {
-    if (logger.loglevel < level) { return false; }
+    if (logger.loglevel < level) return false;
     return true;
 }
 
@@ -226,15 +224,13 @@ logger.set_timestamps = value => {
 }
 
 logger._init_timestamps = function () {
-    const self = this;
 
     const _timestamps = config.get('log_timestamps', 'value', () => {
-        self._init_timestamps();
+        this._init_timestamps();
     });
 
-    // If we've already been toggled to true by the cfg, we should respect
-    // this.
-    self.set_timestamps(logger.timestamps || _timestamps);
+    // If we've already been toggled to true by the cfg, we should respect this.
+    this.set_timestamps(logger.timestamps || _timestamps);
 }
 
 logger._init();
@@ -247,8 +243,7 @@ logger.log_if_level = (level, key, plugin) => function () {
         origin: (plugin || 'core'),
         message: ''
     };
-    for (let i=0; i < arguments.length; i++) {
-        const data = arguments[i];
+    for (const data of arguments) {
         if (typeof data !== 'object') {
             logobj.message += (data);
             continue;
@@ -258,9 +253,7 @@ logger.log_if_level = (level, key, plugin) => function () {
         // if the object is a connection, add the connection id
         if (data instanceof connection.Connection) {
             logobj.uuid = data.uuid;
-            if (data.tran_count > 0) {
-                logobj.uuid += `.${data.tran_count}`;
-            }
+            if (data.tran_count > 0) logobj.uuid += `.${data.tran_count}`;
         }
         else if (data instanceof plugins.Plugin) {
             logobj.origin = data.name;
@@ -271,10 +264,8 @@ logger.log_if_level = (level, key, plugin) => function () {
         else if (data instanceof outbound.HMailItem) {
             logobj.origin = 'outbound';
             if (data.todo) {
-                if (data.todo.uuid)
-                    logobj.uuid = data.todo.uuid;
-                if (data.todo.client_uuid) {
-                    // dirty hack
+                if (data.todo.uuid) logobj.uuid = data.todo.uuid;
+                if (data.todo.client_uuid) {    // dirty hack
                     logobj.origin = `outbound] [${data.todo.client_uuid}`;
                 }
             }
@@ -298,32 +289,34 @@ logger.log_if_level = (level, key, plugin) => function () {
             logobj.message += (util.inspect(data));
         }
     }
+
     switch (logger.format) {
         case logger.formats.LOGFMT:
             logger.log(
                 level,
                 stringify(logobj)
             );
-            return true;
+            break
         case logger.formats.JSON:
             logger.log(
                 level,
                 JSON.stringify(logobj)
             );
-            return true;
+            break
         case logger.formats.DEFAULT:
         default:
             logger.log(
                 level,
                 `[${logobj.level}] [${logobj.uuid}] [${logobj.origin}] ${logobj.message}`
             );
-            return true;
     }
+    return true;
 }
 
 logger.add_log_methods = (object, plugin) => {
     if (!object) return;
     if (typeof(object) !== 'object') return;
+
     for (const level in logger.levels) {
         const fname = `log${level.toLowerCase()}`;
         if (object[fname]) continue;  // already added

package/outbound/client_pool.js

@@ -1,29 +1,19 @@
-"use strict";
+'use strict';
 
-const generic_pool = require('generic-pool');
 const utils        = require('haraka-utils');
 
 const sock         = require('../line_socket');
-const server       = require('../server');
 const logger       = require('../logger');
 
 const obc          = require('./config');
 
-function _create_socket (pool_name, port, host, local_addr, is_unix_socket, callback) {
-    const socket = is_unix_socket ? sock.connect({path: host}) :
-        sock.connect({port, host, localAddress: local_addr});
-    socket.__pool_name = pool_name;
+function _create_socket (name, port, host, local_addr, is_unix_socket, callback) {
+
+    const socket = is_unix_socket ? sock.connect({path: host}) : sock.connect({port, host, localAddress: local_addr});
+    socket.name = name;
     socket.__uuid = utils.uuid();
     socket.setTimeout(obc.cfg.connect_timeout * 1000);
-    logger.logdebug(
-        '[outbound] created',
-        {
-            uuid: socket.__uuid,
-            host,
-            port,
-            pool_timeout: obc.cfg.pool_timeout
-        }
-    );
+    logger.logdebug(`[outbound] created. host: ${host} port: ${port}`, { uuid: socket.__uuid });
     socket.once('connect', () => {
         socket.removeAllListeners('error'); // these get added after callback
         socket.removeAllListeners('timeout');
@@ -43,148 +33,16 @@ function _create_socket (pool_name, port, host, local_addr, is_unix_socket, call
     });
 }
 
-// Separate pools are kept for each set of server attributes.
-function get_pool (port, host, local_addr, is_unix_socket, max) {
-    port = port || 25;
-    host = host || 'localhost';
-    const name = `outbound::${port}:${host}:${local_addr}:${obc.cfg.pool_timeout}`;
-    if (!server.notes.pool) server.notes.pool = {};
-    if (server.notes.pool[name]) return server.notes.pool[name];
-
-    const pool = generic_pool.Pool({
-        name,
-        create (done) {
-            _create_socket(this.name, port, host, local_addr, is_unix_socket, done);
-        },
-        validate: socket => socket.__fromPool && socket.writable,
-        destroy: socket => {
-            logger.logdebug(`[outbound] destroying pool entry ${socket.__uuid} for ${host}:${port}`);
-            socket.removeAllListeners();
-            socket.__fromPool = false;
-            socket.on('line', line => {
-                // Just assume this is a valid response
-                logger.logprotocol(`[outbound] S: ${line}`);
-            });
-            socket.once('error', err => {
-                logger.logwarn(`[outbound] Socket got an error while shutting down: ${err}`);
-            });
-            socket.once('end', () => {
-                logger.loginfo("[outbound] Remote end half closed during destroy()");
-                socket.destroy();
-            })
-            if (socket.writable) {
-                logger.logprotocol(`[outbound] [${socket.__uuid}] C: QUIT`);
-                socket.write("QUIT\r\n");
-            }
-            socket.end(); // half close
-        },
-        max: max || 10,
-        idleTimeoutMillis: obc.cfg.pool_timeout * 1000,
-        log: (str, level) => {
-            if (/this._availableObjects.length=/.test(str)) return;
-            level = (level === 'verbose') ? 'debug' : level;
-            logger[`log${level}`](`[outbound] [${name}] ${str}`);
-        }
-    });
-    server.notes.pool[name] = pool;
-
-    return pool;
-}
 
 // Get a socket for the given attributes.
-exports.get_client = (port, host, local_addr, is_unix_socket, callback) => {
-    if (obc.cfg.pool_concurrency_max == 0) {
-        return _create_socket(null, port, host, local_addr, is_unix_socket, callback);
-    }
+exports.get_client = (port = 25, host = 'localhost', local_addr, is_unix_socket, callback) => {
+    const name = `outbound::${port}:${host}:${local_addr}`;
 
-    const pool = get_pool(port, host, local_addr, is_unix_socket, obc.cfg.pool_concurrency_max);
-    if (pool.waitingClientsCount() >= obc.cfg.pool_concurrency_max) {
-        return callback("Too many waiting clients for pool", null);
-    }
-    pool.acquire((err, socket) => {
-        if (err) return callback(err);
-        socket.__acquired = true;
-        logger.loginfo(`[outbound] acquired socket ${socket.__uuid} for ${socket.__pool_name}`);
-        callback(null, socket);
-    });
+    _create_socket(name, port, host, local_addr, is_unix_socket, callback)
 }
 
 exports.release_client = (socket, port, host, local_addr, error) => {
     logger.logdebug(`[outbound] release_client: ${socket.__uuid} ${host}:${port} to ${local_addr}`);
-
-    const name = socket.__pool_name;
-
-    if (!name && obc.cfg.pool_concurrency_max == 0) {
-        return sockend();
-    }
-
-    if (!socket.__acquired) {
-        logger.logwarn(`Release an un-acquired socket. Stack: ${(new Error()).stack}`);
-        return;
-    }
-    socket.__acquired = false;
-
-    if (!(server.notes && server.notes.pool)) {
-        logger.logcrit(`[outbound] Releasing a pool (${name}) that doesn't exist!`);
-        return;
-    }
-    const pool = server.notes.pool[name];
-    if (!pool) {
-        logger.logcrit(`[outbound] Releasing a pool (${name}) that doesn't exist!`);
-        return;
-    }
-
-    if (error) {
-        return sockend();
-    }
-
-    if (obc.cfg.pool_timeout == 0) {
-        logger.loginfo("[outbound] Pool_timeout is zero - shutting it down");
-        return sockend();
-    }
-
-    for (const event of ['close','error','end','timeout','line']) {
-        socket.removeAllListeners(event);
-    }
-
-    socket.__fromPool = true;
-
-    socket.once('error', err => {
-        logger.logwarn(`[outbound] Socket [${name}] in pool got an error: ${err}`);
-        sockend();
-    });
-
-    socket.once('end', () => {
-        logger.loginfo(`[outbound] Socket [${name}] in pool got FIN`);
-        socket.writable = false;
-        sockend();
-    });
-
-    pool.release(socket);
-
-    function sockend () {
-        socket.__fromPool = false;
-        if (server.notes.pool && server.notes.pool[name]) {
-            server.notes.pool[name].destroy(socket);
-        }
-        else {
-            socket.removeAllListeners();
-            socket.destroy();
-        }
-    }
-}
-
-exports.drain_pools = () => {
-    if (!server.notes.pool || Object.keys(server.notes.pool).length == 0) {
-        return logger.logdebug("[outbound] Drain pools: No pools available");
-    }
-    Object.keys(server.notes.pool).forEach(p => {
-        logger.logdebug(`[outbound] Drain pools: Draining SMTP connection pool ${p}`);
-        server.notes.pool[p].drain(() => {
-            if (!server.notes.pool[p]) return;
-            server.notes.pool[p].destroyAllNow();
-            delete server.notes.pool[p];
-        });
-    });
-    logger.logdebug("[outbound] Drain pools: Pools shut down");
+    socket.removeAllListeners();
+    socket.destroy();
 }

package/outbound/config.js

@@ -35,12 +35,6 @@ function load_config () {
     if (!cfg.connect_timeout) {
         cfg.connect_timeout = 30;
     }
-    if (cfg.pool_timeout === undefined) {
-        cfg.pool_timeout = 50;
-    }
-    if (cfg.pool_concurrency_max === undefined) {
-        cfg.pool_concurrency_max = 10;
-    }
     if (!cfg.ipv6_enabled && config.get('outbound.ipv6_enabled')) {
         cfg.ipv6_enabled = true;
     }
@@ -58,13 +52,13 @@ exports.set_temp_fail_intervals = function () {
     //      it with the equivalent times of maxTempFailures using the original 2^N formula
     //   3) the word "none" can be specified if you do not want to retry a temp failure,
     //      equivalent behavior of specifying maxTempFailures=1
-    const cfg = this.cfg;
+    const { cfg } = this;
 
     // Fallback function to create an array of the original retry times
     function set_old_defaults () {
         cfg.temp_fail_intervals = [];
         for (let i=1; i<cfg.maxTempFailures; i++) {
-            cfg.temp_fail_intervals.push(Math.pow(2, (i + 5)));
+            cfg.temp_fail_intervals.push(2 ** (i + 5));
         }
     }
 
@@ -109,13 +103,13 @@ exports.set_temp_fail_intervals = function () {
                 // do nothing, this is the base unit
                 break;
             case 'm':
-                num = num * 60;
+                num *= 60;
                 break;
             case 'h':
-                num = num * 3600;
+                num *= 3600;
                 break;
             case 'd':
-                num = num * 86400;
+                num *= 86400;
                 break;
             default:
                 return error(i, 'invalid time span symbol');