u8-mqtt 0.5.3 → 0.6.1

package/code/_cmdid_dispatch.jsy

@@ -1,71 +1,47 @@
 
-export const _mqtt_cmdid_dispatch = @{}
-  create(target) ::
-    return @{} __proto__: this, target, hashbelt: [new Map()]
-
-  bind_pkt_future(_pkt_id=100) ::
-    let {hashbelt} = this
-
-    let _tmp_ // use _tmp_ to reuse _by_key closure
-    let _by_key = answer_monad =>
-      hashbelt[0].set(_tmp_, answer_monad)
-
-    return @\ pkt_or_key ::
-      if 'string' === typeof pkt_or_key ::
-        _tmp_ = pkt_or_key
-      else ::
-        _pkt_id = (_pkt_id + 1) & 0xffff
-        _tmp_ = pkt_or_key.pkt_id = _pkt_id
-
-      return new Promise(_by_key)
-
-  answer(key, pkt) ::
-    for let map of this.hashbelt ::
-      let answer_monad = map.get(key)
-      if undefined !== answer_monad ::
-        map.delete(key)
-
-        answer_monad([pkt, /*err*/]) // option/maybe monad
-        return true
-    return false
-
-  rotate_belt(n) ::
-    let {hashbelt} = this
-    hashbelt.unshift @ new Map()
-    for let old of hashbelt.splice(n || 5) ::
-      for let answer_monad of old.values() ::
-        answer_monad([/*pkt*/, 'expired']) // option/maybe monad
-
-  cmdids: @!
-    return @[]
-      @=>{}    // 0x0 reserved
-      by_evt   // 0x1 connect
-      by_type  // 0x2 connack
-      by_evt   // 0x3 publish
-      by_id    // 0x4 puback
-      by_id    // 0x5 pubrec
-      by_id    // 0x6 pubrel
-      by_id    // 0x7 pubcomp
-      by_evt   // 0x8 subscribe
-      by_id    // 0x9 suback
-      by_evt   // 0xa unsubscribe
-      by_id    // 0xb unsuback
-      by_type  // 0xc pingreq
-      by_type  // 0xd pingresp
-      by_evt   // 0xe disconnect
-      by_type  // 0xf auth
-
-
-    function by_id(disp, pkt) ::
-      disp.answer @ pkt.pkt_id, pkt
-
-    function by_type(disp, pkt, ctx) ::
-      disp.answer @ pkt.type, pkt
-      by_evt(disp, pkt, ctx)
-
-    async function by_evt({target}, pkt, ctx) ::
-      let fn = target[`mqtt_${pkt.type}`]
-        || target.mqtt_pkt
-
-      await fn?.call(target, pkt, ctx)
+async function _mqtt_cmd_evt(target, answer, pkt, ctx) ::
+  /* target : on_mqtt_type = {
+        mqtt_pkt(pkt, ctx) {}, // generic
+
+        mqtt_auth(pkt, ctx) {},
+        mqtt_connect(pkt, ctx) {},
+        mqtt_connack(pkt, ctx) {},
+        mqtt_disconnect(pkt, ctx) {},
+
+        mqtt_publish(pkt, ctx) {},
+        mqtt_subscribe(pkt, ctx) {},
+        mqtt_unsubscribe(pkt, ctx) {},
+
+        mqtt_pingreq(pkt, ctx) {},
+        mqtt_pingresp(pkt, ctx) {},
+    } */
+
+  let pkt_fn = target[`mqtt_${pkt.type}`] || target.mqtt_pkt
+  await pkt_fn?.call(target, pkt, ctx)
+
+function _mqtt_cmd_type(target, answer, pkt, ctx) ::
+  answer(pkt.type, pkt)
+  _mqtt_cmd_evt(target, answer, pkt, ctx)
+
+function _mqtt_cmd_id(target, answer, pkt) ::
+  answer(pkt.pkt_id, pkt)
+
+
+export const _mqtt_cmdids = @[]
+  _ => {}    // 0x0 reserved
+  _mqtt_cmd_evt   // 0x1 connect
+  _mqtt_cmd_type  // 0x2 connack
+  _mqtt_cmd_evt   // 0x3 publish
+  _mqtt_cmd_id    // 0x4 puback
+  _mqtt_cmd_id    // 0x5 pubrec
+  _mqtt_cmd_id    // 0x6 pubrel
+  _mqtt_cmd_id    // 0x7 pubcomp
+  _mqtt_cmd_evt   // 0x8 subscribe
+  _mqtt_cmd_id    // 0x9 suback
+  _mqtt_cmd_evt   // 0xa unsubscribe
+  _mqtt_cmd_id    // 0xb unsuback
+  _mqtt_cmd_type  // 0xc pingreq
+  _mqtt_cmd_type  // 0xd pingresp
+  _mqtt_cmd_evt   // 0xe disconnect
+  _mqtt_cmd_type  // 0xf auth
 

