miolo 2.0.0-beta.1 → 2.0.0-beta.3

package/src/server/engines/http/index.mjs

@@ -0,0 +1,79 @@
+import http                         from 'http'
+//import util                       from 'util'
+import { createHttpTerminator }     from 'http-terminator'
+
+
+// promisify the server.listen()
+
+// opt1
+// let server = http.createServer(app.callback())
+// const promise = util.promisify( server.listen.bind( server ) )
+// await promise( config.port, config.hostname)
+
+// opt2
+const _listenAsync = (server, port, hostname) => {
+  return new Promise((resolve, reject) => {
+    server.listen(port, hostname, (error) => {
+      if (error) {
+        reject(error)
+      } else {
+        resolve()
+      }
+    })
+  })
+}
+
+export function init_http_server(app, config) {
+  const miolo = app.context.miolo
+  const logger= miolo.logger
+
+  const _http_start = async () => {
+    try {
+      // If previous server already created, lets avoid
+      if (app.http?.server != undefined) {
+        logger.warn(`[http][start] Server already running on ${app?.http?.hostname}:${app?.http?.port}`)
+        return
+      }
+
+      // Init server
+      const server = http.createServer(app.callback())
+
+      // Init terminator
+      const httpTerminator = createHttpTerminator({
+        server,
+      })
+
+      const http_stop = async () => {
+        try {
+          await httpTerminator.terminate()
+          delete app.http.server
+          logger.info(`[http][stop] miolo has been shutdowned from ${config.hostname}:${config.port}`)
+        } catch(error) {
+          logger.error(`[http][stop] error: ${error}`)
+        }
+      }
+
+      app.http.server = server
+      app.http.stop = http_stop
+
+      // Finally start the server
+      await _listenAsync(server, config.port, config.hostname)
+      logger.info(`[http][start] miolo is listening on ${config.hostname}:${config.port}`)
+    } catch(error) {
+      logger.error(`[http][start] error: ${error}`)
+    }
+  }  
+
+  // Attach objects to app
+  app.http = {
+    server: undefined,
+    start: _http_start,
+    stop: async () => {
+      logger.warn(`[http] stop() stop() function still not attached. Is server running?`)
+    },
+    hostname: config.hostname,
+    port: config.port
+  }  
+
+  return app
+}

package/src/server/engines/logger/index.mjs

