[debug dump util] Module implementation Logic and Port Module

dump/plugins/__init__.py

@@ -0,0 +1,16 @@
+import os
+import sys
+import pkgutil
+import importlib
+from .executor import Executor
+
+
+dump_modules = {}
+pkg_dir = os.path.dirname(__file__)
+
+# import child classes automatically                      
+for (module_loader, name, ispkg) in pkgutil.iter_modules([pkg_dir]):
+    importlib.import_module('.' + name, __package__)
+
+# Classes inheriting Executor
+dump_modules = {cls.__name__.lower(): cls for cls in Executor.__subclasses__()}

dump/plugins/executor.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+class Executor(ABC):
+    """ Abstract Class which should be extended from in order to be included in the dump state CLI """
+
+    ARG_NAME = "id" # Arg Identifier
+    CONFIG_FILE = "" # Path to config file, if any
+
+    @abstractmethod
+    def execute(self, params):
+        pass
+
+    @abstractmethod
+    def get_all_args(self, ns):
+        pass
+

dump/plugins/port.py

@@ -0,0 +1,77 @@
+from .executor import Executor
+from dump.match_infra import MatchEngine, MatchRequest
+from dump.helper import create_template_dict
+
+class Port(Executor):
+    """
+    Debug Dump Plugin for PORT Module
+    """
+    ARG_NAME = "port_name"
+
+    def __init__(self):
+        self.match_engine = MatchEngine()
+        self.ret_temp = {}
+        self.ns = ''
+
+    def get_all_args(self, ns=""):
+        req = MatchRequest(db="CONFIG_DB", table="PORT", key_pattern="*", ns=ns)
+        ret = self.match_engine.fetch(req)
+        all_ports = ret["keys"]
+        return [key.split("|")[-1] for key in all_ports]
+
+    def execute(self, params):
+        self.ret_temp = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
+        port_name = params[Port.ARG_NAME]
+        self.ns = params["namespace"]
+        self.init_port_config_info(port_name)
+        self.init_port_appl_info(port_name)
+        port_asic_obj = self.init_asic_hostif_info(port_name)
+        self.init_asic_port_info(port_asic_obj)
+        self.init_state_port_info(port_name)
+        return self.ret_temp
+
+    def add_to_ret_template(self, table, db, keys, err):
+        if not err and keys:
+            self.ret_temp[db]["keys"].extend(keys)
+            return True
+        else:
+            self.ret_temp[db]["tables_not_found"].extend([table])
+            return False
+
+    def init_port_config_info(self, port_name):
+        req = MatchRequest(db="CONFIG_DB", table="PORT", key_pattern=port_name, ns=self.ns)
+        ret = self.match_engine.fetch(req)
+        self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
+
+    def init_port_appl_info(self, port_name):
+        req = MatchRequest(db="APPL_DB", table="PORT_TABLE", key_pattern=port_name, ns=self.ns)
+        ret = self.match_engine.fetch(req)
+        self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
+
+    def init_state_port_info(self, port_name):
+        req = MatchRequest(db="STATE_DB", table="PORT_TABLE", key_pattern=port_name, ns=self.ns)
+        ret = self.match_engine.fetch(req)
+        self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
+
+    def init_asic_hostif_info(self, port_name):
+        req = MatchRequest(db="ASIC_DB", table="ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF", key_pattern="*", field="SAI_HOSTIF_ATTR_NAME", 
+                           value=port_name, return_fields=["SAI_HOSTIF_ATTR_OBJ_ID"], ns=self.ns)
+        ret = self.match_engine.fetch(req)
+        asic_port_obj_id = ""
+
+        if not ret["error"] and len(ret["keys"]) != 0:
+            self.ret_temp[req.db]["keys"] = ret["keys"]
+            sai_hostif_obj_key = ret["keys"][-1]
+            if sai_hostif_obj_key in ret["return_values"] and "SAI_HOSTIF_ATTR_OBJ_ID" in ret["return_values"][sai_hostif_obj_key]:
+                asic_port_obj_id = ret["return_values"][sai_hostif_obj_key]["SAI_HOSTIF_ATTR_OBJ_ID"]
+        else:
+            self.ret_temp[req.db]["tables_not_found"] = [req.table]
+        return asic_port_obj_id
+
+    def init_asic_port_info(self, asic_port_obj_id):
+        if not asic_port_obj_id: 
+            self.ret_temp["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_PORT")
+            return 
+        req = MatchRequest(db="ASIC_DB", table="ASIC_STATE:SAI_OBJECT_TYPE_PORT", key_pattern=asic_port_obj_id, ns=self.ns)
+        ret = self.match_engine.fetch(req)
+        self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])

