def setUp(self):
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
)
self.metrics = metrics = Mock(spec=SinkMetrics)
self.db = db = test_db(metrics=metrics)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.agent_mock = agent = Mock(spec=Agent)
self.router = WebPushRouter(conf, {}, db, agent)
self.notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=headers,
ttl=20,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
mock_result = Mock(spec=gcmclient.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.retry_after = 1000
self.router_mock = db.router
self.message_mock = db._message = Mock(spec=Message)
self.conf = conf
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.router = WebPushRouter(settings, {})
self.notif = Notification("EncMessageId", "data",
dummy_chid, headers, 20)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.message_mock = settings.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
self.settings = settings
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.router = WebPushRouter(settings, {})
self.notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=headers,
ttl=20,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.message_mock = settings.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
self.settings = settings
class WebPushRouterTestCase(unittest.TestCase):
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"encryption-key": "niftykey"
}
self.router = WebPushRouter(settings, {})
self.notif = Notification(10, "data", dummy_chid, headers, 20)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.message_mock = settings.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
self.settings = settings
def test_route_to_busy_node_saves_looks_up_and_sends_check_201(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid,
current_month=self.settings.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 201)
self.router.metrics.increment.assert_called_with(
"router.broadcast.save_hit"
)
ok_("Location" in result.headers)
d.addCallback(verify_deliver)
return d
def test_route_to_busy_node_with_ttl_zero(self):
notif = Notification(10, "data", dummy_chid, self.headers, 0)
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid,
current_month=self.settings.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterResponse)
eq_(exc.status_code, 201)
eq_(len(self.router.metrics.increment.mock_calls), 0)
ok_("Location" not in exc.headers)
d.addBoth(verify_deliver)
return d
def test_route_with_invalid_channel_id(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 404)
self.flushLoggedErrors()
d.addBoth(verify_deliver)
return d
def test_ammend(self):
resp = {"key": "value"}
eq_(resp, self.router.amend_msg(resp))
def test_check_token(self):
(t, v) = self.router.check_token("")
ok_(t)
class WebPushRouterTestCase(unittest.TestCase):
def setUp(self):
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
)
self.metrics = metrics = Mock(spec=SinkMetrics)
self.db = db = test_db(metrics=metrics)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.agent_mock = agent = Mock(spec=Agent)
self.router = WebPushRouter(conf, {}, db, agent)
self.notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=headers,
ttl=20,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
mock_result = Mock(spec=gcmclient.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.retry_after = 1000
self.router_mock = db.router
self.message_mock = db._message = Mock(spec=Message)
self.conf = conf
def test_route_to_busy_node_saves_looks_up_and_sends_check_201(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
self.db.message_table = Mock(return_value=self.message_mock)
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
assert isinstance(result, RouterResponse)
assert result.status_code == 201
kwargs = self.message_mock.store_message.call_args[1]
t_h = kwargs["notification"].headers
assert t_h.get('encryption') == self.headers.get('encryption')
assert t_h.get('crypto_key') == self.headers.get('crypto-key')
assert t_h.get('encoding') == self.headers.get('content-encoding')
assert "Location" in result.headers
d.addCallback(verify_deliver)
return d
def test_route_failure(self):
self.agent_mock.request = Mock(side_effect=ConnectionRefusedError)
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
self.db.message_table = Mock(return_value=self.message_mock)
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
assert isinstance(result, RouterResponse)
assert result.status_code == 201
kwargs = self.message_mock.store_message.call_args[1]
assert len(self.metrics.increment.mock_calls) == 3
t_h = kwargs["notification"].headers
assert t_h.get('encryption') == self.headers.get('encryption')
assert t_h.get('crypto_key') == self.headers.get('crypto-key')
assert t_h.get('encoding') == self.headers.get('content-encoding')
assert "Location" in result.headers
d.addCallback(verify_deliver)
return d
def test_route_to_busy_node_with_ttl_zero(self):
notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=self.headers,
ttl=0,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
self.db.message_table = Mock(return_value=self.message_mock)
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(notif, router_data)
def verify_deliver(fail):
exc = fail.value
assert isinstance(exc, RouterException)
assert exc.status_code == 201
assert len(self.metrics.increment.mock_calls) == 0
assert "Location" in exc.headers
d.addBoth(verify_deliver)
return d
def test_amend(self):
resp = {"key": "value"}
expected = resp.copy()
self.router.amend_endpoint_response(resp, {})
assert resp == expected
def test_route_to_busy_node_save_throws_db_error(self):
def throw():
raise ClientError({'Error': {
'Code': 'InternalServerError'
}}, 'mock_store_message')
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.message_mock.store_message.side_effect = MockAssist([throw])
self.db.message_table = Mock(return_value=self.message_mock)
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
assert isinstance(exc, RouterException)
assert exc.status_code == 503
d.addBoth(verify_deliver)
return d
def test_route_lookup_uaid_fails(self):
def throw():
raise ClientError({'Error': {
'Code': 'InternalServerError'
}}, 'mock_get_uaid')
self.message_mock.store_message.return_value = True
self.db.message_table = Mock(return_value=self.message_mock)
self.router_mock.get_uaid.side_effect = MockAssist([throw])
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(status):
assert status.status_code == 201
d.addBoth(verify_deliver)
return d
def test_route_lookup_uaid_not_found(self):
def throw():
raise ItemNotFound()
self.message_mock.store_message.return_value = True
self.db.message_table = Mock(return_value=self.message_mock)
self.router_mock.get_uaid.side_effect = MockAssist([throw])
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(status):
assert status.value.status_code == 410
d.addBoth(verify_deliver)
return d
def test_route_lookup_uaid_no_nodeid(self):
self.message_mock.store_message.return_value = True
self.db.message_table = Mock(return_value=self.message_mock)
self.router_mock.get_uaid.return_value = dict()
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(status):
assert status.status_code == 201
d.addBoth(verify_deliver)
return d
def test_route_and_clear_failure(self):
self.agent_mock.request = Mock(side_effect=ConnectionRefusedError)
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
self.db.message_table = Mock(return_value=self.message_mock)
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.db.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
def throw():
raise ClientError({'Error': {
'Code': 'InternalServerError'
}}, 'mock_clear_node')
self.router_mock.clear_node.side_effect = MockAssist([throw])
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
assert isinstance(result, RouterResponse)
assert result.status_code == 201
kwargs = self.message_mock.store_message.call_args[1]
assert len(self.metrics.increment.mock_calls) == 3
t_h = kwargs["notification"].headers
assert t_h.get('encryption') == self.headers.get('encryption')
assert t_h.get('crypto_key') == self.headers.get('crypto-key')
assert t_h.get('encoding') == self.headers.get('content-encoding')
assert "Location" in result.headers
d.addCallback(verify_deliver)
return d
class WebPushRouterTestCase(unittest.TestCase):
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"encryption-key": "niftykey"
}
self.router = WebPushRouter(settings, {})
self.notif = Notification(10, "data", dummy_chid, headers, 20)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.message_mock = settings.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
def test_route_to_busy_node_saves_looks_up_and_sends_check_201(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = [dummy_chid]
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 201)
self.router.metrics.increment.assert_called_with(
"router.broadcast.save_hit"
)
ok_("Location" in result.headers)
d.addCallback(verify_deliver)
return d
def test_route_to_busy_node_with_ttl_zero(self):
notif = Notification(10, "data", dummy_chid, self.headers, 0)
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = [dummy_chid]
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterResponse)
eq_(exc.status_code, 201)
eq_(len(self.router.metrics.increment.mock_calls), 0)
ok_("Location" not in exc.headers)
d.addBoth(verify_deliver)
return d
def test_route_with_invalid_channel_id(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = []
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 404)
self.flushLoggedErrors()
d.addBoth(verify_deliver)
return d
def test_ammend(self):
resp = {"key": "value"}
eq_(resp, self.router.amend_msg(resp))
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={},
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,
s3_bucket=DEFAULT_BUCKET,
senderid_expry=SENDERID_EXPRY,
senderid_list={},
hello_timeout=0,
):
"""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)
self.agent = Agent(reactor, connectTimeout=5, pool=pool)
# Metrics setup
if datadog_api_key:
self.metrics = DatadogMetrics(
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()
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
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.port = port
self.endpoint_hostname = endpoint_hostname or self.hostname
self.router_hostname = router_hostname or self.hostname
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)
# 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_message_table(message_tablename,
message_read_throughput,
message_write_throughput)
self.storage = Storage(self.storage_table, self.metrics)
self.router = Router(self.router_table, self.metrics)
self.message = Message(self.message_table, self.metrics)
# Run preflight check
preflight_check(self.storage, self.router)
# CORS
self.cors = enable_cors
# Force timeout in idle seconds
self.wake_timeout = wake_timeout
# Setup the routers
self.routers = {}
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
class WebPushRouterTestCase(unittest.TestCase):
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.router = WebPushRouter(settings, {})
self.notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=headers,
ttl=20,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.message_mock = settings.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
self.settings = settings
def test_route_to_busy_node_saves_looks_up_and_sends_check_201(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.settings.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 201)
kwargs = self.message_mock.store_message.call_args[1]
t_h = kwargs["notification"].headers
eq_(t_h.get('encryption'), self.headers.get('encryption'))
eq_(t_h.get('crypto_key'), self.headers.get('crypto-key'))
eq_(t_h.get('encoding'), self.headers.get('content-encoding'))
self.router.metrics.increment.assert_called_with(
"router.broadcast.save_hit")
ok_("Location" in result.headers)
d.addCallback(verify_deliver)
return d
def test_route_to_busy_node_with_ttl_zero(self):
notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=self.headers,
ttl=0,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.message_mock.store_message.return_value = True
self.message_mock.all_channels.return_value = (True, [dummy_chid])
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
current_month=self.settings.current_msg_month)
self.router_mock.get_uaid.return_value = router_data
self.router.message_id = uuid.uuid4().hex
d = self.router.route_notification(notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterResponse)
eq_(exc.status_code, 201)
eq_(len(self.router.metrics.increment.mock_calls), 0)
ok_("Location" in exc.headers)
d.addBoth(verify_deliver)
return d
def test_amend(self):
resp = {"key": "value"}
expected = resp.copy()
self.router.amend_endpoint_response(resp, {})
eq_(resp, expected)
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