package/code/_conn.jsy

@@ -1,82 +1,106 @@
-import { ao_defer_v } from 'roap'
-export { ao_defer_v }
+import { _interval } from './_utils.jsy'
+
+const _defer_obj = o => @
+  o.p = new Promise @ (a,e) => { o.a=a; o.e=e }
+  , o
+
+function _dfn_reset(client, attr, fn_after) ::
+  // a resetable deferred for a function
+  let self = {set}, afn = async (...args) => (await self.p)(...args)
+  return set()
+
+  function set() ::
+    if afn !== client[attr] ::
+      _defer_obj(self).p.then(fn_after, _=>0)
+      client[attr] = afn
+    return self
+
+export function _mqtt_conn(opt, client, [on_mqtt, pkt_future]) ::
+  let _abort
+  let _dfn_send0 = _dfn_reset @ client, '_send0', // client._send0 getter/setter
+    _=> client.conn_emit('on_live', conn.has_connected)
+  let _dfn_ready = _dfn_reset @ client, '_send', // client._send getter/setter
+    _=> client.conn_emit('on_ready')
+  let _keep_alive_ival = _interval @=> client._send0('pingreq') // resettable interval for keep_alive ping
+
+  let conn = Object.create @:
+    ping: (td=conn.keep_alive) => _keep_alive_ival(td)
+
+    on_conn(pkt, response) ::
+      conn.has_connected = true
+      conn.keep_alive = opt.keep_alive || response[0].props?.server_keep_alive || pkt.keep_alive
+      client.conn_emit('on_conn')
+      return opt.use_auth
+        ? response // wait on enhanced authentication step
+        : conn.on_auth(null, response) // otherwise, connect is also auth
+
+    on_auth(pkt, response) ::
+      _dfn_ready.a(_dfn_send0.p)
+      if 0 != opt.keep_alive ::
+        conn.ping()
+      client.conn_emit('on_auth', !pkt)
+      return response
+
+    on_dis(pkt, response) ::
+      conn.reset(false)
+      return response
 
-export function _mqtt_conn(client, [on_mqtt, pkt_future]) ::
-  let _q_init = ao_defer_v(), _q_ready = ao_defer_v()
-  let _send_ready = async (...args) => (await _q_ready[0])(...args)
-  let _send_mqtt_pkt, _has_connected
-  client._send = _send_ready
+    reset(err) ::
+      if err ::
+        _dfn_send0.e(err) // send error to uses of _send0 (connect, auth)
+      _abort.e(err) // abort in-progress connections
 
-  return @{}
-    async when_ready() :: await _q_ready[0]
+      delete conn.is_set
+      conn.ready = handshake()
+      client.conn_emit('on_disconnect', false===err, err)
 
-    ping: _ping_interval @=> _send_mqtt_pkt?.('pingreq')
+    abort() ::
+      _dfn_ready.e(err) // abort all messages awaiting ready state
+      return conn.reset(err)
 
-    reset(err) ::
-      if ! _send_mqtt_pkt :: return
+    async setup(gate, send_u8_pkt, init_msg_loop) ::
+      if conn.is_set ::
+        throw new Error() // already in-progress
 
-      if err ::
-        _q_init[2](err)
+      conn.is_set = true
+      await gate
 
-      _send_mqtt_pkt = null
-      _q_init = ao_defer_v()
-      client._send = _send_ready
+      // setup send/recv MQTT parsing context
+      let mqtt_ctx = client.mqtt_ctx.mqtt_stream()
 
