def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
service = MagicMock()
service.config = {
# Replicate arbitrary orc8r protos
'state_protos': [
{
'proto_file': 'orc8r.protos.common_pb2',
'proto_msg': 'NetworkID',
'redis_key': NID_TYPE,
'state_scope': 'network'
},
{
'proto_file': 'orc8r.protos.service303_pb2',
'proto_msg': 'LogVerbosity',
'redis_key': LOG_TYPE,
'state_scope': 'gateway'
},
],
'json_state': [{
'redis_key': FOO_TYPE,
'state_scope': 'gateway'
}]
}
service.loop = self.loop
# Bind the rpc server to a free port
self._rpc_server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10))
port = self._rpc_server.add_insecure_port('0.0.0.0:0')
# Add the servicer
self._servicer = DummyStateServer()
self._servicer.add_to_server(self._rpc_server)
self._rpc_server.start()
# Create a rpc stub
self.channel = grpc.insecure_channel('0.0.0.0:{}'.format(port))
serde1 = RedisSerde(NID_TYPE, get_proto_serializer(),
get_proto_deserializer(NetworkID))
serde2 = RedisSerde(FOO_TYPE, get_json_serializer(),
get_json_deserializer())
serde3 = RedisSerde(LOG_TYPE, get_proto_serializer(),
get_proto_deserializer(LogVerbosity))
self.nid_client = RedisFlatDict(get_default_client(), serde1)
self.foo_client = RedisFlatDict(get_default_client(), serde2)
self.log_client = RedisFlatDict(get_default_client(), serde3)
# Set up and start garbage collecting loop
grpc_client_manager = GRPCClientManager(
service_name="state",
service_stub=StateServiceStub,
max_client_reuse=60,
)
# Start state garbage collection loop
self.garbage_collector = GarbageCollector(service, grpc_client_manager)
def setUp(self):
client = get_default_client()
# Use arbitrary orc8r proto to test with
self._hash_dict = RedisHashDict(client, "unittest",
get_proto_serializer(),
get_proto_deserializer(LogVerbosity))
serde = RedisSerde('log_verbosity', get_proto_serializer(),
get_proto_deserializer(LogVerbosity))
self._flat_dict = RedisFlatDict(client, serde)
def get_proto_redis_dicts(config):
redis_dicts = []
state_protos = config.get('state_protos', []) or []
for proto_cfg in state_protos:
is_invalid_cfg = 'proto_msg' not in proto_cfg or \
'proto_file' not in proto_cfg or \
'redis_key' not in proto_cfg or \
'state_scope' not in proto_cfg
if is_invalid_cfg:
logging.warning(
"Invalid proto config found in state_protos "
"configuration: %s", proto_cfg)
continue
try:
proto_module = importlib.import_module(proto_cfg['proto_file'])
msg = getattr(proto_module, proto_cfg['proto_msg'])
redis_key = proto_cfg['redis_key']
logging.info('Initializing RedisSerde for proto state %s',
proto_cfg['redis_key'])
serde = RedisSerde(redis_key, get_proto_serializer(),
get_proto_deserializer(msg))
redis_dict = StateDict(serde, proto_cfg['state_scope'],
PROTO_FORMAT)
redis_dicts.append(redis_dict)
except (ImportError, AttributeError) as err:
logging.error(err)
return redis_dicts
def __init__(self):
client = get_default_client()
super().__init__(
client,
self._DICT_HASH,
get_proto_serializer(),
get_proto_deserializer(ChargingRuleNameSet))
def _get_proto_redis_serdes(self):
state_protos = self._service.config.get('state_protos', []) or []
for proto_cfg in state_protos:
is_invalid_cfg = 'proto_msg' not in proto_cfg or \
'proto_file' not in proto_cfg or \
'redis_key' not in proto_cfg or \
'state_scope' not in proto_cfg
if is_invalid_cfg:
logging.warning(
"Invalid proto config found in state_protos "
"configuration: %s", proto_cfg)
continue
try:
proto_module = importlib.import_module(proto_cfg['proto_file'])
msg = getattr(proto_module, proto_cfg['proto_msg'])
redis_key = proto_cfg['redis_key']
logging.info('Initializing RedisSerde for proto state %s',
proto_cfg['redis_key'])
serde = StateSerde(redis_key, get_proto_serializer(),
get_proto_deserializer(msg),
proto_cfg['state_scope'], PROTO_FORMAT)
self._serdes[redis_key] = serde
except (ImportError, AttributeError) as err:
logging.error(err)
def __init__(self):
serde = RedisSerde(
self.REDIS_VALUE_TYPE,
get_proto_serializer(),
get_proto_deserializer(ServiceExitStatus),
)
self._flat_dict = RedisFlatDict(get_default_client(), serde)
def __init__(self):
client = get_default_client()
super().__init__(
client,
self._DICT_HASH,
get_proto_serializer(),
get_proto_deserializer(RedirectInformation))
def __init__(self):
client = get_default_client()
super().__init__(
client,
self._DICT_HASH,
get_proto_serializer(),
get_proto_deserializer(PolicyRule))
def __init__(self):
client = get_default_client()
super().__init__(
client,
self._DICT_HASH,
get_proto_serializer(),
get_proto_deserializer(RatingGroup),
)
def __init__(self):
client = get_default_client()
super().__init__(
client,
self._DICT_HASH,
get_proto_serializer(),
get_proto_deserializer(SubscriberPolicySet),
)
self._clear()
def __init__(self):
client = get_default_client()
super().__init__(
client,
self._DICT_HASH,
get_proto_serializer(),
get_proto_deserializer(InstalledPolicies),
)
# TODO: Remove when sessiond becomes stateless
self._clear()
def setUp(self):
self.mock_redis = fakeredis.FakeStrictRedis()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
service = MagicMock()
service.config = {
# Replicate arbitrary orc8r protos
'state_protos': [
{
'proto_file': 'orc8r.protos.common_pb2',
'proto_msg': 'NetworkID',
'redis_key': NID_TYPE,
'state_scope': 'network',
},
{
'proto_file': 'orc8r.protos.common_pb2',
'proto_msg': 'IDList',
'redis_key': IDList_TYPE,
'state_scope': 'gateway',
},
{
'proto_file': 'orc8r.protos.service303_pb2',
'proto_msg': 'LogVerbosity',
'redis_key': LOG_TYPE,
'state_scope': 'gateway',
},
],
'json_state': [{
'redis_key': FOO_TYPE,
'state_scope': 'network'
}],
}
service.loop = self.loop
# Bind the rpc server to a free port
self._rpc_server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10), )
port = self._rpc_server.add_insecure_port('0.0.0.0:0')
# Add the servicer
self._servicer = DummyStateServer()
self._servicer.add_to_server(self._rpc_server)
self._rpc_server.start()
# Create a rpc stub
self.channel = grpc.insecure_channel('0.0.0.0:{}'.format(port))
serde1 = RedisSerde(
NID_TYPE,
get_proto_serializer(),
get_proto_deserializer(NetworkID),
)
serde2 = RedisSerde(
IDList_TYPE,
get_proto_serializer(),
get_proto_deserializer(IDList),
)
serde3 = RedisSerde(
LOG_TYPE,
get_proto_serializer(),
get_proto_deserializer(LogVerbosity),
)
serde4 = RedisSerde(
FOO_TYPE,
get_json_serializer(),
get_json_deserializer(),
)
self.nid_client = RedisFlatDict(self.mock_redis, serde1)
self.idlist_client = RedisFlatDict(self.mock_redis, serde2)
self.log_client = RedisFlatDict(self.mock_redis, serde3)
self.foo_client = RedisFlatDict(self.mock_redis, serde4)
# Set up and start state replicating loop
grpc_client_manager = GRPCClientManager(
service_name="state",
service_stub=StateServiceStub,
max_client_reuse=60,
)
# mock the get_default_client function used to return the same
# fakeredis object
func_mock = mock.MagicMock(return_value=self.mock_redis)
with mock.patch(
'magma.state.redis_dicts.get_default_client',
func_mock,
):
garbage_collector = GarbageCollector(service, grpc_client_manager)
self.state_replicator = StateReplicator(
service=service,
garbage_collector=garbage_collector,
grpc_client_manager=grpc_client_manager,
)
self.state_replicator.start()
