twisted.internet.reactor.resolve

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 7

Example 1

Project: vumi Source File: metrics_workers.py
Function: setup_worker
    @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)

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)

Example 3

Project: Snoopy Source File: ClientRequest.py
Function: resolve_host
    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)

Example 4

Project: AutonomoTorrent Source File: DHTProtocol.py
Function: dns_resolve
@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)

Example 5

Project: AutonomoTorrent Source File: tools.py
Function: dns_resolve
@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)

Example 6

Project: simDHT Source File: kdht.py
Function: resolve
    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)

Example 7

Project: ZenPacks.zenoss.OpenStackInfrastructure Source File: utils.py
Function: resolve_name
@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))

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)

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)

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

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

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

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)

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

Example 15

Project: txstatsd Source File: protocol.py
Function: create
    @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

Example 16

Project: tensor Source File: network.py
Function: get
    @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)

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

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

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

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