-      // call client.on_conn_reset in next promise microtask
-      client.conn_emit('on_disconnect', false===err, err)
+      :: // setup inbound message loop
+        let sess_ctx = {mqtt: client} // mutable session context
+        let on_mqtt_chunk = u8 => on_mqtt(mqtt_ctx.decode(u8), sess_ctx)
+        init_msg_loop(on_mqtt_chunk, conn)
+
+      // setup outbound message path and transport connection
+      send_u8_pkt = await send_u8_pkt
+      _dfn_send0.a @
+        async (type, pkt, key) => ::
+          let res = undefined !== key
+            ? pkt_future(key) : true
+
+          await send_u8_pkt @
+            mqtt_ctx.encode_pkt(type, pkt)
+          return res
+
+  conn.ready = handshake()
+  return conn
+
+  async function handshake() ::
+    _abort = _defer_obj({})
+
+    _keep_alive_ival(0) // clearInterval on keep alive ping
+    _dfn_send0.set() // reset client._send0 if necessary
+    _dfn_ready.set() // reset client._send if necessary
+
+    try ::
+      // set client._send0 as passtrhough after transport connection
+      client._send0 = await Promise.race @# _dfn_send0.p, _abort.p
 
-    async send_connect(... args) ::
-      if ! _send_mqtt_pkt ::
-        await _q_init[0] // _send_mqtt_pkt is set before fulfilled
-
-      // await connack response
-      let res = await _send_mqtt_pkt(...args)
-      if 0 == res[0].reason ::
-        _has_connected = true
-        // resolve _q_ready[0] with _send_mqtt_pkt closure
-        _q_ready[1](client._send = _send_mqtt_pkt)
-        _q_ready = ao_defer_v()
-        client.conn_emit('on_ready')
-
-      return res
-
-    is_set: @=> !! _send_mqtt_pkt
-    set(mqtt_ctx, send_u8_pkt) ::
-      if _send_mqtt_pkt ::
-        throw new Error('Already connected')
-
-      mqtt_ctx = mqtt_ctx.mqtt_stream()
-      let sess_ctx = {mqtt: client}
-      let on_mqtt_chunk = u8_buf =>
-        on_mqtt(mqtt_ctx.decode(u8_buf), sess_ctx)
-
-      _send_mqtt_pkt = async (type, pkt, key) => ::
-        let res = undefined !== key
-          ? pkt_future(key) : true
-
-        await send_u8_pkt @
-          mqtt_ctx.encode_pkt(type, pkt)
-
-        return res
-
-      _q_init[1](_send_mqtt_pkt) // resolve _q_init with _send_mqtt_pkt closure
-
-      // call client.on_live in next promise microtask
-      client.conn_emit('on_live', _has_connected)
-      return on_mqtt_chunk
-
-
-function _ping_interval(send_ping) ::
-  let tid
-  return @\ td ::
-    tid = clearInterval(tid)
-    if td ::
-      tid = setInterval(send_ping, 1000 * td)
-      #IF PLAT_DENO
-        // ensure the interval allows the Deno event loop to exit
-        Deno.unrefTimer(tid)
-      #ELSE
-        // ensure the interval allows the NodeJS event loop to exit
-        tid.unref?.()
+      // set client._send as passtrhough after ready
+      client._send = await Promise.race @# _dfn_ready.p, _abort.p
       return true
+    catch err ::
+      return false
 

package/code/_dispatch.jsy

@@ -1,39 +1,47 @@
-import {_mqtt_cmdid_dispatch} from './_cmdid_dispatch.jsy'
+import { _isstr } from './_utils.jsy'
+import {_mqtt_cmdids} from './_cmdid_dispatch.jsy'
 
-/*
-on_mqtt_type = {
-  mqtt_auth(pkt, ctx) ::
-  mqtt_connect(pkt, ctx) ::
-  mqtt_connack(pkt, ctx) ::
-  mqtt_disconnect(pkt, ctx) ::
+export function _mqtt_dispatch(opt, target) ::
+  let hashbelt=[], rotate_ts=0
+  // default rotate at 1s across 5 buckets
+  let { td: rotate_td=1000, n: rotate_n=5 } = opt?.rotate || {}
 
-  mqtt_publish(pkt, ctx)
-  mqtt_subscribe(pkt, ctx) ::
-  mqtt_unsubscribe(pkt, ctx) ::
+  // Promise / future scaffolding
+  let _pkt_id=100, _ftr_key // use _ftr_key to reuse _by_key closure
+  let _ftr_by_key = fn_answer => hashbelt[0].set(_ftr_key, fn_answer)
 
-  mqtt_pingreq(pkt, ctx) ::
-  mqtt_pingresp(pkt, ctx) ::
-}
-*/
+  on_mqtt([]) // init hashbelt and rotate_ts
+  return [on_mqtt, pkt_future]
 
