Python reactor.installResolver函数代码示例

def buildHostMap(ipFile, outFilename):

    reactor.installResolver(client.createResolver(servers=[('127.0.0.1', 53), ('8.8.8.8', 53), ('8.8.4.4', 53)]))
    CHUNK_SIZE = 20000
    
    ipList = []
    with open(ipFile, 'r') as f:
        for line in f:
            if line[0].isdigit():
                ipList.append(line.split(',')[0])

    outFile = open(outFilename, 'w')

    def ret(dummy, chunk, outFile):
        return defer.DeferredList([reverseLookup(ip, outFile) for ip in chunk])

    ipList = [ipList[i:i+CHUNK_SIZE] for i in xrange(0, len(ipList), CHUNK_SIZE-1)]

    d = defer.Deferred()
    for chunk in ipList:
        d.addCallback(ret, chunk, outFile)
    # cleanup after ourselves
    d.addCallback(die, outFile)
    d.callback(None)

    reactor.run()

    def start(self, stop_after_crawl=True):
        """
        This method starts a Twisted `reactor`_, adjusts its pool size to
        :setting:`REACTOR_THREADPOOL_MAXSIZE`, and installs a DNS cache based
        on :setting:`DNSCACHE_ENABLED` and :setting:`DNSCACHE_SIZE`.

        If `stop_after_crawl` is True, the reactor will be stopped after all
        crawlers have finished, using :meth:`join`.

        :param boolean stop_after_crawl: stop or not the reactor when all
            crawlers have finished
        """
        if stop_after_crawl:
            d = self.join()
            # Don't start the reactor if the deferreds are already fired
            if d.called:
                return
            d.addBoth(lambda _: self._stop_reactor())

        cache_size = self.settings.getint('DNSCACHE_SIZE') if self.settings.getbool('DNSCACHE_ENABLED') else 0
        reactor.installResolver(CachingThreadedResolver(reactor, cache_size,
                                                            self.settings.getfloat('DNS_TIMEOUT')))
        tp = reactor.getThreadPool()
        tp.adjustPoolsize(maxthreads=self.settings.getint('REACTOR_THREADPOOL_MAXSIZE'))
        reactor.addSystemEventTrigger('before', 'shutdown', self.stop)
        reactor.run(installSignalHandlers=False)  # blocking call

 def action_JAP_UPDATE(self, request):
     data = request.args["data"][0]
     
     decoder = JAP_LOCAL.JSONDecoder()
     configuration = decoder.decode(data)
     
     JAP_LOCAL.setConfiguration("./JAP.json", configuration, getDefaultConfiguration)
     
     logger = logging.getLogger("JAP")
     
     if configuration["LOGGER"]["LEVEL"] == "DEBUG":
         logger.setLevel(logging.DEBUG)
     elif configuration["LOGGER"]["LEVEL"] == "INFO":
         logger.setLevel(logging.INFO)
     elif configuration["LOGGER"]["LEVEL"] == "WARNING":
         logger.setLevel(logging.WARNING)
     elif configuration["LOGGER"]["LEVEL"] == "ERROR":
         logger.setLevel(logging.ERROR)
     elif configuration["LOGGER"]["LEVEL"] == "CRITICAL":
         logger.setLevel(logging.CRITICAL)
     else:
         logger.setLevel(logging.NOTSET)
     
     resolver = JAP_LOCAL.createResolver(configuration)
     reactor.installResolver(resolver)
     
     return ""

