function mdns(search, callback){
var browser = MDNS.createBrowser(
MDNS.tcp(search), {
'resolverSequence': [
MDNS.rst.DNSServiceResolve(),
MDNS.rst.getaddrinfo({'families': [4]})
]
}
);
var results = [];
browser.on('serviceUp', function(service){
results.push({
address: service.addresses[0],
name: service.name,
port: service.port
});
});
debug('starting mdns search for', search);
browser.start();
setTimeout(function(){
debug('stopping mdns search', search, 'with results', results);
browser.stop();
callback(results.unique());
}, 2000);
}
module.exports = function (node) {
if(!node.name) return
var browser = mdns.createBrowser(mdns.udp('marauders'))
var server = dgram.createSocket('udp4')
var announce = function (str, port, address) {
var message = new Buffer(str)
server.send(message, 0, message.length, port, address, function (e, bytes) {
if(e) throw e
})
}
browser.on('serviceUp', function (service) {
if(service.name !== 'O000fê$YòwpÎ') return
var address = addr(service)
if(!address) return
json.stringify(node, function (e, str) {
if(e) throw e
announce(str, service.port, address)
})
})
var ad = mdns.createAdvertisement(mdns.udp('marauders'), node.port, {
name: node.name
})
browser.start()
ad.start()
}
function MdnsNode(n) {
var mdns = require('mdns');
if (process.platform === "linux") {
RED.log.info("You may ignore the warning about Bonjour compatability.");
}
RED.nodes.createNode(this, n);
this.topic = n.topic || "";
this.service = n.service;
var browser = mdns.createBrowser(this.service);
var node = this;
browser.on('serviceUp', function(service) {
if (RED.settings.verbose) { node.log("here : " + service.name); }
service.state = true;
var msg = {topic:node.topic, payload:service};
node.send(msg);
});
browser.on('serviceDown', function(service) {
if (RED.settings.verbose) { node.log("away : " + service.name); }
service.state = false;
var msg = {topic:node.topic, payload:service};
node.send(msg);
});
browser.start();
node.on("close", function() {
if (browser) { browser.stop(); }
});
}
var Gop = function(options) {
var self = this;
if (!(self instanceof Gop)) return new Gop(options);
self.options = options;
self.logger = DEFAULT_LOGGER;
self.controllers = {};
mdns.createBrowser(mdns.tcp('gop')).on('serviceUp', function(service) {
var controller, ipaddr, params;
for (ipaddr in service.addresses) if ((service.addresses.hasOwnProperty(ipaddr)) && !!self.controllers[ipaddr]) return;
service.event = 'up';
self.logger.debug('_gop._tcp', service);
params = { name : service.name
, host : service.host
, port : service.port
, path : ((!!service.txtRecord) && service.txtRecord.path) || '/'
, ipaddrs : service.addresses
};
controller = new Controller(params);
for (ipaddr in service.addresses) if (service.addresses.hasOwnProperty(ipaddr)) self.controllers[ipaddr] = controller;
controller.login(controller);
self.emit('discover', controller);
}).on('serviceDown', function(service) {
self.logger.debug('_gop._tcp', { event: 'down', name: service.name, host: service.host });
}).on('serviceChanged', function(service) {
self.logger.debug('_gop._tcp', { event: 'changed', name: service.name, host: service.host });
}).on('error', function(err) {
self.logger.error('_gop._tcp', { event: 'mdns', diagnostic: err.message });
}).start();
};
Buzz.prototype.monitorClients = function () {
var self = this;
self.browser = mdns.createBrowser(mdns.tcp('http'));
self.browser.on('serviceUp', function(cli) {
if (cli.port == 7331) {
if (!self.clients[cli.addresses[0]]) {
console.log('up: ' + cli.addresses[0]);
// TODO: abstract
var tempClient = {};
tempClient.name = cli.name;
tempClient.ip = cli.addresses[0];
tempClient.host = cli.host;
} else {
console.log('went up, but already discovered');
self.clients[cli.addresses[0]].name = cli.name;
}
}
});
self.browser.on('serviceDown', function (cli) {
console.log('down: ' + cli.name);
// search for name
for (var ip in self.clients) {
if (self.clients[ip].name == cli.name) {
delete self.clients[ip];
}
};
});
self.browser.start();
}
var Browser = function() {
var self = this;
this.devices_ = {};
this.nextDeviceId_ = 0;
this.browser_ = mdns.createBrowser(mdns.tcp('airplay'));
this.browser_.on('serviceUp', function(info, flags) {
var device = self.findDeviceByInfo_(info);
if (!device) {
device = new Device(self.nextDeviceId_++, info);
self.devices_[device.id] = device;
device.on('ready', function() {
self.emit('deviceOnline', device);
});
device.on('close', function() {
delete self.devices_[device.id];
self.emit('deviceOffline', device);
});
}
});
this.browser_.on('serviceDown', function(info, flags) {
var device = self.findDeviceByInfo_(info);
if (device) {
device.close();
}
});
};
lightArray.on('ready', function(){
// initialize midi stuff
midiInput = new midi.input();
midiInput.openVirtualPort("LightArray");
lightArray.start();
midiInput.on('message', function(time, message){console.log(message);
if (message[0] === 176 && 41 < message[1] < 46){
lightArray.update(message[1] - 42, message[2]);
}
});
// initialize remote
remoteBrowser = mdns.createBrowser(new mdns.ServiceType('lightarray', 'tcp'));
remoteBrowser.on('serviceUp', function(service) {
remoteAddress = service.addresses[0];
remotePort = service.port;
console.log('attempting connection to remote at ' + remoteAddress + ':' + remotePort)
remote = ioClient.connect("http://" + remoteAddress + ":" + remotePort);
if (remote){
console.log('successfully connected to remote');
lightArray.setRemote(remote);
}
});
remoteBrowser.start();
// initialize web server stuff
server.listen(8000);
console.log('listening');
});
var Gop = function(options) {
var self = this;
if (!(self instanceof Gop)) return new Gop(options);
self.options = options || {};
self.logger = DEFAULT_LOGGER;
self.controllers = {};
mdns.createBrowser(mdns.tcp('gop')).on('serviceUp', function(service) {
var controller, ipaddr, params;
for (ipaddr in service.addresses) if ((service.addresses.hasOwnProperty(ipaddr)) && !!self.controllers[ipaddr]) return;
service.event = 'up';
self.logger.debug('_gop._tcp', service);
params = { name : service.name
, host : service.host
, port : service.port
, path : ((!!service.txtRecord) && service.txtRecord.path) || '/'
, ipaddrs : service.addresses
};
controller = new Controller(params);
for (ipaddr in service.addresses) if (service.addresses.hasOwnProperty(ipaddr)) self.controllers[ipaddr] = controller;
controller.login(controller);
self.emit('discover', controller);
}).on('serviceDown', function(service) {
self.logger.debug('_gop._tcp', { event: 'down', name: service.name, host: service.host });
}).on('serviceChanged', function(service) {
self.logger.debug('_gop._tcp', { event: 'changed', name: service.name, host: service.host });
}).on('error', function(err) {
self.logger.error('_gop._tcp', { event: 'mdns', diagnostic: err.message });
}).start();
new ssdp().on('response', function(msg /* , rinfo */) {
var controller, i, info, j, location, lines, params;
lines = msg.toString().split("\r\n");
info = {};
for (i = 1; i < lines.length; i++) {
j = lines[i].indexOf(':');
if (j <= 0) break;
info[lines[i].substring(0, j)] = lines[i].substring(j + 1).trim();
}
if (info.ST !== 'urn:greenwavereality-com:service:gop:1') return;
location = info.LOCATION || info.Location;
if (!!self.controllers[location]) return;
params = url.parse(location);
params.ipaddrs = [ params.hostname ];
controller = new Controller(params);
self.controllers[location] = controller;
controller.login(controller);
self.emit('discover', controller);
}).search('urn:greenwavereality-com:service:gop:1');
};
listDevices: function(callback){
var browser = mdns.createBrowser(mdns.tcp('googlecast'));
browser.on('serviceUp', function(service) {
//console.log('found device "%s" at %s:%d', service.name, service.addresses[0], service.port);
callback(null, service);
browser.stop();
});
browser.start();
},
var MDNSScout = module.exports = function() {
Scout.call(this);
var self = this;
this.browser = mdns.createBrowser(mdns.tcp('intellichilli'));
this.browser.on('serviceUp', function(service) {
self.foundCrockpot(service.addresses[0]);
});
};
function YamahaAVRPlatform(log, config){
this.log = log;
this.config = config;
this.playVolume = config["play_volume"];
this.minVolume = config["min_volume"] || -50.0;
this.maxVolume = config["max_volume"] || -20.0;
this.gapVolume = this.maxVolume - this.minVolume;
this.setMainInputTo = config["setMainInputTo"];
this.expectedDevices = config["expected_devices"] || 100;
this.discoveryTimeout = config["discovery_timeout"] || 30;
this.browser = mdns.createBrowser(mdns.tcp('http'), {resolverSequence: sequence});
}
Service.prototype._startService = function (address, callback) {
var networkName = ifname(address);
var network = networkName;
var isAny = isme(address, 'any');
// If it listen to loopback interface set flag
if (isAny || networkName === LOOPBACK_NAME) {
this._loopbackAllowed = true;
}
// Special case, where loopback interface is used
if (networkName === LOOPBACK_NAME) {
// There is a linux-avahi exception when dealling with a loopback interface
if (mdns.isAvahi) {
return callback(
new Error('loopback address is not supported on linux-avahi platform')
);
}
// Use specical key
network = mdns.loopbackInterface();
} else if (isAny) {
network = undefined;
}
this._discover = mdns.createBrowser(this._key, {
networkInterface: network
});
this._discover.on('error', this._relayError);
this._discover.start();
this._announce = mdns.createAdvertisement(
this._key, this._address.port, {
// workaround for some wird bug
// ref: https://github.com/agnat/node_mdns/issues/51
name: this._uuid,
networkInterface: network
}
);
this._announce.on('error', this._relayError);
this._announce.start();
return callback(null);
};
return promise(function(resolve, reject) {
var scanner = mdns.createBrowser(mdns.tcp('googlecast'));
if (!ttl) ttl = 10000; // default to 10 seconds
var timer = setTimeout(function() {
scanner.stop();
reject('device not found');
}, ttl);
scanner.on('serviceUp', function(service) {
if (deviceName && deviceName !== service.name) return;
resolve(service);
scanner.stop();
clearTimeout(timer);
});
scanner.start();
});
self.sbrowser.on('serviceUp', function (s) {
var browser = mdns.createBrowser(mdns[s.type.protocol](s.type.name));
browser.on('serviceUp', function (cli) {
if (cli.port == 7331) {
var tempClient = {};
tempClient.name = cli.name;
tempClient.ip = cli.addresses[0];
tempClient.host = cli.host;
console.log('up: ' + tempClient.ip);
self.clients[tempClient.ip] = tempClient;
}
});
browser.start();
});
function start_mdns(p){
var browser = mdns.createBrowser(mdns.tcp('http'));
browser.on('error', console.log);
browser.on('serviceUp', function(service) {
if(service.txtRecord && service.txtRecord.name == 'barnstorm:' + p){
console.log("Interface LAN service up at http://" + service.addresses[0] + ':' + service.port);
}
});
browser.start();
var txtRecord = {name: 'barnstorm:' + p};
var ad = mdns.createAdvertisement(mdns.tcp('http'), self.port, {txtRecord: txtRecord});
};
var Singleton = function(options) {
var i, iface, ifaces, ifname, k;
var self = this;
if (!(self instanceof Singleton)) return new Singleton(options);
self.options = options || {};
self.logger = self.options.logger || {};
for (k in DEFAULT_LOGGER) {
if ((DEFAULT_LOGGER.hasOwnProperty(k)) && (typeof self.logger[k] === 'undefined')) self.logger[k] = DEFAULT_LOGGER[k];
}
ifaces = os.networkInterfaces();
self.ifaddrs = [];
for (ifname in ifaces) if (ifaces.hasOwnProperty(ifname)) {
iface = ifaces[ifname];
for (i = 0; i < iface.length; i++) {
if ((!iface[i].internal) && (iface[i].family === 'IPv4')) self.ifaddrs.push(iface[i].address);
}
}
self.hosts = {};
try {
self.mdns = mdns.createBrowser(mdns.tcp('wss')).on('serviceUp', function(service) {
for (i = 0; i < service.addresses.length; i++) {
if (self.ifaddrs.indexOf(service.addresses[i]) !== -1) {
service.localhost = true;
break;
}
}
self.hosts[service.host] = service;
}).on('serviceDown', function(service) {
delete(self.hosts[service.host]);
}).on('serviceChanged', function(service) {
self.hosts[service.host] = service;
}).on('error', function(err) {
self.logger.error('_wss._tcp', { event: 'mdns', diagnostic: err.message });
});
self.mdns.start();
} catch(ex) {
self.logger.error('_wss._tcp', { event: 'browse', diagnostic: ex.message });
}
};
return function( fingerprint ) {
// The first 7 chars are enough to find our broker
let service = fp2service( fingerprint );
// Start browsing for our broker
let browser = mdns.createBrowser( mdns.tcp( service ), { resolverSequence: [
mdns.rst.DNSServiceResolve(),
'DNSServiceGetAddrInfo' in mdns.dns_sd ? mdns.rst.DNSServiceGetAddrInfo() : mdns.rst.getaddrinfo({families:[4]}),
mdns.rst.makeAddressesUnique()
] } );
return new Promise( ( resolve, reject ) => {
// Set a timeout for discovery if user specified one
let timeoutHandle = null;
if( timeout ) timeoutHandle = setTimeout( () => {
// Stop browser
browser.removeAllListeners();
browser.stop();
// Reject since we haven't obtained an anwser within specified time
reject();
}, timeout * 1000 );
// Setup event listener
browser.once( 'serviceUp', ( server ) => {
// If we found a service, stop searching, timeout and resovle
browser.stop();
if( timeoutHandle ) clearTimeout( timeoutHandle );
// Create mqtts URL
resolve( 'mqtts://' + server.host + ':' + server.port.toString() );
} );
browser.start();
} );
}
module.exports = (function(){
var browser = mdns.createBrowser(mdns.tcp('vm'), {resolverSequence: [mdns.rst.DNSServiceResolve()]});
browser.on('serviceUp', vms.add);
browser.on('serviceChanged', vms.add);
browser.on('serviceDown', vms.rm);
browser.on('error', function(e){ console.log('Error: ' + JSON.stringify(e)); });
var ad = mdns.createAdvertisement(
mdns.tcp('vm'),
9300
);
return {
run: function(){
browser.start();
ad.start();
}
};
})();
DenonAVRBridge.prototype._discover_mdns = function () {
var self = this;
var browser = mdns.createBrowser(mdns.tcp('http'));
browser.on('error', function (error) {
logger.error({
method: "discover",
unique_id: self.unique_id,
error: error,
cause: "likely network related - ignoring",
}, "error");
if ((error.code === -3008) && mdns && amdns) {
mdns = null;
logger.warn("switching to avahi-mdns-kludge");
browser.stop();
self._discover_amdns();
}
});
browser.on('serviceUp', function (service) {
if (service.port !== 80) {
return;
} else if (!service.addresses) {
return;
} else if (service.addresses.length === 0) {
return;
}
self._discover_host(_.defaults({
host: service.addresses[0],
name: service.name,
probe: true,
}, self.initd));
});
browser.start();
};
Browser.prototype.init = function ( options ) {
var self = this;
var nextDeviceId = 0;
this.devices = {};
this.browser = mdns.createBrowser( mdns.tcp( 'airplay' ), options );
this.browser.on( 'serviceUp', function( info ) {
if ( !self.isValid( info ) ) {
return;
}
var device = self.getDevice( info );
if ( device ) {
return;
}
device = new Device( nextDeviceId++, info );
device.on( 'ready', function( d ) {
self.emit( 'deviceOn', d );
});
device.on( 'close', function( d ) {
delete self.devices[ d.id ];
self.emit( 'deviceOff', d );
});
self.devices[ device.id ] = device;
});
this.browser.on( 'serviceDown', function( info ) {
if ( !self.isValid( info ) ) {
return;
}
var device = self.getDevice( info );
if ( device ) {
device.close();
}
});
};
function MDNSDiscovery(){
BonjourDiscovery.call(this);
var that = this;
try{
this.browser = mdns && mdns.createBrowser(mdns.tcp('http'));
if(this.browser){
this.browser.on('serviceUp', function(service) {
that.emit('serviceUp', service);
});
this.browser.on('serviceDown', function(service) {
that.emit('serviceDown', service);
});
this.browser.on('error', function(error) {
that.emit('error', error);
});
} else {
this.emit('error', 'could not create Bonjour discovery');
}
} catch (e) {
this.emit('error', e);
}
}
});
// use mqtt for client, socket.io for push,
var mqtt = require('mqtt');
var io = require('socket.io')(http); // the socket listens on the http port
// multicast DNS service discovery
var mdns = require('mdns');
// advertise the http server on the httpport
var ad = new mdns.Advertisement(mdns.tcp('http'), httpport, {
name : 'FLM data processor'
});
ad.start();
// detect mqtt publishers and create corresponding servers
var mdnsbrowser = mdns.createBrowser(mdns.tcp('mqtt'));
// handle detected devices
mdnsbrowser.on('serviceUp', function (service) {
console.log('detected:' + service.addresses[0] + ':' + service.port);
var mqttclient = mqtt.createClient(service.port, service.addresses[0]);
// for the persistence subscription is needed:
mqttclient.subscribe('/sensor/#');
// handle mqtt messages
mqttclient.on('message', function (topic, payload) {
var subtopics = topic.split('/');
switch (subtopics[3]) {
case 'gauge':
var gauge = JSON.parse(payload);
// FLM gauges consist of timestamp, value, and unit
if (gauge.length == 3) {
var insertStr = 'INSERT INTO flmdata'
if (err) throw err;
done();
});
};
var done = function () {
if (cbCount) return;
if (found)
console.log('\nThanks for your help! You deserve a nice cold beer :)');
else
console.log('\nDid not find anything new on your network, but you\'re still awesome :)');
process.exit();
};
console.log('Taking a look around on your network...\nThe whole thing should not take more than a minute');
mdns.createBrowser(mdns.tcp('raop')).on('serviceUp', save).start();
mdns.createBrowser(mdns.tcp('airplay')).on('serviceUp', save).start();
var msg = roundround([
'Still working...',
'You rock! Thanks for waiting :)',
'Ok, I\'m really sorry about this - please wait a little longer',
'While you wait you should check out https://github.com/watson/roundround',
'If you ever bump into me I\'ll buy you a beer...',
'Almost there... almost... I promise',
'I\'m working as fast as I can given your poor network conditions - P.s. I love you!'
]);
setInterval(function () {
console.log(msg());
}, 10000);
/* jslint node: true */
"use strict";
var mdns = require('mdns');
var opts;
var browser = mdns.createBrowser(mdns.tcp('jenkins'));
browser.on('serviceUp', function (service) {
console.log("service up: ", service);
opts.onJenkinsUpCb(service.txtRecord);
});
browser.on('serviceDown', function (service) {
console.log("service down: ", service);
opts.onJenkinsDownCb(service.txtRecord);
});
var start = function start(options) {
opts = options;
if (browser._watcherStarted === false) {
browser.start();
}
};
var stop = function stop() {
if (browser._watcherStarted === true) {
browser.stop();
}
};
exports.start = start;
var mdns = require('mdns');
var browser = mdns.createBrowser(mdns.tcp('googlecast'));
browser.on('serviceUp', function(service) {
//console.log('found device "%s" at %s:%d', service.name, service.addresses[0], service.port);
console.log(service.addresses[0]);
browser.stop();
});
browser.start();
var path = require("path");
var io = require("socket.io")(http);
// multicast DNS service discovery
var mdns = require("mdns");
// resolution requence added due to mdns issue - see https://github.com/agnat/node_mdns/issues/130
var sequence = [ mdns.rst.DNSServiceResolve(), "DNSServiceGetAddrInfo" in mdns.dns_sd ? mdns.rst.DNSServiceGetAddrInfo() : mdns.rst.getaddrinfo({
families: [ 4 ]
}), mdns.rst.makeAddressesUnique() ];
// detect mqtt publishers and create corresponding servers
var mdnsbrowser = mdns.createBrowser(mdns.tcp("mqtt"), {
resolverSequence: sequence
});
mdnsbrowser.on("serviceUp", function(service) {
console.log("Detected MQTT service on: " + service.addresses[0] + ":" + service.port);
mqttconnect(service.addresses[0], service.port);
});
mdnsbrowser.on("serviceDown", function(service) {
console.log("MQTT service down: ", service);
});
mdnsbrowser.on("error", function(exception) {
console.log("An error occured: ", exception);
});
ControllerVolumioDiscovery.prototype.startMDNSBrowse=function()
{
var self=this;
try
{
var serviceName=config.get('service');
var servicePort=config.get('port');
var sequence = [
mdns.rst.DNSServiceResolve()
, mdns.rst.getaddrinfo({families: [4] })
];
self.browser = mdns.createBrowser(mdns.tcp(serviceName),{resolverSequence: sequence});
self.browser.on('error',function(error){
self.context.coreCommand.pushConsoleMessage('mDNS Browse raised the following error ' + error);
self.startMDNSBrowse();
});
self.browser.on('serviceUp', function(service) {
if (registeredUUIDs.indexOf(service.txtRecord.UUID) > -1) {
console.log("Discovery: this is already registered, " + service.txtRecord.UUID);
foundVolumioInstances.delete(service.txtRecord.UUID+'.name');
self.remoteConnections.remove(service.txtRecord.UUID+'.name');
} else {
registeredUUIDs.push(service.txtRecord.UUID);
console.log("Discovery: adding " + service.txtRecord.UUID);
}
//console.log(service);
self.context.coreCommand.pushConsoleMessage('mDNS: Found device '+service.txtRecord.volumioName);
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.name',"string",service.txtRecord.volumioName);
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.addresses',"array",service.addresses);
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.port',"string",service.port);
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.status',"string",'stop');
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.volume',"number",0);
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.mute',"boolean",false);
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.artist',"string",'');
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.track',"string",'');
foundVolumioInstances.addConfigValue(service.txtRecord.UUID+'.albumart',"string",'');
self.connectToRemoteVolumio(service.txtRecord.UUID,service.addresses[0]);
var toAdvertise=self.getDevices();
self.commandRouter.pushMultiroomDevices(toAdvertise);
for(var i in self.callbacks)
{
var c=self.callbacks[i];
var callback= c.bind(c.this);
callback(toAdvertise);
}
});
self.browser.on('serviceDown', function(service) {
self.context.coreCommand.pushConsoleMessage('mDNS: A device disapperared from network');
var keys=foundVolumioInstances.getKeys();
for(var i in keys)
{
var key=keys[i];
var uuidindex = registeredUUIDs.indexOf(key);
if (uuidindex !== -1) {
registeredUUIDs.splice(uuidindex, 1);
}
var osname=foundVolumioInstances.get(key+'.name');
if(osname==service.name)
{
self.context.coreCommand.pushConsoleMessage('mDNS: Device '+service.name+' disapperared from network');
foundVolumioInstances.delete(key);
self.remoteConnections.remove(key);
}
}
var toAdvertise=self.getDevices();
self.commandRouter.pushMultiroomDevices(toAdvertise);
for(var i in self.callbacks)
{
var callback=self.callbacks[i];
callback.call(callback,toAdvertise);
}
});
self.browser.start();
}
catch(error)
{
self.startMDNSBrowse();
}
};
var mdns = require('mdns');
var browser = mdns.createBrowser(mdns.tcp('daap'));
var printInvocation = function() {
console.log(["Timestamp", "Up/Down", "Flags", "Address", "Service Name"].join("\t"));
};
var i = 0;
var once = function(callable) {
for(;i<1; ++i) {
callable();
}
};
var printRow = function(service, event) {
once(printInvocation);
console.log([new Date().toTimeString(),event,service.flags,service.addresses ? service.addresses[0] : "\t",service.name].join("\t"));
};
browser.on('serviceUp', function(service) {
printRow(service, "Up");
});
browser.on('serviceDown', function(service) {
printRow(service, "Down");
});
browser.start();
/* jslint node: true */
"use strict";
var mdns = require('mdns');
var opts;
var browser = mdns.createBrowser(mdns.tcp('jenkins-kicker'));
browser.on('serviceUp', function(service) {
console.log("service up: ", service);
// console.log("service up: ", JSON.parse(service.txtRecord.users));
});
browser.on('serviceDown', function(service) {
console.log("service down: ", service);
});
var start = function(options) {
opts = options;
advertise();
browser.start();
};
function handleAdvertisementError(error) {
switch (error.errorCode) {
case mdns.kDNSServiceErr_Unknown:
console.warn(error);
setTimeout(advertise, 5000);
break;
default:
throw error;
}
var Application = cv2.Application;
var mdns = require('mdns');
var Debug = require('debug');
var debug = Debug('jbe:cc');
const EventEmitter = require('events').EventEmitter;
const util = require('util');
var sequence = [
mdns.rst.DNSServiceResolve(),
'DNSServiceGetAddrInfo' in mdns.dns_sd ? mdns.rst.DNSServiceGetAddrInfo() : mdns.rst.getaddrinfo({
families: [4]
}),
mdns.rst.makeAddressesUnique()
];
var browser = mdns.createBrowser(mdns.tcp('googlecast'), {
resolverSequence: sequence
});
browser.on('serviceUp', function (service) {
debug('found device %s at %s:%d', service.txtRecord.fn, service.addresses[0], service.port);
if (service.txtRecord.fn.search('Couch') < 0) {
// return;
}
retObj.add(new CastItem(service));
// debug(JSON.stringify(retObj, replacer, '\t'));
// onDeviceUp(service);
//debug(JSON.stringify(service, null, '\t'));
});
browser.start();
var retObj = {