Add a backup and restore step on the netplans directory

Author: antlassagne

providers/base/bin/wifi_client_test_netplan.py

@@ -23,6 +23,7 @@
 import shutil
 import ipaddress
 import yaml
+from pathlib import Path
 
 from contextlib import contextmanager
 
@@ -50,6 +51,8 @@ def print_cmd(cmd):
 
 NETPLAN_CFG_PATHS = ("/etc/netplan", "/lib/netplan", "/run/netplan")
 NETPLAN_TEST_CFG = "/etc/netplan/99-CREATED-BY-CHECKBOX.yaml"
+BACKUP_PATH = "/tmp/netplan_backup"  # hardcoded so that no one can send "/"
+NETPLAN_DIR = NETPLAN_CFG_PATHS[1]
 
 
 def netplan_renderer():
@@ -482,6 +485,94 @@ def handle_test_np_config(args):
         delete_test_config()
 
 
+def backup_netplan_files() -> bool:
+    """
+    Backup netplan YAML files from /etc/netplan/ to a
+    temporary directory, if there are.
+
+    Returns:
+        bool: True if the operation succeded.
+    """
+    netplan_pattern = os.path.join(NETPLAN_DIR, "*.yaml")
+
+    # Find all netplan YAML files
+    yaml_files = glob.glob(netplan_pattern)
+
+    if not yaml_files:
+        print("No netplan YAML files found")
+        return True
+
+    # Create temporary directory
+    Path(BACKUP_PATH).mkdir(parents=True, exist_ok=True)
+
+    # Copy each file to temp directory
+    for yaml_file in yaml_files:
+        filename = os.path.basename(yaml_file)
+        temp_path = os.path.join(BACKUP_PATH, filename)
+        shutil.copy2(yaml_file, temp_path)
+        print(f"Backed up: {yaml_file} -> {temp_path}")
+
+    print(f"Netplan files backed up to: {BACKUP_PATH}")
+    return True
+
+
+def restore_netplan_files() -> bool:
+    """
+    Restore netplan YAML files from backup directory to /etc/netplan/.
+
+    Returns:
+        bool: True if restoration successful, False otherwise
+    """
+    if not BACKUP_PATH or not os.path.exists(BACKUP_PATH):
+        print(f"Backup directory does not exist: {BACKUP_PATH}")
+        return False
+
+    # Clean up existing netplan files first
+    existing_files = glob.glob(os.path.join(NETPLAN_DIR, "*.yaml"))
+    for existing_file in existing_files:
+        os.remove(existing_file)
+        print(f"Removed: {existing_file}")
+
+    # Find all YAML files in backup directory
+    backup_pattern = os.path.join(BACKUP_PATH, "*.yaml")
+    backup_files = glob.glob(backup_pattern)
+
+    if not backup_files:
+        print("No netplan files found in backup directory")
+        return False
+
+    try:
+        # Restore each file
+        for backup_file in backup_files:
+            filename = os.path.basename(backup_file)
+            target_path = os.path.join(NETPLAN_DIR, filename)
+            shutil.copy2(backup_file, target_path)
+            print(f"Restored: {backup_file} -> {target_path}")
+
+        print("Netplan files restored successfully")
+        return True
+
+    except Exception as e:
+        print(f"Error during restoration: {e}")
+        return False
+
+
+def cleanup_backup() -> bool:
+    """
+    Clean up temporary backup directory.
+    """
+    if not os.path.exists(BACKUP_PATH):
+        return True
+
+    try:
+        shutil.rmtree(BACKUP_PATH)
+        print(f"Cleaned up backup directory: {BACKUP_PATH}")
+        return True
+    except Exception as e:
+        print(f"Error cleaning up backup: {e}")
+        return False
+
+
 def main():
     args = parse_args()
 
@@ -490,6 +581,7 @@ def main():
     start_time = datetime.datetime.now()
     renderer = check_and_get_renderer(args.renderer)
     args.renderer = renderer