def installResolver(reactor=None,
                    resolv='/etc/resolv.conf',
                    servers=[],
                    hosts='/etc/hosts'):
    theResolver = Resolver(resolv, servers)
    hostResolver = hostsModule.Resolver(hosts)
    L = [hostResolver, cache.CacheResolver(), theResolver]
    if reactor is None:
        from twisted.internet import reactor
    reactor.installResolver(ResolverChain(L))

 def start(self, stop_after_crawl=True):
     if stop_after_crawl:
         d = defer.DeferredList(self.crawl_deferreds)
         if d.called:
             # Don't start the reactor if the deferreds are already fired
             return
         d.addBoth(lambda _: self._stop_reactor())
     if self.settings.getbool('DNSCACHE_ENABLED'):
         reactor.installResolver(CachingThreadedResolver(reactor))
     reactor.addSystemEventTrigger('before', 'shutdown', self.stop)
     reactor.run(installSignalHandlers=False)  # blocking call

    def setUp(self):
        self.fromAddress = q2q.Q2QAddress(self.fromDomain, self.fromResource)
        self.toAddress = q2q.Q2QAddress(self.toDomain, self.toResource)

        # A mapping of host names to port numbers Our connectTCP will always
        # connect to 127.0.0.1 and on a port which is a value in this
        # dictionary.
        fakeDNS = FakeConnectTCP(reactor.connectTCP)
        reactor.connectTCP = fakeDNS.connectTCP

        # ALSO WE MUST DO OTHER SIMILAR THINGS
        self._oldResolver = reactor.resolver
        reactor.installResolver(fakeDNS)

        # Set up a know-nothing service object for the client half of the
        # conversation.
        self.serverService2 = self._makeQ2QService(
            self.fromDomain, self.fromIP, noResources
        )

        # Do likewise for the server half of the conversation.  Also, allow
        # test methods to set up some trivial resources which we can attempt to
        # access from the client.
        self.resourceMap = {}
        self.serverService = self._makeQ2QService(
            self.toDomain, self.toIP, self.protocolFactoryLookup
        )

        self.msvc = service.MultiService()
        self.serverService2.setServiceParent(self.msvc)
        self.serverService.setServiceParent(self.msvc)

        # Let the kernel allocate a random port for each of
        # these service's listeners
        self.msvc.startService()

        fakeDNS.addHostPort(
            self.fromDomain, 8788,
            self.serverService2.q2qPort.getHost().port)

        fakeDNS.addHostPort(
            self.toDomain, 8788,
            self.serverService.q2qPort.getHost().port)

        self._addQ2QProtocol('pony', OneTrickPonyServerFactory())

        self.dataEater = DataEater()
        self._addQ2QProtocol('eat', self.dataEater)

        self._addQ2QProtocol('error', ErroneousServerFactory())

    def start(self, stop_after_crawl=True):
        if stop_after_crawl:
            d = self.join()
            # Don't start the reactor if the deferreds are already fired
            if d.called:
                return
            d.addBoth(lambda _: self._stop_reactor())

        if self.settings.getbool('DNSCACHE_ENABLED'):
            reactor.installResolver(CachingThreadedResolver(reactor))

        tp = reactor.getThreadPool()
        tp.adjustPoolsize(maxthreads=self.settings.getint('REACTOR_THREADPOOL_MAXSIZE'))
        reactor.addSystemEventTrigger('before', 'shutdown', self.stop)
        reactor.run(installSignalHandlers=False)  # blocking call

def makeService(config):

    # install simple, blocking DNS resolver.
    from twisted.internet import reactor
    from twisted.internet.base import BlockingResolver
    reactor.installResolver(BlockingResolver())

    try:
        # Create dbus mainloop
        import dbus.mainloop.glib
        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
    except ImportError:
        warnings.warn('Failed to import the dbus module, some functionality might not work.')

    # Check if it is the right thing
    if not hasattr(config.module, 'Application'):
        raise usage.UsageError("Invalid application module: " + config.appName)

    # Instantiate the main application
    s = config.module.Application(config.appName, config.opts, config.appOpts)

    # Set quitflag
    s.quitFlag = launcher.QuitFlag(s.path("temp").child("quitflag"))

    # Set the name
    s.setName(config.appName)

    # make sure the relevant paths exist
    for kind in ["temp", "db"]:
        path = s.path(kind)
        if not path.exists():
            path.createDirectory()

    # Set up logging
    logFile = s.path("logfile")
    if not logFile.parent().exists():
        logFile.parent().createDirectory()
    filename = s.path("logfile").path

    if config.opts['no-logrotate']:
        observer = RotatableFileLogObserver(filename)
    else:
        logFile = LogFile.fromFullPath(filename, maxRotatedFiles=9)
        observer = log.FileLogObserver(logFile).emit
    log.addObserver(observer)

    return s

This application does a lot of things.
1. Creates a server (nwn format) that clients can connect to...
2. Ingests data...
   a. Connects to Baron to get its data
   b. Watches for wx32 files from KELO (provided by LDM)
   c. Connects to IEM service for KIMT data
   d. Listens for TWI poller connections
