| '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) |
| }) |
| } |