Merge branch 'sonic-net:master' into agg-voq-changes

Author: vivekverma-arista

clear/main.py

@@ -79,21 +79,21 @@ def get_command(self, ctx, cmd_name):
 # location (configdb?), so that we prevent the continous execution of this
 # bash oneliner. To be revisited once routing-stack info is tracked somewhere.
 def get_routing_stack():
-    cmd0 = ["sudo", "docker", "ps"]
-    cmd1 = ["grep", "bgp"]
-    cmd2 = ["awk", '{print$2}']
-    cmd3 = ["cut", "-d-", "-f3"]
-    cmd4 = ["cut", "-d:", "-f1"]
+    result = 'frr'
+
+    cmd0 = ["sudo", "docker", "ps", "--format", "{{.Image}}\t{{.Names}}"]
+    cmd1 = ["awk", '$2 ~ /^bgp([0-9]+)?$/']
+    cmd2 = ["cut", "-d-", "-f3"]
+    cmd3 = ["cut", "-d:", "-f1"]
+    cmd4 = ["head", "-n", "1"]
 
     try:
         _, result = getstatusoutput_noshell_pipe(cmd0, cmd1, cmd2, cmd3, cmd4)
-
     except OSError as e:
         raise OSError("Cannot detect routing-stack")
 
     return (result)
 
-
 # Global Routing-Stack variable
 routing_stack = get_routing_stack()
 

config/chassis_modules.py

@@ -6,10 +6,27 @@
 import subprocess
 import utilities_common.cli as clicommon
 from utilities_common.chassis import is_smartswitch, get_all_dpus
+from datetime import datetime, timedelta
 
 TIMEOUT_SECS = 10
+TRANSITION_TIMEOUT = timedelta(seconds=240)  # 4 minutes
 
 
+class StateDBHelper:
+    def __init__(self, sonic_db):
+        self.db = sonic_db
+
+    def get_entry(self, table, key):
+        """Fetch all fields from table|key."""
+        redis_key = f"{table}|{key}"
+        return self.db.get_all("STATE_DB", redis_key) or {}
+
+    def set_entry(self, table, key, entry):
+        """Set multiple fields to table|key."""
+        redis_key = f"{table}|{key}"
+        for field, value in entry.items():
+            self.db.set("STATE_DB", redis_key, field, value)
+
 #
 # 'chassis_modules' group ('config chassis_modules ...')
 #
@@ -24,6 +41,12 @@ def modules():
     pass
 
 
+def ensure_statedb_connected(db):
+    if not hasattr(db, 'statedb'):
+        chassisdb = db.db
+        chassisdb.connect("STATE_DB")
+        db.statedb = StateDBHelper(chassisdb)
+
 def get_config_module_state(db, chassis_module_name):
     config_db = db.cfgdb
     fvs = config_db.get_entry('CHASSIS_MODULE', chassis_module_name)
@@ -36,6 +59,41 @@ def get_config_module_state(db, chassis_module_name):
         return fvs['admin_status']
 
 
+def get_state_transition_in_progress(db, chassis_module_name):
+    ensure_statedb_connected(db)
+    fvs = db.statedb.get_entry('CHASSIS_MODULE_TABLE', chassis_module_name)
+    value = fvs.get('state_transition_in_progress', 'False') if fvs else 'False'
+    return value
+
+
+def set_state_transition_in_progress(db, chassis_module_name, value):
+    ensure_statedb_connected(db)
+    state_db = db.statedb
+    entry = state_db.get_entry('CHASSIS_MODULE_TABLE', chassis_module_name) or {}
+    entry['state_transition_in_progress'] = value
+    if value == 'True':
+        entry['transition_start_time'] = datetime.utcnow().isoformat()
+    else:
+        entry.pop('transition_start_time', None)
+        state_db.delete_field('CHASSIS_MODULE_TABLE', chassis_module_name, 'transition_start_time')
+    state_db.set_entry('CHASSIS_MODULE_TABLE', chassis_module_name, entry)
+
+
+def is_transition_timed_out(db, chassis_module_name):
+    ensure_statedb_connected(db)
+    state_db = db.statedb
+    fvs = state_db.get_entry('CHASSIS_MODULE_TABLE', chassis_module_name)
+    if not fvs:
+        return False
+    start_time_str = fvs.get('transition_start_time')
+    if not start_time_str:
+        return False
+    try:
+        start_time = datetime.fromisoformat(start_time_str)
+    except ValueError:
+        return False
+    return datetime.utcnow() - start_time > TRANSITION_TIMEOUT
+
 #
 # Name: check_config_module_state_with_timeout
 # return: True: timeout, False: not timeout
