Here are the examples of the python api twisted.internet.reactor.resolve taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
20 Examples
3
Example 1
@inlineCallbacks
def setup_worker(self):
self.format_string = self.config.get(
'format_string', self.DEFAULT_FORMAT_STRING)
self.timestamp_format = self.config.get(
'timestamp_format', self.DEFAULT_TIMESTAMP_FORMAT)
self.metrics_ip = yield reactor.resolve(self.config['metrics_host'])
self.metrics_port = int(self.config['metrics_port'])
self.metrics_protocol = UDPMetricsProtocol(
self.metrics_ip, self.metrics_port)
self.listener = yield reactor.listenUDP(0, self.metrics_protocol)
3
Example 2
Project: pwn_plug_sources Source File: ClientRequest.py
def resolveHost(self, host):
address = self.dnsCache.getCachedAddress(host)
if address != None:
logging.debug("Host cached.")
return defer.succeed(address)
else:
logging.debug("Host not cached.")
return reactor.resolve(host)
3
Example 3
def resolveHost(self, host):
address = self.dnsCache.getCachedAddress(host)
if address != None:
logging.debug("Client:%s Host cached." % (self.getClientIP()))
return defer.succeed(address)
else:
logging.debug("Client:%s Host not cached." % (self.getClientIP()))
return reactor.resolve(host)
3
Example 4
@defer.inlineCallbacks
def dns_resolve(addr):
ip, port = addr
if re.match(r'^(\d+\.){3}\d+$', ip):
defer.returnValue(addr)
else:
try:
ip = yield reactor.resolve(ip)
addr = ip, port
defer.returnValue(addr)
except Exception as err :
raise DHTError(err)
3
Example 5
@defer.inlineCallbacks
def dns_resolve(addr):
ip, port = addr
if re.match(r'^(\d+\.){3}\d+$', ip):
defer.returnValue(addr)
else:
ip = yield reactor.resolve(ip)
addr = ip, port
defer.returnValue(addr)
3
Example 6
def resolve(self, host, port):
"""解析域名"""
def callback(ip, port):
"""解析成功后, 开始发送find_node"""
self.findNode((ip, port))
def errback(failure, host, port):
"""解析失败, 再继续解析, 直到成功为止"""
self.resolve(host, port)
d = reactor.resolve(host)
d.addCallback(callback, port)
d.addErrback(errback, host, port)
3
Example 7
@defer.inlineCallbacks
def resolve_name(name):
## If you have an IP already, return it.
# if isip(name):
# returnValue((name, name))
ip = yield reactor.resolve(name)
defer.returnValue((name, ip))
3
Example 8
Project: MITMf Source File: ClientRequest.py
def resolveHost(self, host):
address = self.dnsCache.getCachedAddress(host)
if address != None:
log.debug("[ClientRequest] Host cached: {} {}".format(host, address))
return defer.succeed(address)
else:
return reactor.resolve(host)
3
Example 9
Project: MITMf Source File: ClientRequest.py
def resolveHost(self, host):
address = self.dnsCache.getCachedAddress(host)
if address != None:
log.debug("Host cached: {} {}".format(host, address))
return defer.succeed(address)
else:
log.debug("Host not cached.")
self.customResolver.port = self.urlMonitor.getResolverPort()
try:
log.debug("Resolving with DNSChef")
address = str(self.customResolver.query(host)[0].address)
return defer.succeed(address)
except Exception:
log.debug("Exception occured, falling back to Twisted")
return reactor.resolve(host)
3
Example 10
Project: lbry Source File: Publisher.py
def start_reflector(self):
reflector_server = random.choice(settings.reflector_servers)
reflector_address, reflector_port = reflector_server[0], reflector_server[1]
log.info("Reflecting new publication")
factory = reflector.ClientFactory(
self.session.blob_manager,
self.lbry_file_manager.stream_info_manager,
self.stream_hash
)
d = reactor.resolve(reflector_address)
d.addCallback(lambda ip: reactor.connectTCP(ip, reflector_port, factory))
d.addCallback(lambda _: factory.finished_deferred)
return d
3
Example 11
Project: lbry Source File: reupload.py
def _check_if_reflector_has_stream(lbry_file, reflector_server):
reflector_address, reflector_port = reflector_server[0], reflector_server[1]
factory = BlobClientFactory(
lbry_file.blob_manager,
[lbry_file.sd_hash]
)
d = reactor.resolve(reflector_address)
d.addCallback(lambda ip: reactor.connectTCP(ip, reflector_port, factory))
d.addCallback(lambda _: factory.finished_deferred)
d.addCallback(lambda _: not factory.sent_blobs)
return d
3
Example 12
Project: lbry Source File: reupload.py
def _reflect_stream(lbry_file, reflector_server):
reflector_address, reflector_port = reflector_server[0], reflector_server[1]
factory = ClientFactory(
lbry_file.blob_manager,
lbry_file.stream_info_manager,
lbry_file.stream_hash
)
d = reactor.resolve(reflector_address)
d.addCallback(lambda ip: reactor.connectTCP(ip, reflector_port, factory))
d.addCallback(lambda _: factory.finished_deferred)
return d
3
Example 13
Project: clipcaptcha Source File: ClientRequest.py
def resolveHost(self, host):
address = self.dnsCache.getCachedAddress(host)
if address != None:
logging.debug("Host cached.")
return defer.succeed(address)
else:
logging.debug("Host not cached.")
return reactor.resolve(host)
0
Example 14
Project: Eventlet Source File: socket.py
def _gethostbyname_twisted(name):
from twisted.internet import reactor
from eventlet.twistedutil import block_on as _block_on
return _block_on(reactor.resolve(name))
0
Example 15
@staticmethod
def create(host, port, connect_callback=None, disconnect_callback=None,
resolver_errback=None):
"""Create an instance that resolves the host to an IP asynchronously.
Will queue all messages while the host is not yet resolved.
Build a connection that reports to the endpoint (on C{host} and
C{port}) using UDP.
@param host: The StatsD server host.
@param port: The StatsD server port.
@param resolver_errback: The errback to invoke should
issues occur resolving the supplied C{host}.
@param connect_callback: The callback to invoke on connection.
@param disconnect_callback: The callback to invoke on disconnection."""
from twisted.internet import reactor
instance = TwistedStatsDClient(
host=host, port=port, connect_callback=connect_callback,
disconnect_callback=disconnect_callback)
if resolver_errback is None:
resolver_errback = log.err
instance.resolve_later = reactor.resolve(host)
instance.resolve_later.addCallbacks(instance.host_resolved,
resolver_errback)
return instance
0
Example 16
@defer.inlineCallbacks
def get(self):
host = self.config.get('destination', self.hostname)
try:
ip = yield reactor.resolve(host)
except:
ip = None
if ip:
try:
loss, latency = yield icmp.ping(ip, 5)
except:
loss, latency = 100, None
event = [self.createEvent('ok', '%s%% loss to %s' % (loss,host), loss,
prefix="loss")]
if latency:
event.append(self.createEvent('ok', 'Latency to %s' % host, latency,
prefix="latency"))
else:
event = [self.createEvent('critical', 'Unable to resolve %s' % host, 100,
prefix="loss")]
defer.returnValue(event)
0
Example 17
Project: conn-check Source File: checks.py
@inlineCallbacks
def do_tcp_check(host, port, tls=False, tls_verify=True,
timeout=None):
"""Generic connection check function."""
if not isIPAddress(host):
try:
ip = yield reactor.resolve(host, timeout=(1, timeout))
except DNSLookupError:
raise ValueError("dns resolution failed")
else:
ip = host
creator = ClientCreator(reactor, TCPCheckProtocol)
try:
if tls:
context = VerifyingContextFactory(tls_verify, CA_CERTS)
yield creator.connectSSL(ip, port, context,
timeout=timeout)
else:
yield creator.connectTCP(ip, port, timeout=timeout)
except TimeoutError:
if ip == host:
raise ValueError("timed out")
else:
raise ValueError("timed out connecting to {}".format(ip))
0
Example 18
Project: conn-check Source File: checks.py
@inlineCallbacks
def do_udp_check(host, port, send, expect, timeout=None):
"""Generic connection check function."""
if not isIPAddress(host):
try:
ip = yield reactor.resolve(host, timeout=(1, timeout))
except DNSLookupError:
raise ValueError("dns resolution failed")
else:
ip = host
deferred = Deferred()
protocol = UDPCheckProtocol(ip, port, send, expect, deferred, timeout)
reactor.listenUDP(0, protocol)
try:
yield deferred
except TimeoutError:
if ip == host:
raise ValueError("timed out")
else:
raise ValueError("timed out waiting for {}".format(ip))
0
Example 19
Project: p2pool-n Source File: ipdiscover.py
@defer.inlineCallbacks
def get_local_ip():
"""
Returns a deferred which will be called with a
2-uple (lan_flag, ip_address) :
- lan_flag:
- True if it's a local network (RFC1918)
- False if it's a WAN address
- ip_address is the actual ip address
@return: A deferred called with the above defined tuple
@rtype: L{twisted.internet.defer.Deferred}
"""
# first we try a connected udp socket, then via multicast
logging.debug("Resolving dns to get udp ip")
try:
ipaddr = yield reactor.resolve('A.ROOT-SERVERS.NET')
except:
pass
else:
udpprot = DatagramProtocol()
port = reactor.listenUDP(0, udpprot)
udpprot.transport.connect(ipaddr, 7)
localip = udpprot.transport.getHost().host
port.stopListening()
if is_bogus_ip(localip):
raise RuntimeError, "Invalid IP address returned"
else:
defer.returnValue((is_rfc1918_ip(localip), localip))
logging.debug("Multicast ping to retrieve local IP")
ipaddr = yield _discover_multicast()
defer.returnValue((is_rfc1918_ip(ipaddr), ipaddr))
0
Example 20
Project: lbry Source File: Session.py
def _setup_dht(self):
from twisted.internet import reactor
log.debug("Starting the dht")
def match_port(h, p):
return h, p
def join_resolved_addresses(result):
addresses = []
for success, value in result:
if success is True:
addresses.append(value)
return addresses
def start_dht(addresses):
self.dht_node.joinNetwork(addresses)
self.peer_finder.run_manage_loop()
self.hash_announcer.run_manage_loop()
return True
ds = []
for host, port in self.known_dht_nodes:
d = reactor.resolve(host)
d.addCallback(match_port, port)
ds.append(d)
self.dht_node = self.dht_node_class(
udpPort=self.dht_node_port,
lbryid=self.lbryid,
externalIP=self.external_ip
)
self.peer_finder = DHTPeerFinder(self.dht_node, self.peer_manager)
if self.hash_announcer is None:
self.hash_announcer = DHTHashAnnouncer(self.dht_node, self.peer_port)
dl = defer.DeferredList(ds)
dl.addCallback(join_resolved_addresses)
dl.addCallback(start_dht)
return dl