def test_lookupService(self): """ See L{test_lookupAddress} """ d = client.lookupService(self.hostname) d.addCallback(self.checkResult, dns.SRV) return d
def _fetchServers(self, host): try: service = "_matrix._tcp.%s" % host answers, auth, add = yield client.lookupService(service) except DNSNameError: answers = [] if (len(answers) == 1 and answers[0].type == dns.SRV and answers[0].payload and answers[0].payload.target == dns.Name(".")): raise DNSNameError("Service %s unavailable", service) servers = [] for answer in answers: if answer.type != dns.SRV or not answer.payload: continue payload = answer.payload servers.append(ThreepidBinder._Server( host=str(payload.target), port=int(payload.port), priority=int(payload.priority), weight=int(payload.weight) )) servers.sort() defer.returnValue(servers)
def fetch_servers(self): try: answers, auth, add = yield client.lookupService(self.service_name) except DNSNameError: answers = [] if (len(answers) == 1 and answers[0].type == dns.SRV and answers[0].payload and answers[0].payload.target == dns.Name('.')): raise ConnectError("Service %s unavailable", self.service_name) self.servers = [] self.used_servers = [] for answer in answers: if answer.type != dns.SRV or not answer.payload: continue payload = answer.payload self.servers.append(self._Server( host=str(payload.target), port=int(payload.port), priority=int(payload.priority), weight=int(payload.weight) )) self.servers.sort()
def connect(self): """Start connection to remote server.""" self.factory.doStart() self.factory.startedConnecting(self) if not self.servers: if self.domain is None: self.connectionFailed( error.DNSLookupError("Domain is not defined."), ) return d = client.lookupService( "_%s._%s.%s" % ( nativeString(self.service), nativeString(self.protocol), nativeString(self.domain), ), ) d.addCallbacks(self._cbGotServers, self._ebGotServers) d.addCallback(lambda x, self=self: self._reallyConnect()) if self._defaultPort: d.addErrback(self._ebServiceUnknown) d.addErrback(self.connectionFailed) elif self.connector is None: self._reallyConnect() else: self.connector.connect()
def fetch_servers(self): try: answers, auth, add = yield client.lookupService(self.service_name) except DNSNameError: answers = [] if (len(answers) == 1 and answers[0].type == dns.SRV and answers[0].payload and answers[0].payload.target == dns.Name('.')): raise ConnectError("Service %s unavailable", self.service_name) self.servers = [] self.used_servers = [] for answer in answers: if answer.type != dns.SRV or not answer.payload: continue payload = answer.payload self.servers.append( self._Server(host=str(payload.target), port=int(payload.port), priority=int(payload.priority), weight=int(payload.weight))) self.servers.sort()
def getService(failure): service_fqdn = ".".join(("_mammatus._tcp", root_zone)) d = client.lookupService(service_fqdn) def gotSrvRecord(result): (answer, authority, additional) = result serviceUri = str(answer[0].payload.target) d = client.lookupText(".".join(getZone(serviceUri))) d.addCallbacks(getConfigFromText, gotFailure) return d d.addCallbacks(gotSrvRecord, gotFailure) return d
def _do_lookup(self): defers = [] for addr, port, is_domain in RelayConfig.dispatchers: if is_domain: defer = lookupService("_sip._udp.%s" % addr) defer.addCallback(self._cb_got_srv, port) defer.addErrback(self._eb_no_srv, addr, port) defers.append(defer) else: defers.append(succeed((addr, port))) defer = DeferredList(defers) defer.addCallback(self._cb_got_all) return KeepRunning
def __init__(self, center, target, myname = None): # TODO: dont try to resolve IP addresses ;) # must subclass if not self.factory_type: raise NotImplementedError try: self.factory = self.factory_type(center, target, myname) except: print self.factory_type raise u = parseUNL(target) self.host = u['host'] d = client.lookupService('_psyc._tcp.' + self.host) d.addCallback(self.srvResolved)
def rjid_dns(x): z=None global RJID_C from twisted.names import client as dns d = dns.lookupService('_xmpp-client._tcp.'+x, timeout = [2,10]) d.addCallback(rjid_clbc) d.addErrback(rjid_pass) t=time.time() while not RJID_C and time.time()-t<4.5: time.sleep(1) pass if not RJID_C: return r = random.choice(RJID_C[0]) RJID_C = None return unicode(r.payload.target), int(r.payload.port)
def connect(self): """Start connection to remote server.""" self.factory.doStart() self.factory.startedConnecting(self) if not self.servers: if self.domain is None: self.connectionFailed(error.DNSLookupError("Domain is not defined.")) return d = client.lookupService("_%s._%s.%s" % (self.service, self.protocol, self.domain)) d.addCallbacks(self._cbGotServers, self._ebGotServers) d.addCallback(lambda x, self=self: self._reallyConnect()) d.addErrback(self.connectionFailed) elif self.connector is None: self._reallyConnect() else: self.connector.connect()
def connect(self): """Start connection to remote server.""" self.factory.doStart() self.factory.startedConnecting(self) if not self.servers: if self.domain is None: self.connectionFailed(error.DNSLookupError("Domain is not defined.")) return d = client.lookupService('_%s._%s.%s' % (self.service, self.protocol, self.domain)) d.addCallbacks(self._cbGotServers, self._ebGotServers) d.addCallback(lambda x, self=self: self._reallyConnect()) d.addErrback(self.connectionFailed) elif self.connector is None: self._reallyConnect() else: self.connector.connect()
def lookupService(self, name, timeouts=[2]): self.logger.debug("lookupService(name=%r, timeouts=%r)", name, timeouts) deferred = client.lookupService(name, timeouts) def cb(result): self.logger.debug("lookupService() cb(result=%r)", result) payload = result[0][0].payload port = payload.port name = payload.target.name return (name, port) def eb(failure): self.logger.warning("lookupService(name=%r, timeouts=%r) eb(failure=%r)", name, timeouts, failure) if isinstance(failure.type, Exception): util.logTwistedFailure(self.logger, failure, "lookupService(name=%r, timeouts=%r) threw exception", name, timeouts) self.logger.warning("failure.__dict__: %r", failure.__dict__) return (None, None) deferred.addCallbacks(cb, eb) return deferred
def connect(self): from twisted.names import client as dns d = dns.lookupService('_xmpp-client._tcp.'+self.servername, timeout = [2,10]) d.addCallback(self._dnsLookup) d.addErrback(self._dnsLookupErr)