tests/dump_input/port/appl_db.json

@@ -0,0 +1,35 @@
+{	
+	"PORT_TABLE:Ethernet176": {
+        	"index": "0",
+        	"lanes": "0",
+        	"alias": "etp45",
+        	"speed": "25000",
+        	"oper_status": "up",
+        	"pfc_asym": "off",
+        	"mtu": "9100",
+        	"fec": "rs",
+        	"admin_status": "up"
+	},
+	"PORT_TABLE:Ethernet160": {
+                "index": "0",
+                "lanes": "0",
+                "alias": "etp41",
+                "speed": "25000",
+                "oper_status": "up",
+                "pfc_asym": "off",
+                "mtu": "9100",
+                "fec": "rs",
+                "admin_status": "up"
+        },
+	"PORT_TABLE:Ethernet164": {
+                "index": "0",
+                "lanes": "0",
+                "alias": "etp42",
+                "speed": "25000",
+                "oper_status": "up",
+                "pfc_asym": "off",
+                "mtu": "9100",
+                "fec": "rs",
+                "admin_status": "up"
+        }
+}

tests/dump_input/port/asic_db.json

@@ -0,0 +1,29 @@
+{
+	"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF:oid:0xd000000000a4d":{
+		"SAI_HOSTIF_ATTR_TYPE" : "SAI_HOSTIF_TYPE_NETDEV",
+		"SAI_HOSTIF_ATTR_OBJ_ID": "oid:0x100000000036a",
+		"SAI_HOSTIF_ATTR_NAME" : "Ethernet176",
+		"SAI_HOSTIF_ATTR_OPER_STATUS" : "true"
+	},
+	"ASIC_STATE:SAI_OBJECT_TYPE_PORT:oid:0x100000000036a": { 
+		"SAI_PORT_ATTR_ADMIN_STATE" : "true",
+		"SAI_PORT_ATTR_SPEED" : "25000",
+		"SAI_PORT_ATTR_MTU"   : "9122"
+	},
+	"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF:oid:0xd000000000a49":{
+                "SAI_HOSTIF_ATTR_TYPE" : "SAI_HOSTIF_TYPE_NETDEV",
+                "SAI_HOSTIF_ATTR_OBJ_ID": "oid:0x10000000002e6",
+                "SAI_HOSTIF_ATTR_NAME" : "Ethernet160",
+                "SAI_HOSTIF_ATTR_OPER_STATUS" : "true"
+        },
+	"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF:oid:0xd000000000a4a":{
+                "SAI_HOSTIF_ATTR_TYPE" : "SAI_HOSTIF_TYPE_NETDEV",
+                "SAI_HOSTIF_ATTR_OBJ_ID": "oid:0x1000000000307",
+                "SAI_HOSTIF_ATTR_OPER_STATUS" : "true"
+        },
+	"ASIC_STATE:SAI_OBJECT_TYPE_PORT:oid:0x1000000000307": {
+                "SAI_PORT_ATTR_ADMIN_STATE" : "true",
+                "SAI_PORT_ATTR_SPEED" : "25000",
+                "SAI_PORT_ATTR_MTU"   : "9122"
+        }
+}

tests/dump_input/port/config_db.json