@@ -116,20 +174,33 @@ def shutdown_chassis_module(db, chassis_module_name):
     config_db = db.cfgdb
     ctx = click.get_current_context()
 
-    if not chassis_module_name.startswith("SUPERVISOR") and \
-       not chassis_module_name.startswith("LINE-CARD") and \
-       not chassis_module_name.startswith("FABRIC-CARD") and \
-       not chassis_module_name.startswith("DPU"):
-        ctx.fail("'module_name' has to begin with 'SUPERVISOR', 'LINE-CARD', 'FABRIC-CARD', 'DPU'")
+    if not chassis_module_name.startswith(("SUPERVISOR", "LINE-CARD", "FABRIC-CARD", "DPU")):
+        ctx.fail("'module_name' has to begin with 'SUPERVISOR', 'LINE-CARD', 'FABRIC-CARD', or 'DPU'")
 
-    # To avoid duplicate operation
     if get_config_module_state(db, chassis_module_name) == 'down':
-        click.echo("Module {} is already in down state".format(chassis_module_name))
+        click.echo(f"Module {chassis_module_name} is already in down state")
         return
 
-    click.echo("Shutting down chassis module {}".format(chassis_module_name))
-    fvs = {'admin_status': 'down'}
-    config_db.set_entry('CHASSIS_MODULE', chassis_module_name, fvs)
+    if is_smartswitch():
+        if get_state_transition_in_progress(db, chassis_module_name) == 'True':
+            if is_transition_timed_out(db, chassis_module_name):
+                set_state_transition_in_progress(db, chassis_module_name, 'False')
+                click.echo(f"Previous transition for module {chassis_module_name} timed out. Proceeding with shutdown.")
+            else:
+                click.echo(f"Module {chassis_module_name} state transition is already in progress")
+                return
+        else:
+            set_state_transition_in_progress(db, chassis_module_name, 'True')
+
+        click.echo(f"Shutting down chassis module {chassis_module_name}")
+        fvs = {
+            'admin_status': 'down',
+        }
+        config_db.set_entry('CHASSIS_MODULE', chassis_module_name, fvs)
+    else:
+        click.echo(f"Shutting down chassis module {chassis_module_name}")
+        config_db.set_entry('CHASSIS_MODULE', chassis_module_name, {'admin_status': 'down'})
+
     if chassis_module_name.startswith("FABRIC-CARD"):
         if not check_config_module_state_with_timeout(ctx, db, chassis_module_name, 'down'):
             fabric_module_set_admin_status(db, chassis_module_name, 'down')
@@ -149,16 +220,32 @@ def startup_chassis_module(db, chassis_module_name):
     config_db = db.cfgdb
     ctx = click.get_current_context()
 
-    # To avoid duplicate operation
+    if not chassis_module_name.startswith(("SUPERVISOR", "LINE-CARD", "FABRIC-CARD", "DPU")):
+        ctx.fail("'module_name' has to begin with 'SUPERVISOR', 'LINE-CARD', 'FABRIC-CARD', or 'DPU'")
+        return
+
     if get_config_module_state(db, chassis_module_name) == 'up':
-        click.echo("Module {} is already set to up state".format(chassis_module_name))
+        click.echo(f"Module {chassis_module_name} is already set to up state")
         return
 
-    click.echo("Starting up chassis module {}".format(chassis_module_name))
     if is_smartswitch():
-        fvs = {'admin_status': 'up'}
+        if get_state_transition_in_progress(db, chassis_module_name) == 'True':
+            if is_transition_timed_out(db, chassis_module_name):
+                set_state_transition_in_progress(db, chassis_module_name, 'False')
+                click.echo(f"Previous transition for module {chassis_module_name} timed out. Proceeding with startup.")
+            else:
+                click.echo(f"Module {chassis_module_name} state transition is already in progress")
+                return
+        else:
+            set_state_transition_in_progress(db, chassis_module_name, 'True')
+
+        click.echo(f"Starting up chassis module {chassis_module_name}")
+        fvs = {
+            'admin_status': 'up',
+        }
         config_db.set_entry('CHASSIS_MODULE', chassis_module_name, fvs)
     else:
