def cleared_ip_states(client, key):
""" Get cleared Redis view of IP states. """
redis_dict = RedisHashDict(client,
'mobilityd:ip_to_descriptor:{}'.format(key),
serialize_utils.serialize_ip_desc,
serialize_utils.deserialize_ip_desc)
redis_dict.clear()
return redis_dict
def ip_states(client, key):
""" Get Redis view of IP states. """
redis_dict = RedisHashDict(
client,
IPSTATES_REDIS_TYPE.format(key),
serialize_utils.serialize_ip_desc,
serialize_utils.deserialize_ip_desc,
)
return redis_dict
def ip_states(client, key):
""" Get Redis view of IP states. """
redis_dict = RedisHashDict(
client,
"mobilityd:ip_to_descriptor:{}".format(key),
serialize_utils.serialize_ip_desc,
serialize_utils.deserialize_ip_desc,
)
return redis_dict
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 __init__(self,
*,
recycling_interval=DEFAULT_IP_RECYCLE_INTERVAL,
persist_to_redis=True,
redis_port=6379):
""" Initializes a new IP allocator
Args:
recycling_interval (number): minimum time, in seconds, before a
released IP is recycled and freed into the pool of available
IPs.
Default: None, no recycling will occur automatically.
persist_to_redis (bool): store all state in local process if falsy,
else write state to Redis service
"""
logging.debug('Persist to Redis: %s', persist_to_redis)
self._lock = threading.RLock() # re-entrant locks
self._recycle_timer = None # reference to recycle timer
self._recycling_interval_seconds = recycling_interval
if not persist_to_redis:
self._assigned_ip_blocks = set() # {ip_block}
self._ip_states = defaultdict(dict) # {state=>{ip=>ip_desc}}
self._sid_ips_map = defaultdict(list) # {SID=>[IPDesc]}
else:
if not redis_port:
raise ValueError(
'Must specify a redis_port in mobilityd config.')
client = redis.Redis(host='localhost', port=redis_port)
self._assigned_ip_blocks = RedisSet(
client, 'mobilityd:assigned_ip_blocks',
serialize_utils.serialize_ip_block,
serialize_utils.deserialize_ip_block)
self._ip_states = defaultdict_key(
lambda key: cleared_ip_states(client, key))
self._sid_ips_map = RedisHashDict(
client,
'mobilityd:sid_to_descriptors',
serialize_utils.serialize_ip_descs,
serialize_utils.deserialize_ip_descs,
default_factory=list)
# NOTE: clearing below (and _ip_states above) is done to sync
# a mobilityd restart with restarts from other services. Once
# all mobilityd-related services store persistent state (e.g.
# using the Redis service), we can remove these sync-necessitated
# clears on initialization.
# TODO: once we are no longer clearing all values on initialization,
# we should add unit tests to ensure values are written to Redis
# correctly.
self._assigned_ip_blocks.clear()
self._sid_ips_map.clear()
def ip_states(client, key):
""" Get Redis view of IP states. """
redis_dict = RedisHashDict(
client,
"mobilityd:ip_to_descriptor:{}".format(key),
serialize_utils.serialize_ip_desc,
serialize_utils.deserialize_ip_desc,
)
# TODO: Remove clear of container once mobilityd is not dependent on MME
redis_dict.clear()
return redis_dict