@@ -0,0 +1,313 @@
+// import fs from 'fs'
+// import path from 'path'
+import { red, cyan, magenta, yellow, gray, red_light } from 'tinguir'
+/* https://github.com/winstonjs/winston/issues/925 */
+/* https://github.com/winstonjs/winston/issues/287 */
+import {init_logger_to_mail} from './logger_mail.mjs'
+import { createLogger, format, transports } from 'winston'
+import { reopenTransportOnHupSignal } from './reopenTransportOnHupSignal.mjs'
+// import  'winston-daily-rotate-file'
+// import { /*intre_to_str,*/ intre_now } from 'intre'
+
+const { combine, timestamp, _label, printf, errors } = format
+
+
+
+const init_logger = (config, emailer, prefix= 'miolo') => {
+  const LEVEL_COLORS= {
+    silly  : gray,
+    debug  : magenta,
+    verbose: cyan,
+    info   : yellow,
+    warn   : red_light,
+    error  : red
+  }
+
+  const LEVEL_ABBRV= {
+    silly  : 'sly',
+    debug  : 'dbg',
+    verbose: 'vbs',
+    info   : 'inf',
+    warn   : 'wrn',
+    error  : 'err',
+  }
+
+  const _INDENT_SIZE = 4
+  let _INDENT = 0
+  let _SECTIONS = {}
+
+  const myFormat = info => {
+    const lc = LEVEL_COLORS[info.level]
+    const tm = new Date(info.timestamp)
+    const ts= tm.toLocaleString(config?.format?.locale || 'en')
+    let sindent = ''.padStart(_INDENT, ' ')
+    //const ts= tm.toString().substr(4, 20)
+    const log= `[${prefix}] ${lc(ts)} ${lc(LEVEL_ABBRV[info.level])} ${sindent}${info.message}`
+    return info.stack
+      ? `${log}\n${info.stack}`
+      : log    
+  }
+
+  let _log_transports= []
+  //
+  // Console transport
+  // If we're not in production then log to the `console` with the format:
+  // `${info.level}: ${info.message} JSON.stringify({ ...rest }) `
+  // 
+
+  if (config?.console?.enabled === true) {
+    _log_transports.push(
+        new transports.Console({
+          humanReadableUnhandledException: true,
+          level    : config?.console?.level || config?.level || 'silly',
+          handleExceptions: true
+    }))
+  }
+
+  //
+  // File transport
+  //
+  // logrotate's copytruncate seems not enough
+  //  https://github.com/winstonjs/winston/issues/943
+  //  https://gist.github.com/suprememoocow/5133080
+  //
+  if (config?.file?.enabled === true) {
+    
+    const fileTransport = new transports.File({ 
+      filename : config?.file?.filename 
+      ? config.file.filename.replace('%MIOLO%', prefix)
+      : '/var/log/afialapis/miolo.log',
+      level    : config?.file?.level || config?.level || 'info' ,
+      humanReadableUnhandledException: true,
+      handleExceptions: true,
+      maxRetries: 10
+    })
+    
+    if (config?.file?.hup_patch === true) {
+      reopenTransportOnHupSignal(fileTransport)
+    }
+
+    _log_transports.push(fileTransport)
+
+
+  //    const _file_log = (s) => {
+  //      const filename = path.join(fileTransport.dirname, fileTransport.filename)
+  //      
+  //      // console.log(fileTransport._stream )
+  //      const msg = myFormat({
+  //        level: 'info',
+  //        message: `[logger][file-rotate] ${s}\n`,
+  //        timestamp: intre_now()
+  //      })
+  //
+  //      try {
+  //        fs.accessSync(filename, fs.constants.F_OK)
+  //        fs.appendFileSync(filename, msg)
+  //      } catch(_) {
+  //        fs.writeFileSync(filename, msg, { encoding: 'utf-8' })
+  //      }
+  //      if (config?.console?.enabled === true) {
+  //        if (fileTransport.levels[config?.console?.level || config?.level || 'error'] >= fileTransport.levels['info']) {
+  //          console.log(msg)
+  //        }
+  //      }
+  //    }
+  //
+  //    fileTransport.on('finish', function(info) {
+  //      // do something fun
+  //      _file_log('Log done')
+  //    })    
+  //    fileTransport.on('error', function(error) {
+  //      // do something fun
+  //      _file_log(red(`Error: ${error}`))
+  //    })
+  //
+  }
+
+  //  if (config?.file?.enabled === true) {
+  //    const datePattern = config?.file?.datePattern || 'YYYY-MM-DD'
+  //
+  //    const fileTransport = new transports.DailyRotateFile({ 
+  //      level    : config?.file?.level || config?.level || 'info' ,
+  //
+  //      frequency: config?.file?.frequency,
+  //      datePattern,
+  //      zippedArchive: config?.file?.zippedArchive == true,
+  //      maxSize: config?.file?.maxSize || '20m',
+  //      maxFiles: config?.file?.maxFiles || '10d',
+  //      
+  //      filename : config?.file?.filename 
+  //        ? config.file.filename.replace('%MIOLO%', prefix)
+  //        : '/var/log/afialapis/miolo.%DATE%.log', 
+  //      
+  //      auditFile: config?.file?.auditFile
+  //        ? config.file.auditFile.replace('%MIOLO%', prefix)
+  //        : '/var/log/afialapis/miolo.audit.json',
+  //      
+  //      symlinkName: config?.file?.symlinkName
+  //        ? config.file.symlinkName.replace('%MIOLO%', prefix)
+  //        : 'miolo.log',
+  //
+  //      createSymlink: config?.file?.createSymlink == true,
+  //      
+  //      watchLog: true,
+  //
+  //      humanReadableUnhandledException: true,
+  //      handleExceptions: true
+  //    })
+  //
+  //    const _file_log = (s) => {
+  //      const currentDate = intre_to_str(intre_now(), datePattern)
+  //      const filename = path.join(fileTransport.dirname, fileTransport.filename.replace('%DATE%', currentDate))
+  //      
+  //      const msg = myFormat({
+  //        level: 'info',
+  //        message: `[logger][file-rotate] ${s}\n`,
+  //        timestamp: intre_now()
+  //      })
+  //      try {
+  //        fs.accessSync(filename, fs.constants.F_OK)
+  //        fs.appendFileSync(filename, msg)
+  //      } catch(_) {
+  //        fs.writeFileSync(filename, msg, { encoding: 'utf-8' })
+  //      }
+  //      if (config?.console?.enabled === true) {
+  //        if (fileTransport.levels[config?.console?.level || config?.level || 'error'] >= fileTransport.levels['info']) {
+  //          console.log(msg)
+  //        }
+  //      }
+  //    }
+  //
+  //    const _fname = (f) => magenta(f.replace(fileTransport.dirname+path.sep, ''))
+  //
+  //
+  //    fileTransport.on('new', function(newFilename) {
+  //      _file_log(`New log file: ${_fname(newFilename)}`)
+  //    });
+  //
+  //    fileTransport.on('rotate', function(oldFilename, newFilename) {
+  //      _file_log(`Rotating log file: ${_fname(oldFilename)} -- ${_fname(newFilename)}`)
+  //    })
+  //
+  //    fileTransport.on('archive', function(zipFilename) {
+  //      _file_log(`Archived log file: ${_fname(zipFilename)}`)
+  //    })
+  //
+  //    fileTransport.on('logRemoved', function(removedFilename) {
+  //      _file_log(`Removed log file: ${_fname(removedFilename)}`)
+  //    })
+  //
+  //    fileTransport.on('error', function(error) {
+  //      // do something fun
+  //      _file_log(red(`Error: ${error}`))
+  //    })
+  //
+  //    _log_transports.push(fileTransport)
+  //  }
+
+
+  //  if (config?.file?.enabled === true) {
+  //    const fileTransport = new transports.File({ 
+  //      level    : config?.file?.level || config?.level || 'info' ,
+  //
+  //      zippedArchive: config?.file?.zippedArchive == true,
+  //      maxsize: config?.file?.maxsize || (1024 * 1024 * 20),
+  //      maxFiles: config?.file?.maxFiles || 20,
+  //        //      
+  //      filename : config?.file?.filename 
+  //        ? config.file.filename.replace('%MIOLO%', prefix)
+  //        : '/var/log/afialapis/miolo.log', 
+  //        //      
+  //
+  //      humanReadableUnhandledException: true,
+  //      handleExceptions: true,
+  //      lazy: false,
+  //      tailable: true,
+  //
+  //    })
+  //  
+  //    _log_transports.push(fileTransport)
+  //  }
+
+
+  //
+  // Mail transport
+  //
+  if (config?.mail?.enabled === true) {    
+    const MailerLogger= init_logger_to_mail(config.mail, emailer)
+    transports.MailerLogger = MailerLogger
+
+    _log_transports.push(
+      new transports.MailerLogger({
+        humanReadableUnhandledException: true,
+        handleExceptions: true    
+      })
+    )
+  }
+
+  //
+  // Logger
+  //
+  const logger = createLogger({
+    level: config?.level || 'silly',
+    format: combine(
+      errors({ stack: true }),
+      timestamp(),
+      printf(myFormat)
+    ),
+    transports: _log_transports
+  })
+
+  const _make_indented_log = (f, name) => {
+    const _indented_func = (text, opts) => {
+      try {
+        if (opts?.section) {
+          if (! (opts.section in _SECTIONS)) {
+            // Section starts
+            _SECTIONS[opts.section]= {
+              indentIncr: parseInt(opts?.indent || _INDENT_SIZE),
+              timeStart: Date.now()
+            }
+            const nIndent = Math.max(_INDENT + _SECTIONS[opts.section].indentIncr, 0)
+            f(text, opts)
+            _INDENT= nIndent
+            
+          } else {
+            // Section ends
+            const elapsed = parseFloat( (Date.now() - _SECTIONS[opts.section].timeStart) / 1000.0 ).toFixed(2)
+            text = `${text} (time: ${elapsed})`
+            _INDENT-= _SECTIONS[opts.section].indentIncr
+            f(text, opts)
+            delete _SECTIONS[opts.section]      
+          }
+        } else {
+          f(text, opts)
+        }
+      } catch(error) {
+        // TODO - How to exxpose info from here
+        console.error(error)
+
+      }
+    }
+    Object.defineProperty(_indented_func, "name", { value: name });
+    return _indented_func
+  }
+
+  logger.error   = _make_indented_log(logger.error, 'error')
+  logger.warn    = _make_indented_log(logger.warn, 'warn')
+  logger.info    = _make_indented_log(logger.info, 'info')
+  logger.http    = _make_indented_log(logger.http, 'http')
+  logger.verbose = _make_indented_log(logger.verbose, 'verbose')
+  logger.debug   = _make_indented_log(logger.debug, 'debug')
+  logger.silly   = _make_indented_log(logger.silly, 'silly')
+
+  //console.log(logger.transports[0])
+  try {
+    logger.debug(`[logger] Inited for ${logger.transports.map(t => `${t.name} (${t.level})${t.silent ? red(' SILENT!') : ''}`).join(',')}`)
+  } catch(_) {}
+
+  return logger
+}
+
+
+export {init_logger}

