def make_http_pool_and_agent(params): cp_size = params.get('cp_size', 5) c_timeout = params.get('c_timeout', 30.0) # XXX: more extensibility auth = params.get('auth', 'authhmac') assert not auth or auth.lower() in ['none', 'authhmac', 'basic', 'digest'] http_pool = client.HTTPConnectionPool(reactor) http_pool._factory = _NoiselessHTTP11ClientFactory http_pool.retryAutomatically = False http_pool.maxPersistentPerHost = cp_size agent = client.Agent(reactor, pool=http_pool, connectTimeout=c_timeout) if not auth or auth.lower() == 'none': pass elif auth.lower() == 'authhmac': access_key = params['access_key'] secret_key = params.get('secret_key') agent = authhmac.AuthHMACAgent(agent, access_key, secret_key) elif auth.lower() == 'basic': username = params['username'] password = params.get('password') agent = httprpc.BasicAuthAgent(agent, username, password) else: raise AssertionError("unknown %r auth" % auth) return http_pool, agent
def test_repr(self): """connection L{repr()} includes endpoint's L{repr()}""" pool = client.HTTPConnectionPool(reactor=None) ep = DummyEndPoint("this_is_probably_unique") d = pool.getConnection("someplace", ep) result = self.successResultOf(d) representation = repr(result) self.assertIn(repr(ep), representation)
def __init__(self, config=None, reactor=reactor): if config is None: raise ValueError("Missing configuration") super().__init__() self.config = config self.http_pool = client.HTTPConnectionPool(reactor) # TODO refactor path to config with open('templates/banner.xml', 'rb') as f: self.banner = f.read()
def build_pool(self): """Create connection pool """ # XXX create limited number of instances pool = client.HTTPConnectionPool(reactor, persistent=True) # 1 connection for each proxy or thread # XXX will this take too much memory? pool.maxPersistentPerHost = len( self.D.settings.proxies) or self.settings.num_threads pool.cachedConnectionTimeout = 240 return pool
def setUp(self): # set up a full master serving HTTP yield self.setUpRealDatabase(table_names=['masters', 'objects', 'object_state'], sqlite_memory=False) master = fakemaster.FakeMaster(reactor) master.config.db = dict(db_url=self.db_url) master.db = dbconnector.DBConnector('basedir') yield master.db.setServiceParent(master) yield master.db.setup(check_version=False) master.config.mq = dict(type='simple') master.mq = mqconnector.MQConnector() yield master.mq.setServiceParent(master) yield master.mq.setup() master.data = dataconnector.DataConnector() yield master.data.setServiceParent(master) master.config.www = dict( port='tcp:0:interface=127.0.0.1', debug=True, auth=auth.NoAuth(), authz=authz.Authz(), avatar_methods=[], logfileName='http.log') master.www = wwwservice.WWWService() yield master.www.setServiceParent(master) yield master.www.startService() yield master.www.reconfigServiceWithBuildbotConfig(master.config) session = mock.Mock() session.uid = "0" master.www.site.sessionFactory = mock.Mock(return_value=session) # now that we have a port, construct the real URL and insert it into # the config. The second reconfig isn't really required, but doesn't # hurt. self.url = 'http://127.0.0.1:%d/' % master.www.getPortnum() self.url = unicode2bytes(self.url) master.config.buildbotURL = self.url yield master.www.reconfigServiceWithBuildbotConfig(master.config) self.master = master # build an HTTP agent, using an explicit connection pool if Twisted # supports it (Twisted 13.0.0 and up) if hasattr(client, 'HTTPConnectionPool'): self.pool = client.HTTPConnectionPool(reactor) self.agent = client.Agent(reactor, pool=self.pool) else: self.pool = None self.agent = client.Agent(reactor)
def makeService(opt): """Make a service :params opt: dictionary-like object with 'freq', 'config' and 'messages' :returns: twisted.application.internet.TimerService that at opt['freq'] checks for stale processes in opt['config'], and sends restart messages through opt['messages'] """ restarter, path = beatcheck.parseConfig(opt) pool = client.HTTPConnectionPool(reactor) agent = client.Agent(reactor=reactor, pool=pool) settings = Settings(reactor=reactor, agent=agent) states = {} checker = functools.partial(check, settings, states, path) httpcheck = tainternet.TimerService(opt['freq'], run, restarter, checker) httpcheck.setName('httpcheck') return heart.wrapHeart(httpcheck)
def setUp(self): # set up a full master serving HTTP yield self.setUpRealDatabase(table_names=['masters'], sqlite_memory=False) master = fakemaster.FakeMaster() master.config.db = dict(db_url=self.db_url) master.db = dbconnector.DBConnector(master, 'basedir') yield master.db.setup(check_version=False) master.config.mq = dict(type='simple') master.mq = mqconnector.MQConnector(master) master.mq.setup() master.data = dataconnector.DataConnector(master) master.config.www = dict(port='tcp:0:interface=127.0.0.1', debug=True, auth=auth.NoAuth(), url="not yet known", avatar_methods=[]) master.www = wwwservice.WWWService(master) yield master.www.startService() yield master.www.reconfigService(master.config) # now that we have a port, construct the real URL and insert it into # the config. The second reconfig isn't really required, but doesn't # hurt. self.url = 'http://127.0.0.1:%d/' % master.www.getPortnum() master.config.www['url'] = self.url yield master.www.reconfigService(master.config) self.master = master # build an HTTP agent, using an explicit connection pool if Twisted # supports it (Twisted 13.0.0 and up) if hasattr(client, 'HTTPConnectionPool'): self.pool = client.HTTPConnectionPool(reactor) self.agent = client.Agent(reactor, pool=self.pool) else: self.pool = None self.agent = client.Agent(reactor)
def __init__( self, reactor: IReactorTCP, endpoint_url: str, id_generator: Optional[Callable[[], Iterator[Union[ str, int]]]] = lambda: count(), ): """ Create a client for the Bitcoin RPC API. Arguments: - endpoint_url: example: 'http://*****:*****@host:port/' - id_generator: function/lambda that when called returns an iterator of ids, note: iterator must never stop """ from base64 import b64encode from urllib.parse import urlparse self.log = logger.new() quietPool = client.HTTPConnectionPool(reactor) quietPool._factory = QuietHTTP11ClientFactory super().__init__(reactor, pool=quietPool) url = urlparse(endpoint_url) self._url = f'{url.scheme or "http"}://{url.hostname}:{url.port or 8332}{url.path or "/"}'.encode( 'ascii') self._base_headers = { 'User-Agent': [self.USER_AGENT], } auth = ':'.join([url.username or '', url.password or '' ]) if url.username or url.password else None if auth: self._base_headers['Authorization'] = [ 'Basic ' + b64encode(auth.encode('ascii')).decode('ascii') ] self._iter_id = id_generator and id_generator() or None
qeXUWaUr/GcZOfqTGBhs3t0lig4zFEfC7wFQeeT9adGnwKziV28CAwEAAaOBozCB oDAfBgNVHSMEGDAWgBRI5mj5K9KylddH2CMgEE8zmJCf1DAdBgNVHQ4EFgQUv8Aw 6/VDET5nup6R+/xq2uNrEiQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8E BAMCAQYwOgYDVR0fBDMwMTAvoC2gK4YpaHR0cDovL2NybC5nZW90cnVzdC5jb20v Y3Jscy9zZWN1cmVjYS5jcmwwDQYJKoZIhvcNAQEFBQADgYEAvprjecFG+iJsxzEF ZUNgujFQodUovxOWZshcnDW7fZ7mTlk3zpeVJrGPZzhaDhvuJjIfKqHweFB7gwB+ ARlIjNvrPq86fpVg0NOTawALkSqOUMl3MynBQO+spR7EHcRbADQ/JemfTEh2Ycfl vZqhEFBfurZkX0eTANq98ZvVfpg= -----END CERTIFICATE-----""")) # `t.w.client.HTTPConnectionPool` isn't available in Twisted-12.0.0 # (see ticket #11219: https://bugs.torproject.org/11219): _connectionPoolAvailable = _twistedversion >= Version('twisted', 12, 1, 0) if _connectionPoolAvailable: logging.info("Using HTTPConnectionPool for reCaptcha API server.") _pool = client.HTTPConnectionPool(reactor, persistent=False) _pool.maxPersistentPerHost = 5 _pool.cachedConnectionTimeout = 30 _agent = client.Agent(reactor, pool=_pool) else: logging.warn("Twisted-%s is too old for HTTPConnectionPool! Disabling..." % _twistedversion.short()) _pool = None _agent = client.Agent(reactor) # Twisted>=14.0.0 changed the way in which hostname verification works. if _twistedversion >= Version('twisted', 14, 0, 0): from twisted.internet._sslverify import OpenSSLCertificateAuthorities class RecaptchaOpenSSLCertificateAuthorities(OpenSSLCertificateAuthorities):
def main(): config = SafeConfigParser() config.read("relaybot.config") defaults = config.defaults() # Webhook stuff webhooks = resource.Resource() pool = client.HTTPConnectionPool(reactor) agent = client.Agent(reactor, pool=pool) for section in config.sections(): def get(option): if option in defaults or config.has_option(section, option): return config.get(section, option) or defaults[option] else: return None options = {'servername': section} for option in [ "timeout", "host", "port", "nick", "channel", "channels", "heartbeat", "password", "username", "realname", "mode", "ssl", "fingerprint", "nickcolor", "topicsync" ]: options[option] = get(option) mode = get("mode") #Not using endpoints pending http://twistedmatrix.com/trac/ticket/4735 #(ReconnectingClientFactory equivalent for endpoints.) factory = None if mode == "Default": factory = RelayFactory elif mode == "FLIP": factory = FLIPFactory elif mode == "NickServ": factory = NickServFactory options["nickServPassword"] = get("nickServPassword") elif mode == "ReadOnly": factory = ReadOnlyFactory options["nickServPassword"] = get("nickServPassword") # RelayByCommand: only messages with <nickname>: will be relayed. elif mode == "RelayByCommand": factory = CommandFactory elif mode == "Webhooks": options['webhookNonce'] = get('webhookNonce') options['outgoingWebhook'] = get('outgoingWebhook') webhooks.putChild(options['webhookNonce'], Webhook(agent, options)) continue factory = factory(options) if options['ssl'] == "True": if options['fingerprint']: ctx = certoptions(fingerprint=options['fingerprint'], verifyDepth=0) reactor.connectSSL(options['host'], int(options['port']), factory, ctx, int(options['timeout'])) else: reactor.connectSSL(options['host'], int(options['port']), factory, ssl.ClientContextFactory(), int(options['timeout'])) else: reactor.connectTCP(options['host'], int(options['port']), factory, int(options['timeout'])) # Start incoming webhook server if 'webhook' in defaults: serverFromString(reactor, defaults['webhook']).listen(server.Site(webhooks)) reactor.callWhenRunning(signal, SIGINT, handler)