@signalk/streams 1.19.0 → 2.0.3

package/serialport.js

@@ -62,10 +62,9 @@ const child_process = require('child_process')
 const shellescape = require('any-shell-escape')
 const SerialPort = require('serialport')
 const isArray = require('lodash').isArray
-const debug = require('debug')('signalk:streams:serialport')
 const isBuffer = require('lodash').isBuffer
 
-function SerialStream (options) {
+function SerialStream(options) {
   if (!(this instanceof SerialStream)) {
     return new SerialStream(options)
   }
@@ -79,11 +78,16 @@ function SerialStream (options) {
   this.maxPendingWrites = options.maxPendingWrites || 5
   this.start()
   this.isFirstError = true
+
+  const createDebug = options.createDebug || require('debug')
+  this.debug = createDebug('signalk:streams:serialport')
 }
 
 require('util').inherits(SerialStream, Transform)
 
 SerialStream.prototype.start = function () {
+  const that = this
+
   if (this.serial !== null) {
     this.serial.unpipe(this)
     this.serial.removeAllListeners()
@@ -101,7 +105,7 @@ SerialStream.prototype.start = function () {
   }
 
   this.serial = new SerialPort(this.options.device, {
-    baudRate: this.options.baudrate
+    baudRate: this.options.baudrate,
   })
 
   this.serial.on(
@@ -125,7 +129,7 @@ SerialStream.prototype.start = function () {
       if (this.isFirstError) {
         console.log(x.message)
       }
-      debug(x.message)
+      this.debug(x.message)
       this.isFirstError = false
       this.scheduleReconnect()
     }.bind(this)
@@ -141,26 +145,25 @@ SerialStream.prototype.start = function () {
     }.bind(this)
   )
 
-  const that = this
   let pendingWrites = 0
   const stdOutEvent = this.options.toStdout
   if (stdOutEvent) {
-    (isArray(stdOutEvent) ? stdOutEvent : [stdOutEvent]).forEach(event => {
+    ;(isArray(stdOutEvent) ? stdOutEvent : [stdOutEvent]).forEach((event) => {
       const onDrain = () => {
         pendingWrites--
       }
 
-      that.options.app.on(event, d => {
+      that.options.app.on(event, (d) => {
         if (pendingWrites > that.maxPendingWrites) {
-          debug('Buffer overflow, not writing:' + d)
+          that.debug('Buffer overflow, not writing:' + d)
           return
         }
-        debug('Writing:' + d)
-        if ( isBuffer(d) ) {
+        that.debug('Writing:' + d)
+        if (isBuffer(d)) {
           that.serial.write(d)
         } else {
           that.serial.write(d + '\r\n')
-        } 
+        }
         pendingWrites++
         that.serial.drain(onDrain)
       })
@@ -182,7 +185,7 @@ SerialStream.prototype.scheduleReconnect = function () {
   const msg = `Not connected (retry delay ${(
     this.reconnectDelay / 1000
   ).toFixed(0)} s)`
-  debug(msg)
+  this.debug(msg)
   this.options.app.setProviderStatus(this.options.providerId, msg)
   setTimeout(this.start.bind(this), this.reconnectDelay)
 }

package/simple.js

@@ -1,7 +1,6 @@
 const Transform = require('stream').Transform
 const Writable = require('stream').Writable
 const _ = require('lodash')
-const debug = require('debug')('signalk:simple')
 const N2kAnalyzer = require('./n2kAnalyzer')
 const FromJson = require('./from_json')
 const MultiplexedLog = require('./multiplexedlog')
@@ -24,12 +23,17 @@ const Ydwg02 = require('@canboat/canboatjs').Ydwg02
 const gpsd = require('./gpsd')
 const pigpioSeatalk = require('./pigpio-seatalk')
 
-function Simple (options) {
+function Simple(options) {
   Transform.call(this, { objectMode: true })
 
-  const { emitPropertyValue, onPropertyValues } = options
+  const { emitPropertyValue, onPropertyValues, createDebug } = options
   options = { ...options }
-  options.subOptions = { ...options.subOptions, emitPropertyValue, onPropertyValues }
+  options.subOptions = {
+    ...options.subOptions,
+    emitPropertyValue,
+    onPropertyValues,
+    createDebug,
+  }
 
   options.subOptions.providerId = options.providerId
   const dataType = options.subOptions.dataType || options.type
@@ -57,14 +61,18 @@ function Simple (options) {
       options.subOptions.type === 'canbus-canboatjs'
     ) {
       mappingType = 'NMEA2000JS'
-    } else if (options.subOptions.type === 'ikonvert-canboatjs' ||
-               options.subOptions.type === 'navlink2-tcp-canboatjs' ) {
+    } else if (
+      options.subOptions.type === 'ikonvert-canboatjs' ||
+      options.subOptions.type === 'navlink2-tcp-canboatjs'
+    ) {
       mappingType = 'NMEA2000IK'
-    } else if (options.subOptions.type === 'ydwg02-canboatjs' ||
-               options.subOptions.type === 'ydwg02-udp-canboatjs' ||
-               options.subOptions.type === 'ydwg02-usb-canboatjs') {
+    } else if (
+      options.subOptions.type === 'ydwg02-canboatjs' ||
+      options.subOptions.type === 'ydwg02-udp-canboatjs' ||
+      options.subOptions.type === 'ydwg02-usb-canboatjs'
+    ) {
       mappingType = 'NMEA2000YD'
-    } 
+    }
   }
 
   const pipeline = [].concat(
@@ -99,8 +107,8 @@ const getLogger = (app, logging, discriminator) =>
     ? [
         new Log({
           app: app,
-          discriminator
-        })
+          discriminator,
+        }),
       ]
     : []
 
@@ -111,73 +119,77 @@ const discriminatorByDataType = {
   NMEA2000: 'A',
   NMEA0183: 'N',
   SignalK: 'I',
-  Seatalk: 'N'
+  Seatalk: 'N',
 }
 
 const dataTypeMapping = {
-  SignalK: options =>
+  SignalK: (options) =>
     options.subOptions.type !== 'wss' && options.subOptions.type !== 'ws'
       ? [new FromJson(options.subOptions)]
       : [],
-  Seatalk:  options => [new nmea0183_signalk({...options.subOptions, validateChecksum: false})],
-  NMEA0183: options => {
+  Seatalk: (options) => [
+    new nmea0183_signalk({ ...options.subOptions, validateChecksum: false }),
+  ],
+  NMEA0183: (options) => {
     const result = [new nmea0183_signalk(options.subOptions)]
     if (options.type === 'FileStream') {
       result.unshift(
         new Throttle({
-          rate: options.subOptions.throttleRate || 1000
+          rate: options.subOptions.throttleRate || 1000,
         })
       )
     }
     return result
   },
-  NMEA2000: options => {
+  NMEA2000: (options) => {
     const result = [new N2kAnalyzer(options.subOptions)]
     if (options.type === 'FileStream') {
       result.push(new TimestampThrottle())
     }
     return result.concat([new N2kToSignalK(options.subOptions)])
   },
-  NMEA2000JS: options => {
+  NMEA2000JS: (options) => {
     const result = [new CanboatJs(options.subOptions)]
     if (options.type === 'FileStream') {
       result.push(new TimestampThrottle())
     }
     return result.concat([new N2kToSignalK(options.subOptions)])
   },
-  NMEA2000IK: options => {
+  NMEA2000IK: (options) => {
     const result = [new CanboatJs(options.subOptions)]
     if (options.type === 'FileStream') {
       result.push(
         new TimestampThrottle({
-          getMilliseconds: msg => {
+          getMilliseconds: (msg) => {
             return msg.timer * 1000
-          }
+          },
         })
       )
     } // else
     {
       let subOptions
-      if ( options.subOptions.type === 'navlink2-tcp-canboatjs' )
-      {
-        subOptions = {...options.subOptions, tcp: true}
-      }
-      else
-      {
+      if (options.subOptions.type === 'navlink2-tcp-canboatjs') {
+        subOptions = { ...options.subOptions, tcp: true }
+      } else {
         subOptions = options.subOptions
       }
       result.unshift(new iKonvert(subOptions))
     }
     return result.concat([new N2kToSignalK(options.subOptions)])
   },
-  NMEA2000YD: options => {
-    const result = [new Ydwg02(options.subOptions, options.subOptions.type === 'ydwg02-usb-canboatjs' ? 'usb' : 'network')]
+  NMEA2000YD: (options) => {
+    const result = [
+      new Ydwg02(
+        options.subOptions,
+        options.subOptions.type === 'ydwg02-usb-canboatjs' ? 'usb' : 'network'
+      ),
+    ]
     if (options.type === 'FileStream') {
       result.push(new TimestampThrottle())
     }
     return result.concat([new N2kToSignalK(options.subOptions)])
   },
-  Multiplexed: options => [new MultiplexedLog(options.subOptions)]
+  Multiplexed: (options) => [new MultiplexedLog(options.subOptions)],
 }
 
 const pipeStartByType = {
@@ -186,28 +198,28 @@ const pipeStartByType = {
   Execute: executeInput,
   FileStream: fileInput,
   SignalK: signalKInput,
-  Seatalk: seatalkInput
+  Seatalk: seatalkInput,
 }
 
-function nmea2000input (subOptions, logging) {
+function nmea2000input(subOptions, logging) {
   if (subOptions.type === 'ngt-1-canboatjs') {
     const actisenseSerial = require('./actisense-serial')
-    if ( ! actisenseSerial ) {
+    if (!actisenseSerial) {
       throw new Error('unable to load actisense serial')
     }
     return [
       new actisenseSerial({
         ...subOptions,
         outEvent: 'nmea2000out',
-        plainText: logging
-      })
+        plainText: logging,
+      }),
     ]
   } else if (subOptions.type === 'canbus-canboatjs') {
     return [
       new require('./canbus')({
         ...subOptions,
         canDevice: subOptions.interface,
-      })
+      }),
     ]
   } else if (subOptions.type === 'ikonvert-canboatjs') {
     const serialport = require('./serialport')
@@ -215,22 +227,28 @@ function nmea2000input (subOptions, logging) {
       new serialport({
         ...subOptions,
         baudrate: 230400,
-        toStdout: 'ikonvertOut'
-      })
+        toStdout: 'ikonvertOut',
+      }),
     ]
   } else if (subOptions.type === 'ydwg02-canboatjs') {
-    return [new Tcp({
-      ...subOptions,
-      outEvent: 'ydwg02-out'
-    }), new Liner(subOptions)]
+    return [
+      new Tcp({
+        ...subOptions,
+        outEvent: 'ydwg02-out',
+      }),
+      new Liner(subOptions),
+    ]
   } else if (subOptions.type === 'ydwg02-udp-canboatjs') {
     return [new Udp(subOptions), new Liner(subOptions)]
   } else if (subOptions.type === 'navlink2-tcp-canboatjs') {
-    return [new Tcp({
-      ...subOptions,
-      outEvent: 'navlink2-out'
-    }), new Liner(subOptions)]
-  } else if (subOptions.type === 'navlink2-udp-canboatjs' ) {
+    return [
+      new Tcp({
+        ...subOptions,
+        outEvent: 'navlink2-out',
+      }),
+      new Liner(subOptions),
+    ]
+  } else if (subOptions.type === 'navlink2-udp-canboatjs') {
     return [new Udp(subOptions), new Liner(subOptions)]
   } else if (subOptions.type === 'ydwg02-usb-canboatjs') {
     const serialport = require('./serialport')
@@ -238,8 +256,8 @@ function nmea2000input (subOptions, logging) {
       new serialport({
         ...subOptions,
         baudrate: 38400,
-        toStdout: 'ydwg02-out'
-      })
+        toStdout: 'ydwg02-out',
+      }),
     ]
   } else {
     let command
@@ -260,14 +278,14 @@ function nmea2000input (subOptions, logging) {
         command: command,
         toChildProcess: toChildProcess,
         app: subOptions.app,
-        providerId: subOptions.providerId
+        providerId: subOptions.providerId,
       }),
-      new Liner(subOptions)
+      new Liner(subOptions),
     ]
   }
 }
 
-function nmea0183input (subOptions) {
+function nmea0183input(subOptions) {
   let pipePart
   if (subOptions.type === 'tcp') {
     pipePart = [new Tcp(subOptions), new Liner(subOptions)]
@@ -284,19 +302,23 @@ function nmea0183input (subOptions) {
 
   if (pipePart) {
     if (subOptions.removeNulls) {
-      pipePart.push(new Replacer({
-        regexp: '\u0000',
-        template: ''
-      }))
+      pipePart.push(
+        new Replacer({
+          regexp: '\u0000',
+          template: '',
+        })
+      )
     }
     if (subOptions.ignoredSentences) {
       console.log(subOptions.ignoredSentences)
-      subOptions.ignoredSentences.forEach(sentence => {
+      subOptions.ignoredSentences.forEach((sentence) => {
         if (sentence.length > 0) {
-          pipePart.push(new Replacer({
-            regexp: `^...${sentence}.*`,
-            template: ''
-          }))
+          pipePart.push(
+            new Replacer({
+              regexp: `^...${sentence}.*`,
+              template: '',
+            })
+          )
         }
       })
     }
@@ -306,17 +328,17 @@ function nmea0183input (subOptions) {
   }
 }
 
-function executeInput (subOptions) {
+function executeInput(subOptions) {
   return [new execute(subOptions), new Liner(subOptions)]
 }
 
-function fileInput (subOptions) {
+function fileInput(subOptions) {
   const result = [new FileStream(subOptions)]
   result.push(new Liner(subOptions))
   return result
 }
 
-function signalKInput (subOptions) {
+function signalKInput(subOptions) {
   if (subOptions.type === 'ws' || subOptions.type === 'wss') {
     const mdns_ws = require('./mdns-ws')
     return [new mdns_ws(subOptions)]

package/splitting-liner.js

@@ -28,9 +28,9 @@ const Transform = require('stream').Transform
 
 require('util').inherits(SplittingLiner, Transform)
 
-function SplittingLiner (options) {
+function SplittingLiner(options) {
   Transform.call(this, {
-    objectMode: true
+    objectMode: true,
   })
   this.doPush = this.push.bind(this)
   this.lineSeparator = options.lineSeparator || '\n'

package/tcp.js

@@ -32,23 +32,25 @@ const net = require('net')
 const Transform = require('stream').Transform
 const isArray = require('lodash').isArray
 
-const debug = require('debug')('signalk-server:streams:tcp')
-const debugData = require('debug')('signalk-server:streams:tcp-data')
-
-function TcpStream (options) {
+function TcpStream(options) {
   Transform.call(this, options)
   this.options = options
-  this.noDataReceivedTimeout = Number.parseInt((this.options.noDataReceivedTimeout + '').trim()) * 1000
+  this.noDataReceivedTimeout =
+    Number.parseInt((this.options.noDataReceivedTimeout + '').trim()) * 1000
+  this.debug = (options.createDebug || require('debug'))('signalk:streams:tcp')
+  this.debugData = (options.createDebug || require('debug'))(
+    'signalk:streams:tcp-data'
+  )
 }
 
 require('util').inherits(TcpStream, Transform)
 
 TcpStream.prototype.pipe = function (pipeTo) {
-  if ( this.options.outEvent ) {
-    const that = this
+  const that = this
+  if (this.options.outEvent) {
     that.options.app.on(that.options.outEvent, function (d) {
-      if ( that.tcpStream ) {
-        debug('sending %s', d)
+      if (that.tcpStream) {
+        that.debug('sending %s', d)
         that.tcpStream.write(d)
       }
     })
@@ -56,57 +58,57 @@ TcpStream.prototype.pipe = function (pipeTo) {
 
   const stdOutEvent = this.options.toStdout
   if (stdOutEvent) {
-    const that = this; //semicolon required here
-    (isArray(stdOutEvent) ? stdOutEvent : [stdOutEvent]).forEach(stdEvent => {
-      that.options.app.on(stdEvent, function (d) {
-        if (that.tcpStream) {
-          that.tcpStream.write(d + '\r\n')
-          debug('event %s sending %s', stdEvent, d)
-        }
-      })
-    })
+    const that = this //semicolon required here
+    ;(isArray(stdOutEvent) ? stdOutEvent : [stdOutEvent]).forEach(
+      (stdEvent) => {
+        that.options.app.on(stdEvent, function (d) {
+          if (that.tcpStream) {
+            that.tcpStream.write(d + '\r\n')
+            that.debug('event %s sending %s', stdEvent, d)
+          }
+        })
+      }
+    )
   }
 
   const re = require('reconnect-core')(function () {
     return net.connect.apply(null, arguments)
-  })({ maxDelay: 5 * 1000 }, tcpStream => {
+  })({ maxDelay: 5 * 1000 }, (tcpStream) => {
     if (!isNaN(this.noDataReceivedTimeout)) {
       tcpStream.setTimeout(this.noDataReceivedTimeout)
-      debug(
+      that.debug(
         `Setting socket idle timeout ${this.options.host}:${this.options.port} ${this.noDataReceivedTimeout}`
       )
       tcpStream.on('timeout', () => {
-        debug(
+        that.debug(
           `Idle timeout, closing socket ${this.options.host}:${this.options.port}`
         )
         tcpStream.end()
       })
     }
-    tcpStream.on('data', data => {
-      if (debugData.enabled) {
-        debugData(data.toString())
+    tcpStream.on('data', (data) => {
+      if (that.debugData.enabled) {
+        that.debugData(data.toString())
       }
       this.write(data)
     })
   })
-    .on('connect', con => {
+    .on('connect', (con) => {
       this.tcpStream = con
       const msg = `Connected to ${this.options.host} ${this.options.port}`
       this.options.app.setProviderStatus(this.options.providerId, msg)
-      debug(msg)
+      that.debug(msg)
     })
     .on('reconnect', (n, delay) => {
-      const msg = `Reconnect ${this.options.host} ${
-        this.options.port
-      } retry ${n} delay ${delay}`
+      const msg = `Reconnect ${this.options.host} ${this.options.port} retry ${n} delay ${delay}`
       this.options.app.setProviderError(this.options.providerId, msg)
-      debug(msg)
+      that.debug(msg)
     })
-    .on('disconnect', err => {
+    .on('disconnect', (err) => {
       delete this.tcpStream
-      debug(`Disconnected ${this.options.host} ${this.options.port}`)
+      that.debug(`Disconnected ${this.options.host} ${this.options.port}`)
     })
-    .on('error', err => {
+    .on('error', (err) => {
       this.options.app.setProviderError(this.options.providerId, err.message)
       console.error('TcpProvider:' + err.message)
     })

package/tcpserver.js

@@ -21,7 +21,7 @@
 
 const Transform = require('stream').Transform
 
-function TcpServer (options) {
+function TcpServer(options) {
   Transform.call(this)
   this.options = options
 }
@@ -29,7 +29,7 @@ function TcpServer (options) {
 require('util').inherits(TcpServer, Transform)
 
 TcpServer.prototype.pipe = function (pipeTo) {
-  this.options.app.on('tcpserver0183data', d => this.write(d))
+  this.options.app.on('tcpserver0183data', (d) => this.write(d))
   Transform.prototype.pipe.call(this, pipeTo)
 }
 

package/timestamp-throttle.js

@@ -23,9 +23,9 @@ so that throughput rate is real time. Aimed at canboat analyzer output
 rate control
 */
 
-function TimestampThrottle (options) {
+function TimestampThrottle(options) {
   Transform.call(this, {
-    objectMode: true
+    objectMode: true,
   })
   this.lastMsgMillis = new Date().getTime()
   this.getMilliseconds =
@@ -55,7 +55,7 @@ TimestampThrottle.prototype._transform = function (msg, encoding, done) {
   }
 }
 
-function getMilliseconds (msg) {
+function getMilliseconds(msg) {
   // 2014-08-15-16:00:00.083
   return moment(msg.timestamp, 'YYYY-MM-DD-HH:mm:ss.SSS').valueOf()
 }

package/udp.js

@@ -34,13 +34,13 @@
  */
 
 const Transform = require('stream').Transform
-const debug = require('debug')('signalk:streams:udp')
 
-function Udp (options) {
+function Udp(options) {
   Transform.call(this, {
-    objectMode: false
+    objectMode: false,
   })
   this.options = options
+  this.debug = (options.createDebug || require('debug'))('signalk:streams:udp')
 }
 
 require('util').inherits(Udp, Transform)
@@ -52,7 +52,7 @@ Udp.prototype.pipe = function (pipeTo) {
   const socket = require('dgram').createSocket('udp4')
   const self = this
   socket.on('message', function (message, remote) {
-    debug(message.toString())
+    self.debug(message.toString())
     self.push(message)
   })
   socket.bind(this.options.port)