package/src/server/engines/logger/logger_mail.mjs

@@ -0,0 +1,89 @@
+// "use strict";
+import util from 'util'
+import winston from 'winston'
+import { uncolor } from 'tinguir'
+
+function init_logger_to_mail(config, emailer) {
+
+
+  let MailerLogger = function (options) {
+      winston.Transport.call(this, options);
+      options = options || {};
+
+      this.level = config.level  || 'info'
+      this.ename = config?.name  || emailer.defaults.name
+      this.to    = config.to     || emailer.defaults.to
+      this.from  = config.from   || emailer.defaults.from
+      this.humanReadableUnhandledException = options.humanReadableUnhandledException || true;
+      this.handleExceptions                = options.handleExceptions || true;
+      this.json                            = options.json || false;
+      this.colorize                        = options.colorize || false;
+
+
+
+      
+  };
+
+  /** @extends winston.Transport */
+  util.inherits(MailerLogger, winston.Transport);
+
+  //
+  // Expose the name of this Transport on the prototype
+  //
+  MailerLogger.prototype.name = 'MailerLogger';
+
+
+  MailerLogger.prototype.log = function (info, callback) {
+    let self = this;
+
+    let title = ''
+    let body = ''
+
+    try {
+      try {
+        title= info.message.split("\n")[0]
+      } catch(e) {
+        title= info.message.toString();
+      }
+
+      title= uncolor(title)
+      
+    } catch(err) {
+      title = `Could not create a title for the error (${err.toString()})`
+    }
+
+    try {
+      try {
+        body = uncolor(info.message)
+      } catch(err) {
+        body = info.message.toString()
+      }  
+    } catch(err) {
+      body = `Could not create a body for the error (${err.toString()})`
+    }
+    
+    try {
+      let subject = `${config?.name} [${info.level.toUpperCase()}] ${title}`
+
+      let mail= {
+        from    : this.from,
+        to      : this.to,
+        subject : subject, 
+        text    : body
+      }
+
+      emailer.queue_email(mail)
+      self.emit("logged")
+      callback(null, true)
+
+    } catch(error) {
+      // TODO - How to exxpose info from here
+      self.emit("logged");
+      callback(null, true);    
+    }
+  };
+  
+  return MailerLogger
+}
+
+export {init_logger_to_mail}

