chushihua

node_modules/bonjour/lib/registry.js

@@ -0,0 +1,189 @@
+'use strict'
+
+var dnsEqual = require('dns-equal')
+var flatten = require('array-flatten')
+var Service = require('./service')
+
+var REANNOUNCE_MAX_MS = 60 * 60 * 1000
+var REANNOUNCE_FACTOR = 3
+
+module.exports = Registry
+
+function Registry (server) {
+  this._server = server
+  this._services = []
+}
+
+Registry.prototype.publish = function (opts) {
+  var service = new Service(opts)
+  service.start = start.bind(service, this)
+  service.stop = stop.bind(service, this)
+  service.start({ probe: opts.probe !== false })
+  return service
+}
+
+Registry.prototype.unpublishAll = function (cb) {
+  teardown(this._server, this._services, cb)
+  this._services = []
+}
+
+Registry.prototype.destroy = function () {
+  this._services.forEach(function (service) {
+    service._destroyed = true
+  })
+}
+
+function start (registry, opts) {
+  if (this._activated) return
+  this._activated = true
+
+  registry._services.push(this)
+
+  if (opts.probe) {
+    var service = this
+    probe(registry._server.mdns, this, function (exists) {
+      if (exists) {
+        service.stop()
+        service.emit('error', new Error('Service name is already in use on the network'))
+        return
+      }
+      announce(registry._server, service)
+    })
+  } else {
+    announce(registry._server, this)
+  }
+}
+
+function stop (registry, cb) {
+  if (!this._activated) return // TODO: What about the callback?
+
+  teardown(registry._server, this, cb)
+
+  var index = registry._services.indexOf(this)
+  if (index !== -1) registry._services.splice(index, 1)
+}
+
+/**
+ * Check if a service name is already in use on the network.
+ *
+ * Used before announcing the new service.
+ *
+ * To guard against race conditions where multiple services are started
+ * simultaneously on the network, wait a random amount of time (between
+ * 0 and 250 ms) before probing.
+ *
+ * TODO: Add support for Simultaneous Probe Tiebreaking:
+ * https://tools.ietf.org/html/rfc6762#section-8.2
+ */
+function probe (mdns, service, cb) {
+  var sent = false
+  var retries = 0
+  var timer
+
+  mdns.on('response', onresponse)
+  setTimeout(send, Math.random() * 250)
+
+  function send () {
+    // abort if the service have or is being stopped in the meantime
+    if (!service._activated || service._destroyed) return
+
+    mdns.query(service.fqdn, 'ANY', function () {
+      // This function will optionally be called with an error object. We'll
+      // just silently ignore it and retry as we normally would
+      sent = true
+      timer = setTimeout(++retries < 3 ? send : done, 250)
+      timer.unref()
+    })
+  }
+
+  function onresponse (packet) {
+    // Apparently conflicting Multicast DNS responses received *before*
+    // the first probe packet is sent MUST be silently ignored (see
+    // discussion of stale probe packets in RFC 6762 Section 8.2,
+    // "Simultaneous Probe Tiebreaking" at
+    // https://tools.ietf.org/html/rfc6762#section-8.2
+    if (!sent) return
+
+    if (packet.answers.some(matchRR) || packet.additionals.some(matchRR)) done(true)
+  }
+
+  function matchRR (rr) {
+    return dnsEqual(rr.name, service.fqdn)
+  }
+
+  function done (exists) {
+    mdns.removeListener('response', onresponse)
+    clearTimeout(timer)
+    cb(!!exists)
+  }
+}
+
+/**
+ * Initial service announcement
+ *
+ * Used to announce new services when they are first registered.
+ *
+ * Broadcasts right away, then after 3 seconds, 9 seconds, 27 seconds,
+ * and so on, up to a maximum interval of one hour.
+ */
+function announce (server, service) {
+  var delay = 1000
+  var packet = service._records()
+
+  server.register(packet)
+
+  ;(function broadcast () {
+    // abort if the service have or is being stopped in the meantime
+    if (!service._activated || service._destroyed) return
+
+    server.mdns.respond(packet, function () {
+      // This function will optionally be called with an error object. We'll
+      // just silently ignore it and retry as we normally would
+      if (!service.published) {
+        service._activated = true
+        service.published = true
+        service.emit('up')
+      }
+      delay = delay * REANNOUNCE_FACTOR
+      if (delay < REANNOUNCE_MAX_MS && !service._destroyed) {
+        setTimeout(broadcast, delay).unref()
+      }
+    })
+  })()
+}
+
+/**
+ * Stop the given services
+ *
+ * Besides removing a service from the mDNS registry, a "goodbye"
+ * message is sent for each service to let the network know about the
+ * shutdown.
+ */
+function teardown (server, services, cb) {
+  if (!Array.isArray(services)) services = [services]
+
+  services = services.filter(function (service) {
+    return service._activated // ignore services not currently starting or started
+  })
+
+  var records = flatten.depth(services.map(function (service) {
+    service._activated = false
+    var records = service._records()
+    records.forEach(function (record) {
+      record.ttl = 0 // prepare goodbye message
+    })
+    return records
+  }), 1)
+
+  if (records.length === 0) return cb && cb()
+
+  server.unregister(records)
+
+  // send goodbye message
+  server.mdns.respond(records, function () {
+    services.forEach(function (service) {
+      service.published = false
+    })
+    if (cb) cb.apply(null, arguments)
+  })
+}