@signalk/streams 5.1.4 → 6.1.0

package/simple.js

@@ -1,448 +0,0 @@
-const Transform = require('stream').Transform
-const _ = require('lodash')
-const N2kAnalyzer = require('./n2kAnalyzer')
-const FromJson = require('./from_json')
-const MultiplexedLog = require('./multiplexedlog')
-const nmea0183_signalk = require('./nmea0183-signalk')
-const N2kToSignalK = require('./n2k-signalk')
-const Log = require('./log')
-const Liner = require('./liner')
-const SplittingLiner = require('./splitting-liner')
-const execute = require('./execute')
-const Udp = require('./udp')
-const Tcp = require('./tcp')
-const TcpServer = require('./tcpserver')
-const FileStream = require('./filestream')
-const Replacer = require('./replacer')
-const Throttle = require('./throttle')
-const TimestampThrottle = require('./timestamp-throttle')
-const CanboatJs = require('./canboatjs')
-const iKonvert = require('@canboat/canboatjs').iKonvert
-const Ydwg02 = require('@canboat/canboatjs').Ydwg02
-const W2k01 = require('@canboat/canboatjs').W2k01
-const gpsd = require('./gpsd')
-const pigpioSeatalk = require('./pigpio-seatalk')
-const gpiodSeatalk = require('./gpiod-seatalk')
-
-function Simple(options) {
-  Transform.call(this, { objectMode: true })
-
-  const { emitPropertyValue, onPropertyValues, createDebug } = options
-  options = { ...options }
-  options.subOptions = {
-    ...options.subOptions,
-    emitPropertyValue,
-    onPropertyValues,
-    createDebug
-  }
-
-  options.subOptions.providerId = options.providerId
-  const dataType = options.subOptions.dataType || options.type
-  if (!dataType) {
-    throw new Error(`Unknown data type for ${options.type}`)
-  }
-
-  if (!pipeStartByType[options.type]) {
-    throw new Error(`Invalid input type: ${options.type}`)
-  }
-  if (!dataTypeMapping[dataType]) {
-    throw new Error(`Unknown data type: ${dataType}`)
-  }
-  if (dataType !== 'Multiplexed' && !discriminatorByDataType[dataType]) {
-    throw new Error(`No discriminator for: ${dataType}`)
-  }
-
-  options.subOptions.app = options.app
-
-  let mappingType = dataType
-
-  if (options.type === 'NMEA2000' && options.subOptions) {
-    if (
-      options.subOptions.type === 'ngt-1-canboatjs' ||
-      options.subOptions.type === 'canbus-canboatjs' ||
-      options.subOptions.type === 'w2k-1-n2k-actisense-canboatjs' ||
-      options.subOptions.type === 'w2k-1-n2k-ascii-canboatjs'
-    ) {
-      mappingType = 'NMEA2000JS'
-    } 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'
-    ) {
-      mappingType = 'NMEA2000YD'
-    }
-    options.app.on('nmea2000out', () => {
-      setImmediate(() =>
-        options.app.emit('connectionwrite', { providerId: options.providerId })
-      )
-    })
-    options.app.on('nmea2000JsonOut', () => {
-      setImmediate(() =>
-        options.app.emit('connectionwrite', { providerId: options.providerId })
-      )
-    })
-  }
-
-  const pipeline = [].concat(
-    pipeStartByType[options.type](options.subOptions, options.logging),
-    getLogger(options.app, options.logging, discriminatorByDataType[dataType]),
-    dataTypeMapping[mappingType](options)
-  )
-
-  const dataReceivedEventName = `${options.subOptions.providerId}-received`
-
-  const spy = new Transform({
-    objectMode: true,
-    transform(chunk, encoding, callback) {
-      options.app.emit(dataReceivedEventName, chunk)
-      callback(null, chunk)
-    }
-  })
-  pipeline.splice(pipeline.length - 1, 0, spy)
-
-  options.subOptions.app.emitPropertyValue('pipedprovider', {
-    id: options.subOptions.providerId,
-    type: mappingType,
-    eventNames: {
-      received: dataReceivedEventName
-    }
-  })
-
-  if (options.subOptions.overrideTimestamp) {
-    pipeline.push(
-      new Transform({
-        objectMode: true,
-        transform(delta, encoding, callback) {
-          if (delta.updates) {
-            const now = new Date().toISOString()
-            delta.updates.forEach((update) => {
-              update.timestamp = now
-            })
-          }
-          callback(null, delta)
-        }
-      })
-    )
-  }
-
-  for (let i = pipeline.length - 2; i >= 0; i--) {
-    pipeline[i].pipe(pipeline[i + 1])
-  }
-  pipeline[pipeline.length - 1].pipe(this)
-
-  this.pipeline = pipeline
-}
-
-require('util').inherits(Simple, Transform)
-
-Simple.prototype._transform = function (msg, encoding, done) {
-  this.push(msg)
-  done()
-}
-
-Simple.prototype.end = function () {
-  this.pipeline[0].end()
-}
-
-module.exports = Simple
-
-const getLogger = (app, logging, discriminator) =>
-  logging
-    ? [
-        new Log({
-          app: app,
-          discriminator
-        })
-      ]
-    : []
-
-const discriminatorByDataType = {
-  NMEA2000JS: 'A',
-  NMEA2000IK: 'A',
-  NMEA2000YD: 'A',
-  NMEA2000: 'A',
-  NMEA0183: 'N',
-  SignalK: 'I',
-  Seatalk: 'N'
-}
-
-const dataTypeMapping = {
-  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) => {
-    const result = [new nmea0183_signalk(options.subOptions)]
-    if (options.type === 'FileStream') {
-      result.unshift(
-        new Throttle({
-          rate: options.subOptions.throttleRate || 1000,
-          chunksize: options.subOptions.throttleRate || 1000
-        })
-      )
-    }
-    return result
-  },
-  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) => {
-    const result = [new CanboatJs(options.subOptions)]
-    if (options.type === 'FileStream') {
-      result.push(new TimestampThrottle())
-    }
-    return result.concat([new N2kToSignalK(options.subOptions)])
-  },
-  NMEA2000IK: (options) => {
-    const result = [new CanboatJs(options.subOptions)]
-    if (options.type === 'FileStream') {
-      result.push(
-        new TimestampThrottle({
-          getMilliseconds: (msg) => {
-            return msg.timer * 1000
-          }
-        })
-      )
-    } // else
-    {
-      let subOptions
-      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'
-      )
-    ]
-    if (options.type === 'FileStream') {
-      result.push(new TimestampThrottle())
-    }
-    return result.concat([new N2kToSignalK(options.subOptions)])
-  },
-  NMEA2000W2K_ASCII: (options) => {
-    const result = [new W2k01({ format: 'ascii', ...options.subOptions })]
-    if (options.type === 'FileStream') {
-      result.push(new TimestampThrottle())
-    }
-    return result.concat([new N2kToSignalK(options.subOptions)])
-  },
-  NMEA2000W2K_ACTISENSE: (options) => {
-    const result = [new W2k01({ format: 'actisense', ...options.subOptions })]
-    if (options.type === 'FileStream') {
-      result.push(new TimestampThrottle())
-    }
-    return result.concat([new N2kToSignalK(options.subOptions)])
-  },
-  Multiplexed: (options) => [new MultiplexedLog(options.subOptions)]
-}
-
-const pipeStartByType = {
-  NMEA2000: nmea2000input,
-  NMEA0183: nmea0183input,
-  Execute: executeInput,
-  FileStream: fileInput,
-  SignalK: signalKInput,
-  Seatalk: seatalkInput
-}
-
-function nmea2000input(subOptions, logging) {
-  if (subOptions.type === 'ngt-1-canboatjs') {
-    const actisenseSerial = require('./actisense-serial')
-    if (!actisenseSerial) {
-      throw new Error('unable to load actisense serial')
-    }
-    return [
-      new actisenseSerial({
-        ...subOptions,
-        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')
-    return [
-      new serialport({
-        ...subOptions,
-        baudrate: 230400,
-        toStdout: 'ikonvertOut'
-      })
-    ]
-  } else if (subOptions.type === 'ydwg02-canboatjs') {
-    return [
-      new Tcp({
-        ...subOptions,
-        outEvent: 'ydwg02-out'
-      }),
-      new Liner(subOptions)
-    ]
-  } else if (subOptions.type === 'ydwg02-udp-canboatjs') {
-    return [
-      new Udp({
-        ...subOptions,
-        outEvent: 'ydwg02-out'
-      }),
-      new Liner(subOptions)
-    ]
-  } else if (subOptions.type === 'navlink2-tcp-canboatjs') {
-    return [
-      new Tcp({
-        ...subOptions,
-        outEvent: 'navlink2-out'
-      }),
-      new Liner(subOptions)
-    ]
-  } else if (subOptions.type === 'w2k-1-n2k-ascii-canboatjs') {
-    return [
-      new Tcp({
-        ...subOptions,
-        outEvent: 'w2k-1-out'
-      }),
-      new Liner(subOptions),
-      new W2k01(subOptions, 'ascii', 'w2k-1-out')
-    ]
-  } else if (subOptions.type === 'w2k-1-n2k-actisense-canboatjs') {
-    return [
-      new Tcp({
-        ...subOptions,
-        outEvent: 'w2k-1-out'
-      }),
-      new W2k01(subOptions, 'actisense', 'w2k-1-out')
-    ]
-  } 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')
-    return [
-      new serialport({
-        ...subOptions,
-        baudrate: 38400,
-        toStdout: 'ydwg02-out'
-      })
-    ]
-  } else {
-    let command
-    let toChildProcess
-    if (subOptions.type === 'ngt-1') {
-      command = `actisense-serial -s ${subOptions.baudrate || 115200} ${
-        subOptions.device
-      }`
-      toChildProcess = 'nmea2000out'
-    } else if (subOptions.type === 'canbus') {
-      command = `candump ${subOptions.interface} | candump2analyzer`
-      toChildProcess = null
-    } else {
-      throw new Error(`unknown NMEA2000 type ${subOptions.type}`)
-    }
-    return [
-      new execute({
-        command: command,
-        toChildProcess: toChildProcess,
-        app: subOptions.app,
-        providerId: subOptions.providerId
-      }),
-      new Liner(subOptions)
-    ]
-  }
-}
-
-function nmea0183input(subOptions) {
-  let pipePart
-  if (subOptions.type === 'tcp') {
-    pipePart = [new Tcp(subOptions), new Liner(subOptions)]
-  } else if (subOptions.type === 'tcpserver') {
-    pipePart = [new TcpServer(subOptions), new Liner(subOptions)]
-  } else if (subOptions.type === 'udp') {
-    pipePart = [new Udp(subOptions), new SplittingLiner(subOptions)]
-  } else if (subOptions.type === 'serial') {
-    const serialport = require('./serialport')
-    pipePart = [new serialport(subOptions)]
-  } else if (subOptions.type === 'gpsd') {
-    pipePart = [new gpsd(subOptions)]
-  }
-
-  if (pipePart) {
-    if (subOptions.removeNulls) {
-      pipePart.push(
-        new Replacer({
-          regexp: '\u0000',
-          template: ''
-        })
-      )
-    }
-    if (subOptions.ignoredSentences) {
-      console.log(subOptions.ignoredSentences)
-      subOptions.ignoredSentences.forEach((sentence) => {
-        if (sentence.length > 0) {
-          pipePart.push(
-            new Replacer({
-              regexp: `^...${sentence}.*`,
-              template: ''
-            })
-          )
-        }
-      })
-    }
-    return pipePart
-  } else {
-    throw new Error(`Unknown networking tyoe: ${subOptions.networking}`)
-  }
-}
-
-function executeInput(subOptions) {
-  return [new execute(subOptions), new Liner(subOptions)]
-}
-
-function fileInput(subOptions) {
-  const result = [new FileStream(subOptions)]
-  result.push(new Liner(subOptions))
-  return result
-}
-
-function signalKInput(subOptions) {
-  if (subOptions.type === 'ws' || subOptions.type === 'wss') {
-    const mdns_ws = require('./mdns-ws')
-    return [new mdns_ws(subOptions)]
-  } else if (subOptions.type === 'tcp') {
-    return [new Tcp(subOptions), new Liner(subOptions)]
-  } else if (subOptions.type === 'udp') {
-    return [new Udp(subOptions)]
-  } else if (subOptions.type === 'serial') {
-    const serialport = require('./serialport')
-    return [new serialport(subOptions)]
-  }
-  throw new Error(`unknown SignalK type: ${subOptions.type}`)
-}
-
-function seatalkInput(subOptions) {
-  if (subOptions.type === 'gpiod') {
-    return [new gpiodSeatalk(subOptions)]
-  } else {
-    return [new pigpioSeatalk(subOptions)]
-  }
-}

package/splitting-liner.js

@@ -1,46 +0,0 @@
-/*
- * Copyright 2019 Scott Bender <scott@scottbender.net>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* Usage:
- *  This is part of a PipedProvider that splits the input into separate lines and passes one line at a time to the next provider.
- *  You can specify the line separator with the option lineSeparator.
-
- {
-   "type": "providers/splitting-liner"
- },
-
- */
-
-const Transform = require('stream').Transform
-
-require('util').inherits(SplittingLiner, Transform)
-
-function SplittingLiner(options) {
-  Transform.call(this, {
-    objectMode: true
-  })
-  this.doPush = this.push.bind(this)
-  this.lineSeparator = options.lineSeparator || '\n'
-}
-
-SplittingLiner.prototype._transform = function (chunk, encoding, done) {
-  const data = chunk.toString()
-  const lines = data.split(this.lineSeparator)
-  lines.forEach(this.doPush)
-  done()
-}
-
-module.exports = SplittingLiner

package/tcp.js

@@ -1,138 +0,0 @@
-/*
- * Copyright 2014-2018 Fabian Tollenaar <fabian@decipher.industries>,Teppo Kurki <teppo.kurki@iki.fi
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* Usage: This is TCP client provider that can connect to a tcp server and pass data from there to the provider pipeline.
- * It takes the options "host" and "port".
- * Example:
-
- {
-   "type": "providers/tcp",
-   "options": {
-     "host": 'localhost',
-     "port": 10110,
-   }
- },
-
- */
-
-const net = require('net')
-const Transform = require('stream').Transform
-const isArray = require('lodash').isArray
-
-function TcpStream(options) {
-  Transform.call(this, options)
-  this.options = options
-  this.noDataReceivedTimeout =
-    Number.parseInt((this.options.noDataReceivedTimeout + '').trim()) * 1000
-  this.debug = (options.createDebug || require('debug'))('signalk:streams:tcp')
-  this.debug(`noDataReceivedTimeout:${this.noDataReceivedTimeout}`)
-  this.debugData = (options.createDebug || require('debug'))(
-    'signalk:streams:tcp-data'
-  )
-}
-
-require('util').inherits(TcpStream, Transform)
-
-TcpStream.prototype.pipe = function (pipeTo) {
-  const that = this
-  if (this.options.outEvent) {
-    that.options.app.on(that.options.outEvent, function (d) {
-      if (that.tcpStream) {
-        that.debug('sending %s', d)
-        that.tcpStream.write(d)
-        setImmediate(() => {
-          that.options.app.emit('connectionwrite', {
-            providerId: that.options.providerId
-          })
-        })
-      }
-    })
-  }
-
-  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')
-            that.debug('event %s sending %s', stdEvent, d)
-          }
-        })
-      }
-    )
-  }
-
-  require('reconnect-core')(function () {
-    return net.connect.apply(null, arguments)
-  })({ maxDelay: 5 * 1000 }, (tcpStream) => {
-    if (!isNaN(this.noDataReceivedTimeout)) {
-      tcpStream.setTimeout(this.noDataReceivedTimeout)
-      that.debug(
-        `Setting socket idle timeout ${this.options.host}:${this.options.port} ${this.noDataReceivedTimeout}`
-      )
-      tcpStream.on('timeout', () => {
-        that.debug(
-          `Idle timeout, closing socket ${this.options.host}:${this.options.port}`
-        )
-        tcpStream.end()
-      })
-    }
-    tcpStream.on('data', (data) => {
-      if (that.debugData.enabled) {
-        that.debugData(data.toString())
-      }
-      this.write(data)
-    })
-  })
-    .on('connect', (con) => {
-      this.tcpStream = con
-      const msg = `Connected to ${this.options.host} ${this.options.port}`
-      this.options.app.setProviderStatus(this.options.providerId, msg)
-      that.debug(msg)
-    })
-    .on('reconnect', (n, delay) => {
-      const msg = `Reconnect ${this.options.host} ${this.options.port} retry ${n} delay ${delay}`
-      this.options.app.setProviderError(this.options.providerId, msg)
-      that.debug(msg)
-    })
-    .on('disconnect', () => {
-      delete this.tcpStream
-      that.debug(`Disconnected ${this.options.host} ${this.options.port}`)
-    })
-    .on('error', (err) => {
-      let msg = err
-      if (err.message && err.message.length > 0) {
-        msg = err.message
-      } else if (err.errors) {
-        msg = err.errors.toString()
-      } else {
-        msg = err.toString()
-      }
-      this.options.app.setProviderError(this.options.providerId, msg)
-      console.error('TcpProvider:' + msg)
-    })
-    .connect(this.options)
-
-  Transform.prototype.pipe.call(this, pipeTo)
-}
-
-TcpStream.prototype._transform = function (data, encoding, callback) {
-  callback(null, data)
-}
-
-module.exports = TcpStream

