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()