-export function _mqtt_dispatch(opt, target) ::
-  let _disp_ = _mqtt_cmdid_dispatch.create(target)
-  let { cmdids } = _disp_
 
-  // default rotate at 1s across 5 buckets
-  let { td: rotate_td=1000, n: rotate_n=5 } =
-    opt && opt.rotate || {}
+  function pkt_future(pkt_or_key) ::
+    if ! _isstr(pkt_or_key) ::
+      _pkt_id = (_pkt_id + 1) & 0xffff // 16-bit unsigned short
+      _ftr_key = pkt_or_key.pkt_id = _pkt_id
+    else _ftr_key = pkt_or_key
+
+    return new Promise(_ftr_by_key)
 
-  let rotate_ts = rotate_td + Date.now()
+  function answer(key, pkt) ::
+    for let map of hashbelt ::
+      let fn_answer = map.get(key)
+      if fn_answer ::
+        map.delete(key)
 
-  return @[] on_mqtt,
-    _disp_.bind_pkt_future()
+        fn_answer([pkt, /*err*/]) // option/maybe monad
+        return true
+    return false
 
   function on_mqtt(pkt_list, ctx) ::
     for let pkt of pkt_list ::
-      cmdids[pkt.id] @ _disp_, pkt, ctx
-
-    if Date.now() > rotate_ts ::
-      _disp_.rotate_belt(rotate_n)
-      rotate_ts = rotate_td + Date.now()
+      _mqtt_cmdids[pkt.id](target, answer, pkt, ctx)
+
+    // rotate after rotate_ts
+    let now = Date.now()
+    if now > rotate_ts ::
+      rotate_ts = rotate_td + now
+      hashbelt.unshift(new Map())
+      while hashbelt.length > rotate_n ::
+        for let fn_answer of hashbelt.pop().values() ::
+          fn_answer([/*pkt*/, 'expired']) // option/maybe monad
 

package/code/_utils.jsy

@@ -0,0 +1,17 @@
+export const _isfn = v => typeof v === 'function'
+export const _isstr = v => typeof v === 'string'
+
+export function _interval(fn_callback) ::
+  let tid
+  return @\ td ::
+    tid = clearInterval(tid)
+    if td ::
+      tid = setInterval(fn_callback, 1000 * td)
+      #IF PLAT_DENO
+        // ensure the interval allows the Deno event loop to exit
+        Deno.unrefTimer(tid)
+      #ELSE
+        // ensure the interval allows the NodeJS event loop to exit
+        tid.unref?.()
+      return true
+

package/code/base.jsy

@@ -1,41 +1,18 @@
-import {_mqtt_conn} from './_conn.jsy'
-import {_mqtt_dispatch} from './_dispatch.jsy'
+import { _isfn, _isstr } from './_utils.jsy'
+import { _mqtt_dispatch } from './_dispatch.jsy'
 
 export class MQTTError extends Error ::
   constructor(mqtt_pkt, reason=mqtt_pkt.reason) ::
+    // use hex-encoded reasons to match MQTT spec documentation
     super(`[0x${reason.toString(16)}] ${reason.reason}`)
     this.mqtt_pkt = mqtt_pkt
     this.reason = reason
 
 export class MQTTBase ::
-  constructor(opt={}) ::
-    this.with(opt)
-    this._conn_ = _mqtt_conn @ this,
-      this._init_dispatch(opt, this)
-
-  with(fns_ns) ::
-    for let [k,v] of Object.entries(fns_ns) ::
-      if 'function' === typeof v :: this[k] = v
-    return this
-
-  async conn_emit(evt, arg, err_arg) ::
-    this.log_conn?.(evt, arg, err_arg)
-    try ::
-      let fn_evt = this[await evt] // microtask break using `await evt`
-      if fn_evt ::
-        await fn_evt.call(this, this, arg, err_arg)
-      else if err_arg :: throw err_arg
-    catch err ::
-      this.on_error(err, evt)
-
-  on_error(err, evt) ::
-    console.warn @ '[[u8-mqtt error: %s]]', evt, err
-
   // Handshaking Packets
-
   async connect(pkt={}) ::
     let cid = pkt.client_id
-    if 'string' !== typeof cid ::
+    if ! _isstr(cid) ::
       // see init_client_id implementation in core.jsy
       pkt.client_id = cid = this.client_id || this.init_client_id(cid)
     this.client_id = cid