@@ -0,0 +1,30 @@
+{
+	"PORT|Ethernet176": {
+		"admin_status" : "up",
+        	"alias": "etp45",
+       		"index": "45",
+        	"lanes": "176",
+        	"speed": "25000"
+	},
+	"PORT|Ethernet164": {
+                "admin_status" : "up",
+                "alias": "etp42",
+                "index": "42",
+                "lanes": "164",
+                "speed": "25000"
+        },
+	"PORT|Ethernet160": {
+                "admin_status" : "up",
+                "alias": "etp41",
+                "index": "41",
+                "lanes": "160",
+                "speed": "25000"
+        },
+	"PORT|Ethernet156": {
+                "admin_status" : "up",
+                "alias": "etp40",
+                "index": "40",
+                "lanes": "156",
+                "speed": "25000"
+        }
+}

tests/dump_input/port/state_db.json

@@ -0,0 +1,14 @@
+{
+	"PORT_TABLE|Ethernet176":{
+		"state" : "ok",
+		"netdev_oper_status" : "up"
+	},
+	"PORT_TABLE|Ethernet160":{
+                "state" : "ok",
+                "netdev_oper_status" : "up"
+        },
+	"PORT_TABLE|Ethernet164":{
+                "state" : "ok",
+                "netdev_oper_status" : "up"
+        }
+}

tests/dump_tests/module_tests/mock_sonicv2connector.py

@@ -0,0 +1,69 @@
+import json, re, os
+from utilities_common.constants import DEFAULT_NAMESPACE
+
+class MockSonicV2Connector():
+    def __init__(self, dedicated_dbs, **kwargs):
+        if "namespace" in kwargs and kwargs["namespace"] != DEFAULT_NAMESPACE:
+            raise "This Mock doesn't support multi-asic configuration"
+        self.db = None
+        self.db_name_connect_to = None
+        self.dedicated_dbs = dedicated_dbs
+        db_config_path = os.path.join(os.path.dirname(__file__), "../../mock_tables/database_config.json")
+        with open(db_config_path) as f:
+            self.db_cfg = json.load(f)
+
+    def connect(self, db_name, retry=False):
+        if db_name not in self.dedicated_dbs:
+            raise Exception("{} not found. Available db's: {}".format(db_name, self.dedicated_dbs.keys()))
+        try:
+            with open(self.dedicated_dbs[db_name]) as f:
+                self.db = json.load(f)
+                self.db_name_connect_to = db_name  
+        except BaseException as e:
+            raise "Connection Failure" + str(e)
+
+    def get_db_separator(self, db_name):
+        return self.db_cfg["DATABASES"][db_name]["separator"]
+
+    def keys(self, db_name, pattern):
+        if not self.db:
+            raise "MockDB Not Connected"
+        if self.db_name_connect_to != db_name:
+            raise "Failed to find {} in the MockDB".format(db_name)
+
+        pattern = re.escape(pattern)
+        pattern = pattern.replace("\\*", ".*")
+        filtered_keys = []
+        all_keys = self.db.keys()
+        for key in all_keys:
+            if re.match(pattern, key):
+                filtered_keys.append(key)
+        return filtered_keys
+
+    def get_all(self, db_name, key):
+        if not self.db:
+            raise "MockDB Not Connected"
+        if self.db_name_connect_to != db_name:
+            raise "Failed to find {} in the MockDB".format(db_name)
+        if key not in self.db:
+            return {}
+        return self.db[key]
+
+    def get(self, db_name, key, field):
+        if not self.db:
+            raise "MockDB Not Connected"
+        if self.db_name_connect_to != db_name:
+            raise "Failed to find {} in the MockDB".format(db_name)
+        if key not in self.db or field not in self.db[key]:
+            return ""
+        return self.db[key][field]
+
+    def hexists(self, db_name, key, field):
+        if not self.db:
+            raise "MockDB Not Connected"
+        if self.db_name_connect_to != db_name:
+            raise "Failed to find {} in the MockDB".format(db_name)
+        if key not in self.db or field not in self.db[key]:
+            return False
+        else:
+            return True