def test_incomplete_uaid(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
router.register_user(dict(uaid=uaid))
self.assertRaises(ItemNotFound, router.get_uaid, uaid)
self.assertRaises(ItemNotFound, router.table.get_item,
consistent=True, uaid=uaid)
def test_drop_user(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(dict(uaid=uaid, node_id="asdf",
connected_at=1234))
router.drop_user(uaid)
def test_save_new(self):
r = get_router_table()
router = Router(r, SinkMetrics())
# Sadly, moto currently does not return an empty value like boto
# when not updating data.
router.table.connection = Mock()
router.table.connection.update_item.return_value = {}
result = router.register_user(dict(uaid="", node_id="me", connected_at=1234))
eq_(result[0], True)
def test_save_uaid(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
result = router.register_user(dict(uaid=uaid, node_id="me", connected_at=1234))
eq_(result[0], True)
eq_(result[1], {"uaid": uaid, "connected_at": 1234, "node_id": "me"})
result = router.get_uaid(uaid)
eq_(bool(result), True)
eq_(result["node_id"], "me")
def test_uaid_provision_failed(self):
r = get_router_table()
router = Router(r, SinkMetrics())
router.table = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
router.table.get_item.side_effect = raise_error
with self.assertRaises(ProvisionedThroughputExceededException):
router.get_uaid(uaid="asdf")
def test_register_user_provision_failed(self):
r = get_router_table()
router = Router(r, SinkMetrics())
router.table.connection = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
router.table.connection.update_item.side_effect = raise_error
with self.assertRaises(ProvisionedThroughputExceededException):
router.register_user(dict(uaid="asdf", node_id="me", connected_at=1234))
def test_clear_node_provision_failed(self):
r = get_router_table()
router = Router(r, SinkMetrics())
router.table.connection.put_item = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
router.table.connection.put_item.side_effect = raise_error
with self.assertRaises(ProvisionedThroughputExceededException):
router.clear_node(Item(r, dict(uaid="asdf", connected_at="1234", node_id="asdf")))
def test_drop_user(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(dict(uaid=uaid, node_id="asdf", connected_at=1234))
result = router.drop_user(uaid)
eq_(result, True)
# Deleting already deleted record should return false.
result = router.drop_user(uaid)
eq_(result, False)
def test_preflight_check_fail(self):
router = Router(get_router_table(), SinkMetrics())
storage = Storage(get_storage_table(), SinkMetrics())
def raise_exc(*args, **kwargs): # pragma: no cover
raise Exception("Oops")
router.clear_node = Mock()
router.clear_node.side_effect = raise_exc
with self.assertRaises(Exception):
preflight_check(storage, router)
def test_save_fail(self):
r = get_router_table()
router = Router(r, SinkMetrics())
def raise_condition(*args, **kwargs):
raise ConditionalCheckFailedException(None, None)
router.table.connection = Mock()
router.table.connection.update_item.side_effect = raise_condition
router_data = dict(uaid="asdf", node_id="asdf", connected_at=1234)
result = router.register_user(router_data)
eq_(result, (False, {}, router_data))
def test_node_clear_fail(self):
r = get_router_table()
router = Router(r, SinkMetrics())
def raise_condition(*args, **kwargs):
raise ConditionalCheckFailedException(None, None)
router.table.connection.put_item = Mock()
router.table.connection.put_item.side_effect = raise_condition
data = dict(uaid="asdf", node_id="asdf", connected_at=1234)
result = router.clear_node(Item(r, data))
eq_(result, False)
def test_node_clear(self):
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(dict(uaid="asdf", node_id="asdf", connected_at=1234))
# Verify
user = router.get_uaid("asdf")
eq_(user["node_id"], "asdf")
# Clear
router.clear_node(user)
# Verify
user = router.get_uaid("asdf")
eq_(user.get("node_id"), None)
def test_drop_user(self):
uaid = str(uuid.uuid4())
router = Router(self.table_conf, SinkMetrics(), resource=self.resource)
# Register a node user
router.register_user(
dict(uaid=uaid,
node_id="asdf",
router_type="webpush",
connected_at=1234))
result = router.drop_user(uaid)
assert result is True
# Deleting already deleted record should return false.
result = router.drop_user(uaid)
assert result is False
def test_failed_uaid(self):
uaid = str(uuid.uuid4())
router = Router(self.table_conf, SinkMetrics(), resource=self.resource)
mm = Mock()
mm.get_item = Mock()
mm.get_item.return_value = {
"ResponseMetadata": {
"HTTPStatusCode": 400
},
}
router.table = mm
router.drop_user = Mock()
with pytest.raises(ItemNotFound):
router.get_uaid(uaid)
def test_node_clear(self):
router = Router(self.table_conf, SinkMetrics(),
resource=self.resource)
# Register a node user
router.register_user(dict(uaid=dummy_uaid, node_id="asdf",
connected_at=1234,
router_type="webpush"))
# Verify
user = router.get_uaid(dummy_uaid)
assert user["node_id"] == "asdf"
assert user["connected_at"] == 1234
assert user["router_type"] == "webpush"
# Clear
router.clear_node(user)
# Verify
user = router.get_uaid(dummy_uaid)
assert user.get("node_id") is None
assert user["connected_at"] == 1234
assert user["router_type"] == "webpush"
def test_drop_user(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(
dict(uaid=uaid,
node_id="asdf",
router_type="simplepush",
connected_at=1234))
result = router.drop_user(uaid)
eq_(result, True)
# Deleting already deleted record should return false.
result = router.drop_user(uaid)
eq_(result, False)
def test_preflight_check_wait(self):
router = Router(get_router_table(), SinkMetrics())
storage = Storage(get_storage_table(), SinkMetrics())
storage.table.describe = mock_describe = Mock()
values = [
dict(Table=dict(TableStatus="PENDING")),
dict(Table=dict(TableStatus="ACTIVE")),
]
def return_vals(*args, **kwargs):
return values.pop(0)
mock_describe.side_effect = return_vals
pf_uaid = "deadbeef00000000deadbeef01010101"
preflight_check(storage, router, pf_uaid)
# now check that the database reports no entries.
notifs = storage.fetch_notifications(pf_uaid)
eq_(len(notifs), 0)
assert_raises(ItemNotFound, router.get_uaid, pf_uaid)
def test_uaid_provision_failed(self):
router = Router(self.table_conf, SinkMetrics(), resource=self.resource)
router.table = Mock()
def raise_condition(*args, **kwargs):
raise ClientError(
{'Error': {
'Code': 'ProvisionedThroughputExceededException'
}}, 'mock_update_item')
mm = Mock()
mm.get_item = Mock(side_effect=raise_condition)
router.table = mm
with pytest.raises(ClientError) as ex:
router.get_uaid(uaid="asdf")
assert (ex.value.response['Error']['Code'] ==
"ProvisionedThroughputExceededException")
def test_node_clear(self):
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(
dict(uaid=dummy_uaid,
node_id="asdf",
connected_at=1234,
router_type="webpush"))
# Verify
user = router.get_uaid(dummy_uaid)
eq_(user["node_id"], "asdf")
eq_(user["connected_at"], 1234)
eq_(user["router_type"], "webpush")
# Clear
router.clear_node(user)
# Verify
user = router.get_uaid(dummy_uaid)
eq_(user.get("node_id"), None)
eq_(user["connected_at"], 1234)
eq_(user["router_type"], "webpush")
def test_incomplete_uaid(self):
# Older records may be incomplete. We can't inject them using normal
# methods.
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
router.table.get_item = Mock()
router.drop_user = Mock()
router.table.get_item.return_value = {
"ResponseMetadata": {
"HTTPStatusCode": 200
},
"Item": {
"uaid": uuid.uuid4().hex
}
}
try:
router.register_user(dict(uaid=uaid))
except AutopushException:
pass
with pytest.raises(ItemNotFound):
router.get_uaid(uaid)
assert router.drop_user.called
def test_node_clear(self):
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(dict(uaid=dummy_uaid, node_id="asdf",
connected_at=1234,
router_key="webpush"))
# Verify
user = router.get_uaid(dummy_uaid)
eq_(user["node_id"], "asdf")
eq_(user["connected_at"], 1234)
eq_(user["router_key"], "webpush")
# Clear
router.clear_node(user)
# Verify
user = router.get_uaid(dummy_uaid)
eq_(user.get("node_id"), None)
eq_(user["connected_at"], 1234)
eq_(user["router_key"], "webpush")
def test_no_uaid_found(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
self.assertRaises(ItemNotFound, router.get_uaid, uaid)
def setUp(cls):
cls.resource = autopush.tests.boto_resource
cls.table_conf = DDBTableConfig("router_test")
cls.router = Router(cls.table_conf,
SinkMetrics(),
resource=cls.resource)
def setup_module():
global test_router
config = DDBTableConfig("router_test")
test_router = Router(config,
SinkMetrics(),
resource=autopush.tests.boto_resource)
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
def test_no_uaid_found(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
with pytest.raises(ItemNotFound):
router.get_uaid(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={},
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
