From 233f238f5f81c259082b6881433be1a47e73953b Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Fri, 26 Mar 2021 14:08:18 +0000 Subject: [PATCH 01/13] [config] cli support for firmware upgrade on Y-Cable Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 312 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 312 insertions(+) diff --git a/config/muxcable.py b/config/muxcable.py index 518446435d..548b22f41d 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -631,3 +631,315 @@ def setswitchmode(state, port): if rc == False: click.echo("ERR: Unable to set switching mode one or more ports to {}".format(state)) sys.exit(CONFIG_FAIL) + +@muxcable.group(cls=clicommon.AbbreviationGroup) +def firmware(): + """Configure muxcable firmware command""" + pass + +# 'muxcable' command ("config muxcable mode active|auto") +@firmware.command() +@click.argument('fwfile', metavar='', required=True)) +@click.argument('port', metavar='', required=True, default=None) +def download(fwfile, port): + """Config muxcable firmware download""" + + port_table_keys = {} + y_cable_asic_table_keys = {} + 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_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": + + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + asic_index = None + if platform_sfputil is not None: + asic_index = platform_sfputil_helper.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)) + + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + sys.exit(CONFIG_FAIL) + + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) + sys.exit(CONFIG_FAIL) + + physical_port = physical_port_list[0] + 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: + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.download_firmware(physical_port, fwfile) + if result == sonic_y_cable.y_cable.FIRMWARE_DOWNLOAD_SUCCESS: + click.echo("firmware download successful {}".format(port)) + else: + click.echo("firmware download failure {}".format(port)) + + 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 table for this asic_index".format(asic_index)) + sys.exit(CONFIG_FAIL) + + elif port == "all" and port is not None: + + port_status_dict = {} + rc = True + for namespace in namespaces: + asic_id = multi_asic.get_asic_index_from_namespace(namespace) + for key in port_table_keys[asic_id]: + port = key.split("|")[1] + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + rc = False + continue + + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) + rc = False + continue + physical_port = physical_port_list[0] + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.download_firmware(physical_port, fwfile) + if result == sonic_y_cable.y_cable.FIRMWARE_DOWNLOAD_SUCCESS: + click.echo("firmware download successful for {}".format(port)) + else: + click.echo("firmware download failure for {}".format(port)) + rc = False + + if rc: + sys.exit(CONFIG_SUCCESSFUL) + else: + sys.exit(CONFIG_FAIL) + +@firmware.command() +@click.argument('port', metavar='', required=True, default=None) +def activate(port): + """Config muxcable firmware activate""" + + port_table_keys = {} + y_cable_asic_table_keys = {} + 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_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": + + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + asic_index = None + if platform_sfputil is not None: + asic_index = platform_sfputil_helper.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)) + + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + sys.exit(CONFIG_FAIL) + + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) + sys.exit(CONFIG_FAIL) + + physical_port = physical_port_list[0] + 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: + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.activate_firmware(physical_port) + if result == sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS: + click.echo("firmware activate successful {}".format(port)) + else: + click.echo("firmware activate failure {}".format(port)) + + 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 table for this asic_index".format(asic_index)) + sys.exit(CONFIG_FAIL) + + elif port == "all" and port is not None: + + port_status_dict = {} + rc = True + for namespace in namespaces: + asic_id = multi_asic.get_asic_index_from_namespace(namespace) + for key in port_table_keys[asic_id]: + port = key.split("|")[1] + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + rc = False + continue + + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) + rc = False + continue + + physical_port = physical_port_list[0] + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.activate_firmware(physical_port) + if result == sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS: + click.echo("firmware ACTIVATE successful for {}".format(port)) + else: + click.echo("firmware ACTIVATE failure for {}".format(port)) + rc = False + + if rc: + sys.exit(CONFIG_SUCCESSFUL) + else: + sys.exit(CONFIG_FAIL) + i +@firmware.command() +@click.argument('port', metavar='', required=True, default=None) +def rollback(port): + """Config muxcable firmware rollback""" + + port_table_keys = {} + y_cable_asic_table_keys = {} + 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_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": + + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + asic_index = None + if platform_sfputil is not None: + asic_index = platform_sfputil_helper.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)) + + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + sys.exit(CONFIG_FAIL) + + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) + sys.exit(CONFIG_FAIL) + + physical_port = physical_port_list[0] + 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: + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.rollback_firmware(physical_port) + if result == sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS: + click.echo("firmware rollback successful {}".format(port)) + else: + click.echo("firmware rollback failure {}".format(port)) + + 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 table for this asic_index".format(asic_index)) + sys.exit(CONFIG_FAIL) + + elif port == "all" and port is not None: + + port_status_dict = {} + rc = True + for namespace in namespaces: + asic_id = multi_asic.get_asic_index_from_namespace(namespace) + for key in port_table_keys[asic_id]: + port = key.split("|")[1] + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + rc = False + continue + + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) + rc = False + continue + + physical_port = physical_port_list[0] + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.rollback_firmware(physical_port) + if result == sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS: + click.echo("firmware ROLLBACK successful for {}".format(port)) + else: + click.echo("firmware ROLLBACK failure for {}".format(port)) + rc = False + + if rc: + sys.exit(CONFIG_SUCCESSFUL) + else: + sys.exit(CONFIG_FAIL) From b44a442adafd71e79e9ff426951aca89e069b6cb Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Fri, 26 Mar 2021 14:50:14 +0000 Subject: [PATCH 02/13] fix LGTM Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index 548b22f41d..4bacc6ac1a 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -637,9 +637,8 @@ def firmware(): """Configure muxcable firmware command""" pass -# 'muxcable' command ("config muxcable mode active|auto") @firmware.command() -@click.argument('fwfile', metavar='', required=True)) +@click.argument('fwfile', metavar='', required=True) @click.argument('port', metavar='', required=True, default=None) def download(fwfile, port): """Config muxcable firmware download""" From 0b3bdba659955151fd94dbfd612b35ccb42d90ef Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Fri, 26 Mar 2021 15:21:13 +0000 Subject: [PATCH 03/13] fix LGTM Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index 4bacc6ac1a..682755b09d 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -706,7 +706,6 @@ def download(fwfile, port): elif port == "all" and port is not None: - port_status_dict = {} rc = True for namespace in namespaces: asic_id = multi_asic.get_asic_index_from_namespace(namespace) @@ -807,7 +806,6 @@ def activate(port): elif port == "all" and port is not None: - port_status_dict = {} rc = True for namespace in namespaces: asic_id = multi_asic.get_asic_index_from_namespace(namespace) @@ -909,7 +907,6 @@ def rollback(port): elif port == "all" and port is not None: - port_status_dict = {} rc = True for namespace in namespaces: asic_id = multi_asic.get_asic_index_from_namespace(namespace) From 63c6977f57621a71cde91355c2c1d25b81c72888 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Mon, 29 Mar 2021 17:46:21 +0000 Subject: [PATCH 04/13] refactor Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 275 +++++++++++++++++---------------------------- 1 file changed, 101 insertions(+), 174 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index 682755b09d..c8e0dec05d 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -632,20 +632,10 @@ def setswitchmode(state, port): click.echo("ERR: Unable to set switching mode one or more ports to {}".format(state)) sys.exit(CONFIG_FAIL) -@muxcable.group(cls=clicommon.AbbreviationGroup) -def firmware(): - """Configure muxcable firmware command""" - pass -@firmware.command() -@click.argument('fwfile', metavar='', required=True) -@click.argument('port', metavar='', required=True, default=None) -def download(fwfile, port): - """Config muxcable firmware download""" +def get_per_npu_statedb(per_npu_statedb, port_table_keys): - port_table_keys = {} y_cable_asic_table_keys = {} - per_npu_statedb = {} # Getting all front asic namespace and correspding config and state DB connector @@ -656,46 +646,98 @@ def download(fwfile, port): 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": - if platform_sfputil is not None: - physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) +def get_physical_port_list(port, physical_port_list) - asic_index = None - if platform_sfputil is not None: - asic_index = platform_sfputil_helper.get_asic_id_for_logical_port(port) + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + asic_index = None + if platform_sfputil is not None: + asic_index = platform_sfputil_helper.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: - # 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)) + click.echo("Got invalid asic index for port {}, cant retreive mux status".format(port)) - if not isinstance(physical_port_list, list): - click.echo(("ERR: Unable to locate physical port information for {}".format(port))) - sys.exit(CONFIG_FAIL) + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + sys.exit(CONFIG_FAIL) - if len(physical_port_list) != 1: - click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( - ", ".join(physical_port_list), port)) + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) sys.exit(CONFIG_FAIL) + return asic_index + + +def perform_download_firmware(physical_port, fwfile): + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.download_firmware(physical_port, fwfile) + if result == sonic_y_cable.y_cable.FIRMWARE_DOWNLOAD_SUCCESS: + click.echo("firmware download successful {}".format(port)) + return True + else: + click.echo("firmware download failure {}".format(port)) + return False + + +def perform_activate_firmware(physical_port, fwfile): + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.activate_firmware(physical_port) + if result == sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS: + click.echo("firmware ACTIVATE successful for {}".format(port)) + return True + else: + click.echo("firmware ACTIVATE failure for {}".format(port)) + return False + + +def perform_rollback_firmware(physical_port, fwfile): + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.rollback_firmware(physical_port) + if result == sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS: + click.echo("firmware rollback successful {}".format(port)) + return True + else: + click.echo("firmware rollback failure {}".format(port)) + return False + + +@muxcable.group(cls=clicommon.AbbreviationGroup) +def firmware(): + """Configure muxcable firmware command""" + pass + + +@firmware.command() +@click.argument('fwfile', metavar='', required=True) +@click.argument('port', metavar='', required=True, default=None) +def download(fwfile, port): + """Config muxcable firmware download""" + + per_npu_statedb = {} + physical_port_list = [] + port_table_keys = {} + + get_per_npu_statedb(per_npu_statedb, port_table_keys) + + if port is not None and port != "all": + + get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] 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: - import sonic_y_cable.y_cable - result = sonic_y_cable.y_cable.download_firmware(physical_port, fwfile) - if result == sonic_y_cable.y_cable.FIRMWARE_DOWNLOAD_SUCCESS: - click.echo("firmware download successful {}".format(port)) - else: - click.echo("firmware download failure {}".format(port)) + perform_download_firmware(physical_port, fwfile) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -711,26 +753,15 @@ def download(fwfile, port): asic_id = multi_asic.get_asic_index_from_namespace(namespace) for key in port_table_keys[asic_id]: port = key.split("|")[1] - if platform_sfputil is not None: - physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) - if not isinstance(physical_port_list, list): - click.echo(("ERR: Unable to locate physical port information for {}".format(port))) - rc = False - continue + physical_port_list = [] + get_physical_port_list(port, physical_port_list) - if len(physical_port_list) != 1: - click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( - ", ".join(physical_port_list), port)) - rc = False - continue physical_port = physical_port_list[0] - import sonic_y_cable.y_cable - result = sonic_y_cable.y_cable.download_firmware(physical_port, fwfile) - if result == sonic_y_cable.y_cable.FIRMWARE_DOWNLOAD_SUCCESS: - click.echo("firmware download successful for {}".format(port)) - else: - click.echo("firmware download failure for {}".format(port)) + + status = perform_download_firmware(physical_port, fwfile) + + if !status: rc = False if rc: @@ -738,6 +769,7 @@ def download(fwfile, port): else: sys.exit(CONFIG_FAIL) + @firmware.command() @click.argument('port', metavar='', required=True, default=None) def activate(port): @@ -747,55 +779,17 @@ def activate(port): y_cable_asic_table_keys = {} 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_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|*') + get_per_npu_statedb(per_npu_statedb, port_table_keys) if port is not None and port != "all": - if platform_sfputil is not None: - physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) - - asic_index = None - if platform_sfputil is not None: - asic_index = platform_sfputil_helper.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)) - - if not isinstance(physical_port_list, list): - click.echo(("ERR: Unable to locate physical port information for {}".format(port))) - sys.exit(CONFIG_FAIL) - - if len(physical_port_list) != 1: - click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( - ", ".join(physical_port_list), port)) - sys.exit(CONFIG_FAIL) - + get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] 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: - import sonic_y_cable.y_cable - result = sonic_y_cable.y_cable.activate_firmware(physical_port) - if result == sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS: - click.echo("firmware activate successful {}".format(port)) - else: - click.echo("firmware activate failure {}".format(port)) + perform_activate_firmware(physical_port, fwfile) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -811,34 +805,20 @@ def activate(port): asic_id = multi_asic.get_asic_index_from_namespace(namespace) for key in port_table_keys[asic_id]: port = key.split("|")[1] - if platform_sfputil is not None: - physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) - - if not isinstance(physical_port_list, list): - click.echo(("ERR: Unable to locate physical port information for {}".format(port))) - rc = False - continue - - if len(physical_port_list) != 1: - click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( - ", ".join(physical_port_list), port)) - rc = False - continue + get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] - import sonic_y_cable.y_cable - result = sonic_y_cable.y_cable.activate_firmware(physical_port) - if result == sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS: - click.echo("firmware ACTIVATE successful for {}".format(port)) - else: - click.echo("firmware ACTIVATE failure for {}".format(port)) + status = perform_activate_firmware(physical_port, fwfile) + + if !status: rc = False if rc: sys.exit(CONFIG_SUCCESSFUL) else: sys.exit(CONFIG_FAIL) - i + + @firmware.command() @click.argument('port', metavar='', required=True, default=None) def rollback(port): @@ -848,55 +828,17 @@ def rollback(port): y_cable_asic_table_keys = {} 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_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|*') + get_per_npu_statedb(per_npu_statedb, port_table_keys) if port is not None and port != "all": - if platform_sfputil is not None: - physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) - - asic_index = None - if platform_sfputil is not None: - asic_index = platform_sfputil_helper.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)) - - if not isinstance(physical_port_list, list): - click.echo(("ERR: Unable to locate physical port information for {}".format(port))) - sys.exit(CONFIG_FAIL) - - if len(physical_port_list) != 1: - click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( - ", ".join(physical_port_list), port)) - sys.exit(CONFIG_FAIL) - + get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] 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: - import sonic_y_cable.y_cable - result = sonic_y_cable.y_cable.rollback_firmware(physical_port) - if result == sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS: - click.echo("firmware rollback successful {}".format(port)) - else: - click.echo("firmware rollback failure {}".format(port)) + perform_rollback_firmware(physical_port, fwfile) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -912,27 +854,12 @@ def rollback(port): asic_id = multi_asic.get_asic_index_from_namespace(namespace) for key in port_table_keys[asic_id]: port = key.split("|")[1] - if platform_sfputil is not None: - physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) - - if not isinstance(physical_port_list, list): - click.echo(("ERR: Unable to locate physical port information for {}".format(port))) - rc = False - continue - - if len(physical_port_list) != 1: - click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( - ", ".join(physical_port_list), port)) - rc = False - continue + get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] - import sonic_y_cable.y_cable - result = sonic_y_cable.y_cable.rollback_firmware(physical_port) - if result == sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS: - click.echo("firmware ROLLBACK successful for {}".format(port)) - else: - click.echo("firmware ROLLBACK failure for {}".format(port)) + status = perform_rollback_firmware(physical_port, fwfile) + + if !status: rc = False if rc: From d04d25aefdf4deb1b83291939ecc4318d165d707 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Mon, 29 Mar 2021 18:02:06 +0000 Subject: [PATCH 05/13] fix LGTM Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/muxcable.py b/config/muxcable.py index c8e0dec05d..3d2209f1b6 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -650,7 +650,7 @@ def get_per_npu_statedb(per_npu_statedb, port_table_keys): per_npu_statedb[asic_id].STATE_DB, 'MUX_CABLE_TABLE|*') -def get_physical_port_list(port, physical_port_list) +def get_physical_port_list(port, physical_port_list): if platform_sfputil is not None: physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) From a81c9439bb3f92faa2aaac7a30fca4eb97de5392 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Mon, 29 Mar 2021 18:16:56 +0000 Subject: [PATCH 06/13] fix python warnings Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/muxcable.py b/config/muxcable.py index 3d2209f1b6..4b85014c30 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -673,7 +673,7 @@ def get_physical_port_list(port, physical_port_list): if len(physical_port_list) != 1: click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( ", ".join(physical_port_list), port)) - sys.exit(CONFIG_FAIL) + sys.exit(CONFIG_FAIL) return asic_index From e12a491563170b381420788e01a5fd14eb41b441 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Mon, 29 Mar 2021 18:58:24 +0000 Subject: [PATCH 07/13] fix some syntax Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index 4b85014c30..f808612b7d 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -761,7 +761,7 @@ def download(fwfile, port): status = perform_download_firmware(physical_port, fwfile) - if !status: + if status is not True: rc = False if rc: @@ -810,7 +810,7 @@ def activate(port): physical_port = physical_port_list[0] status = perform_activate_firmware(physical_port, fwfile) - if !status: + if status is not True: rc = False if rc: @@ -859,7 +859,7 @@ def rollback(port): physical_port = physical_port_list[0] status = perform_rollback_firmware(physical_port, fwfile) - if !status: + if status is not True: rc = False if rc: From 19debd84c2312356e3c80bb8b249fd489b4c6554 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Tue, 30 Mar 2021 14:20:29 +0000 Subject: [PATCH 08/13] add logic for show Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 32 ++++++++------- show/muxcable.py | 99 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 117 insertions(+), 14 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index f808612b7d..62ca1fb5a9 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -635,8 +635,6 @@ def setswitchmode(state, port): def get_per_npu_statedb(per_npu_statedb, port_table_keys): - y_cable_asic_table_keys = {} - # Getting all front asic namespace and correspding config and state DB connector namespaces = multi_asic.get_front_end_namespaces() @@ -689,18 +687,18 @@ def perform_download_firmware(physical_port, fwfile): return False -def perform_activate_firmware(physical_port, fwfile): +def perform_activate_firmware(physical_port): import sonic_y_cable.y_cable result = sonic_y_cable.y_cable.activate_firmware(physical_port) if result == sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS: - click.echo("firmware ACTIVATE successful for {}".format(port)) + click.echo("firmware activate successful for {}".format(port)) return True else: - click.echo("firmware ACTIVATE failure for {}".format(port)) + click.echo("firmware activate failure for {}".format(port)) return False -def perform_rollback_firmware(physical_port, fwfile): +def perform_rollback_firmware(physical_port): import sonic_y_cable.y_cable result = sonic_y_cable.y_cable.rollback_firmware(physical_port) if result == sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS: @@ -718,19 +716,20 @@ def firmware(): @firmware.command() -@click.argument('fwfile', metavar='', required=True) +@click.argument('fwfile', metavar='', required=True) @click.argument('port', metavar='', required=True, default=None) def download(fwfile, port): """Config muxcable firmware download""" per_npu_statedb = {} - physical_port_list = [] + y_cable_asic_table_keys = {} port_table_keys = {} get_per_npu_statedb(per_npu_statedb, port_table_keys) if port is not None and port != "all": + physical_port_list = [] get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] if per_npu_statedb[asic_index] is not None: @@ -775,21 +774,22 @@ def download(fwfile, port): def activate(port): """Config muxcable firmware activate""" - port_table_keys = {} - y_cable_asic_table_keys = {} per_npu_statedb = {} + y_cable_asic_table_keys = {} + port_table_keys = {} get_per_npu_statedb(per_npu_statedb, port_table_keys) if port is not None and port != "all": + physical_port_list = [] get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] 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: - perform_activate_firmware(physical_port, fwfile) + perform_activate_firmware(physical_port) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -806,9 +806,11 @@ def activate(port): for key in port_table_keys[asic_id]: port = key.split("|")[1] + physical_port_list = [] + get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] - status = perform_activate_firmware(physical_port, fwfile) + status = perform_activate_firmware(physical_port) if status is not True: rc = False @@ -832,13 +834,14 @@ def rollback(port): if port is not None and port != "all": + physical_port_list = [] get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] 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: - perform_rollback_firmware(physical_port, fwfile) + perform_rollback_firmware(physical_port) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -855,9 +858,10 @@ def rollback(port): for key in port_table_keys[asic_id]: port = key.split("|")[1] + physical_port_list = [] get_physical_port_list(port, physical_port_list) physical_port = physical_port_list[0] - status = perform_rollback_firmware(physical_port, fwfile) + status = perform_rollback_firmware(physical_port) if status is not True: rc = False diff --git a/show/muxcable.py b/show/muxcable.py index 4c053dfd84..bc5e8717c4 100644 --- a/show/muxcable.py +++ b/show/muxcable.py @@ -820,3 +820,102 @@ def switchmode(port): click.echo(tabulate(body, headers=headers)) if rc == False: sys.exit(EXIT_FAIL) + + +def get_firmware_dict(physical_port, target, side, mux_info_dict): + + import sonic_y_cable.y_cable + result = sonic_y_cable.y_cable.get_firmware_version(physical_port, target) + + if result is not None and isinstance(result, dict): + mux_info_dict[("build_slot1_{}".format(side))] = result.get("build_slot1", None) + mux_info_dict[("version_slot1_{}".format(side))] = result.get("version_slot1", None) + mux_info_dict[("build_slot2_{}".format(side))] = result.get("build_slot2", None) + mux_info_dict[("version_slot2_{}".format(side))] = result.get("version_slot2", None) + mux_info_dict[("run_slot1_{}".format(side))] = result.get("run_slot1", None) + mux_info_dict[("run_slot2_{}".format(side))] = result.get("run_slot2", None) + mux_info_dict[("commit_slot1_{}".format(side))] = result.get("commit_slot1", None) + mux_info_dict[("commit_slot2_{}".format(side))] = result.get("commit_slot2", None) + mux_info_dict[("empty_slot1_{}".format(side))] = result.get("empty_slot1", None) + mux_info_dict[("empty_slot2_{}".format(side))] = result.get("empty_slot2", None) + else: + mux_info_dict[("build_slot1_{}".format(side))] = "N/A" + mux_info_dict[("version_slot1_{}".format(side))] = "N/A" + mux_info_dict[("build_slot2_{}".format(side))] = "N/A" + mux_info_dict[("version_slot2_{}".format(side))] = "N/A" + mux_info_dict[("run_slot1_{}".format(side))] = "N/A" + mux_info_dict[("run_slot2_{}".format(side))] = "N/A" + mux_info_dict[("commit_slot1_{}".format(side))] = "N/A" + mux_info_dict[("commit_slot2_{}".format(side))] = "N/A" + mux_info_dict[("empty_slot1_{}".format(side))] = "N/A" + mux_info_dict[("empty_slot2_{}".format(side))] = "N/A" + + +@muxcable.group(cls=clicommon.AbbreviationGroup) +def firmware(): + """Show muxcable firmware command""" + pass + + +@firmware.command() +@click.argument('port', metavar='', required=True, default=None) +def version(port): + """Show muxcable firmware version""" + + port_table_keys = {} + y_cable_asic_table_keys = {} + 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_statedb[asic_id] = swsscommon.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": + + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + + asic_index = None + if platform_sfputil is not None: + asic_index = platform_sfputil_helper.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)) + + if not isinstance(physical_port_list, list): + click.echo(("ERR: Unable to locate physical port information for {}".format(port))) + sys.exit(CONFIG_FAIL) + + if len(physical_port_list) != 1: + click.echo("ERR: Found multiple physical ports ({}) associated with {}".format( + ", ".join(physical_port_list), port)) + sys.exit(CONFIG_FAIL) + + mux_info_dict = {} + physical_port = physical_port_list[0] + 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: + get_firmware_dict(physical_port, 0, "nic", mux_info_dict) + get_firmware_dict(physical_port, 1, "tor1", mux_info_dict) + get_firmware_dict(physical_port, 2, "tor2", mux_info_dict) + click.echo("{}".format(json.dumps(mux_info_dict, indent=4))) + + 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 table for this asic_index".format(asic_index)) From 52ece4bbcfa563126254197b0440cca0a94a74a1 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Tue, 30 Mar 2021 19:33:37 +0000 Subject: [PATCH 09/13] fix comment/ add more logic Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 28 +++++--------- show/muxcable.py | 94 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+), 19 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index 62ca1fb5a9..2bb33f5cb2 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -747,7 +747,7 @@ def download(fwfile, port): elif port == "all" and port is not None: - rc = True + rc = CONFIG_SUCCESSFUL for namespace in namespaces: asic_id = multi_asic.get_asic_index_from_namespace(namespace) for key in port_table_keys[asic_id]: @@ -761,12 +761,9 @@ def download(fwfile, port): status = perform_download_firmware(physical_port, fwfile) if status is not True: - rc = False + rc = CONFIG_FAIL - if rc: - sys.exit(CONFIG_SUCCESSFUL) - else: - sys.exit(CONFIG_FAIL) + sys.exit(rc) @firmware.command() @@ -800,7 +797,7 @@ def activate(port): elif port == "all" and port is not None: - rc = True + rc = CONFIG_SUCCESSFUL for namespace in namespaces: asic_id = multi_asic.get_asic_index_from_namespace(namespace) for key in port_table_keys[asic_id]: @@ -813,13 +810,9 @@ def activate(port): status = perform_activate_firmware(physical_port) if status is not True: - rc = False - - if rc: - sys.exit(CONFIG_SUCCESSFUL) - else: - sys.exit(CONFIG_FAIL) + rc = CONFIG_FAIL + sys.exit(rc) @firmware.command() @click.argument('port', metavar='', required=True, default=None) @@ -852,7 +845,7 @@ def rollback(port): elif port == "all" and port is not None: - rc = True + rc = CONFIG_SUCCESSFUL for namespace in namespaces: asic_id = multi_asic.get_asic_index_from_namespace(namespace) for key in port_table_keys[asic_id]: @@ -864,9 +857,6 @@ def rollback(port): status = perform_rollback_firmware(physical_port) if status is not True: - rc = False + rc = CONFIG_FAIL - if rc: - sys.exit(CONFIG_SUCCESSFUL) - else: - sys.exit(CONFIG_FAIL) + sys.exit(rc) diff --git a/show/muxcable.py b/show/muxcable.py index bc5e8717c4..74476acd73 100644 --- a/show/muxcable.py +++ b/show/muxcable.py @@ -822,6 +822,97 @@ def switchmode(port): sys.exit(EXIT_FAIL) +def create_result_dict(physical_port, mux_info_dict, result_dict): + + import sonic_y_cable.y_cable + read_side = sonic_y_cable.y_cable.check_read_side(physical_port) + + version_build_slot1_nic = mux_info_dict[("version_slot1_nic".format(side))] + \ + mux_info_dict[("build_slot1_nic".format(side))] + version_build_slot2_nic = mux_info_dict[("version_slot2_nic".format(side))] + \ + mux_info_dict[("build_slot2_nic".format(side))] + version_build_slot1_tor1 = mux_info_dict[("version_slot1_tor1".format(side))] + \ + mux_info_dict[("build_slot1_tor1".format(side))] + version_build_slot2_tor1 = mux_info_dict[("version_slot2_tor1".format(side))] + \ + mux_info_dict[("build_slot2_tor1".format(side))] + version_build_slot1_tor2 = mux_info_dict[("version_slot1_tor2".format(side))] + \ + mux_info_dict[("build_slot1_tor2".format(side))] + version_build_slot2_tor2 = mux_info_dict[("version_slot2_tor2".format(side))] + \ + mux_info_dict[("build_slot2_tor2".format(side))] + + if read_side == 1: + if mux_info_dict[("run_slot1_tor1".format(side))] == "True": + # slot 1 is active for self + result_dict["version_self_active"] = version_build_slot1_tor1 + result_dict["version_self_inactive"] = version_build_slot2_tor1 + elif mux_info_dict[("run_slot2_tor1".format(side))] == "True": + # slot 2 is active for self + result_dict["version_self_active"] = version_build_slot2_tor1 + result_dict["version_self_inactive"] = version_build_slot1_tor1 + + if mux_info_dict[("run_slot1_tor2".format(side))] == "True": + # slot 1 is active for peer + result_dict["version_peer_active"] = version_build_slot1_tor2 + result_dict["version_peer_inactive"] = version_build_slot2_tor2 + elif mux_info_dict[("run_slot2_tor2".format(side))] == "True": + # slot 2 is active for peer + result_dict["version_peer_active"] = version_build_slot2_tor2 + result_dict["version_peer_inactive"] = version_build_slot1_tor2 + + if mux_info_dict[("commit_slot1_tor1".format(side))] == "True": + result_dict["version_self_next"] = version_build_slot1_tor1 + elif mux_info_dict[("commit_slot2_tor1".format(side))] == "True": + result_dict["version_self_next"] = version_build_slot2_tor1 + + if mux_info_dict[("commit_slot1_tor2".format(side))] == "True": + result_dict["version_peer_next"] = version_build_slot1_tor2 + elif mux_info_dict[("commit_slot2_tor2".format(side))] == "True": + result_dict["version_peer_next"] = version_build_slot2_tor2 + + elif read_side == 2: + if mux_info_dict[("run_slot1_tor2".format(side))] == "True": + # slot 1 is active for self + result_dict["version_self_active"] = version_build_slot1_tor2 + result_dict["version_self_inactive"] = version_build_slot2_tor2 + elif mux_info_dict[("run_slot2_tor2".format(side))] == "True": + # slot 2 is active for self + result_dict["version_self_active"] = version_build_slot2_tor2 + result_dict["version_self_inactive"] = version_build_slot1_tor2 + + if mux_info_dict[("run_slot1_tor1".format(side))] == "True": + # slot 1 is active for peer + result_dict["version_peer_active"] = version_build_slot1_tor1 + result_dict["version_peer_inactive"] = version_build_slot2_tor1 + elif mux_info_dict[("run_slot2_tor1".format(side))] == "True": + # slot 2 is active for peer + result_dict["version_peer_active"] = version_build_slot2_tor1 + result_dict["version_peer_inactive"] = version_build_slot1_tor1 + + if mux_info_dict[("commit_slot1_tor2".format(side))] == "True": + result_dict["version_self_next"] = version_build_slot1_tor2 + elif mux_info_dict[("commit_slot2_tor2".format(side))] == "True": + result_dict["version_self_next"] = version_build_slot2_tor2 + + if mux_info_dict[("commit_slot1_tor1".format(side))] == "True": + result_dict["version_peer_next"] = version_build_slot1_tor1 + elif mux_info_dict[("commit_slot2_tor1".format(side))] == "True": + result_dict["version_peer_next"] = version_build_slot2_tor1 + + if mux_info_dict[("run_slot1_nic".format(side))] == "True": + # slot 1 is active for self + result_dict["version_nic_active"] = version_build_slot1_nic + result_dict["version_nic_inactive"] = version_build_slot2_nic + elif mux_info_dict[("run_slot2_nic".format(side))] == "True": + # slot 2 is active for self + result_dict["version_nic_active"] = version_build_slot2_nic + result_dict["version_nic_inactive"] = version_build_slot1_nic + + if mux_info_dict[("commit_slot1_nic".format(side))] == "True": + result_dict["version_nic_next"] = version_build_slot1_nic + elif mux_info_dict[("commit_slot2_nic".format(side))] == "True": + result_dict["version_nic_next"] = version_build_slot2_nic + + def get_firmware_dict(physical_port, target, side, mux_info_dict): import sonic_y_cable.y_cable @@ -838,6 +929,7 @@ def get_firmware_dict(physical_port, target, side, mux_info_dict): mux_info_dict[("commit_slot2_{}".format(side))] = result.get("commit_slot2", None) mux_info_dict[("empty_slot1_{}".format(side))] = result.get("empty_slot1", None) mux_info_dict[("empty_slot2_{}".format(side))] = result.get("empty_slot2", None) + else: mux_info_dict[("build_slot1_{}".format(side))] = "N/A" mux_info_dict[("version_slot1_{}".format(side))] = "N/A" @@ -904,6 +996,7 @@ def version(port): sys.exit(CONFIG_FAIL) mux_info_dict = {} + result_dict = {} physical_port = physical_port_list[0] if per_npu_statedb[asic_index] is not None: y_cable_asic_table_keys = port_table_keys[asic_index] @@ -912,6 +1005,7 @@ def version(port): get_firmware_dict(physical_port, 0, "nic", mux_info_dict) get_firmware_dict(physical_port, 1, "tor1", mux_info_dict) get_firmware_dict(physical_port, 2, "tor2", mux_info_dict) + create_result_dict(physical_port, mux_info_dict, result_dict): click.echo("{}".format(json.dumps(mux_info_dict, indent=4))) else: From 77b187417075fe12cfe03a269684ef10c5d3c9f9 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Tue, 30 Mar 2021 20:09:21 +0000 Subject: [PATCH 10/13] fix LGTM Signed-off-by: vaibhav-dahiya --- show/muxcable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/show/muxcable.py b/show/muxcable.py index 74476acd73..a3199d5cbd 100644 --- a/show/muxcable.py +++ b/show/muxcable.py @@ -1005,7 +1005,7 @@ def version(port): get_firmware_dict(physical_port, 0, "nic", mux_info_dict) get_firmware_dict(physical_port, 1, "tor1", mux_info_dict) get_firmware_dict(physical_port, 2, "tor2", mux_info_dict) - create_result_dict(physical_port, mux_info_dict, result_dict): + create_result_dict(physical_port, mux_info_dict, result_dict) click.echo("{}".format(json.dumps(mux_info_dict, indent=4))) else: From f1c1550dbe89fa8c303d34c6c6bd8a2f422b2c54 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Sun, 4 Apr 2021 22:51:14 +0000 Subject: [PATCH 11/13] add unit Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 39 ++++++----- show/muxcable.py | 151 +++++++++-------------------------------- tests/muxcable_test.py | 84 +++++++++++++++++++++++ 3 files changed, 138 insertions(+), 136 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index 2bb33f5cb2..baa29b55cd 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -648,8 +648,9 @@ def get_per_npu_statedb(per_npu_statedb, port_table_keys): per_npu_statedb[asic_id].STATE_DB, 'MUX_CABLE_TABLE|*') -def get_physical_port_list(port, physical_port_list): +def get_physical_port_list(port): + physical_port_list = [] if platform_sfputil is not None: physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) @@ -673,10 +674,10 @@ def get_physical_port_list(port, physical_port_list): ", ".join(physical_port_list), port)) sys.exit(CONFIG_FAIL) - return asic_index + return (physical_port_list, asic_index) -def perform_download_firmware(physical_port, fwfile): +def perform_download_firmware(physical_port, fwfile, port): import sonic_y_cable.y_cable result = sonic_y_cable.y_cable.download_firmware(physical_port, fwfile) if result == sonic_y_cable.y_cable.FIRMWARE_DOWNLOAD_SUCCESS: @@ -687,7 +688,7 @@ def perform_download_firmware(physical_port, fwfile): return False -def perform_activate_firmware(physical_port): +def perform_activate_firmware(physical_port, port): import sonic_y_cable.y_cable result = sonic_y_cable.y_cable.activate_firmware(physical_port) if result == sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS: @@ -698,7 +699,7 @@ def perform_activate_firmware(physical_port): return False -def perform_rollback_firmware(physical_port): +def perform_rollback_firmware(physical_port, port): import sonic_y_cable.y_cable result = sonic_y_cable.y_cable.rollback_firmware(physical_port) if result == sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS: @@ -730,13 +731,16 @@ def download(fwfile, port): if port is not None and port != "all": physical_port_list = [] - get_physical_port_list(port, physical_port_list) + physical_port_list, asic_index = get_physical_port_list(port) + f = open("demofile2.txt", "w") + f.write("yes ") + f.write("{} ".format(len(physical_port_list))) physical_port = physical_port_list[0] 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: - perform_download_firmware(physical_port, fwfile) + perform_download_firmware(physical_port, fwfile, port) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -754,11 +758,11 @@ def download(fwfile, port): port = key.split("|")[1] physical_port_list = [] - get_physical_port_list(port, physical_port_list) + (physical_port_list, asic_index) = get_physical_port_list(port) physical_port = physical_port_list[0] - status = perform_download_firmware(physical_port, fwfile) + status = perform_download_firmware(physical_port, fwfile, port) if status is not True: rc = CONFIG_FAIL @@ -780,13 +784,13 @@ def activate(port): if port is not None and port != "all": physical_port_list = [] - get_physical_port_list(port, physical_port_list) + (physical_port_list, asic_index) = get_physical_port_list(port) physical_port = physical_port_list[0] 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: - perform_activate_firmware(physical_port) + perform_activate_firmware(physical_port, port) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -805,15 +809,16 @@ def activate(port): physical_port_list = [] - get_physical_port_list(port, physical_port_list) + (physical_port_list, asic_index) = get_physical_port_list(port) physical_port = physical_port_list[0] - status = perform_activate_firmware(physical_port) + status = perform_activate_firmware(physical_port, port) if status is not True: rc = CONFIG_FAIL sys.exit(rc) + @firmware.command() @click.argument('port', metavar='', required=True, default=None) def rollback(port): @@ -828,13 +833,13 @@ def rollback(port): if port is not None and port != "all": physical_port_list = [] - get_physical_port_list(port, physical_port_list) + (physical_port_list, asic_index) = get_physical_port_list(port) physical_port = physical_port_list[0] 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: - perform_rollback_firmware(physical_port) + perform_rollback_firmware(physical_port, port) else: click.echo("this is not a valid port present on mux_cable".format(port)) @@ -852,9 +857,9 @@ def rollback(port): port = key.split("|")[1] physical_port_list = [] - get_physical_port_list(port, physical_port_list) + (physical_port_list, asic_index) = get_physical_port_list(port) physical_port = physical_port_list[0] - status = perform_rollback_firmware(physical_port) + status = perform_rollback_firmware(physical_port, port) if status is not True: rc = CONFIG_FAIL diff --git a/show/muxcable.py b/show/muxcable.py index a3199d5cbd..94e9a33266 100644 --- a/show/muxcable.py +++ b/show/muxcable.py @@ -8,6 +8,7 @@ from natsort import natsorted from sonic_py_common import multi_asic from swsscommon.swsscommon import SonicV2Connector, ConfigDBConnector +from swsscommon import swsscommon from tabulate import tabulate from utilities_common import platform_sfputil_helper @@ -822,125 +823,20 @@ def switchmode(port): sys.exit(EXIT_FAIL) -def create_result_dict(physical_port, mux_info_dict, result_dict): - - import sonic_y_cable.y_cable - read_side = sonic_y_cable.y_cable.check_read_side(physical_port) - - version_build_slot1_nic = mux_info_dict[("version_slot1_nic".format(side))] + \ - mux_info_dict[("build_slot1_nic".format(side))] - version_build_slot2_nic = mux_info_dict[("version_slot2_nic".format(side))] + \ - mux_info_dict[("build_slot2_nic".format(side))] - version_build_slot1_tor1 = mux_info_dict[("version_slot1_tor1".format(side))] + \ - mux_info_dict[("build_slot1_tor1".format(side))] - version_build_slot2_tor1 = mux_info_dict[("version_slot2_tor1".format(side))] + \ - mux_info_dict[("build_slot2_tor1".format(side))] - version_build_slot1_tor2 = mux_info_dict[("version_slot1_tor2".format(side))] + \ - mux_info_dict[("build_slot1_tor2".format(side))] - version_build_slot2_tor2 = mux_info_dict[("version_slot2_tor2".format(side))] + \ - mux_info_dict[("build_slot2_tor2".format(side))] - - if read_side == 1: - if mux_info_dict[("run_slot1_tor1".format(side))] == "True": - # slot 1 is active for self - result_dict["version_self_active"] = version_build_slot1_tor1 - result_dict["version_self_inactive"] = version_build_slot2_tor1 - elif mux_info_dict[("run_slot2_tor1".format(side))] == "True": - # slot 2 is active for self - result_dict["version_self_active"] = version_build_slot2_tor1 - result_dict["version_self_inactive"] = version_build_slot1_tor1 - - if mux_info_dict[("run_slot1_tor2".format(side))] == "True": - # slot 1 is active for peer - result_dict["version_peer_active"] = version_build_slot1_tor2 - result_dict["version_peer_inactive"] = version_build_slot2_tor2 - elif mux_info_dict[("run_slot2_tor2".format(side))] == "True": - # slot 2 is active for peer - result_dict["version_peer_active"] = version_build_slot2_tor2 - result_dict["version_peer_inactive"] = version_build_slot1_tor2 - - if mux_info_dict[("commit_slot1_tor1".format(side))] == "True": - result_dict["version_self_next"] = version_build_slot1_tor1 - elif mux_info_dict[("commit_slot2_tor1".format(side))] == "True": - result_dict["version_self_next"] = version_build_slot2_tor1 - - if mux_info_dict[("commit_slot1_tor2".format(side))] == "True": - result_dict["version_peer_next"] = version_build_slot1_tor2 - elif mux_info_dict[("commit_slot2_tor2".format(side))] == "True": - result_dict["version_peer_next"] = version_build_slot2_tor2 - - elif read_side == 2: - if mux_info_dict[("run_slot1_tor2".format(side))] == "True": - # slot 1 is active for self - result_dict["version_self_active"] = version_build_slot1_tor2 - result_dict["version_self_inactive"] = version_build_slot2_tor2 - elif mux_info_dict[("run_slot2_tor2".format(side))] == "True": - # slot 2 is active for self - result_dict["version_self_active"] = version_build_slot2_tor2 - result_dict["version_self_inactive"] = version_build_slot1_tor2 - - if mux_info_dict[("run_slot1_tor1".format(side))] == "True": - # slot 1 is active for peer - result_dict["version_peer_active"] = version_build_slot1_tor1 - result_dict["version_peer_inactive"] = version_build_slot2_tor1 - elif mux_info_dict[("run_slot2_tor1".format(side))] == "True": - # slot 2 is active for peer - result_dict["version_peer_active"] = version_build_slot2_tor1 - result_dict["version_peer_inactive"] = version_build_slot1_tor1 - - if mux_info_dict[("commit_slot1_tor2".format(side))] == "True": - result_dict["version_self_next"] = version_build_slot1_tor2 - elif mux_info_dict[("commit_slot2_tor2".format(side))] == "True": - result_dict["version_self_next"] = version_build_slot2_tor2 - - if mux_info_dict[("commit_slot1_tor1".format(side))] == "True": - result_dict["version_peer_next"] = version_build_slot1_tor1 - elif mux_info_dict[("commit_slot2_tor1".format(side))] == "True": - result_dict["version_peer_next"] = version_build_slot2_tor1 - - if mux_info_dict[("run_slot1_nic".format(side))] == "True": - # slot 1 is active for self - result_dict["version_nic_active"] = version_build_slot1_nic - result_dict["version_nic_inactive"] = version_build_slot2_nic - elif mux_info_dict[("run_slot2_nic".format(side))] == "True": - # slot 2 is active for self - result_dict["version_nic_active"] = version_build_slot2_nic - result_dict["version_nic_inactive"] = version_build_slot1_nic - - if mux_info_dict[("commit_slot1_nic".format(side))] == "True": - result_dict["version_nic_next"] = version_build_slot1_nic - elif mux_info_dict[("commit_slot2_nic".format(side))] == "True": - result_dict["version_nic_next"] = version_build_slot2_nic - - def get_firmware_dict(physical_port, target, side, mux_info_dict): import sonic_y_cable.y_cable result = sonic_y_cable.y_cable.get_firmware_version(physical_port, target) if result is not None and isinstance(result, dict): - mux_info_dict[("build_slot1_{}".format(side))] = result.get("build_slot1", None) - mux_info_dict[("version_slot1_{}".format(side))] = result.get("version_slot1", None) - mux_info_dict[("build_slot2_{}".format(side))] = result.get("build_slot2", None) - mux_info_dict[("version_slot2_{}".format(side))] = result.get("version_slot2", None) - mux_info_dict[("run_slot1_{}".format(side))] = result.get("run_slot1", None) - mux_info_dict[("run_slot2_{}".format(side))] = result.get("run_slot2", None) - mux_info_dict[("commit_slot1_{}".format(side))] = result.get("commit_slot1", None) - mux_info_dict[("commit_slot2_{}".format(side))] = result.get("commit_slot2", None) - mux_info_dict[("empty_slot1_{}".format(side))] = result.get("empty_slot1", None) - mux_info_dict[("empty_slot2_{}".format(side))] = result.get("empty_slot2", None) + mux_info_dict[("version_{}_active".format(side))] = result.get("version_active", None) + mux_info_dict[("version_{}_inactive".format(side))] = result.get("version_inactive", None) + mux_info_dict[("version_{}_next".format(side))] = result.get("version_next", None) else: - mux_info_dict[("build_slot1_{}".format(side))] = "N/A" - mux_info_dict[("version_slot1_{}".format(side))] = "N/A" - mux_info_dict[("build_slot2_{}".format(side))] = "N/A" - mux_info_dict[("version_slot2_{}".format(side))] = "N/A" - mux_info_dict[("run_slot1_{}".format(side))] = "N/A" - mux_info_dict[("run_slot2_{}".format(side))] = "N/A" - mux_info_dict[("commit_slot1_{}".format(side))] = "N/A" - mux_info_dict[("commit_slot2_{}".format(side))] = "N/A" - mux_info_dict[("empty_slot1_{}".format(side))] = "N/A" - mux_info_dict[("empty_slot2_{}".format(side))] = "N/A" + mux_info_dict[("version_{}_active".format(side))] = "N/A" + mux_info_dict[("version_{}_inactive".format(side))] = "N/A" + mux_info_dict[("version_{}_next".format(side))] = "N/A" @muxcable.group(cls=clicommon.AbbreviationGroup) @@ -957,6 +853,7 @@ def version(port): port_table_keys = {} y_cable_asic_table_keys = {} per_npu_statedb = {} + physical_port_list = [] # Getting all front asic namespace and correspding config and state DB connector @@ -970,10 +867,13 @@ def version(port): 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": + if port is not None: - if platform_sfputil is not None: - physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + logical_port_list = platform_sfputil_helper.get_logical_list() + + if port not in logical_port_list: + click.echo(("ERR: Not a valid logical port for muxcable firmware {}".format(port))) + sys.exit(CONFIG_FAIL) asic_index = None if platform_sfputil is not None: @@ -986,6 +886,9 @@ def version(port): if asic_index is None: click.echo("Got invalid asic index for port {}, cant retreive mux status".format(port)) + if platform_sfputil is not None: + physical_port_list = platform_sfputil_helper.logical_port_name_to_physical_port_list(port) + if not isinstance(physical_port_list, list): click.echo(("ERR: Unable to locate physical port information for {}".format(port))) sys.exit(CONFIG_FAIL) @@ -1001,12 +904,22 @@ def version(port): 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) + import sonic_y_cable.y_cable + read_side = sonic_y_cable.y_cable.check_read_side(physical_port) if logical_key in y_cable_asic_table_keys: - get_firmware_dict(physical_port, 0, "nic", mux_info_dict) - get_firmware_dict(physical_port, 1, "tor1", mux_info_dict) - get_firmware_dict(physical_port, 2, "tor2", mux_info_dict) - create_result_dict(physical_port, mux_info_dict, result_dict) - click.echo("{}".format(json.dumps(mux_info_dict, indent=4))) + if read_side == 1: + get_firmware_dict(physical_port, 1, "self", mux_info_dict) + get_firmware_dict(physical_port, 2, "peer", mux_info_dict) + get_firmware_dict(physical_port, 0, "nic", mux_info_dict) + click.echo("{}".format(json.dumps(mux_info_dict, indent=4))) + elif read_side == 2: + get_firmware_dict(physical_port, 2, "self", mux_info_dict) + get_firmware_dict(physical_port, 1, "peer", mux_info_dict) + get_firmware_dict(physical_port, 0, "nic", mux_info_dict) + click.echo("{}".format(json.dumps(mux_info_dict, indent=4))) + else: + click.echo("Did not get a valid read_side for muxcable".format(port)) + sys.exit(CONFIG_FAIL) else: click.echo("this is not a valid port present on mux_cable".format(port)) diff --git a/tests/muxcable_test.py b/tests/muxcable_test.py index 9f91a0336b..a28662e21a 100644 --- a/tests/muxcable_test.py +++ b/tests/muxcable_test.py @@ -175,6 +175,20 @@ Ethernet12 standby """ +show_muxcable_firmware_version_expected_output = """\ +{ + "version_self_active": "0.6MS", + "version_self_inactive": "0.6MS", + "version_self_next": "0.6MS", + "version_peer_active": "0.6MS", + "version_peer_inactive": "0.6MS", + "version_peer_next": "0.6MS", + "version_nic_active": "0.6MS", + "version_nic_inactive": "0.6MS", + "version_nic_next": "0.6MS" +} +""" + class TestMuxcable(object): @classmethod @@ -696,6 +710,76 @@ def test_config_muxcable_hwmode_state_standby(self): ["standby", "all"], obj=db) assert result.exit_code == 0 + @mock.patch('utilities_common.platform_sfputil_helper.get_logical_list', mock.MagicMock(return_value=["Ethernet0", "Ethernet12"])) + @mock.patch('utilities_common.platform_sfputil_helper.get_asic_id_for_logical_port', mock.MagicMock(return_value=0)) + @mock.patch('show.muxcable.platform_sfputil', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.get_physical_to_logical', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.logical_port_name_to_physical_port_list', mock.MagicMock(return_value=[0])) + @mock.patch('sonic_y_cable.y_cable.check_read_side', mock.MagicMock(return_value=(1))) + @mock.patch('click.confirm', mock.MagicMock(return_value=("y"))) + @mock.patch('sonic_y_cable.y_cable.get_firmware_version', mock.MagicMock(return_value={"version_active": "0.6MS", + "version_inactive": "0.6MS", + "version_next": "0.6MS"})) + def test_show_muxcable_firmware_version(self): + runner = CliRunner() + db = Db() + + result = runner.invoke(show.cli.commands["muxcable"].commands["firmware"].commands["version"], [ + "Ethernet0"], obj=db) + assert result.exit_code == 0 + assert result.output == show_muxcable_firmware_version_expected_output + + @mock.patch('utilities_common.platform_sfputil_helper.get_logical_list', mock.MagicMock(return_value=["Ethernet0", "Ethernet12"])) + @mock.patch('utilities_common.platform_sfputil_helper.get_asic_id_for_logical_port', mock.MagicMock(return_value=0)) + @mock.patch('config.muxcable.platform_sfputil', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.get_physical_to_logical', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.logical_port_name_to_physical_port_list', mock.MagicMock(return_value=[0])) + @mock.patch('sonic_y_cable.y_cable.check_read_side', mock.MagicMock(return_value=(1))) + @mock.patch('click.confirm', mock.MagicMock(return_value=("y"))) + @mock.patch('sonic_y_cable.y_cable.download_fimware', mock.MagicMock(return_value=(1))) + @mock.patch('sonic_y_cable.y_cable.FIRMWARE_DOWNLOAD_SUCCESS', mock.MagicMock(return_value=(1))) + def test_config_muxcable_download_firmware(self): + runner = CliRunner() + db = Db() + + result = runner.invoke(config.config.commands["muxcable"].commands["firmware"].commands["download"], [ + "fwfile", "Ethernet0"], obj=db) + assert result.exit_code == 0 + + @mock.patch('utilities_common.platform_sfputil_helper.get_logical_list', mock.MagicMock(return_value=["Ethernet0", "Ethernet12"])) + @mock.patch('utilities_common.platform_sfputil_helper.get_asic_id_for_logical_port', mock.MagicMock(return_value=0)) + @mock.patch('config.muxcable.platform_sfputil', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.get_physical_to_logical', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.logical_port_name_to_physical_port_list', mock.MagicMock(return_value=[0])) + @mock.patch('sonic_y_cable.y_cable.check_read_side', mock.MagicMock(return_value=(1))) + @mock.patch('click.confirm', mock.MagicMock(return_value=("y"))) + @mock.patch('sonic_y_cable.y_cable.activate_firmware', mock.MagicMock(return_value=(1))) + @mock.patch('sonic_y_cable.y_cable.FIRMWARE_ACTIVATE_SUCCESS', mock.MagicMock(return_value=(1))) + def test_config_muxcable_activate_firmware(self): + runner = CliRunner() + db = Db() + + result = runner.invoke(config.config.commands["muxcable"].commands["firmware"].commands["activate"], [ + "Ethernet0"], obj=db) + assert result.exit_code == 0 + + @mock.patch('utilities_common.platform_sfputil_helper.get_logical_list', mock.MagicMock(return_value=["Ethernet0", "Ethernet12"])) + @mock.patch('utilities_common.platform_sfputil_helper.get_asic_id_for_logical_port', mock.MagicMock(return_value=0)) + @mock.patch('config.muxcable.platform_sfputil', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.get_physical_to_logical', mock.MagicMock(return_value={0: ["Ethernet12", "Ethernet0"]})) + @mock.patch('utilities_common.platform_sfputil_helper.logical_port_name_to_physical_port_list', mock.MagicMock(return_value=[0])) + @mock.patch('sonic_y_cable.y_cable.check_read_side', mock.MagicMock(return_value=(1))) + @mock.patch('click.confirm', mock.MagicMock(return_value=("y"))) + @mock.patch('sonic_y_cable.y_cable.rollback_firmware', mock.MagicMock(return_value=(1))) + @mock.patch('sonic_y_cable.y_cable.FIRMWARE_ROLLBACK_SUCCESS', mock.MagicMock(return_value=(1))) + def test_config_muxcable_rollback_firmware(self): + runner = CliRunner() + db = Db() + + result = runner.invoke(config.config.commands["muxcable"].commands["firmware"].commands["rollback"], [ + "Ethernet0"], obj=db) + assert result.exit_code == 0 + @classmethod def teardown_class(cls): os.environ['UTILITIES_UNIT_TESTING'] = "0" From 70004f49195b1f7102fa3eb21dfa3c4070ed5b27 Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Mon, 5 Apr 2021 16:34:31 +0000 Subject: [PATCH 12/13] fix LGTM Signed-off-by: vaibhav-dahiya --- show/muxcable.py | 1 - 1 file changed, 1 deletion(-) diff --git a/show/muxcable.py b/show/muxcable.py index 94e9a33266..15a846666f 100644 --- a/show/muxcable.py +++ b/show/muxcable.py @@ -899,7 +899,6 @@ def version(port): sys.exit(CONFIG_FAIL) mux_info_dict = {} - result_dict = {} physical_port = physical_port_list[0] if per_npu_statedb[asic_index] is not None: y_cable_asic_table_keys = port_table_keys[asic_index] From 1af160c4ce71a56c3c72bcd3a581d27887fcdc8f Mon Sep 17 00:00:00 2001 From: vaibhav-dahiya Date: Mon, 5 Apr 2021 17:56:16 +0000 Subject: [PATCH 13/13] remove debug statements Signed-off-by: vaibhav-dahiya --- config/muxcable.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/config/muxcable.py b/config/muxcable.py index baa29b55cd..965bceb6de 100644 --- a/config/muxcable.py +++ b/config/muxcable.py @@ -732,9 +732,6 @@ def download(fwfile, port): physical_port_list = [] physical_port_list, asic_index = get_physical_port_list(port) - f = open("demofile2.txt", "w") - f.write("yes ") - f.write("{} ".format(len(physical_port_list))) physical_port = physical_port_list[0] if per_npu_statedb[asic_index] is not None: y_cable_asic_table_keys = port_table_keys[asic_index]