+        click.echo(f"Starting up chassis module {chassis_module_name}")
         config_db.set_entry('CHASSIS_MODULE', chassis_module_name, None)
 
     if chassis_module_name.startswith("FABRIC-CARD"):

config/muxcable.py

@@ -277,52 +277,14 @@ def lookup_statedb_and_update_configdb(db, per_npu_statedb, config_db, port, sta
             port_status_dict[port_name] = 'OK'
 
 def update_configdb_pck_loss_data(config_db, port, val):
-    fvs = {}
     configdb_state = get_value_for_key_in_config_tbl(config_db, port, "state", "MUX_CABLE")
-    fvs["state"] = configdb_state
     ipv4_value = get_value_for_key_in_config_tbl(config_db, port, "server_ipv4", "MUX_CABLE")
-    fvs["server_ipv4"] = ipv4_value
     ipv6_value = get_value_for_key_in_config_tbl(config_db, port, "server_ipv6", "MUX_CABLE")
-    fvs["server_ipv6"] = ipv6_value
-    soc_ipv4_value = get_optional_value_for_key_in_config_tbl(config_db, port, "soc_ipv4", "MUX_CABLE")
-    if soc_ipv4_value is not None:
-        fvs["soc_ipv4"] = soc_ipv4_value
-    cable_type = get_optional_value_for_key_in_config_tbl(config_db, port, "cable_type", "MUX_CABLE")
-    if cable_type is not None:
-        fvs["cable_type"] = cable_type
-    prober_type_val = get_optional_value_for_key_in_config_tbl(config_db, port, "prober_type", "MUX_CABLE")
-    if prober_type_val is not None:
-        fvs["prober_type"] = prober_type_val
 
-    fvs["pck_loss_data_reset"] = val
     try:
-        config_db.set_entry("MUX_CABLE", port, fvs)
-    except ValueError as e:
-        ctx = click.get_current_context()
-        ctx.fail("Invalid ConfigDB. Error: {}".format(e))
-
-
-def update_configdb_prober_type(config_db, port, val):
-    fvs = {}
-    configdb_state = get_value_for_key_in_config_tbl(config_db, port, "state", "MUX_CABLE")
-    fvs["state"] = configdb_state
-    ipv4_value = get_value_for_key_in_config_tbl(config_db, port, "server_ipv4", "MUX_CABLE")
-    fvs["server_ipv4"] = ipv4_value
-    ipv6_value = get_value_for_key_in_config_tbl(config_db, port, "server_ipv6", "MUX_CABLE")
-    fvs["server_ipv6"] = ipv6_value
-    soc_ipv4_value = get_optional_value_for_key_in_config_tbl(config_db, port, "soc_ipv4", "MUX_CABLE")
-    if soc_ipv4_value is not None:
-        fvs["soc_ipv4"] = soc_ipv4_value
-    cable_type = get_optional_value_for_key_in_config_tbl(config_db, port, "cable_type", "MUX_CABLE")
-    if cable_type is not None:
-        fvs["cable_type"] = cable_type
-    pck_loss_data = get_optional_value_for_key_in_config_tbl(config_db, port, "pck_loss_data_reset", "MUX_CABLE")
-    if pck_loss_data is not None:
-        fvs["pck_loss_data_reset"] = pck_loss_data
-
-    fvs["prober_type"] = val
-    try:
-        config_db.set_entry("MUX_CABLE", port, fvs)
+        config_db.set_entry("MUX_CABLE", port, {"state": configdb_state,
+                                                "server_ipv4": ipv4_value, "server_ipv6": ipv6_value, 
+                                                "pck_loss_data_reset": val})
     except ValueError as e:
         ctx = click.get_current_context()
         ctx.fail("Invalid ConfigDB. Error: {}".format(e))
@@ -419,73 +381,6 @@ def mode(db, state, port, json_output):
         sys.exit(CONFIG_SUCCESSFUL)
 
 
-# 'muxcable' command ("config muxcable probertype hardware/software <port|all>")
-@muxcable.command()
-@click.argument('probertype', metavar='<operation_status>', required=True, type=click.Choice(["hardware", "software"]))
-@click.argument('port', metavar='<port_name>', required=True, default=None)
-@clicommon.pass_db
-def probertype(db, probertype, port):
-    """Config muxcable probertype"""
-
-    port = platform_sfputil_helper.get_interface_name(port, db)
-
-    port_table_keys = {}
-    y_cable_asic_table_keys = {}
-    per_npu_configdb = {}
-    per_npu_statedb = {}
-
-    # Getting all front asic namespace and correspding config and state DB connector
-
-    namespaces = multi_asic.get_front_end_namespaces()
-    for namespace in namespaces:
-        asic_id = multi_asic.get_asic_index_from_namespace(namespace)
-        # replace these with correct macros
-        per_npu_configdb[asic_id] = ConfigDBConnector(use_unix_socket_path=True, namespace=namespace)
-        per_npu_configdb[asic_id].connect()
-        per_npu_statedb[asic_id] = SonicV2Connector(use_unix_socket_path=True, namespace=namespace)
-        per_npu_statedb[asic_id].connect(per_npu_statedb[asic_id].STATE_DB)
-
-        port_table_keys[asic_id] = per_npu_statedb[asic_id].keys(
-            per_npu_statedb[asic_id].STATE_DB, 'MUX_CABLE_TABLE|*')
-
-    if port is not None and port != "all":
-
-        asic_index = None
-        if platform_sfputil is not None:
-            asic_index = platform_sfputil.get_asic_id_for_logical_port(port)
-        if asic_index is None:
-            # TODO this import is only for unit test purposes, and should be removed once sonic_platform_base
-            # is fully mocked
-            import sonic_platform_base.sonic_sfp.sfputilhelper
-            asic_index = sonic_platform_base.sonic_sfp.sfputilhelper.SfpUtilHelper().get_asic_id_for_logical_port(port)
-            if asic_index is None:
-                click.echo("Got invalid asic index for port {}, cant retreive mux status".format(port))
-                sys.exit(CONFIG_FAIL)
-
-        if per_npu_statedb[asic_index] is not None:
-            y_cable_asic_table_keys = port_table_keys[asic_index]
-            logical_key = "MUX_CABLE_TABLE|{}".format(port)
-            if logical_key in y_cable_asic_table_keys:
-                update_configdb_prober_type(per_npu_configdb[asic_index], port, probertype)
-                sys.exit(CONFIG_SUCCESSFUL)
-            else:
-                click.echo("this is not a valid port {} present on mux_cable".format(port))
-                sys.exit(CONFIG_FAIL)
-        else:
-            click.echo("there is not a valid asic asic-{} table for this asic_index".format(asic_index))
-            sys.exit(CONFIG_FAIL)
-
-    elif port == "all" and port is not None:
-
-        for namespace in namespaces:
-            asic_id = multi_asic.get_asic_index_from_namespace(namespace)
-            for key in port_table_keys[asic_id]:
-                logical_port = key.split("|")[1]
-                update_configdb_prober_type(per_npu_configdb[asic_id], logical_port, probertype)
-
-        sys.exit(CONFIG_SUCCESSFUL)
-
-
 # 'muxcable' command ("config muxcable kill-radv <enable|disable> ")
 @muxcable.command(short_help="Kill radv service when it is meant to be stopped, so no good-bye packet is sent for ceasing To Be an Advertising Interface")
 @click.argument('knob', metavar='<feature_knob>', required=True, type=click.Choice(["enable", "disable"]))
@@ -501,7 +396,8 @@ def kill_radv(db, knob):
         mux_lmgrd_cfg_tbl = config_db.get_table("MUX_LINKMGR")
         config_db.mod_entry("MUX_LINKMGR", "SERVICE_MGMT", {"kill_radv": "True" if knob == "enable" else "False"})
 
-# 'muxcable' command ("config muxcable packetloss reset <port|all>")
+
+ #'muxcable' command ("config muxcable packetloss reset <port|all>")
 @muxcable.command()
 @click.argument('action', metavar='<action_name>', required=True, type=click.Choice(["reset"]))
 @click.argument('port', metavar='<port_name>', required=True, default=None)