+    backup_netplan_files()
 
     with handle_original_np_config():
         with handle_test_np_config(args):
@@ -512,6 +604,16 @@ def main():
                 else:
                     print("Connection test failed\n")
     print_journal_entries(start_time, renderer)
+
+    if restore_netplan_files():
+        print("Files restored successfully")
+
+        # Clean up backup
+        cleanup_backup()
+    else:
+        print("Failed to restore files")
+        raise SystemExit(1)
+
     if not test_result:
         raise SystemExit(1)
 

providers/base/tests/test_wifi_client_test_netplan.py

@@ -24,6 +24,9 @@
 import io
 import sys
 from unittest.mock import call
+from pathlib import Path
+import shutil
+
 from wifi_client_test_netplan import (
     netplan_renderer,
     check_and_get_renderer,
@@ -38,6 +41,9 @@
     print_journal_entries,
     main,
     get_interface_info,
+    restore_netplan_files,
+    backup_netplan_files,
+    cleanup_backup,
 )
 
 
@@ -931,3 +937,173 @@ def test_main_ping_test_failure(
         self.assertEqual(mock_apply.call_count, 2)
         self.assertEqual(mock_print_journal.call_count, 1)
         mock_ping.assert_called_once_with("wlan0", "networkd")
+
+
+# Mock BACKUP_PATH for testing
+BACKUP_PATH = "/tmp/test_netplan_backup"
+NETPLAN_DIR = "/tmp/lib/netplan"
+
+
+@patch("wifi_client_test_netplan.BACKUP_PATH", "/tmp/test_netplan_backup")
+@patch("wifi_client_test_netplan.NETPLAN_DIR", "/tmp/lib/netplan")
+class TestNetplanBackupFunctions(TestCase):
+
+    def setUp(self):
+        self.assertEqual(BACKUP_PATH, "/tmp/test_netplan_backup")
+        self.assertEqual(NETPLAN_DIR, "/tmp/lib/netplan")
+        """Set up test fixtures before each test method."""
+        Path(BACKUP_PATH).mkdir(parents=True, exist_ok=True)
+        Path(NETPLAN_DIR).mkdir(parents=True, exist_ok=True)
+
+    def tearDown(self):
+        """Clean up after each test method."""
+        # Clean up test directories
+        shutil.rmtree(Path(BACKUP_PATH), ignore_errors=True)
+        shutil.rmtree(Path(NETPLAN_DIR), ignore_errors=True)
+
+    @patch("glob.glob")
+    @patch("builtins.print")
+    def test_backup_netplan_files_no_files_found(self, mock_print, mock_glob):
+        """Test backup when no YAML files are found."""
+        mock_glob.return_value = []
+
+        result = backup_netplan_files()
+        self.assertTrue(result)
+
+    @patch("glob.glob")
+    @patch("shutil.copy2")
+    @patch("pathlib.Path.mkdir")
+    @patch("builtins.print")
+    def test_backup_netplan_files_success(
+        self, mock_print, mock_mkdir, mock_copy2, mock_glob
+    ):
+        """Test successful backup of netplan files."""
+        mock_glob.return_value = [
+            NETPLAN_DIR + "/config1.yaml",
+            NETPLAN_DIR + "/config2.yaml",
+        ]
+
+        result = backup_netplan_files()
+
+        self.assertTrue(result)
+        self.assertEqual(mock_copy2.call_count, 2)
+        mock_mkdir.assert_called_once_with(parents=True, exist_ok=True)
+
+    @patch("os.path.exists")
+    @patch("glob.glob")
+    @patch("os.remove")
+    @patch("os.makedirs")
+    @patch("shutil.copy2")
+    @patch("builtins.print")
+    def test_restore_netplan_files_success(
+        self,
+        mock_print,
+        mock_copy2,
+        mock_makedirs,
+        mock_remove,
+        mock_glob,
+        mock_exists,
+    ):
+        """Test successful restore of netplan files."""
+        mock_exists.return_value = True
+        mock_glob.side_effect = [
+            [NETPLAN_DIR + "/old1.yaml"],  # Existing files to remove
+            [
+                f"{BACKUP_PATH}/config1.yaml",
+                f"{BACKUP_PATH}/config2.yaml",
+            ],  # Backup files
+        ]
+
+        result = restore_netplan_files()
+
+        self.assertTrue(result)
+        mock_remove.assert_called_once_with(NETPLAN_DIR + "/old1.yaml")
+        self.assertEqual(mock_copy2.call_count, 2)
+
+    @patch("os.path.exists")
+    @patch("glob.glob")
+    @patch("os.remove")
+    @patch("shutil.copy2")
+    @patch("builtins.print")
+    def test_restore_netplan_files_copy_error(
+        self, mock_print, mock_copy2, mock_remove, mock_glob, mock_exists
+    ):
+        """Test restore when copy operation fails."""
+        mock_exists.return_value = True
+        mock_glob.side_effect = [[], [f"{BACKUP_PATH}/config1.yaml"]]
+        mock_copy2.side_effect = OSError("Permission denied")
+
+        result = restore_netplan_files()
+
+        self.assertFalse(result)
+
+    @patch("os.path.exists")
+    @patch("builtins.print")
+    def test_cleanup_backup_not_exists(self, mock_print, mock_exists):
+        """Test cleanup when backup directory doesn't exist."""
+        mock_exists.return_value = False
+
+        result = cleanup_backup()
+
+        self.assertTrue(result)
+
+    @patch("os.path.exists")
+    @patch("shutil.rmtree")
+    @patch("builtins.print")
+    def test_cleanup_backup_success(
+        self, mock_print, mock_rmtree, mock_exists
+    ):
+        """Test successful cleanup of backup directory."""
+        mock_exists.return_value = True
+
+        result = cleanup_backup()
+
+        self.assertTrue(result)
+        mock_rmtree.assert_called_once_with(BACKUP_PATH)
+
+    @patch("os.path.exists")
+    @patch("shutil.rmtree")
+    @patch("builtins.print")
+    def test_cleanup_backup_error(self, mock_print, mock_rmtree, mock_exists):
+        """Test cleanup when rmtree operation fails."""
+        mock_exists.return_value = True
+        mock_rmtree.side_effect = OSError("Permission denied")
+
+        result = cleanup_backup()
+
+        self.assertFalse(result)
+
+    @patch("os.path.exists")
+    @patch("glob.glob")
+    @patch("os.remove")
+    @patch("builtins.print")
+    def test_restore_netplan_files_remove_error(
+        self, mock_print, mock_remove, mock_glob, mock_exists
+    ):
+        """Test restore when removing existing files fails."""
+        mock_exists.return_value = True
+        mock_glob.side_effect = [
+            [NETPLAN_DIR + "/old1.yaml"],  # Existing files to remove
+            [f"{BACKUP_PATH}/config1.yaml"],  # Backup files
+        ]
+        mock_remove.side_effect = OSError("Permission denied")
+
+        result = restore_netplan_files()
+
+        self.assertFalse(result)
+
+    @patch("os.path.exists")
+    @patch("glob.glob")
+    @patch("os.makedirs")
+    @patch("builtins.print")
+    def test_restore_netplan_files_makedirs_error(
+        self, mock_print, mock_makedirs, mock_glob, mock_exists
+    ):
+        """Test restore when makedirs operation fails."""
+        mock_exists.return_value = True
+        mock_glob.side_effect = [[], [f"{BACKUP_PATH}/config1.yaml"]]
+        mock_makedirs.side_effect = OSError("Permission denied")
+
+        result = restore_netplan_files()
+
+        self.assertFalse(result)