def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
logging.debug(serviceName)
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
update_services_cache(serviceName + '.' + regtype + replyDomain, 'del')
return
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName,
regtype, replyDomain,
resolve_callback)
try:
while not resolved:
ready = select.select([resolve_sdRef], [], [], timeout)
if resolve_sdRef not in ready[0]:
logging.debug('Resolve timed out', 1)
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
resolved.pop()
finally:
resolve_sdRef.close()
def browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
serial = serviceName.split()[-1].strip('()')
# FIXME: IPV4 and IPv6 are separate services and are resolved twice
if not (flags & pybonjour.kDNSServiceFlagsAdd):
if self.devices.has_key(serial):
#print "%s removed" % serial
del self.devices[serial]
return
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex,
serviceName, regtype,
replyDomain,
self.resolve_callback)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], 5)
if resolve_sdRef not in ready[0]:
print 'Resolve timed out'
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
finally:
resolve_sdRef.close()
if self.resolved and not self.devices.has_key(serial):
#print "%s detected" % serial
self.devices[serial] = (self.resolved_host, self.resolved_port)
self.resolved = False
def browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
self.unsubscribe()
return
resolve_sdRef = pybonjour.DNSServiceResolve(0,
interfaceIndex,
serviceName,
regtype,
replyDomain,
self.resolve_callback)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], self.timeout)
if resolve_sdRef not in ready[0]:
print('Resolve timed out')
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
self.resolved.pop()
finally:
resolve_sdRef.close()
def browse_cb(self, sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
# print 'Service removed: ', serviceName, " ", regtype
discovered_lock.acquire()
del self.discovered[hash(serviceName + regtype)]
for item in discovered:
if item[0] == serviceName:
discovered.remove(item)
discovered_lock.release()
return
if hash(serviceName + regtype) not in self.discovered:
self.discovered[hash(serviceName + regtype)] = True
# print 'Service added; resolving'
resolve_sdRef = pybonjour.DNSServiceResolve(
0, interfaceIndex, serviceName, regtype, replyDomain,
self.resolve_cb)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], TIMEOUT)
if resolve_sdRef not in ready[0]:
print('Resolve timed out')
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
self.resolved.pop()
finally:
resolve_sdRef.close()
discovered_event.clear()
def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName, regtype, replyDomain): if errorCode != pybonjour.kDNSServiceErr_NoError: return if not (flags & pybonjour.kDNSServiceFlagsAdd): print 'Service removed' return print 'DC Service found; resolving' global resolved_addrs resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName, regtype, replyDomain, resolve_callback) try: while True: ready = select.select([resolve_sdRef], [], [], timeout) if resolve_sdRef not in ready[0]: break pybonjour.DNSServiceProcessResult(resolve_sdRef) finally: resolve_sdRef.close()
def _callback_browse(self, sdref, flags, interfaceindex, error,
servicename, regtype, replydomain):
if error != pybonjour.kDNSServiceErr_NoError:
self.close()
return
self.__service = self.__class__.Service()
self.__service._name = servicename
self.__service._type = regtype
self.__service._domain = replydomain
sdref = pybonjour.DNSServiceResolve(0, interfaceindex, servicename,
regtype, replydomain,
self._callback_resolve)
ready = select.select([sdref], [], [], 5)
if sdref not in ready[0]:
return
pybonjour.DNSServiceProcessResult(sdref)
sdref.close()
if (flags & pybonjour.kDNSServiceFlagsAdd):
self.on_added(self.__service)
else:
self.on_removed(self.__service)
def browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
# ignore our own stuff
if serviceName.startswith(GRIDDLE_SERVICE_PREFIX):
return
# FIXME: IPV4 and IPv6 are separate services and are resolved twice
if not (flags & pybonjour.kDNSServiceFlagsAdd):
self.app.monome_removed(serviceName)
return
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex,
serviceName, regtype,
replyDomain,
self.resolve_callback)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], 5)
if resolve_sdRef not in ready[0]:
print 'Resolve timed out'
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
self.resolved.pop()
finally:
resolve_sdRef.close()
self.app.monome_discovered(serviceName, self.resolved_host,
self.resolved_port)
def browse_callback(sd_ref, flags, interface_index, error_code,
service_name, regtype, reply_domain):
if error_code != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
return
self._logger.debug(
"Got a browsing result for Zeroconf resolution of {service_type}, resolving..."
.format(service_type=service_type))
resolve_ref = pybonjour.DNSServiceResolve(0, interface_index,
service_name, regtype,
reply_domain,
resolve_callback)
try:
while not resolved:
ready = select.select([resolve_ref], [], [],
resolve_timeout)
if resolve_ref not in ready[0]:
break
pybonjour.DNSServiceProcessResult(resolve_ref)
else:
resolved.pop()
finally:
resolve_ref.close()
def browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
log.debug('Found service %s in domain %s on %i(type: %s).',
serviceName, replyDomain, interfaceIndex, regtype)
if not self.connected:
return
if errorCode != pybonjour.kDNSServiceErr_NoError:
log.debug('Error in browse_callback: %s', str(errorCode))
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
self.remove_service_callback(serviceName)
return
try:
# asynchronous resolving
resolve_sdRef = None
resolve_sdRef = pybonjour.DNSServiceResolve(
0, interfaceIndex, serviceName, regtype, replyDomain,
self.service_resolved_callback)
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], resolve_timeout)
if resolve_sdRef not in ready[0]:
log.info('Resolve timed out')
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
self.resolved.pop()
except pybonjour.BonjourError as error:
log.info('Error when resolving DNS: %s', error)
finally:
if resolve_sdRef:
resolve_sdRef.close()
def _browse_callback(self, sdRef, flags, interfaceIndex, errorCode, serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
return
if ( self.name_filter
and serviceName != self.name_filter):
print "Found service '%s' but it does not match '%s'" % (serviceName, self.name_filter)
return
resolve_sdRef = pybonjour.DNSServiceResolve(
0,
interfaceIndex,
serviceName,
regtype,
replyDomain,
self._resolve_callback
)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], self.timeout)
if resolve_sdRef not in ready[0]:
print 'Resolve timed out'
self.resolve_error = True
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
finally:
resolve_sdRef.close()
def _browse_callback(self, ref, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
# TODO: tell app that zero conf is not working
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
if serviceName == self._name:
self.resolved = False
if hasattr(self._unresolved_callback, '__call__'):
self._unresolved_callback()
return
# TODO: check for correct service type
if serviceName != self._name:
return
resolve_ref = pybonjour.DNSServiceResolve(0, interfaceIndex,
serviceName, regtype,
replyDomain,
self._resolve_callback)
try:
while not self._resolved:
ready = gevent.select.select([resolve_ref], [], [],
self._timeout)
if resolve_ref not in ready[0]:
# TODO: tell app about resolve timeout
break
pybonjour.DNSServiceProcessResult(resolve_ref)
else:
self._resolved.pop()
finally:
resolve_ref.close()
def _resolve_server(self, if_idx, ec, service_name, regtype, reply_domain):
"""Invoked to resolve mDNS information about a service that
was discovered by a Browse call."""
timedout = False
tval = self.__timeout
def resolve_cb(sd_hdl, flags, interface_idx, error_code, full_name,
host_target, port, txt_record):
if error_code != pybonjour.kDNSServiceErr_NoError:
return
tr = pybonjour.TXTRecord.parse(txt_record)
if "url" in tr:
url = tr["url"]
if not misc.valid_pub_url(url):
return
self._mirrors.append(pub.RepositoryURI(url))
try:
sd_hdl = pybonjour.DNSServiceResolve(0, if_idx, service_name,
regtype, reply_domain,
resolve_cb)
except pybonjour.BonjourError, e:
errstr = "mDNS Service Resolve Failed: %s\n" % e[0][1]
raise tx.mDNSException(errstr)
def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
print 'Service removed %s' % serviceName
print interfaceIndex, regtype, replyDomain
return
print 'Service added; resolving'
for resolve_sdRef in [
pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName,
regtype, replyDomain,
resolve_callback),
#pybonjour.DNSServiceResolve(
# 0,
# interfaceIndex,
# "_device-info._tcp.",
# regtype,
# replyDomain,
# resolve_callback)
]:
try:
while not resolved:
ready = select.select([resolve_sdRef], [], [], timeout)
if resolve_sdRef not in ready[0]:
print 'Resolve timed out :', serviceName
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
resolved.pop()
finally:
resolve_sdRef.close()
def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
#print 'Service removed'
return
#print 'Service added; resolving'
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName,
regtype, replyDomain,
resolve_callback)
try:
while not resolved:
ready = select.select([resolve_sdRef], [], [], timeout)
if resolve_sdRef not in ready[0]:
print 'Resolve timed out'
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
resolved.pop()
finally:
resolve_sdRef.close()
def __inner(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
# print "_browse_callback(%r, %r, %r, %r, %r, %r, %r)" % (sdRef, flags, interfaceIndex, errorCode, serviceName, regtype, replyDomain)
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
if not registerOnly:
callback({"action": "remove", "name": serviceName, "type": regtype})
return
if replyDomain == "local.":
resolve_sdRef = pybonjour.DNSServiceResolve(0,
interfaceIndex,
serviceName,
regtype,
replyDomain,
_resolve_callback(serviceName, regtype, callback))
self.rlist.append((resolve_sdRef, pybonjour.DNSServiceProcessResult))
else:
query_sdRef = pybonjour.DNSServiceQueryRecord(interfaceIndex=interfaceIndex,
fullname=serviceName + '.' + replyDomain,
rrtype = pybonjour.kDNSServiceType_SRV,
callBack = _query_SRV_callback(serviceName, regtype, callback))
self.rlist.append((query_sdRef, pybonjour.DNSServiceProcessResult))
def browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
logger.info('The service entry was removed')
self.callback("unknown")
return
logger.info('Another service identified, resolving')
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex,
serviceName, regtype,
replyDomain,
self.resolve_callback)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], self.timeout)
if resolve_sdRef not in ready[0]:
logger.info('Resolution timed out')
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
self.resolved.pop()
finally:
resolve_sdRef.close()
def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
logger.info(' [*] attempting bonjour lookup')
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
# needs testing but this should happen when the RabbitMQ server is
# going away as advertised by Bonjour
logger.info(' [*] RabbitMQ is going away')
return
# we get here when we've successfully queried for _amqp._tcp
logger.info(' [*] Found a RabbitMQ server, resolving')
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName,
regtype, replyDomain,
resolve_callback)
try:
while not resolved:
ready = select.select([resolve_sdRef], [], [], bjTimeout)
if resolve_sdRef not in ready[0]:
logger.critical('Resolve timed out')
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
resolved.pop()
finally:
resolve_sdRef.close()
def BrowseCallback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
resolved = False
def ResolveCallback(sdRef, flags, interfaceIndex, errorCode, fullname,
hosttarget, port, txtRecord):
global resolved
if errorCode == pybonjour.kDNSServiceErr_NoError:
print 'Resolved service:'
print ' host =', hosttarget
print ' port =', port
resolved = True
resolver = pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName,
regtype, replyDomain,
ResolveCallback)
try:
while not resolved:
ready = select.select([resolver], [], [], TIMEOUT)
if resolver not in ready[0]:
print 'Resolve timed out'
break
pybonjour.DNSServiceProcessResult(resolver)
finally:
resolver.close()
def run(self):
while True:
try:
obj = self.queue.get(block=True, timeout=self.timeout)
except queue.Empty:
if self.finished.is_set():
break
continue
sdRef = pybonjour.DNSServiceResolve(flags=obj.flags,
interfaceIndex=obj.interface,
name=obj.name,
regtype=obj.regtype,
domain=obj.domain,
callBack=self.on_resolve)
self.references.append(sdRef)
_references = list(filter(self.active, self.references))
r, w, x = select.select(_references, [], [])
for ref in r:
pybonjour.DNSServiceProcessResult(ref)
if self.finished.is_set():
break
for ref in self.references:
self.references.remove(ref)
if self.active(ref):
ref.close()
def browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
gajim.log.debug('Found service %s in domain %s on %i(type: %s).' %
(serviceName, replyDomain, interfaceIndex, regtype))
if not self.connected:
return
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
self.remove_service_callback(serviceName)
return
# asynchronous resolving
resolve_sdRef = pybonjour.DNSServiceResolve(
0, interfaceIndex, serviceName, regtype, replyDomain,
self.service_resolved_callback)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], resolve_timeout)
if resolve_sdRef not in ready[0]:
gajim.log.debug('Resolve timed out')
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
self.resolved.pop()
finally:
resolve_sdRef.close()
def find(self, servicename=None):
''' Method: find
Description:
finds the named Auto Install service
Returns:
True -- if the service is found -- OR --
False -- if the service is not found
Raises:
AImDNSError - if there are no service references available
'''
self.sdrefs = dict()
self._found = False
self._lookup = True
self.servicename = servicename if servicename else self.servicename
# only find over the number of interfaces available
self.count = len(self.interfaces)
list_sdrefs = list()
for inf in self.interfaces:
# register the service on the appropriate interface index
try:
interfaceindex = netif.if_nametoindex(inf)
except netif.NetIFError, err:
raise AIMDNSError(err)
sdref = pyb.DNSServiceResolve(0,
interfaceindex,
servicename,
regtype=common.REGTYPE,
domain=common.DOMAIN,
callBack=self._resolve_callback)
list_sdrefs.append(sdref)
def resolve(self):
keys = ['_interfaceIndex', 'name', 'stype', 'domain']
args = [0] + [getattr(self, key) for key in keys]
args.append(self.on_resolve)
self.resolve_sdRef = pybonjour.DNSServiceResolve(*args)
self.resolve_thread = ProcessThread(sdRef=self.resolve_sdRef,
close_when_finished=True,
_name='resolve_%s' % (self.name))
self.resolve_thread.start()
def browser(self, sdRef, flags, ifidx, err, svc, rtype, dom):
'''
Invoked when a new instance of the browsed service is
identified. Attempt to repeat the service with the new service
type, modified TXT record and altered service name.
'''
# Do nothing if there was a browse error
if err != mdns.kDNSServiceErr_NoError: return
# Generate a unique key to identify the service to be repeated
rptkey = ','.join(repr(s) for s in [svc, rtype, dom, ifidx])
# If the key already exists in the repeater dictionary, then
# either the identified service has been removed or the service
# has changed. Either way, stop repeating the old service.
try:
# Attempt to deregister the repeated service
self.repeater[rptkey].close()
# Attempt to eliminate the service name from the repeat list
del self.repeater[rptkey]
print('Stopped repeating', svc)
except KeyError: pass
# Nothing to do if the service is noted as removed
if not (flags & mdns.kDNSServiceFlagsAdd): return
# Add the prefix (and a space) to the existing service name
rptname = self.prefix + ' ' + svc
# Attempt to resolve the advertised service on the interface
resref = mdns.DNSServiceResolve(0, ifidx, svc, rtype, dom, self.resolver)
try:
# Wait for the resolution to finish and return the record data
rec = self.wait(resref)
# If the resolution attempt yielded no useful result,
# throw an exception to skip advertisement and ensure
# the lookup is closed
if rec is None: raise mdns.BonjourError(mdns.kDNSServiceErr_Unknown)
# Register the new service on the same interface
regref = mdns.DNSServiceRegister(0, ifidx,
rptname, self.rpttype, dom,
rec[0], rec[1], rec[2], self.register)
try:
# Copy the finished registration if successful
if self.wait(regref): self.repeater[rptkey] = regref
else: raise mdns.BonjourError(mdns.kDNSServiceErr_Unknown)
except mdns.BonjourError:
# Only close the reference in the event of a failure
regref.close()
print('Failed to register service', rptname)
except mdns.BonjourError: print('Service', svc, 'not repeated')
finally: resref.close()
def _handle_event(self, sdRef, flags, ifaceidx, error, srvname, regtype, replyfrm):
"upon a browser event receipt"
if error != pybonjour.kDNSServiceErr_NoError:
logger.error("browser error: %s" % str(error))
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
logger.info("REMOVED: '%s' (%s) at %s" % (srvname, get_service(regtype), replyfrm))
return
logger.info("SERVICE: '%s' (%s) at %s" % (srvname, get_service(regtype), replyfrm))
new_ref = pybonjour.DNSServiceResolve(0, ifaceidx, srvname, regtype, replyfrm, callBack=self._handle_resolved)
self._registrations.append(new_ref)
def _browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
print "browse callback"
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
print 'Service removed'
return
print 'Service added; resolving'
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex,
serviceName, regtype,
replyDomain,
self._resolve_callback)
try:
while not self.resolved:
ready = select.select([resolve_sdRef], [], [], self.timeout)
if resolve_sdRef not in ready[0]:
print 'Resolve timed out'
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
self.resolved.pop()
finally:
resolve_sdRef.close()
####
query_sdRef = pybonjour.DNSServiceQueryRecord(
interfaceIndex=self.host.interfaceIndex,
fullname=self.host.hosttarget,
rrtype=pybonjour.kDNSServiceType_A,
callBack=self._query_record_callback)
try:
while not self.queried:
ready = select.select([query_sdRef], [], [], self.timeout)
if query_sdRef not in ready[0]:
print "Query not in record"
break
pybonjour.DNSServiceProcessResult(query_sdRef)
else:
self.queried.pop()
finally:
query_sdRef.close()
def _resolve_server(self, if_idx, ec, service_name, regtype,
reply_domain):
"""Invoked to resolve mDNS information about a service that
was discovered by a Browse call."""
timedout = False
tval = self.__timeout
def resolve_cb(sd_hdl, flags, interface_idx, error_code,
full_name, host_target, port, txt_record):
if error_code != pybonjour.kDNSServiceErr_NoError:
return
tr = pybonjour.TXTRecord.parse(txt_record)
if "url" in tr:
url = tr["url"]
if not misc.valid_pub_url(url):
return
self._mirrors.append(pub.RepositoryURI(url))
try:
sd_hdl = pybonjour.DNSServiceResolve(0, if_idx,
service_name, regtype, reply_domain, resolve_cb)
except pybonjour.BonjourError as e:
errstr = "mDNS Service Resolve Failed: {0}\n".format(
e.args[0][1])
raise tx.mDNSException(errstr)
try:
while not timedout:
avail = select.select([sd_hdl], [], [], tval)
if sd_hdl in avail[0]:
pybonjour.DNSServiceProcessResult(
sd_hdl)
tval = 0
else:
timedout = True
except select.error as e:
errstr = "Select failed; {0}\n".format(e.args[1])
raise tx.mDNSException(errstr)
except pybonjour.BonjourError as e:
errstr = "mDNS Process Result Failed: {0}\n".format(
e.args[0][1])
raise tx.mDNSException(errstr)
finally:
sd_hdl.close()
def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if flags & pybonjour.kDNSServiceFlagsAdd:
it = itunes(interfaceIndex, serviceName, replyDomain)
itunesClients[serviceName] = it
it.resolve_sdRef = pybonjour.DNSServiceResolve(
0, interfaceIndex, serviceName, regtype, replyDomain,
resolve_callback)
else:
print 'Service removed', interfaceIndex, serviceName, replyDomain
it = itunesClients[serviceName]
it.closeConnexions()
del itunesClients[serviceName]
def browse_callback(self, sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if (flags & pybonjour.kDNSServiceFlagsAdd):
host = HostObject()
host.added = True
host.servicename = serviceName
try:
ref = pybonjour.DNSServiceResolve(0, interfaceIndex,
serviceName, regtype,
replyDomain,
self.resolve_callback)
self.host[ref.fileno()] = host
self.add_ref(ref)
except pybonjour.BonjourError, e:
logging.debug('browse_callback: %s', str(e))
def browse_callback(sdRef, flags, interfaceIndex, errorCode,
serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
with self.browserLock:
if self.clients.has_key(serviceName):
print("client exists to be removed= " +
str(serviceName))
client = self.clients.get(serviceName)
self.clientEventHandler.fire(client.ip, client.port)
self.clients.pop(serviceName)
return
with self.browserLock:
self.currentClient = Client()
self.currentClient.serviceName = serviceName
resolve_sdRef = pybonjour.DNSServiceResolve(
0, interfaceIndex, serviceName, regtype, replyDomain,
resolve_callback)
try:
while not self.browserResolved:
ready = select.select([resolve_sdRef], [], [],
self.timeout * 2)
if resolve_sdRef not in ready[0]:
print 'Resolve timed out'
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
with self.browserLock:
if not self.clients.has_key(
serviceName) and self.currentClient.resolved:
print("ading client=" + str(serviceName))
self.currentClient.regType = regtype
#print(self.currentClient)
self.clients[serviceName] = self.currentClient
self.clientEventHandler.fire(
self.currentClient.ip, self.currentClient.port)
self.browserResolved.pop()
finally:
resolve_sdRef.close()
def browse_callback(sdref, flags, ifindex, error, service_name,
regtype, reply_domain):
nonlocal found, done
if error != pybonjour.kDNSServiceErr_NoError or (
not flags & pybonjour.kDNSServiceFlagsMoreComing):
self.event_loop.unregister(sdref)
with cv:
done = True
cv.notify()
return
self.event_loop.register(
pybonjour.DNSServiceResolve(0, ifindex, service_name, regtype,
reply_domain, resolve_callback))
with cv:
found += 1
cv.notify()