"""

#from twisted.internet.app import Application
from twisted.application import service, internet
from twisted.cred import checkers, portal

# Hack around 2.0 problem
from twisted.internet import reactor, base
reactor.installResolver(base.BlockingResolver())

# Import nwnserver stuff!
from nwnserver import hubclient, proxyserver, pollerserv, filewatcher
import os
import sys
sys.path.insert(0, os.getcwd())
import secret

# Create the Python Hub application
application = service.Application("PythonHub")
serviceCollection = service.IServiceCollection(application)


#______________________________________________________________________
# 1. Setup hub server!

 def start(self):
     super(CrawlerProcess, self).start()
     if self.dnscache_enable.to_value():
         reactor.installResolver(CachingThreadedResolver(reactor))
     reactor.addSystemEventTrigger('before', 'shutdown', self.stop)
     reactor.run(installSignalHandlers=False) # blocking call

 def start_reactor(self):
     if self.settings.getbool('DNSCACHE_ENABLED'):
         reactor.installResolver(CachingThreadedResolver(reactor))
     reactor.addSystemEventTrigger('before', 'shutdown', self.stop)
     reactor.run(installSignalHandlers=False)  # blocking call

 def tearDown(self):
     reactor.installResolver(self._oldResolver)
     del reactor.connectTCP
     return self.msvc.stopService()

import JAP.JAP_LOCAL
import JAP.JAP_LOCAL_SSH

configuration = JAP.JAP_LOCAL.getConfiguration("./JAP_LOCAL_SSH.json", JAP.JAP_LOCAL_SSH.getDefaultConfiguration)

logging.basicConfig()
logger = logging.getLogger("JAP")

if configuration["LOGGER"]["LEVEL"] == "DEBUG":
    logger.setLevel(logging.DEBUG)
elif configuration["LOGGER"]["LEVEL"] == "INFO":
    logger.setLevel(logging.INFO)
elif configuration["LOGGER"]["LEVEL"] == "WARNING":
    logger.setLevel(logging.WARNING)
elif configuration["LOGGER"]["LEVEL"] == "ERROR":
    logger.setLevel(logging.ERROR)
elif configuration["LOGGER"]["LEVEL"] == "CRITICAL":
    logger.setLevel(logging.CRITICAL)
else:
    logger.setLevel(logging.NOTSET)

resolver = JAP.JAP_LOCAL.createResolver(configuration)
reactor.installResolver(resolver)

factory = JAP.JAP_LOCAL_SSH.SSHInputProtocolFactory(configuration)
factory.protocol = JAP.JAP_LOCAL_SSH.SSHInputProtocol
reactor.listenTCP(
    configuration["LOCAL_PROXY_SERVER"]["PORT"], factory, 50, configuration["LOCAL_PROXY_SERVER"]["ADDRESS"]
)
reactor.run()

#############################
threadable.init()
if aztk_config.setup.get("site", "environment") == "sandbox":
	reactor.suggestThreadPoolSize(3)
else:
	try:
		reactor.suggestThreadPoolSize(25)
	except Exception, ex:
		print Exception
		print ex
		sys.exit(1)

##################################
## Setup Threaded Name Resolver ##
##################################
reactor.installResolver(client.ThreadedResolver(reactor))

	

__version__ = "$Revision: 1.18 $"

class Application(object):
	"""
	This is the main application definition. All instances of an AZKT
	server will be started with this class.
	"""
	def __init__(self, profile):
		"""
		@param profile: Server profile as mentioned in install.cfg
		"""
		self.profile = profile

###

import supybot.log as log
import supybot.conf as conf
import supybot.drivers as drivers
import supybot.ircmsgs as ircmsgs

from twisted.names import client
from twisted.internet import reactor, error
from twisted.protocols.basic import LineReceiver
from twisted.internet.protocol import ReconnectingClientFactory


# This hack prevents the standard Twisted resolver from starting any
# threads, which allows for a clean shut-down in Twisted>=2.0
reactor.installResolver(client.createResolver())


try:
    from OpenSSL import SSL
    from twisted.internet import ssl
except ImportError:
    drivers.log.debug('PyOpenSSL is not available, '
                      'cannot connect to SSL servers.')
    SSL = None

class TwistedRunnerDriver(drivers.IrcDriver):
    def name(self):
        return self.__class__.__name__

    def run(self):