package/src/server/engines/logger/reopenTransportOnHupSignal.mjs

@@ -0,0 +1,57 @@
+/**
+ * https://gist.github.com/suprememoocow/5133080
+ * 
+ * https://github.com/winstonjs/winston/issues/943
+ * 
+ * A function for reopening a winston File logging transport post logrotation on a HUP signal.
+ * To send a HUP to your node service, use the postrotate configuration option from logrotate. 
+ *   `postrotate kill -HUP ‘cat /var/run/mynodeservice.pid‘`
+ */
+import path from 'path'
+import fs from 'fs'
+
+export function reopenTransportOnHupSignal(fileTransport) {
+  process.on('SIGHUP', function() {    
+
+    const fullname = path.join(fileTransport.dirname, fileTransport._getFile(false))
+
+    //console.log(`[miolo][file-logger] SIGHUP received. Check if we need to re-open log file ${fullname}...`)
+
+    function reopen() {
+      console.log(`[miolo][file-logger] SIGHUP received. Reopening ${fullname}...`)
+      try {
+        if (fileTransport._stream) {
+          fileTransport._stream.end()
+          fileTransport._stream.destroy() // Soon()
+        }
+
+        let stream = fs.createWriteStream(fullname, fileTransport.options)
+        stream.setMaxListeners(Infinity)
+
+        fileTransport._size = 0
+        fileTransport._stream = stream
+
+        //fileTransport.once('flush', function () {
+          fileTransport.opening = false
+          fileTransport.emit('open', fullname)
+        //})
+
+        //fileTransport.flush()
+
+        console.log(`[miolo][file-logger] Reopened ${fullname} successfully`)
+      } catch(error) {
+        console.error(`[miolo][file-logger] Error reopening ${fullname}: ${error.toString()}`)
+      }
+    }
+
+    /*
+    fs.stat(fullname, function (err) {
+      if (err && err.code == 'ENOENT') {
+        return reopen()
+      }
+    })
+    */
+    return reopen()
+
+  })
+}

