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