@@ -43,23 +20,20 @@ export class MQTTBase ::
     if null == pkt.keep_alive ::
       pkt.keep_alive = 60
 
-    let res = await this._conn_
-      .send_connect('connect', pkt, 'connack')
-
-    if 0 != res[0].reason ::
-      throw new this.MQTTError(res[0])
-
-    // TODO: merge with server's keep_alive frequency
-    this._conn_.ping(pkt.keep_alive)
-    return res
+    let response = await this._send0('connect', pkt, 'connack')
+    if 0 != response[0].reason :: // compare to 0 to coerce to number
+      throw new this.MQTTError(response[0])
+    return this.conn.on_conn(pkt, response)
 
   async disconnect(pkt={}) ::
-    let res = await this._send('disconnect', pkt)
-    this._conn_.reset(false)
-    return res
+    let response = await this._send0('disconnect', pkt)
+    return this.conn.on_dis(pkt, response)
 
-  auth(pkt={}) ::
-    return this._send('auth', pkt, 'auth')
+  async auth(pkt={}) ::
+    let response = await this._send0('auth', pkt, 'auth')
+    if response[0].reason ::
+      throw new this.MQTTError(response[0])
+    return this.conn.on_auth(pkt, response)
 
   ping() :: return this._send('pingreq', null, 'pingresp')
   puback({pkt_id}) :: return this._send('puback', {pkt_id})
@@ -96,20 +70,18 @@ export class MQTTBase ::
   // alias: publish -- because 'pub' is shorter for semantic aliases above
   async pub(pkt, pub_opt) ::
     if undefined === pkt.payload ::
-      if 'function' === typeof pub_opt ::
+      if _isfn(pub_opt) ::
+        // pub_opt as a function is fn_encode value
         pub_opt = {fn_encode: pub_opt}
 
-      let {msg} = pkt
-      switch typeof msg ::
-        case 'function':
-          pub_opt = {...pub_opt, fn_encode: msg}
-          // flow into 'undefined' case
-        case 'undefined':
-          // return a single-value closure to publish packets
-          return v => this.pub({...pkt, [pkt.arg || 'payload']: v}, pub_opt)
+      let msg = pkt.msg, fn_encode = pub_opt?.fn_encode
+      if null == msg || _isfn(msg) ::
+        // when msg is a function, return closure using fn_encode
+        if msg :: pub_opt = {...pub_opt, fn_encode: msg}
+        // return a single-value closure to publish packets
+        return v => this.pub({...pkt, [pkt.arg || 'payload']: v}, pub_opt)
 
       // Encode payload from msg; fn_encode allows alternative to JSON.stringify
-      let {fn_encode} = pub_opt || {}
       pkt.payload = fn_encode
         ? await fn_encode(msg)
         : JSON.stringify(msg)
@@ -121,31 +93,31 @@ export class MQTTBase ::
         pkt = pub_opt.xform(pkt) || pkt
 
     return this._send @ 'publish', pkt,
-      pkt.qos ? pkt : void 0 // key
+      pkt.qos ? pkt : null // key
 
 
   // Internal API
 
-  /* async _send(type, pkt) -- provided by _conn_ and transport */
+  /* async _send0(type, pkt) -- provided by conn and transport */
+  /* async _send(type, pkt) -- provided by conn and transport */
 
   _init_dispatch(opt) ::
     this.constructor?._once_()
     let target = @{} __proto__: opt.on_mqtt_type
     target.mqtt_publish ||=
       this._init_router?.(opt, this, target)
-    return _mqtt_dispatch(this, target)
+    return _mqtt_dispatch(opt, target)
 
   static _aliases() ::
     return ' publish:pub sub:subscribe unsub:unsubscribe json_post:obj_post json_send:obj_send json_store:obj_store'
 
-  static _once_(self=this) ::
-    self._once_ = _=>0
-    let p = self.prototype
+  static _once_(klass=this) ::
+    klass._once_ = _=>0
+    var alias, name, p = klass.prototype
     p.MQTTError = MQTTError
-    for let alias of self._aliases().split(/\s+/) ::
-      alias = alias.split(':')
-      let fn = alias[1] && p[alias[1]]
-      if fn :: p[alias[0]] = fn
+    for alias of klass._aliases().split(/\s+/) ::
+      [alias, name] = alias.split(':')
+      p[alias] = p[name]
 
 
 function _as_topics(pkt, ex, topic_prefix) ::