def __init__(self, context):
self.regtype = '_machinekit._tcp'
self.timeout = 3
self.querytimeout = 2
self.queried = []
self.resolved = []
self.results = []
browse_sdRef = pybonjour.DNSServiceBrowse(regtype = self.regtype,
callBack = self.browse_callback)
try:
try:
while True:
ready = select.select([browse_sdRef], [], [], self.timeout)
if browse_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(browse_sdRef)
else:
break
except KeyboardInterrupt:
pass
finally:
browse_sdRef.close()
print("results: ", self.results)
# connect to first result
if not self.results:
print("no results")
sys.exit(1)
(fullname, hosttarget, port, txt,ip) = self.results[0]
print("connecting to '%s'" % fullname)
uri = "tcp://%s:%d" % (ip, port)
self.socket = context.socket(zmq.DEALER)
self.socket.identity = "fooclient"
self.socket.connect(uri)
self.socket.RCVTIMEO = 2000
self.rx = Container()
self.tx = Container()
self.run()
def resolve_callback(self, sdRef, flags, interfaceIndex, errorCode,
fullname, hosttarget, port, txtRecord):
if errorCode != pb.kDNSServiceErr_NoError:
logging.error('AvahiService: resolve_callback: error={}'.
format(errorCode))
return
logging.debug('Resolved service: {}; {}; {}'.format(fullname,
hosttarget,
port))
if fullname not in self._targets:
self._targets[fullname] = []
host = hosttarget[:hosttarget.rfind('.local')]
if INCLUDE_SELF or host != platform.node():
service = fullname[fullname.find('.') + 1:-7]
target = {'host': host, 'port': port, 'service': service}
self._targets[fullname].append(target)
self.fire_event()
self._lock.acquire()
sd = pb.DNSServiceQueryRecord(interfaceIndex=interfaceIndex,
fullname=hosttarget,
rrtype=pb.kDNSServiceType_A,
callBack=self.query_callback)
old_input = self._input
self._input = (sd,)
self._lock.release()
while not self._stoped and not self._queried:
R, W, E = select(self._input, [], [], self.TIMEOUT)
if not (R or W or E):
break
map(lambda sd: pb.DNSServiceProcessResult(sd), R)
else:
self._queried.pop()
self.remove_input()
self._lock.acquire()
self._input = old_input
self._lock.release()
self._resolved.append(True)
def resolve_callback(sdRef, flags, interfaceIndex, errorCode, fullname,
hosttarget, port, txtRecord):
global queried, resolved
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
query_sdRef = pybonjour.DNSServiceQueryRecord(interfaceIndex = interfaceIndex, fullname = hosttarget, rrtype = pybonjour.kDNSServiceType_A, callBack = query_record_callback(port))
print "Service {} Resolved; Querying".format(hosttarget)
while service_address is None and not queried:
ready = select.select([query_sdRef], [], [], 5)
if query_sdRef not in ready[0]:
print 'Query record timed out'
break
pybonjour.DNSServiceProcessResult(query_sdRef)
else:
queried.pop()
query_sdRef.close()
resolved.append(True)
def run(self):
logging.debug("Bonjour: Started")
if not have_bonjour:
logging.warn("Bonjour: Missing Package Please Install")
return
sdRef = pybonjour.DNSServiceRegister(name = self.name,
regtype = self.regtype,
port = self.port,
callBack = self.register_callback)
try:
try:
while True:
ready = select.select([sdRef], [], [])
if sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(sdRef)
except KeyboardInterrupt:
pass
finally:
sdRef.close()
def __bonjour_browse_callback(self, sdRef, flags, interfaceIndex, errorCode, serviceName, regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
if serviceName in self.httpd.peers:
del self.httpd.peers[serviceName]
print 'self.httpd.peers', self.httpd.peers
return
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName, regtype, replyDomain, self.__bonjour_resolve_callback)
try:
while not resolved:
ready = select.select([resolve_sdRef], [], [], 5)
if resolve_sdRef not in ready[0]:
#print 'Resolve timed out'
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
resolved.pop()
finally:
resolve_sdRef.close()
def wait(self, sdref): ''' Wait (with timeout) for the provided Bonjour reference to complete, then process the result to invoke the provided callback. After the callback has been called in the call to DNSServiceProcessResult, copy and return the result. ''' rec = None while not self.cbresult: # Wait until the resolution result is ready ready = select.select([sdref], [], [], self.timeout) if sdref not in ready[0]: break # Continue to attempt the query if an error occurred mdns.DNSServiceProcessResult(sdref) else: rec = self.cbresult.pop() return rec
def findConferoViewServer():
"""
Call this to get a list of server s. A list will be returned in most cases
because the computer running the server have multiple ip's.
:return:
"""
browse_sdRef = pybonjour.DNSServiceBrowse(regtype=regtype,
callBack=browse_callback)
try:
try:
ready = select.select([browse_sdRef], [], [])
if browse_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(browse_sdRef)
except KeyboardInterrupt:
pass
finally:
browse_sdRef.close()
return confero_server_bonjour_info[0]
def resolve_callback(self, sdRef, flags, interfaceIndex, errorCode,
fullname, hosttarget, port, txtRecord):
"""
Callback for resolving hosts that have been detected through the browse
routine.
"""
if errorCode == pybonjour.kDNSServiceErr_NoError:
if self.fullname == fullname:
localhost = True
self.debug("Resolved Self")
else:
localhost = False
for client in self.clients.itervalues():
if sdRef == client.resolve_sdRef:
client.hostname = hosttarget.decode('utf-8')
client.port = port
break;
if localhost:
if self.clients.has_key(client.serviceName):
del self.clients[client.serviceName]
return
client.query_sdRef = \
pybonjour.DNSServiceQueryRecord(interfaceIndex=interfaceIndex,
fullname=hosttarget,
rrtype=pybonjour.kDNSServiceType_A,
callBack=self.query_record_callback)
try:
while not self.queried:
ready = select.select([client.query_sdRef], [], [], self.timeout)
if client.query_sdRef not in ready[0]:
self.debug("Query record timed out")
break
pybonjour.DNSServiceProcessResult(client.query_sdRef)
else:
self.queried.pop()
finally:
client.query_sdRef.close()
self.resolved.append(True)
else:
self.error("Resolve failed with code: %s" % errorCode)
def discovery(self, regtype):
def resolve_callback(sdRef, flags, interfaceIndex, errorCode, fullname,
hosttarget, port, txtRecord):
if errorCode == pybonjour.kDNSServiceErr_NoError:
self.devices.append(hosttarget)
def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
log.debug('Bonjour service removed')
return
resolve_sdRef = pybonjour.DNSServiceResolve(0,
interfaceIndex,
serviceName,
regtype,
replyDomain,
resolve_callback)
while True:
ready = select.select([resolve_sdRef], [], [], self.timeout)
if resolve_sdRef not in ready[0]:
log.debug('Bonjour discovery timeout reached')
self.is_timeout = True
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
resolve_sdRef.close()
browse_sdRef = pybonjour.DNSServiceBrowse(regtype = regtype,
callBack = browse_callback)
try:
while not self.devices and not self.is_timeout:
ready = select.select([browse_sdRef], [], [])
if browse_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(browse_sdRef)
finally:
browse_sdRef.close()
return self.devices
def run(self):
while True:
if not self.mdnsd.is_alive():
self.mdnsd.wait(timeout=10)
try:
obj = self.queue.get(block=True, timeout=self.timeout)
except queue.Empty:
if self.finished.is_set():
break
continue
regtype = self.to_regtype(obj)
if not regtype:
continue
sdRef = pybonjour.DNSServiceBrowse(
regtype=regtype,
callBack=self.on_discover
)
self.references.append(sdRef)
_references = list(filter(self.active, self.references))
r, w, x = select.select(_references + [self.pipe[0]], [], [])
if self.pipe[0] in r:
break
for ref in r:
pybonjour.DNSServiceProcessResult(ref)
if not (obj.flags & kDNSServiceFlagsAdd):
self.references.remove(sdRef)
if self.active(sdRef):
sdRef.close()
if self.finished.is_set():
break
for ref in self.references:
self.references.remove(ref)
if self.active(ref):
ref.close()
def find_all(self, protocol_version='5', timeout=5):
self.pversion = protocol_version
self.timeout = timeout
self.moku_list = []
browse_sdRef = pybonjour.DNSServiceBrowse(
regtype='_moku._tcp', callBack=self.browse_callback)
start = time.time()
try:
try:
while time.time() - start < timeout:
ready = select.select([browse_sdRef], [], [], self.timeout)
if browse_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(browse_sdRef)
except KeyboardInterrupt:
pass
finally:
browse_sdRef.close()
return self.moku_list
def run(self):
if not have_bonjour:
logging.warning(
"Cannot run bonjour server! Maybe some packages need to be installed?"
)
return
sdRef = pybonjour.DNSServiceRegister(name=self.name,
regtype=self.regtype,
port=self.port,
callBack=self.register_callback)
try:
try:
while True:
ready = select.select([sdRef], [], [])
if sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(sdRef)
except KeyboardInterrupt:
pass
finally:
sdRef.close()
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 register(self):
"""
Register a service on the network for type "regtype"
"""
reg_sdRef = pybonjour.DNSServiceRegister(name=self.name,
regtype=self.regtype,
port=self.port,
callBack=self.register_callback)
self.debug("Registration Service Started")
try:
try:
while self._isRegisterRunning:
ready = select.select([reg_sdRef], [], [], self.timeout)
if reg_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(reg_sdRef)
except Exception:
self.error("Exception in Registration")
pass
finally:
reg_sdRef.close()
self.debug("Registration Service Stopped")
def resolve(self, service_type, service_name=None):
self.name_filter = service_name
self.resolve_error = False
browse_sdRef = pybonjour.DNSServiceBrowse(regtype = service_type, callBack = self._browse_callback)
try:
while True:
ready = select.select([browse_sdRef], [], [])
if browse_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(browse_sdRef)
if ( self.resolve_error
or self.resolved):
break
finally:
browse_sdRef.close()
if self.resolved:
return self.resolved
return False
def resolve_all(self):
if not self.connected:
return
# for now put here as this is synchronous
self.browse_loop()
for val in self.contacts.values():
resolve_sdRef = pybonjour.DNSServiceResolve(
0, pybonjour.kDNSServiceInterfaceIndexAny,
val[Constant.BARE_NAME], self.stype + '.',
val[Constant.DOMAIN] + '.', self.service_resolved_all_callback)
try:
ready = select.select([resolve_sdRef], [], [], resolve_timeout)
if resolve_sdRef not in ready[0]:
gajim.log.debug('Resolve timed out (in resolve_all)')
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
finally:
resolve_sdRef.close()
def resolve_all(self):
if not self.connected:
return False
# for now put here as this is synchronous
if not self.browse_loop():
return False
# Monitor TXT Records with DNSServiceQueryRecord because
# its more efficient (see pybonjour documentation)
for val in self.contacts.values():
try:
query_sdRef = None
query_sdRef = \
pybonjour.DNSServiceQueryRecord(
interfaceIndex=pybonjour.kDNSServiceInterfaceIndexAny,
fullname=val[Constant.RESOLVED_INFO][0][Constant.BARE_NAME],
rrtype=pybonjour.kDNSServiceType_TXT,
callBack=self.query_txt_callback)
while not self.queried:
ready = select.select([query_sdRef], [], [],
resolve_timeout)
if query_sdRef not in ready[0]:
log.info('Query record timed out')
break
pybonjour.DNSServiceProcessResult(query_sdRef)
else:
self.queried.pop()
except pybonjour.BonjourError as error:
if error.errorCode == pybonjour.kDNSServiceErr_ServiceNotRunning:
log.info('Service not running')
return False
else:
log.error('Error in query for TXT records. %s', error)
finally:
if query_sdRef:
query_sdRef.close()
return True
def findConferoViewServer():
"""
Call this to get a list of server s. A list will be returned in most cases
because the computer running the server have multiple ip's.
:return:
"""
browse_sdRef = pybonjour.DNSServiceBrowse(regtype=regtype,
callBack=browse_callback)
try:
try:
ready = select.select([browse_sdRef], [], [])
if browse_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(browse_sdRef)
except KeyboardInterrupt:
pass
finally:
browse_sdRef.close()
ip_index = 1
valid_inputs = len(confero_server_bonjour_info)
print 'Number of IPs returned by Bonjour:', valid_inputs
if valid_inputs > 1:
print
print
print '*** Confero View Server IP Address Selection Required ***'
for i, o in enumerate(confero_server_bonjour_info):
print '\t', i + 1, ':', o['ip']
print
ok_ip_selected = False
while ok_ip_selected is False:
ip_index = raw_input(">> Enter the ID of the Server IP Address:")
try:
ip_index = int(ip_index)
if ip_index > 0 and ip_index <= valid_inputs:
ok_ip_selected = True
except:
pass
print 'Bonjour IP Selected:', ip_index
return confero_server_bonjour_info[ip_index - 1]
def query_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return
if not (flags & pybonjour.kDNSServiceFlagsAdd):
return
if state.timeout:
timeout = state.timeout
else:
timeout = None
state.current = {'name': serviceName, 'type': regtype}
sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex, serviceName,
regtype, replyDomain, resolve_callback)
try:
while 1:
ready = select([sdRef], [], [], timeout)
if sdRef not in ready[0]:
break
return pybonjour.DNSServiceProcessResult(sdRef)
finally:
state.current = None
sdRef.close()
def run(self):
def register_callback(sdRef, flags, errorCode, name, regtype, domain):
if errorCode == pybonjour.kDNSServiceErr_NoError:
print 'Registered service:'
print ' name =', name
print ' regtype =', regtype
print ' domain =', domain
sdRef = pybonjour.DNSServiceRegister(name=self.name,
regtype=self.regtype,
port=self.port,
callBack=register_callback)
try:
try:
while True:
ready = select.select([sdRef], [], [])
if sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(sdRef)
except KeyboardInterrupt:
pass
finally:
sdRef.close()
def _register(self, name, regtype, port):
if not (name and regtype and port):
return
sdRef = pybonjour.DNSServiceRegister(name=name,
regtype=regtype,
port=port,
callBack=None)
while True:
r, w, x = select.select([sdRef, self.pipe[0]], [], [])
if self.pipe[0] in r:
break
for ref in r:
pybonjour.DNSServiceProcessResult(ref)
if self.finished.is_set():
break
# This deregisters service
sdRef.close()
def service_resolved_callback(self, sdRef, flags, interfaceIndex,
errorCode, fullname, hosttarget, port,
txtRecord):
if errorCode != pybonjour.kDNSServiceErr_NoError:
log.error('Error in service_resolved_callback: %s', str(errorCode))
return
self.resolved_contacts[hosttarget] = (fullname, port, txtRecord)
try:
query_sdRef = None
query_sdRef = \
pybonjour.DNSServiceQueryRecord(
interfaceIndex=interfaceIndex,
fullname=hosttarget,
rrtype=pybonjour.kDNSServiceType_A,
callBack=self.query_record_callback)
while not self.queried:
ready = select.select([query_sdRef], [], [], resolve_timeout)
if query_sdRef not in ready[0]:
log.warning('Query record timed out')
break
pybonjour.DNSServiceProcessResult(query_sdRef)
else:
self.queried.pop()
except pybonjour.BonjourError as error:
if error.errorCode == pybonjour.kDNSServiceErr_ServiceNotRunning:
log.info('Service not running')
else:
self.error_CB(_('Error while adding service. %s') % error)
finally:
if query_sdRef:
query_sdRef.close()
self.resolved.append(True)
def _callback_resolve(self, sdref, flags, interfaceindex, error, fullname,
hosttarget, port, txtrecord):
if error != pybonjour.kDNSServiceErr_NoError:
return
self.__service._full_name = fullname
self.__service._host_target = hosttarget
self.__service._port = port
self.__service._txt_record = txtrecord
sdref = pybonjour.DNSServiceQueryRecord(
interfaceIndex=interfaceindex,
fullname=hosttarget,
rrtype=pybonjour.kDNSServiceType_A,
callBack=self._callback_query)
ready = select.select([sdref], [], [], 5)
if sdref not in ready[0]:
return
pybonjour.DNSServiceProcessResult(sdref)
sdref.close()
def register(name, regtype, port, host=None, txt=None):
if txt:
txt = pybonjour.TXTRecord(txt)
else:
txt = ''
sdRef = pybonjour.DNSServiceRegister(name=name,
interfaceIndex=0,
regtype=regtype,
port=port,
host=host,
txtRecord=txt,
callBack=None)
try:
try:
while True:
ready = select.select([sdRef], [], [])
if sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(sdRef)
except KeyboardInterrupt:
pass
finally:
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
resolve_sdRef = pybonjour.DNSServiceResolve(0, interfaceIndex,
serviceName, regtype,
replyDomain,
self.resolve_callback)
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)
finally:
resolve_sdRef.close()
def __register(self):
#return
server = jsonrpc.Server(
jsonrpc.JsonRpc20(),
jsonrpc.TransportTcpIp(addr=('', self.rpc_port))
) #, logfunc=jsonrpc.log_file("myrpc.%i.log"%self.rpc_port)
server.register_function(self.get_hg_port)
server.register_function(self.get_bt_port)
server.register_function(self.you_should_pull_from)
server.register_function(self.please_mirror)
server.register_function(self.get_active_info_hashes)
server.register_function(self.get_free_space)
server.register_function(self.please_stop_mirroring)
t = threading.Thread(target=server.serve)
t.daemon = True
t.start()
t = threading.Thread(target=self.repo.hg_serve, args=(self.hg_port, ))
t.daemon = True
t.start()
print 'http://localhost:%i/' % self.hg_port
print 'registering bonjour listener...'
self.bj_name = self.name + '__' + uuid.uuid4().hex
bjservice = pybonjour.DNSServiceRegister(
name=self.bj_name,
regtype="_delugefs._tcp",
port=self.rpc_port,
callBack=self.__bonjour_register_callback)
try:
while True:
ready = select.select([bjservice], [], [])
if bjservice in ready[0]:
pybonjour.DNSServiceProcessResult(bjservice)
except KeyboardInterrupt:
pass
def create_service(self):
txt = {}
# remove empty keys
for key, val in self.txt.items():
if val:
txt[key] = val
txt['port.p2pj'] = self.port
txt['version'] = 1
txt['txtvers'] = 1
# replace gajim's show messages with compatible ones
if 'status' in self.txt:
txt['status'] = self.replace_show(self.txt['status'])
else:
txt['status'] = 'avail'
self.txt = txt
try:
self.service_sdRef = pybonjour.DNSServiceRegister(
name=self.name,
regtype=self.stype,
port=self.port,
txtRecord=pybonjour.TXTRecord(self.txt, strict=True),
callBack=self.service_added_callback)
log.info('Publishing service %s of type %s', self.name, self.stype)
ready = select.select([self.service_sdRef], [], [])
if self.service_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(self.service_sdRef)
except pybonjour.BonjourError as error:
if error.errorCode == pybonjour.kDNSServiceErr_ServiceNotRunning:
log.info('Service not running')
else:
self.error_CB(_('Error while adding service. %s') % error)
self.disconnect()
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 register_service(name, regtype, port):
def register_callback(sdRef, flags, errorCode, name, regtype, domain):
if errorCode == pybonjour.kDNSServiceErr_NoError:
logger.debug('Registered bonjour service %s.%s', name, regtype)
record = pybonjour.TXTRecord(appletv.DEVICE_INFO)
service = pybonjour.DNSServiceRegister(name=name,
regtype=regtype,
port=port,
txtRecord=record,
callBack=register_callback)
try:
try:
while True:
ready = select.select([service], [], [])
if service in ready[0]:
pybonjour.DNSServiceProcessResult(service)
except KeyboardInterrupt:
pass
finally:
service.close()
def create_service(self):
txt = {}
#remove empty keys
for key, val in self.txt:
if val:
txt[key] = val
txt['port.p2pj'] = self.port
txt['version'] = 1
txt['txtvers'] = 1
# replace gajim's show messages with compatible ones
if 'status' in self.txt:
txt['status'] = self.replace_show(self.txt['status'])
else:
txt['status'] = 'avail'
self.txt = pybonjour.TXTRecord(txt, strict=True)
try:
sdRef = pybonjour.DNSServiceRegister(
name=self.name,
regtype=self.stype,
port=self.port,
txtRecord=self.txt,
callBack=self.service_added_callback)
self.service_sdRef = sdRef
except pybonjour.BonjourError as e:
self.service_add_fail_callback(e)
else:
gajim.log.debug('Publishing service %s of type %s' %
(self.name, self.stype))
ready = select.select([sdRef], [], [], resolve_timeout)
if sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(sdRef)
