Haraka 3.0.3 → 3.0.5

package/logger.js

@@ -1,15 +1,13 @@
 'use strict';
 // Log class
 
-const util      = require('util');
-const tty       = require('tty');
+const util      = require('node:util');
+const tty       = require('node:tty');
 
 const config    = require('haraka-config');
 const constants = require('haraka-constants');
 
 let plugins;
-let connection;
-let outbound;
 
 const regex = /(^$|[ ="\\])/;
 const escape_replace_regex = /["\\]/g;
@@ -48,6 +46,7 @@ logger.levels = {
     ALERT:    1,
     EMERG:    0,
 }
+const level_names = Object.keys(logger.levels)
 
 for (const le in logger.levels) {
     logger.levels[`LOG${le}`] = logger.levels[le];
@@ -64,6 +63,7 @@ logger.loglevel      = logger.levels.WARN;
 logger.format        = logger.formats.DEFAULT;
 logger.timestamps    = false;
 logger.deferred_logs = [];
+logger.name          = 'logger'
 
 logger.colors = {
     "DATA" : "green",
@@ -235,14 +235,16 @@ logger._init_timestamps = function () {
 
 logger._init();
 
-logger.log_if_level = (level, key, plugin) => function () {
-    if (logger.loglevel < logger[key]) { return; }
+logger.log_if_level = (level, key, origin) => function () {
+    if (logger.loglevel < logger[key]) return;
+
     let logobj = {
         level,
         uuid: '-',
-        origin: (plugin || 'core'),
+        origin: (origin || 'core'),
         message: ''
     };
+
     for (const data of arguments) {
         if (typeof data !== 'object') {
             logobj.message += (data);
@@ -251,24 +253,17 @@ logger.log_if_level = (level, key, plugin) => function () {
         if (!data) continue;
 
         // if the object is a connection, add the connection id
-        if (data instanceof connection.Connection) {
+        if (data.constructor?.name === 'Connection') {
             logobj.uuid = data.uuid;
             if (data.tran_count > 0) logobj.uuid += `.${data.tran_count}`;
         }
         else if (data instanceof plugins.Plugin) {
             logobj.origin = data.name;
         }
-        else if (data.name) {
+        else if (Object.hasOwn(data, 'name')) { // outbound
             logobj.origin = data.name;
-        }
-        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
-                    logobj.origin = `outbound] [${data.todo.client_uuid}`;
-                }
-            }
+            if (Object.hasOwn(data, 'uuid')) logobj.uuid = data.uuid;
+            if (data.todo?.uuid) logobj.uuid = data.todo.uuid; // outbound/hmail
         }
         else if (
             logger.format === logger.formats.LOGFMT && data.constructor === Object) {
@@ -278,7 +273,7 @@ logger.log_if_level = (level, key, plugin) => function () {
             logger.format === logger.formats.JSON && data.constructor === Object) {
             logobj = Object.assign(logobj, data);
         }
-        else if (typeof data === 'object' && Object.prototype.hasOwnProperty.call(data, "uuid")) {
+        else if (Object.hasOwn(data, 'uuid')) { // outbound/client_pool
             logobj.uuid = data.uuid;
         }
         else if (data.constructor === Object) {
@@ -313,14 +308,37 @@ logger.log_if_level = (level, key, plugin) => function () {
     return true;
 }
 
-logger.add_log_methods = (object, plugin) => {
-    if (!object) return;
-    if (typeof(object) !== 'object') return;
+logger.add_log_methods = (object, logName) => {
+    if (!object) return
 
-    for (const level in logger.levels) {
-        const fname = `log${level.toLowerCase()}`;
-        if (object[fname]) continue;  // already added
-        object[fname] = logger.log_if_level(level, `LOG${level}`, plugin);
+    if (typeof object === 'function') {
+        // add logging methods to class prototypes (Connection, Plugin, etc.)
+
+        for (const level of level_names.map(l => l.toLowerCase())) {
+            object.prototype[`log${level}`] = (function (level) {
+                return function () {
+                    logger[level].apply(logger, [ this, ...arguments ]);
+                };
+            })(`log${level}`);
+        }
+    }
+    else if (typeof object === 'object') {
+        // add logging methods to objects
+
+        for (const level of level_names) {
+            // objects gets log function names: loginfo, logwarn, logdebug, ...
+            const fnNames = [`log${level.toLowerCase()}`]
+
+            // logger also gets short names
+            if (Object.hasOwn(object, 'name') && object.name === 'logger') {
+                fnNames.push(level.toLowerCase())
+            }
+
+            for (const fnName of fnNames) {
+                if (Object.hasOwn(object, fnName)) continue; // already added
+                object[fnName] = logger.log_if_level(level, `LOG${level}`, logName);
+            }
+        }
     }
 }
 
@@ -328,5 +346,3 @@ logger.add_log_methods(logger);
 
 // load these down here so it sees all the logger methods compiled above
 plugins = require('./plugins');
-connection = require('./connection');
-outbound = require('./outbound');

package/outbound/client_pool.js

@@ -1,48 +1,52 @@
 'use strict';
 
-const utils        = require('haraka-utils');
+const utils = require('haraka-utils');
+const net_utils = require('haraka-net-utils')
 
-const sock         = require('../line_socket');
-const logger       = require('../logger');
+const tls_socket = require('../tls_socket');
+const logger = require('../logger');
+const obc  = require('./config');
 
-const obc          = require('./config');
+exports.name = 'outbound'
 
-function _create_socket (name, port, host, local_addr, is_unix_socket, callback) {
+// Get a socket for the given attributes.
+exports.get_client = function (mx, callback) {
+    const socketArgs = mx.path ? { path: mx.path } : { port: mx.port, host: mx.exchange, localAddress: mx.bind };
+
+    const socket = tls_socket.connect(socketArgs);
+    net_utils.add_line_processor(socket);
 
-    const socket = is_unix_socket ? sock.connect({path: host}) : sock.connect({port, host, localAddress: local_addr});
-    socket.name = name;
+    socket.name = `outbound::${JSON.stringify(socketArgs)}`;
     socket.__uuid = utils.uuid();
     socket.setTimeout(obc.cfg.connect_timeout * 1000);
-    logger.logdebug(`[outbound] created. host: ${host} port: ${port}`, { uuid: socket.__uuid });
+
+    logger.debug(exports, `created ${socket.name}`, { uuid: socket.__uuid });
+
     socket.once('connect', () => {
         socket.removeAllListeners('error'); // these get added after callback
         socket.removeAllListeners('timeout');
         callback(null, socket);
-    });
+    })
+
     socket.once('error', err => {
         socket.end();
         socket.removeAllListeners();
         socket.destroy();
-        callback(`Outbound connection error: ${err}`, null);
-    });
+        callback(err.message, null);
+    })
+
     socket.once('timeout', () => {
         socket.end();
         socket.removeAllListeners();
         socket.destroy();
-        callback(`Outbound connection timed out to ${host}:${port}`, null);
-    });
-}
-
-
-// Get a socket for the given attributes.
-exports.get_client = (port = 25, host = 'localhost', local_addr, is_unix_socket, callback) => {
-    const name = `outbound::${port}:${host}:${local_addr}`;
-
-    _create_socket(name, port, host, local_addr, is_unix_socket, callback)
+        callback(`connection timed out to ${socket.name}`, null);
+    })
 }
 
-exports.release_client = (socket, port, host, local_addr, error) => {
-    logger.logdebug(`[outbound] release_client: ${socket.__uuid} ${host}:${port} to ${local_addr}`);
+exports.release_client = (socket, mx) => {
+    let logMsg = `release_client: ${socket.name}`
+    if (mx.bind) logMsg += ` from ${mx.bind}`
+    logger.debug(exports, logMsg);
     socket.removeAllListeners();
     socket.destroy();
 }

package/outbound/config.js

@@ -3,13 +3,14 @@
 const config = require('haraka-config');
 const logger = require('../logger');
 
+exports.name = 'outbound/config'
+
 function load_config () {
     const cfg = exports.cfg = config.get('outbound.ini', {
         booleans: [
             '-disabled',
             '-always_split',
             '+enable_tls',
-            '-ipv6_enabled',
             '-local_mx_ok',
         ],
     }, () => {
@@ -35,9 +36,6 @@ function load_config () {
     if (!cfg.connect_timeout) {
         cfg.connect_timeout = 30;
     }
-    if (!cfg.ipv6_enabled && config.get('outbound.ipv6_enabled')) {
-        cfg.ipv6_enabled = true;
-    }
     if (!cfg.received_header) {
         cfg.received_header = config.get('outbound.received_header') || 'Haraka outbound';
     }
@@ -64,8 +62,8 @@ exports.set_temp_fail_intervals = function () {
 
     // Helpful error function in case of parsing failure
     function error (i, msg) {
-        logger.logerror(`outbound temp_fail_intervals syntax error parsing element ${i}: ${msg}`);
-        logger.logwarn('Setting outbound temp_fail_intervals to old defaults because of previous error');
+        logger.error(exports, `temp_fail_intervals syntax error parsing element ${i}: ${msg}`);
+        logger.warn(exports, 'Setting outbound temp_fail_intervals to old defaults');
         set_old_defaults();
     }
 

package/outbound/fsync_writestream.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const fs      = require('fs');
+const fs = require('node:fs');
 
 class FsyncWriteStream extends fs.WriteStream {
     constructor (path, options) {