package/src/server/engines/logger/verify.mjs

@@ -0,0 +1,22 @@
+import {make_logger} from './index.mjs'
+
+
+function verify_logger(config) {
+  const logger= make_logger(config)
+  try {
+    console.info('[miolo][Verify][LOGGER] Verifying...')
+    
+    logger.error('Error message')
+    logger.warn('Warn message')
+    logger.info('Info message')
+    logger.verbose('Verbose message')
+    logger.debug('Debug message')
+    logger.silly('Silly message')
+
+  } catch(e) {
+    console.error('[miolo][Verify][LOGGER] ERROR: ')
+    console.error(e)
+  }
+}
+
+export {verify_logger}

package/src/server/engines/parser/Parser.mjs

@@ -0,0 +1,126 @@
+export default class Parser {
+  
+  parse_value_str(v, required= false, def= undefined) {
+    if ((v==null) || (v==undefined)) {
+      if (required) {
+       throw `Wrong str value passed: ${v}`
+      }
+      return def
+    }
+  
+    return v.toString()
+  }
+  
+  parse_field_str(fields, name, required= false, def= undefined) {
+    if ( ! (name in fields)) {
+      if (required) {
+       throw `Expected str value not passed for ${name}`
+      }
+      return def
+    }
+    return this.parse_value_str(fields[name], required, def)
+  }
+  
+  parse_value_int(v, required= false, def= undefined) {
+    let vi= parseInt(v)
+    if ((vi==null) || (isNaN(vi))) {
+      if (required) {
+       throw `Wrong int value passed: ${v}`
+      }
+      return def
+    }
+  
+    return vi
+  }
+  
+  parse_field_int(fields, name, required= false, def= undefined) {
+    if ( ! (name in fields)) {
+      if (required) {
+       throw `Expected int value not passed for ${name}`
+      }
+      return def
+    }
+    return this.parse_value_int(fields[name], required, def)
+  }
+  
+  parse_value_float(v, required= false, def= undefined) {
+    const vf= parseFloat(v)
+    if ((vf==null) || (isNaN(vf))) {
+      if (required) {
+       throw `Wrong float value passed: ${v}`
+      }
+      return def
+    }
+  
+    return v
+  }
+  
+  parse_field_float(fields, name, required= false, def= undefined) {
+    if ( ! (name in fields)) {
+      if (required) {
+       throw `Expected float value not passed for ${name}`
+      }
+      return def
+    }
+  
+    return this.parse_value_float(fields[name], required, def) 
+  }
+  
+  parse_value_bool(v, required= false, def= undefined) {
+    if ((v==null) || (v==undefined)) {
+      if (required) {
+       throw `Wrong bool value passed for ${name}`
+      }
+      return undefined
+    }
+    if ( (v===true) || (v==='true') ||(v==='True') ||(v===1) ||(v==='1')) {
+      return true
+    }
+    if ( (v===false) || (v==='false') ||(v==='False') ||(v===0) ||(v==='0')) {
+      return false
+    }
+  
+    return def
+  }
+  
+  parse_field_bool(fields, name, required= false, def= undefined) {
+    if ( ! (name in fields)) {
+      if (required) {
+       throw `Expected bool value not passed for ${name}`
+      }
+      return def
+    }
+  
+    return this.parse_value_bool(fields[name], required, def) 
+  }
+  
+  parse_value_obj(v, required= false, def= undefined) {
+    if ((v==null) || (v==undefined)) {
+      if (required) {
+       throw `Wrong obj value passed: ${v}`
+      }
+      return def
+    }
+    if (Object.keys(v).length==0) {
+      if (required) {
+        throw `Empty obj value passed: ${v}`
+      }
+      return def
+    }  
+    if (typeof v != 'object') {
+      throw `Wrong obj value passed: ${v}`
+    }  
+  
+    return v
+  }
+  
+  parse_field_obj(fields, name, required= false, def= undefined) {
+    if ( ! (name in fields)) {
+      if (required) {
+       throw `Expected obj value not passed for ${name}`
+      }
+      return def
+    }
+    return this.parse_value_obj(fields[name], required, def)
+  }
+}

package/src/server/engines/parser/index.mjs

@@ -0,0 +1,6 @@
+import Parser from "./Parser.mjs"
+
+export const init_parser = () => {
+  const p = new Parser() 
+  return p
+}