@threadedstack/wmd-web 0.0.0-stage → 0.1.12

package/src/net/switch.js

@@ -0,0 +1,160 @@
+// W56: an in-page network switch. The guests of one page that share a NetSwitch reach each other by
+// address and by name, with no relay. Each guest's network Worker (net-worker.js) keeps its own
+// stack (stack.js); the switch is the control plane only: it hands out addresses, keeps the name
+// table, and links two Workers with a MessageChannel the first time one of them opens a connection
+// to the other. Streams then go Worker to Worker (peer.js), never through the page.
+//
+//   const sw = new NetSwitch()
+//   bootWmd({ ..., channels: { services: [..., { port: 9, kind: 'net', switch: sw, name: 'db' }] } })
+//
+// A guest with no switch is alone on its network, as before. Switches are separate networks: two
+// documents with one switch each never see each other's guests.
+//
+// Worker <-> switch (the member's MessagePort):
+//   worker -> switch {t:'link', ip}          a port to the member at ip, please
+//   switch -> worker {t:'table', members}    [{name, ip}] every member (sent on attach and on each change)
+//                    {t:'link', ip, port}    a MessagePort to the member at ip (both ends get one)
+//                    {t:'nolink', ip}        no member has ip
+//                    {t:'gone', ip}          the member at ip left: its streams are over
+//
+// Addresses: the engine's network (192.168.127.0/24, gateway .1). A member gets the address asked
+// for, else the one its name had before on this switch (a guest restored from a checkpoint keeps
+// the address in its memory), else the lowest free one from .2.
+
+import { ipToU32, u32ToIp } from './packet.js'
+
+const NAME_RE = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/
+
+export class NetSwitch {
+  /**
+   * @param {object} [o]
+   * @param {string} [o.gateway]  the gateway's address (default 192.168.127.1)
+   * @param {string} [o.mask]     the network's mask (default 255.255.255.0)
+   */
+  constructor(o = {}) {
+    this.gw = ipToU32(o.gateway || '192.168.127.1')
+    this.mask = ipToU32(o.mask || '255.255.255.0')
+    this.net = (this.gw & this.mask) >>> 0
+    this.bcast = (this.net | ~this.mask) >>> 0
+    this.members = new Map() // name -> member
+    this.byIp = new Map() // u32 -> member
+    this.reserved = new Map() // name -> u32: the address a name had (or was given by address())
+    this.links = new Set() // 'ipA-ipB' (lower first) of linked pairs
+    this.closed = false
+  }
+
+  /** The address `name` gets on this switch (reserved for it from now on). */
+  address(name, ip) {
+    return u32ToIp(this.#addressFor(checkName(name), ip))
+  }
+
+  #addressFor(name, ip) {
+    if (ip !== undefined && ip !== null && ip !== '') {
+      const m = typeof ip === 'string' && /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(ip)
+      if (!m || m.slice(1).some(x => Number(x) > 255)) throw new Error(`net switch: ip ${JSON.stringify(ip)} is not a dotted IPv4 address`)
+      const a = ipToU32(ip)
+      if (((a & this.mask) >>> 0) !== this.net || a === this.net || a === this.bcast || a === this.gw) {
+        throw new Error(`net switch: ${ip} is not a guest address on ${u32ToIp(this.net)}/${maskBits(this.mask)} (gateway ${u32ToIp(this.gw)})`)
+      }
+      for (const [n, r] of this.reserved) if (r === a && n !== name) throw new Error(`net switch: ${ip} is taken by ${n}`)
+      this.reserved.set(name, a)
+      return a
+    }
+    const had = this.reserved.get(name)
+    if (had !== undefined) return had
+    const taken = new Set(this.reserved.values())
+    for (let a = (this.net + 1) >>> 0; a < this.bcast; a++) {
+      if (a === this.gw || taken.has(a)) continue
+      this.reserved.set(name, a)
+      return a
+    }
+    throw new Error('net switch: no free address')
+  }
+
+  /**
+   * Attach a guest (bootWmd does this for a net service with `switch`). Returns its address and the
+   * MessagePort for its network Worker; detach() takes it off (its peers' streams to it fail).
+   */
+  attach({ name, ip } = {}) {
+    if (this.closed) throw new Error('net switch: closed')
+    name = checkName(name)
+    if (this.members.has(name)) throw new Error(`net switch: a guest named ${name} is already on the switch`)
+    const a = this.#addressFor(name, ip)
+    if (this.byIp.has(a)) throw new Error(`net switch: ${u32ToIp(a)} is in use by ${this.byIp.get(a).name}`)
+    const mc = new MessageChannel()
+    const m = { name, ip: a, port: mc.port1, peers: new Set(), detached: false }
+    m.port.onmessage = e => this.#onMessage(m, e.data)
+    this.members.set(name, m)
+    this.byIp.set(a, m)
+    this.#broadcastTable()
+    return {
+      name,
+      ip: u32ToIp(a),
+      port: mc.port2,
+      detach: () => this.#detach(m),
+    }
+  }
+
+  #onMessage(m, x) {
+    if (m.detached || !x || x.t !== 'link') return
+    const peer = this.byIp.get(x.ip >>> 0)
+    if (!peer || peer === m) {
+      m.port.postMessage({ t: 'nolink', ip: x.ip })
+      return
+    }
+    const key = m.ip < peer.ip ? `${m.ip}-${peer.ip}` : `${peer.ip}-${m.ip}`
+    if (this.links.has(key)) return // the two are linked already: the port is on its way (both asked at once)
+    this.links.add(key)
+    const mc = new MessageChannel()
+    m.peers.add(peer)
+    peer.peers.add(m)
+    m.port.postMessage({ t: 'link', ip: peer.ip, port: mc.port1 }, [mc.port1])
+    peer.port.postMessage({ t: 'link', ip: m.ip, port: mc.port2 }, [mc.port2])
+  }
+
+  #detach(m) {
+    if (m.detached) return
+    m.detached = true
+    this.members.delete(m.name)
+    this.byIp.delete(m.ip)
+    for (const p of m.peers) {
+      p.peers.delete(m)
+      const key = m.ip < p.ip ? `${m.ip}-${p.ip}` : `${p.ip}-${m.ip}`
+      this.links.delete(key)
+      p.port.postMessage({ t: 'gone', ip: m.ip })
+    }
+    m.peers.clear()
+    m.port.onmessage = null
+    m.port.close()
+    this.#broadcastTable()
+  }
+
+  #broadcastTable() {
+    const members = this.table()
+    const t = members.map(x => ({ name: x.name, ip: ipToU32(x.ip) }))
+    for (const m of this.members.values()) m.port.postMessage({ t: 'table', members: t })
+  }
+
+  /** The guests on the switch: [{name, ip}]. */
+  table() {
+    return [...this.members.values()].map(m => ({ name: m.name, ip: u32ToIp(m.ip) }))
+  }
+
+  /** Take every guest off (their streams to each other fail); the switch takes no more. */
+  close() {
+    this.closed = true
+    for (const m of [...this.members.values()]) this.#detach(m)
+  }
+}
+
+function checkName(name) {
+  const n = String(name ?? '').toLowerCase()
+  if (!NAME_RE.test(n)) throw new Error(`net switch: a guest's name must be a DNS label (a-z, 0-9, '-', up to 63), not ${JSON.stringify(name)}`)
+  return n
+}
+
+function maskBits(m) {
+  let n = 0
+  for (let v = m >>> 0; v; v = (v << 1) >>> 0) n++
+  return n
+}