async def test():
get_rpc_mock.return_value = self.channel
self.nid_client.clear()
self.foo_client.clear()
self.log_client.clear()
key = 'id1'
foo = Foo("boo", 4)
self.nid_client[key] = NetworkID(id='foo')
self.foo_client[key] = foo
self.nid_client.mark_as_garbage(key)
self.foo_client.mark_as_garbage(key)
req = await self.garbage_collector._collect_states_to_delete()
self.assertEqual(2, len(req.ids))
# Update one of the states, to ensure we don't delete valid state
# from Redis
expected = NetworkID(id='bar')
self.nid_client[key] = expected
# Ensure all garbage collected objects get deleted from Redis
await self.garbage_collector._send_to_state_service(req)
self.assertEqual(1, len(self.nid_client.keys()))
self.assertEqual(0, len(self.foo_client.keys()))
self.assertEqual(0, len(self.nid_client.garbage_keys()))
self.assertEqual(0, len(self.foo_client.garbage_keys()))
self.assertEqual(expected, self.nid_client[key])
async def test():
self.mock_client.clear()
bad_serde_key = 'id1:missing_serde'
good_serde_key = 'id1:' + NID_TYPE
# Force bad serde into mocked redis server
self.mock_client.redis.set(bad_serde_key, NetworkID(id='foo'))
self.mock_client[good_serde_key] = NetworkID(id='bar')
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(1, len(req.states))
self.assertEqual(NID_TYPE, req.states[0].type)
async def test():
get_rpc_mock.return_value = self.channel
# Ensure setup is initialized properly
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
foo = Foo("boo", 4)
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
self.foo_client[key] = foo
# Increment version
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(3, len(req.states))
# Ensure in-memory map updates properly
await self.state_replicator._send_to_state_service(req)
self.assertEqual(3, len(self.state_replicator._state_versions))
mem_key1 = self.state_replicator.make_mem_key('id1', NID_TYPE)
mem_key2 = self.state_replicator.make_mem_key(
'aaa-bbb:id1', IDList_TYPE)
mem_key3 = self.state_replicator.make_mem_key('id1', FOO_TYPE)
self.assertEqual(1,
self.state_replicator._state_versions[mem_key1])
self.assertEqual(2,
self.state_replicator._state_versions[mem_key2])
self.assertEqual(1,
self.state_replicator._state_versions[mem_key3])
# Now add new state and update some existing state
key2 = 'id2'
self.nid_client[key2] = NetworkID(id='bar')
self.idlist_client[key] = IDList(ids=['bar', 'foo'])
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(2, len(req.states))
# Ensure in-memory map updates properly
await self.state_replicator._send_to_state_service(req)
self.assertEqual(4, len(self.state_replicator._state_versions))
mem_key4 = self.state_replicator.make_mem_key('id2', NID_TYPE)
self.assertEqual(1,
self.state_replicator._state_versions[mem_key1])
self.assertEqual(3,
self.state_replicator._state_versions[mem_key2])
self.assertEqual(1,
self.state_replicator._state_versions[mem_key3])
self.assertEqual(1,
self.state_replicator._state_versions[mem_key4])
async def test():
get_grpc_mock.return_value = self.channel
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
self.nid_client[key] = NetworkID(id='foo')
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(1, len(req.states))
# Ensure in-memory map updates properly
await self.state_replicator._send_to_state_service(req)
self.assertEqual(1, len(self.state_replicator._state_versions))
mem_key1 = make_mem_key('id1', NID_TYPE)
self.assertEqual(1,
self.state_replicator._state_versions[mem_key1])
# Now delete state and ensure in-memory map gets updated properly
del self.nid_client[key]
req = await self.state_replicator._collect_states_to_replicate()
self.assertIsNone(req)
await self.state_replicator._cleanup_deleted_keys()
self.assertFalse(key in self.state_replicator._state_versions)
async def test():
# Ensure setup is initialized properly
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
self.foo_client[key] = Foo("boo", 3)
exp1 = self.convert_msg_to_state(self.nid_client[key])
exp2 = self.convert_msg_to_state(self.idlist_client[key])
exp3 = self.convert_msg_to_state(self.foo_client[key], False)
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(3, len(req.states))
for state in req.states:
if state.type == NID_TYPE:
self.assertEqual('id1', state.deviceID)
self.assertEqual(1, state.version)
self.assertEqual(exp1, state.value)
elif state.type == IDList_TYPE:
self.assertEqual('aaa-bbb:id1', state.deviceID)
self.assertEqual(1, state.version)
self.assertEqual(exp2, state.value)
elif state.type == FOO_TYPE:
self.assertEqual('id1', state.deviceID)
self.assertEqual(1, state.version)
self.assertEqual(exp3, state.value)
else:
self.fail("Unknown state type %s" % state.type)
async def test():
get_rpc_mock.return_value = self.channel
self.nid_client.clear()
self.foo_client.clear()
self.log_client.clear()
key = 'id1'
self.nid_client[key] = NetworkID(id='foo')
self.log_client[key] = LogVerbosity(verbosity=3)
self.nid_client.mark_as_garbage(key)
self.log_client.mark_as_garbage(key)
req = await self.garbage_collector._collect_states_to_delete()
self.assertEqual(2, len(req.ids))
# Ensure objects on deleted from Redis on RPC failure
await self.garbage_collector._send_to_state_service(req)
self.assertEqual(0, len(self.nid_client.keys()))
self.assertEqual(0, len(self.log_client.keys()))
self.assertEqual(1, len(self.nid_client.garbage_keys()))
self.assertEqual(1, len(self.log_client.garbage_keys()))
# Cleanup
del self.log_client[key]
del self.nid_client[key]
async def test():
# Ensure setup is initialized properly
self.nid_client.clear()
self.foo_client.clear()
self.log_client.clear()
key = 'id1'
self.nid_client[key] = NetworkID(id='foo')
self.foo_client[key] = Foo("boo", 3)
req = await self.garbage_collector._collect_states_to_delete()
self.assertIsNone(req)
self.nid_client.mark_as_garbage(key)
self.foo_client.mark_as_garbage(key)
req = await self.garbage_collector._collect_states_to_delete()
self.assertEqual(2, len(req.ids))
for state_id in req.ids:
if state_id.type == NID_TYPE:
self.assertEqual('id1', state_id.deviceID)
elif state_id.type == FOO_TYPE:
self.assertEqual('aaa-bbb:id1', state_id.deviceID)
else:
self.fail("Unknown state type %s" % state_id.type)
# Cleanup
del self.foo_client[key]
del self.nid_client[key]
def __init__(
self,
mconfig: mconfigs_pb2.PolicyDB,
subscriberdb_stub: SubscriberDBStub,
):
self._mconfig = mconfig
self._network_id = NetworkID(id="_")
self._subscriberdb_stub = subscriberdb_stub
def _get_rules_for_imsi(self, imsi: str) -> List[StaticRuleInstall]:
try:
info = self._subscriberdb_stub.GetSubscriberData(NetworkID(id=imsi))
return [StaticRuleInstall(rule_id=rule_id)
for rule_id in info.lte.assigned_policies]
except grpc.RpcError:
logging.error('Unable to find data for subscriber %s', imsi)
return []
async def test():
self.mock_client.clear()
bad_key = 'id1'
# Force bad state format into mocked redis server
self.mock_client.redis.set(bad_key, NetworkID(id='foo'))
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(None, req)
def __init__(
self,
mconfig: mconfigs_pb2.PolicyDB,
rating_groups_by_id: RatingGroupsDict,
subscriberdb_stub: SubscriberDBStub,
):
self._mconfig = mconfig
self._network_id = NetworkID(id="_")
self._rating_groups_by_id = rating_groups_by_id
self._subscriberdb_stub = subscriberdb_stub
def __init__(
self,
mconfig: mconfigs_pb2.PolicyDB,
rating_groups_by_id: RatingGroupsDict,
rules_by_basename: BaseNameDict,
apn_rules_by_sid: ApnRuleAssignmentsDict,
):
self._mconfig = mconfig
self._network_id = NetworkID(id="_")
self._rating_groups_by_id = rating_groups_by_id
self._rules_by_basename = rules_by_basename
self._apn_rules_by_sid = apn_rules_by_sid
def _get_rules_for_imsi(self, imsi: str) -> List[StaticRuleInstall]:
"""
Get the list of static rules to be installed for a subscriber
NOTE: Remove "IMSI" prefix from imsi argument.
"""
try:
info = self._subscriberdb_stub.GetSubscriberData(NetworkID(id=imsi))
return [StaticRuleInstall(rule_id=rule_id)
for rule_id in info.lte.assigned_policies]
except grpc.RpcError:
logging.error('Unable to find data for subscriber %s', imsi)
return []
async def test():
get_grpc_mock.return_value = self.channel
# Add initial state to be replicated
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
key2 = 'id2'
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
# Increment version
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
# Set state that will be 'unreplicated'
self.log_client[key2] = LogVerbosity(verbosity=5)
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(3, len(req.states))
# Ensure in-memory map updates properly for successful replications
await self.state_replicator._send_to_state_service(req)
self.assertEqual(2, len(self.state_replicator._state_versions))
mem_key1 = make_mem_key('id1', NID_TYPE)
mem_key2 = make_mem_key(
'aaa-bbb:id1',
IDList_TYPE,
)
self.assertEqual(
1,
self.state_replicator._state_versions[mem_key1],
)
self.assertEqual(
2,
self.state_replicator._state_versions[mem_key2],
)
# Now run again, ensuring only the state the wasn't replicated
# will be sent again
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(1, len(req.states))
self.assertEqual('aaa-bbb:id2', req.states[0].deviceID)
self.assertEqual(LOG_TYPE, req.states[0].type)
async def test():
get_grpc_mock.return_value = self.channel
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
# Set state that will be 'unsynced'
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
# Increment state's version
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
await self.state_replicator._resync()
self.assertEqual(True, self.state_replicator._has_resync_completed)
self.assertEqual(1, len(self.state_replicator._state_versions))
mem_key = make_mem_key('aaa-bbb:id1', IDList_TYPE)
self.assertEqual(2, self.state_replicator._state_versions[mem_key])
def __init__(self, service_config, subscriberdb_stub: SubscriberDBStub):
self._config = service_config
self._network_id = NetworkID(id="_")
self._subscriberdb_stub = subscriberdb_stub
