def __init__(self, base_url='http://localhost:8888', quiet_requests=True, **kwargs):
self.client_id = str(uuid4())
self.base_url = base_url
pool = HTTPConnectionPool(reactor, persistent=True)
agent = ContentDecoderAgent(RedirectAgent(Agent(reactor, pool=pool)), [('gzip', GzipDecoder)])
if quiet_requests:
pool._factory = QuieterHTTP11ClientFactory
auth_url = kwargs.get('auth_url')
if auth_url:
username = kwargs.get('username')
password = kwargs.get('password')
api_key = kwargs.get('api_key')
if not username:
raise RuntimeError('Marconi "auth_url" specified with no username')
if api_key:
cred = api_key
auth_type = 'api_key'
elif password:
cred = password
auth_type = 'password'
else:
raise RuntimeError('Marconi "auth_url" specified with no "password" or "api_key"')
agent = KeystoneAgent(agent, auth_url, (username, cred), auth_type=auth_type)
self.http_client = HTTPClient(agent)
def agent_from_settings(settings):
# type: (AutopushSettings) -> Agent
"""Create a twisted.web.client Agent from settings"""
# Use a persistent connection pool for HTTP requests.
pool = HTTPConnectionPool(reactor)
if not settings.debug:
pool._factory = QuietClientFactory
return Agent(reactor, connectTimeout=settings.connect_timeout, pool=pool)
def agent_from_config(conf):
# type: (AutopushConfig) -> Agent
"""Create a twisted.web.client Agent from the given config"""
# Use a persistent connection pool for HTTP requests.
pool = HTTPConnectionPool(reactor)
if not conf.debug:
pool._factory = QuietClientFactory
return Agent(reactor, connectTimeout=conf.connect_timeout, pool=pool)
def get_agent_for_address(reactor, address):
"""Get an agent that will only connect to a specific IP address."""
pool = HTTPConnectionPool(reactor, persistent=True)
pool.maxPersistentPerHost = 2
pool._factory = QuietHTTP11ClientFactory
endpoint_factory = MyEndpointFactory(reactor, address)
return Agent.usingEndpointFactory(reactor, endpoint_factory, pool=pool)
def __init__(self, reactor, node=('localhost', 4001), ca=None, cert=None):
self.reactor = reactor
self.node = node
self.scheme = 'http'
self.ca = ca
self.cert = cert
context = None
if ca:
self.scheme = 'https'
context = PolicyForHTTPS(ca, cert)
quietPool = HTTPConnectionPool(reactor, persistent = True)
quietPool.maxPersistentPerHost = 2
quietPool._factory = QuietHTTP11ClientFactory
self.agent = Agent(self.reactor, contextFactory=context, pool=quietPool)
def __init__(self, reactor, node=('localhost', 4001), ca=None, cert=None):
self.reactor = reactor
self.node = node
self.scheme = 'http'
self.ca = ca
self.cert = cert
context = None
if ca:
self.scheme = 'https'
context = PolicyForHTTPS(ca, cert)
quietPool = HTTPConnectionPool(reactor, persistent=True)
quietPool.maxPersistentPerHost = 2
quietPool._factory = QuietHTTP11ClientFactory
self.agent = Agent(self.reactor,
contextFactory=context,
pool=quietPool)
def __init__(
self,
crypto_key=None,
datadog_api_key=None,
datadog_app_key=None,
datadog_flush_interval=None,
hostname=None,
port=None,
router_scheme=None,
router_hostname=None,
router_port=None,
endpoint_scheme=None,
endpoint_hostname=None,
endpoint_port=None,
proxy_protocol_port=None,
memusage_port=None,
router_conf=None,
router_tablename="router",
router_read_throughput=5,
router_write_throughput=5,
storage_tablename="storage",
storage_read_throughput=5,
storage_write_throughput=5,
message_tablename="message",
message_read_throughput=5,
message_write_throughput=5,
statsd_host="localhost",
statsd_port=8125,
resolve_hostname=False,
max_data=4096,
# Reflected up from UDP Router
wake_timeout=0,
env='development',
enable_cors=False,
hello_timeout=0,
bear_hash_key=None,
preflight_uaid="deadbeef00000000deadbeef00000000",
ami_id=None,
msg_limit=100,
debug=False,
connect_timeout=0.5,
ssl_key=None,
ssl_cert=None,
ssl_dh_param=None,
router_ssl_key=None,
router_ssl_cert=None,
client_certs=None,
auto_ping_interval=None,
auto_ping_timeout=None,
max_connections=None,
close_handshake_timeout=None,
):
"""Initialize the Settings object
Upon creation, the HTTP agent will initialize, all configured routers
will be setup and started, logging will be started, and the database
will have a preflight check done.
"""
self.debug = debug
# Use a persistent connection pool for HTTP requests.
pool = HTTPConnectionPool(reactor)
if not debug:
pool._factory = QuietClientFactory
self.agent = Agent(reactor, connectTimeout=connect_timeout, pool=pool)
if not crypto_key:
crypto_key = [Fernet.generate_key()]
if not isinstance(crypto_key, list):
crypto_key = [crypto_key]
self.update(crypto_key=crypto_key)
self.crypto_key = crypto_key
if bear_hash_key is None:
bear_hash_key = []
if not isinstance(bear_hash_key, list):
bear_hash_key = [bear_hash_key]
self.bear_hash_key = bear_hash_key
self.max_data = max_data
self.clients = {}
# Setup hosts/ports/urls
default_hostname = socket.gethostname()
self.hostname = hostname or default_hostname
if resolve_hostname:
self.hostname = resolve_ip(self.hostname)
self.datadog_api_key = datadog_api_key
self.datadog_app_key = datadog_app_key
self.datadog_flush_interval = datadog_flush_interval
self.statsd_host = statsd_host
self.statsd_port = statsd_port
self.port = port
self.router_port = router_port
self.proxy_protocol_port = proxy_protocol_port
self.memusage_port = memusage_port
self.endpoint_hostname = endpoint_hostname or self.hostname
self.router_hostname = router_hostname or self.hostname
if router_conf is None:
router_conf = {}
self.router_conf = router_conf
self.router_url = canonical_url(router_scheme or 'http',
self.router_hostname, router_port)
self.endpoint_url = canonical_url(endpoint_scheme or 'http',
self.endpoint_hostname,
endpoint_port)
# not accurate under autoendpoint (like router_url)
self.ws_url = "{}://{}:{}/".format("wss" if ssl_key else "ws",
self.hostname, self.port)
self.ssl_key = ssl_key
self.ssl_cert = ssl_cert
self.ssl_dh_param = ssl_dh_param
self.router_ssl_key = router_ssl_key
self.router_ssl_cert = router_ssl_cert
self.enable_tls_auth = client_certs is not None
self.client_certs = client_certs
self.auto_ping_interval = auto_ping_interval
self.auto_ping_timeout = auto_ping_timeout
self.max_connections = max_connections
self.close_handshake_timeout = close_handshake_timeout
self.router_tablename = router_tablename
self.router_read_throughput = router_read_throughput
self.router_write_throughput = router_write_throughput
self.storage_tablename = storage_tablename
self.storage_read_throughput = storage_read_throughput
self.storage_write_throughput = storage_write_throughput
self.message_tablename = message_tablename
self.message_read_throughput = message_read_throughput
self.message_write_throughput = message_write_throughput
self.msg_limit = msg_limit
# CORS
self.cors = enable_cors
# Force timeout in idle seconds
self.wake_timeout = wake_timeout
# Env
self.env = env
self.hello_timeout = hello_timeout
self.ami_id = ami_id
# Generate messages per legacy rules, only used for testing to
# generate legacy data.
self._notification_legacy = False
self.preflight_uaid = preflight_uaid
def __init__(
self,
crypto_key=None,
datadog_api_key=None,
datadog_app_key=None,
datadog_flush_interval=None,
hostname=None,
port=None,
router_scheme=None,
router_hostname=None,
router_port=None,
endpoint_scheme=None,
endpoint_hostname=None,
endpoint_port=None,
router_conf=None,
router_tablename="router",
router_read_throughput=5,
router_write_throughput=5,
storage_tablename="storage",
storage_read_throughput=5,
storage_write_throughput=5,
message_tablename="message",
message_read_throughput=5,
message_write_throughput=5,
statsd_host="localhost",
statsd_port=8125,
resolve_hostname=False,
max_data=4096,
# Reflected up from UDP Router
wake_timeout=0,
env='development',
enable_cors=False,
hello_timeout=0,
bear_hash_key=None,
preflight_uaid="deadbeef00000000deadbeef00000000",
ami_id=None,
client_certs=None,
msg_limit=100,
debug=False,
connect_timeout=0.5,
):
"""Initialize the Settings object
Upon creation, the HTTP agent will initialize, all configured routers
will be setup and started, logging will be started, and the database
will have a preflight check done.
"""
# Use a persistent connection pool for HTTP requests.
pool = HTTPConnectionPool(reactor)
if not debug:
pool._factory = QuietClientFactory
self.agent = Agent(reactor, connectTimeout=connect_timeout, pool=pool)
if not crypto_key:
crypto_key = [Fernet.generate_key()]
if not isinstance(crypto_key, list):
crypto_key = [crypto_key]
self.update(crypto_key=crypto_key)
self.crypto_key = crypto_key
if bear_hash_key is None:
bear_hash_key = []
if not isinstance(bear_hash_key, list):
bear_hash_key = [bear_hash_key]
self.bear_hash_key = bear_hash_key
self.max_data = max_data
self.clients = {}
# Setup hosts/ports/urls
default_hostname = socket.gethostname()
self.hostname = hostname or default_hostname
if resolve_hostname:
self.hostname = resolve_ip(self.hostname)
# Metrics setup
if datadog_api_key:
self.metrics = DatadogMetrics(
hostname=self.hostname,
api_key=datadog_api_key,
app_key=datadog_app_key,
flush_interval=datadog_flush_interval,
)
elif statsd_host:
self.metrics = TwistedMetrics(statsd_host, statsd_port)
else:
self.metrics = SinkMetrics()
self.port = port
self.endpoint_hostname = endpoint_hostname or self.hostname
self.router_hostname = router_hostname or self.hostname
if router_conf is None:
router_conf = {}
self.router_conf = router_conf
self.router_url = canonical_url(router_scheme or 'http',
self.router_hostname, router_port)
self.endpoint_url = canonical_url(endpoint_scheme or 'http',
self.endpoint_hostname,
endpoint_port)
self.enable_tls_auth = client_certs is not None
self.client_certs = client_certs
# Database objects
self.router_table = get_router_table(router_tablename,
router_read_throughput,
router_write_throughput)
self.storage_table = get_storage_table(storage_tablename,
storage_read_throughput,
storage_write_throughput)
self.message_table = get_rotating_message_table(
message_tablename,
message_read_throughput=message_read_throughput,
message_write_throughput=message_write_throughput)
self._message_prefix = message_tablename
self.message_limit = msg_limit
self.storage = Storage(self.storage_table, self.metrics)
self.router = Router(self.router_table, self.metrics)
# Used to determine whether a connection is out of date with current
# db objects. There are three noteworty cases:
# 1 "Last Month" the table requires a rollover.
# 2 "This Month" the most common case.
# 3 "Next Month" where the system will soon be rolling over, but with
# timing, some nodes may roll over sooner. Ensuring the next month's
# table is present before the switchover is the main reason for this,
# just in case some nodes do switch sooner.
self.create_initial_message_tables()
# Run preflight check
preflight_check(self.storage, self.router, preflight_uaid)
# CORS
self.cors = enable_cors
# Force timeout in idle seconds
self.wake_timeout = wake_timeout
# Setup the routers
self.routers = dict()
self.routers["simplepush"] = SimpleRouter(
self, router_conf.get("simplepush"))
self.routers["webpush"] = WebPushRouter(self, None)
if 'apns' in router_conf:
self.routers["apns"] = APNSRouter(self, router_conf["apns"])
if 'gcm' in router_conf:
self.routers["gcm"] = GCMRouter(self, router_conf["gcm"])
# Env
self.env = env
self.hello_timeout = hello_timeout
self.ami_id = ami_id
# Generate messages per legacy rules, only used for testing to
# generate legacy data.
self._notification_legacy = False
'to finalize request: %s' % self._state)
_requestDeferred.addCallbacks(cbRequestWrotten, ebRequestWriting)
return self._finishedRequest
class _HTTP11ClientFactoryPatched(_HTTP11ClientFactory):
def buildProtocol(self, addr):
proto = HTTP11ClientProtocolPatched(self._quiescentCallback)
proto.timeout = 2 #self.timeout
return proto
pool = HTTPConnectionPool(reactor, True)
pool._factory = _HTTP11ClientFactoryPatched
pool.timeout = 2
agent = Agent(reactor, connectTimeout = 2, pool = pool)
#agent = Agent(reactor)
d = agent.request(
'GET',
'http://192.168.1.141/test1/php/api.php',
Headers({'User-Agent': ['Twisted Web Client Example']}),
None)
#reactor.callLater(2, d.cancel)
def __init__(self, reactor):
self.reactor = reactor
self.log = Logger("Poll")
pool = HTTPConnectionPool(reactor)
pool._factory = QuietHTTP11ClientFactory
self.agent = Agent(reactor, connectTimeout=10.0, pool=pool)
