Add Checkpoint and Rollback for Multi ASIC.

config/main.py

@@ -1168,7 +1168,7 @@ def apply_patch_for_scope(scope_changes, results, config_format, verbose, dry_ru
         log.log_notice(f"'apply-patch' executed successfully for {scope_for_log} by {changes}")
     except Exception as e:
         results[scope_for_log] = {"success": False, "message": str(e)}
-        log.log_error(f"'apply-patch' executed failed for {scope_for_log} by {changes} due to {str(e)}")
+        log.log_warning(f"'apply-patch' executed failed for {scope_for_log} by {changes} due to {str(e)}")
 
 
 # This is our main entrypoint - the main 'config' command
@@ -1397,7 +1397,8 @@ def apply_patch(ctx, patch_file_path, format, dry_run, ignore_non_yang_tables, i
         # Empty case to force validate YANG model.
         if not changes_by_scope:
             asic_list = [multi_asic.DEFAULT_NAMESPACE]
-            asic_list.extend(multi_asic.get_namespace_list())
+            if multi_asic.is_multi_asic():
+                asic_list.extend(multi_asic.get_namespace_list())
             for asic in asic_list:
                 changes_by_scope[asic] = []
 
@@ -1420,6 +1421,11 @@ def apply_patch(ctx, patch_file_path, format, dry_run, ignore_non_yang_tables, i
 
 @config.command()
 @click.argument('target-file-path', type=str, required=True)
+@click.option('-s', '--scope',
+              help='Specify the namespace for Multi-ASIC environments. For Single-ASIC environments, \
+                specifying the namespace is not required.',
+              required=True if multi_asic.is_multi_asic() else False,
+              type=click.Choice(multi_asic.get_namespace_list() + ['localhost']))
 @click.option('-f', '--format', type=click.Choice([e.name for e in ConfigFormat]),
                default=ConfigFormat.CONFIGDB.name,
                help='format of target config is either ConfigDb(ABNF) or SonicYang',
@@ -1429,14 +1435,17 @@ def apply_patch(ctx, patch_file_path, format, dry_run, ignore_non_yang_tables, i
 @click.option('-i', '--ignore-path', multiple=True, help='ignore validation for config specified by given path which is a JsonPointer', hidden=True)
 @click.option('-v', '--verbose', is_flag=True, default=False, help='print additional details of what the operation is doing')
 @click.pass_context
-def replace(ctx, target_file_path, format, dry_run, ignore_non_yang_tables, ignore_path, verbose):
+def replace(ctx, target_file_path, scope, format, dry_run, ignore_non_yang_tables, ignore_path, verbose):
     """Replace the whole config with the specified config. The config is replaced with minimum disruption e.g.
        if ACL config is different between current and target config only ACL config is updated, and other config/services
        such as DHCP will not be affected.
 
        **WARNING** The target config file should be the whole config, not just the part intended to be updated.
 
-       <target-file-path>: Path to the target file on the file-system."""
+       <target-file-path>: Path to the target file on the file-system.
+       If the device is a Multi-ASIC environment, please give the namespace of specific ASIC, for instance:
+        localhost, asic0, asic1, ...
+       """
     try:
         print_dry_run_message(dry_run)
 
@@ -1445,8 +1454,14 @@ def replace(ctx, target_file_path, format, dry_run, ignore_non_yang_tables, igno
             target_config = json.loads(target_config_as_text)
 
         config_format = ConfigFormat[format.upper()]
-
-        GenericUpdater().replace(target_config, config_format, verbose, dry_run, ignore_non_yang_tables, ignore_path)
+        if multi_asic.is_multi_asic():
+            if scope not in (multi_asic.get_namespace_list() + ["localhost"]):
+                raise Exception(f"Failed to replace config due to wrong namespace:{scope}")
+            scope = scope if scope != "localhost" else multi_asic.DEFAULT_NAMESPACE
+        else:
+            scope = multi_asic.DEFAULT_NAMESPACE
+        GenericUpdater(namespace=scope).replace(target_config, config_format, verbose, dry_run,
+                                                ignore_non_yang_tables, ignore_path)
 
         click.secho("Config replaced successfully.", fg="cyan", underline=True)
     except Exception as ex:
@@ -1468,8 +1483,12 @@ def rollback(ctx, checkpoint_name, dry_run, ignore_non_yang_tables, ignore_path,
        <checkpoint-name>: The checkpoint name, use `config list-checkpoints` command to see available checkpoints."""
     try:
         print_dry_run_message(dry_run)
-
-        GenericUpdater().rollback(checkpoint_name, verbose, dry_run, ignore_non_yang_tables, ignore_path)
+        asic_list = [multi_asic.DEFAULT_NAMESPACE]
+        if multi_asic.is_multi_asic():
+            asic_list.extend(multi_asic.get_namespace_list())
+        for asic in asic_list:
+            GenericUpdater(namespace=asic).rollback(checkpoint_name, verbose, dry_run,
+                                                    ignore_non_yang_tables, ignore_path)
 
         click.secho("Config rolled back successfully.", fg="cyan", underline=True)
     except Exception as ex:
@@ -1485,7 +1504,11 @@ def checkpoint(ctx, checkpoint_name, verbose):
 
        <checkpoint-name>: The checkpoint name, use `config list-checkpoints` command to see available checkpoints."""
     try:
-        GenericUpdater().checkpoint(checkpoint_name, verbose)
+        asic_list = [multi_asic.DEFAULT_NAMESPACE]
+        if multi_asic.is_multi_asic():
+            asic_list.extend(multi_asic.get_namespace_list())
+        for asic in asic_list:
+            GenericUpdater(namespace=asic).checkpoint(checkpoint_name, verbose)
 
         click.secho("Checkpoint created successfully.", fg="cyan", underline=True)
     except Exception as ex:
@@ -1501,7 +1524,11 @@ def delete_checkpoint(ctx, checkpoint_name, verbose):
 
        <checkpoint-name>: The checkpoint name, use `config list-checkpoints` command to see available checkpoints."""
     try:
-        GenericUpdater().delete_checkpoint(checkpoint_name, verbose)
+        asic_list = [multi_asic.DEFAULT_NAMESPACE]
+        if multi_asic.is_multi_asic():
+            asic_list.extend(multi_asic.get_namespace_list())
+        for asic in asic_list:
+            GenericUpdater(namespace=asic).delete_checkpoint(checkpoint_name, verbose)
 
         click.secho("Checkpoint deleted successfully.", fg="cyan", underline=True)
     except Exception as ex:

generic_config_updater/generic_updater.py

@@ -84,14 +84,14 @@ def apply(self, patch, sort=True):
         self.config_wrapper.validate_field_operation(old_config, target_config)
 
         # Validate target config does not have empty tables since they do not show up in ConfigDb
-        self.logger.log_notice(f"{scope}: alidating target config does not have empty tables, " \
-                               "since they do not show up in ConfigDb.")
+        self.logger.log_notice(f"{scope}: validating target config does not have empty tables, \
+                               since they do not show up in ConfigDb.")
         empty_tables = self.config_wrapper.get_empty_tables(target_config)
         if empty_tables: # if there are empty tables
             empty_tables_txt = ", ".join(empty_tables)
-            raise EmptyTableError(f"{scope}: given patch is not valid because it will result in empty tables " \
-                             "which is not allowed in ConfigDb. " \
-                            f"Table{'s' if len(empty_tables) != 1 else ''}: {empty_tables_txt}")
+            raise EmptyTableError(f"{scope}: given patch is not valid because it will result in empty tables \
+                                  which is not allowed in ConfigDb. \
+                                  Table{'s' if len(empty_tables) != 1 else ''}: {empty_tables_txt}")
 
         # Generate list of changes to apply
         if sort:
@@ -169,6 +169,7 @@ def __init__(self,
         self.config_wrapper = config_wrapper if config_wrapper is not None else ConfigWrapper(namespace=self.namespace)
 
     def rollback(self, checkpoint_name):
+        checkpoint_name = checkpoint_name + self.namespace
         self.logger.log_notice("Config rollbacking starting.")
         self.logger.log_notice(f"Checkpoint name: {checkpoint_name}.")
 
@@ -185,6 +186,7 @@ def rollback(self, checkpoint_name):
         self.logger.log_notice("Config rollbacking completed.")
 
     def checkpoint(self, checkpoint_name):
+        checkpoint_name = checkpoint_name + self.namespace
         self.logger.log_notice("Config checkpoint starting.")
         self.logger.log_notice(f"Checkpoint name: {checkpoint_name}.")
 
@@ -223,6 +225,7 @@ def list_checkpoints(self):
         return checkpoint_names
 
     def delete_checkpoint(self, checkpoint_name):
+        checkpoint_name = checkpoint_name + self.namespace
         self.logger.log_notice("Deleting checkpoint starting.")
         self.logger.log_notice(f"Checkpoint name: {checkpoint_name}.")
 

tests/config_test.py

@@ -2651,6 +2651,7 @@ def setUp(self):
 
         self.runner = CliRunner()
         self.patch_file_path = 'path/to/patch.json'
+        self.replace_file_path = 'path/to/replace.json'
         self.patch_content = [
             {
                 "op": "add",
@@ -2732,6 +2733,113 @@ def test_apply_patch_dryrun_multiasic(self):
                     # Ensure ConfigDBConnector was never instantiated or called
                     mock_config_db_connector.assert_not_called()
 
+    def test_repalce_multiasic(self):
+        # Mock open to simulate file reading
+        mock_replace_content = "[]"
+        with patch('builtins.open', mock_open(read_data=json.dumps(mock_replace_content)), create=True) as mocked_open:
+            # Mock GenericUpdater to avoid actual patch application
+            with patch('config.main.GenericUpdater') as mock_generic_updater:
+                mock_generic_updater.return_value.replace = MagicMock()
+
+                print("Multi ASIC: {}".format(multi_asic.is_multi_asic()))
+                # Invocation of the command with the CliRunner
+                result = self.runner.invoke(config.config.commands["replace"],
+                                            [self.replace_file_path,
+                                            "--scope", "localhost"],
+                                            catch_exceptions=True)
+
+                print("Exit Code: {}, output: {}".format(result.exit_code, result.output))
+                # Assertions and verifications
+                self.assertEqual(result.exit_code, 0, "Command should succeed")
+                self.assertIn("Config replaced successfully.", result.output)
+
+                # Verify mocked_open was called as expected
+                mocked_open.assert_called_with(self.replace_file_path, 'r')
+
+    def test_repalce_multiasic_missing_scope(self):
+        # Mock GenericUpdater to avoid actual patch application
+        with patch('config.main.GenericUpdater') as mock_generic_updater:
+            mock_generic_updater.return_value.replace = MagicMock()
+
+            print("Multi ASIC: {}".format(multi_asic.is_multi_asic()))
+            # Invocation of the command with the CliRunner
+            result = self.runner.invoke(config.config.commands["replace"],
+                                        [self.replace_file_path],
+                                        catch_exceptions=True)
+
+            print("Exit Code: {}, output: {}".format(result.exit_code, result.output))
+            # Assertions and verifications
+            self.assertEqual(result.exit_code, 2, "Command should failed")
+            self.assertIn("Missing option \"-s\"", result.output)
+
+    def test_repalce_multiasic_with_wrong_scope(self):
+        # Mock GenericUpdater to avoid actual patch application
+        with patch('config.main.GenericUpdater') as mock_generic_updater:
+            mock_generic_updater.return_value.replace = MagicMock()
+
+            print("Multi ASIC: {}".format(multi_asic.is_multi_asic()))
+            # Invocation of the command with the CliRunner
+            result = self.runner.invoke(config.config.commands["replace"],
+                                        [self.replace_file_path,
+                                        "--scope", "x"],
+                                        catch_exceptions=True)
+
+            print("Exit Code: {}, output: {}".format(result.exit_code, result.output))
+            # Assertions and verifications
+            self.assertEqual(result.exit_code, 2, "Command should failed")
+            self.assertIn("Invalid value for \"-s\"", result.output)
+
+    def test_checkpoint_multiasic(self):
+        checkpointname = "checkpointname"
+        # Mock GenericUpdater to avoid actual patch application
+        with patch('config.main.GenericUpdater') as mock_generic_updater:
+            mock_generic_updater.return_value.checkpoint = MagicMock()
+
+            print("Multi ASIC: {}".format(multi_asic.is_multi_asic()))
+            # Invocation of the command with the CliRunner
+            result = self.runner.invoke(config.config.commands["checkpoint"],
+                                        [checkpointname],
+                                        catch_exceptions=True)
+
+            print("Exit Code: {}, output: {}".format(result.exit_code, result.output))
+            # Assertions and verifications
+            self.assertEqual(result.exit_code, 0, "Command should succeed")
+            self.assertIn("Checkpoint created successfully.", result.output)
+
+    def test_rollback_multiasic(self):
+        checkpointname = "checkpointname"
+        # Mock GenericUpdater to avoid actual patch application
+        with patch('config.main.GenericUpdater') as mock_generic_updater:
+            mock_generic_updater.return_value.rollback = MagicMock()
+
+            print("Multi ASIC: {}".format(multi_asic.is_multi_asic()))
+            # Invocation of the command with the CliRunner
+            result = self.runner.invoke(config.config.commands["rollback"],
+                                        [checkpointname],
+                                        catch_exceptions=True)
+
+            print("Exit Code: {}, output: {}".format(result.exit_code, result.output))
+            # Assertions and verifications
+            self.assertEqual(result.exit_code, 0, "Command should succeed")
+            self.assertIn("Config rolled back successfully.", result.output)
+
+    def test_delete_checkpoint_multiasic(self):
+        checkpointname = "checkpointname"
+        # Mock GenericUpdater to avoid actual patch application
+        with patch('config.main.GenericUpdater') as mock_generic_updater:
+            mock_generic_updater.return_value.deletecheckpoint = MagicMock()
+
+            print("Multi ASIC: {}".format(multi_asic.is_multi_asic()))
+            # Invocation of the command with the CliRunner
+            result = self.runner.invoke(config.config.commands["delete-checkpoint"],
+                                        [checkpointname],
+                                        catch_exceptions=True)
+
+            print("Exit Code: {}, output: {}".format(result.exit_code, result.output))
+            # Assertions and verifications
+            self.assertEqual(result.exit_code, 0, "Command should succeed")
+            self.assertIn("Checkpoint deleted successfully.", result.output)
+
     @classmethod
     def teardown_class(cls):
         print("TEARDOWN")
@@ -2741,4 +2849,4 @@ def teardown_class(cls):
         from .mock_tables import dbconnector
         from .mock_tables import mock_single_asic
         importlib.reload(mock_single_asic)
-        dbconnector.load_database_config()
+        dbconnector.load_database_config()