import os
import time
from threading import Thread
-import msgpack
from mdclogpy import Logger
-from ricsdl.syncstorage import SyncStorage
+from ricxappframe.xapp_sdl import SDLWrapper
from a1.exceptions import PolicyTypeNotFound, PolicyInstanceNotFound, PolicyTypeAlreadyExists, CantDeleteNonEmptyType
-mdc_logger = Logger(name=__name__)
-
+# constants
INSTANCE_DELETE_NO_RESP_TTL = int(os.environ.get("INSTANCE_DELETE_NO_RESP_TTL", 5))
INSTANCE_DELETE_RESP_TTL = int(os.environ.get("INSTANCE_DELETE_RESP_TTL", 5))
-
A1NS = "A1m_ns"
-
-
-class SDLWrapper:
- """
- This is a wrapper around the expected SDL Python interface.
- The usage of POLICY_DATA will be replaced with SDL when SDL for python is available.
- The eventual SDL API is expected to be very close to what is here.
-
- We use msgpack for binary (de)serialization: https://msgpack.org/index.html
- """
-
- def __init__(self):
- self.sdl = SyncStorage()
-
- def set(self, key, value):
- """set a key"""
- self.sdl.set(A1NS, {key: msgpack.packb(value, use_bin_type=True)})
-
- def get(self, key):
- """get a key"""
- ret_dict = self.sdl.get(A1NS, {key})
- if key in ret_dict:
- return msgpack.unpackb(ret_dict[key], raw=False)
-
- return None
-
- def find_and_get(self, prefix):
- """get all k v pairs that start with prefix"""
- # note: SDL "*" usage is inconsistent with real python regex, where it would be ".*"
- ret_dict = self.sdl.find_and_get(A1NS, "{0}*".format(prefix))
- return {k: msgpack.unpackb(v, raw=False) for k, v in ret_dict.items()}
-
- def delete(self, key):
- """ delete a key"""
- self.sdl.remove(A1NS, {key})
-
- def healthcheck(self):
- """checks if the sdl connection is healthy"""
- return self.sdl.is_active()
-
-
-SDL = SDLWrapper()
-
TYPE_PREFIX = "a1.policy_type."
INSTANCE_PREFIX = "a1.policy_instance."
METADATA_PREFIX = "a1.policy_inst_metadata."
HANDLER_PREFIX = "a1.policy_handler."
+mdc_logger = Logger(name=__name__)
+SDL = SDLWrapper()
+
# Internal helpers
"""
check that a type is valid
"""
- if SDL.get(_generate_type_key(policy_type_id)) is None:
+ if SDL.get(A1NS, _generate_type_key(policy_type_id)) is None:
raise PolicyTypeNotFound()
check that an instance is valid
"""
_type_is_valid(policy_type_id)
- if SDL.get(_generate_instance_key(policy_type_id, policy_instance_id)) is None:
+ if SDL.get(A1NS, _generate_instance_key(policy_type_id, policy_instance_id)) is None:
raise PolicyInstanceNotFound
"""
_instance_is_valid(policy_type_id, policy_instance_id)
prefixes_for_handler = "{0}{1}.{2}.".format(HANDLER_PREFIX, policy_type_id, policy_instance_id)
- return list(SDL.find_and_get(prefixes_for_handler).values())
+ return list(SDL.find_and_get(A1NS, prefixes_for_handler).values())
def _get_instance_list(policy_type_id):
"""
_type_is_valid(policy_type_id)
prefixes_for_type = "{0}{1}.".format(INSTANCE_PREFIX, policy_type_id)
- instancekeys = SDL.find_and_get(prefixes_for_type).keys()
+ instancekeys = SDL.find_and_get(A1NS, prefixes_for_type).keys()
return [k.split(prefixes_for_type)[1] for k in instancekeys]
delete all the handlers for a policy instance
"""
all_handlers_pref = _generate_handler_prefix(policy_type_id, policy_instance_id)
- keys = SDL.find_and_get(all_handlers_pref)
+ keys = SDL.find_and_get(A1NS, all_handlers_pref)
for k in keys:
- SDL.delete(k)
+ SDL.delete(A1NS, k)
def _get_metadata(policy_type_id, policy_instance_id):
"""
_instance_is_valid(policy_type_id, policy_instance_id)
metadata_key = _generate_instance_metadata_key(policy_type_id, policy_instance_id)
- return SDL.get(metadata_key)
+ return SDL.get(A1NS, metadata_key)
def _delete_after(policy_type_id, policy_instance_id, ttl):
# ready to delete
_clear_handlers(policy_type_id, policy_instance_id) # delete all the handlers
- SDL.delete(_generate_instance_key(policy_type_id, policy_instance_id)) # delete instance
- SDL.delete(_generate_instance_metadata_key(policy_type_id, policy_instance_id)) # delete instance metadata
+ SDL.delete(A1NS, _generate_instance_key(policy_type_id, policy_instance_id)) # delete instance
+ SDL.delete(A1NS, _generate_instance_metadata_key(policy_type_id, policy_instance_id)) # delete instance metadata
mdc_logger.debug("type {0} instance {1} deleted".format(policy_type_id, policy_instance_id))
"""
retrieve all type ids
"""
- typekeys = SDL.find_and_get(TYPE_PREFIX).keys()
+ typekeys = SDL.find_and_get(A1NS, TYPE_PREFIX).keys()
# policy types are ints but they get butchered to strings in the KV
return [int(k.split(TYPE_PREFIX)[1]) for k in typekeys]
store a policy type if it doesn't already exist
"""
key = _generate_type_key(policy_type_id)
- if SDL.get(key) is not None:
+ if SDL.get(A1NS, key) is not None:
raise PolicyTypeAlreadyExists()
- SDL.set(key, body)
+ SDL.set(A1NS, key, body)
def delete_policy_type(policy_type_id):
"""
pil = get_instance_list(policy_type_id)
if pil == []: # empty, can delete
- SDL.delete(_generate_type_key(policy_type_id))
+ SDL.delete(A1NS, _generate_type_key(policy_type_id))
else:
raise CantDeleteNonEmptyType()
retrieve a type
"""
_type_is_valid(policy_type_id)
- return SDL.get(_generate_type_key(policy_type_id))
+ return SDL.get(A1NS, _generate_type_key(policy_type_id))
# Instances
# store the instance
key = _generate_instance_key(policy_type_id, policy_instance_id)
- if SDL.get(key) is not None:
+ if SDL.get(A1NS, key) is not None:
# Reset the statuses because this is a new policy instance, even if it was overwritten
_clear_handlers(policy_type_id, policy_instance_id) # delete all the handlers
- SDL.set(key, instance)
+ SDL.set(A1NS, key, instance)
metadata_key = _generate_instance_metadata_key(policy_type_id, policy_instance_id)
- SDL.set(metadata_key, {"created_at": creation_timestamp, "has_been_deleted": False})
+ SDL.set(A1NS, metadata_key, {"created_at": creation_timestamp, "has_been_deleted": False})
def get_policy_instance(policy_type_id, policy_instance_id):
Retrieve a policy instance
"""
_instance_is_valid(policy_type_id, policy_instance_id)
- return SDL.get(_generate_instance_key(policy_type_id, policy_instance_id))
+ return SDL.get(A1NS, _generate_instance_key(policy_type_id, policy_instance_id))
def get_instance_list(policy_type_id):
metadata_key = _generate_instance_metadata_key(policy_type_id, policy_instance_id)
existing_metadata = _get_metadata(policy_type_id, policy_instance_id)
SDL.set(
+ A1NS,
metadata_key,
{"created_at": existing_metadata["created_at"], "has_been_deleted": True, "deleted_at": deleted_timestamp},
)
"""
_type_is_valid(policy_type_id)
_instance_is_valid(policy_type_id, policy_instance_id)
- SDL.set(_generate_handler_key(policy_type_id, policy_instance_id, handler_id), status)
+ SDL.set(A1NS, _generate_handler_key(policy_type_id, policy_instance_id, handler_id), status)
def get_policy_instance_status(policy_type_id, policy_instance_id):
+++ /dev/null
-"""
-tests data functions
-"""
-# ==================================================================================
-# Copyright (c) 2019-2020 Nokia
-# Copyright (c) 2018-2020 AT&T Intellectual Property.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==================================================================================
-from a1 import data
-from ricsdl.syncstorage import SyncStorage
-
-
-def setup_module():
- """module level setup"""
- data.SDL.sdl = SyncStorage(fake_db_backend="dict")
-
-
-def test_sdl_raw():
- """
- test raw sdl functions
- """
- data.SDL.set("as.df1", "data")
- data.SDL.set("as.df2", "data2")
- assert data.SDL.get("as.df1") == "data"
- assert data.SDL.get("as.df2") == "data2"
- assert data.SDL.find_and_get("as.df1") == {"as.df1": "data"}
- assert data.SDL.find_and_get("as.df2") == {"as.df2": "data2"}
- assert data.SDL.find_and_get("as.df") == {"as.df1": "data", "as.df2": "data2"}
- assert data.SDL.find_and_get("as.d") == {"as.df1": "data", "as.df2": "data2"}
- assert data.SDL.find_and_get("as.") == {"as.df1": "data", "as.df2": "data2"}
- assert data.SDL.find_and_get("asd") == {}
-
- # delete 1
- data.SDL.delete("as.df1")
- assert data.SDL.get("as.df1") is None
- assert data.SDL.get("as.df2") == "data2"
-
- # delete 2
- data.SDL.delete("as.df2")
- assert data.SDL.get("as.df2") is None
-
- assert data.SDL.find_and_get("as.df") == {}
- assert data.SDL.find_and_get("") == {}
Code Review / ric-plt / a1.git / commitdiff