package/tcpserver.js

@@ -1,40 +0,0 @@
-/*
- * Copyright 2018 Teppo Kurki <teppo.kurki@iki.fi>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- The server is the tcp nmea0183 interface, this provider just
- shovels data from tcpserver0183data to the provider pipe.
- */
-
-const Transform = require('stream').Transform
-
-function TcpServer(options) {
-  Transform.call(this)
-  this.options = options
-}
-
-require('util').inherits(TcpServer, Transform)
-
-TcpServer.prototype.pipe = function (pipeTo) {
-  this.options.app.on('tcpserver0183data', (d) => this.write(d))
-  Transform.prototype.pipe.call(this, pipeTo)
-}
-
-TcpServer.prototype._transform = function (data, encoding, callback) {
-  callback(null, data)
-}
-
-module.exports = TcpServer

package/throttle.js

@@ -1,31 +0,0 @@
-/*
- * Copyright 2014-2015 Fabian Tollenaar <fabian@starting-point.nl>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* Usage: This provider is used for throttling input data from files. It takes the option "rate" which is the rate in bytes/s for the stream to come in.
- * Example:
-
- {
-   "type": "providers/throttle",
-   "options": {
-     "rate": 500
-   }
- }
-
- */
-
-const Throttle = require('stream-throttle').Throttle
-
-module.exports = Throttle