def connect(self, db, ns):
try:
self.conn = self.pool.get(db, ns)
except Exception as e:
verbose_print("RedisSource: Connection Failed\n" + str(e))
return False
return True
def connect(self, db, ns):
try:
with open(db) as f:
self.json_data = json.load(f)
except Exception as e:
verbose_print("JsonSource: Loading the JSON file failed" + str(e))
return False
return True
def connect(self, db, ns):
try:
if not SonicDBConfig.isInit():
if multi_asic.is_multi_asic():
SonicDBConfig.load_sonic_global_db_config()
else:
SonicDBConfig.load_sonic_db_config()
self.conn = SonicV2Connector(namespace=ns, use_unix_socket_path=True)
self.conn.connect(db)
except Exception as e:
verbose_print("RedisSource: Connection Failed\n" + str(e))
return False
return True
def fetch(self, req_orig):
req = copy.deepcopy(req_orig)
key = req.table + ":" + req.key_pattern
if key in self.__key_cache:
verbose_print("Cache Hit for Key: {}".format(key))
return self.__fetch_from_cache(key, req)
else:
verbose_print("Cache Miss for Key: {}".format(key))
req, fv_requested, ret_just_keys = self.__mutate_request(req)
ret = self.m_engine.fetch(req)
if ret["error"]:
return ret
self.__fill_cache(ret)
return self.__mutate_response(ret, fv_requested, ret_just_keys)
def __init__(self, **kwargs):
self.table = kwargs["table"] if "table" in kwargs else None
self.key_pattern = kwargs["key_pattern"] if "key_pattern" in kwargs else "*"
self.field = kwargs["field"] if "field" in kwargs else None
self.value = kwargs["value"] if "value" in kwargs else None
self.return_fields = kwargs["return_fields"] if "return_fields" in kwargs else []
self.db = kwargs["db"] if "db" in kwargs else ""
self.file = kwargs["file"] if "file" in kwargs else ""
self.just_keys = kwargs["just_keys"] if "just_keys" in kwargs else True
self.ns = kwargs["ns"] if "ns" in kwargs else ""
self.match_entire_list = kwargs["match_entire_list"] if "match_entire_list" in kwargs else False
err = self.__static_checks()
verbose_print(str(err))
if err:
raise Exception("Static Checks for the MatchRequest Failed, Reason: \n" + err)
def __fill_template(self, src, req, filtered_keys, template):
for key in filtered_keys:
temp = {}
if not req.just_keys:
temp[key] = src.get(req.db, key)
template["keys"].append(temp)
elif len(req.return_fields) > 0:
template["keys"].append(key)
template["return_values"][key] = {}
for field in req.return_fields:
template["return_values"][key][field] = src.hget(req.db, key, field)
else:
template["keys"].append(key)
verbose_print("Return Values:" + str(template["return_values"]))
return template
def __static_checks(self):
if not self.db and not self.file:
return EXCEP_DICT["NO_SRC"]
if self.db and self.file:
return EXCEP_DICT["SRC_VAGUE"]
if not self.db:
try:
with open(self.file) as f:
json.load(f)
except Exception as e:
return EXCEP_DICT["FILE_R_EXEP"] + str(e)
if not self.file and self.db not in SonicDBConfig.getDbList():
return EXCEP_DICT["INV_DB"]
if not self.table:
return EXCEP_DICT["NO_TABLE"]
if not isinstance(self.return_fields, list):
return EXCEP_DICT["BAD_FORMAT_RE_FIELDS"]
if not self.just_keys and self.return_fields:
return EXCEP_DICT["JUST_KEYS_COMPAT"]
if self.field and not self.value:
return EXCEP_DICT["NO_VALUE"]
if self.ns != DEFAULT_NAMESPACE and self.ns not in multi_asic.get_namespace_list(
):
return EXCEP_DICT["INV_NS"] + " Choose From {}".format(
multi_asic.get_namespace_list())
verbose_print("MatchRequest Checks Passed")
return ""
def fetch(self, req):
""" Given a request obj, find its match in the data source provided """
if not isinstance(req, MatchRequest):
return self.__display_error(EXCEP_DICT["INV_REQ"])
verbose_print(str(req))
if not req.key_pattern:
return self.__display_error(EXCEP_DICT["NO_KEY"])
d_src, src = self.__get_source_adapter(req)
if not src.connect(d_src, req.ns):
return self.__display_error(EXCEP_DICT["CONN_ERR"])
template = self.__create_template()
all_matched_keys = src.getKeys(req.db, req.table, req.key_pattern)
if not all_matched_keys:
return self.__display_error(EXCEP_DICT["NO_MATCHES"])
filtered_keys = self.__filter_out_keys(src, req, all_matched_keys)
verbose_print("Filtered Keys:" + str(filtered_keys))
if not filtered_keys:
return self.__display_error(EXCEP_DICT["NO_ENTRIES"])
return self.__fill_template(src, req, filtered_keys, template)
def __display_error(self, err):
template = self.__create_template()
template['error'] = err
verbose_print("MatchEngine: \n" + template['error'])
return template
