Add a backup and restore step on the netplans directory

Author: antlassagne

providers/base/bin/wifi_client_test_netplan.py

@@ -512,6 +512,7 @@ def main():
                 else:
                     print("Connection test failed\n")
     print_journal_entries(start_time, renderer)
+
     if not test_result:
         raise SystemExit(1)
 

providers/base/bin/wifi_nmcli_test.py

@@ -18,12 +18,17 @@
 import subprocess as sp
 import sys
 import shlex
+from pathlib import Path
+import shutil
+import glob
 
 from packaging import version as version_parser
 
 from checkbox_support.helpers.retry import retry
 from gateway_ping_test import ping
 
+BACKUP_DIR = "/tmp/netplan_backup"  # hardcoded so that no one can send "/"
+NETPLAN_DIR = "/lib/netplan"
 
 print = functools.partial(print, flush=True)
 
@@ -386,6 +391,100 @@ def parser_args():
     return args
 
 
+def backup_netplan_files(backup_dir: str, netplan_dir: str) -> 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_dir).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_dir, filename)
+        shutil.copy2(yaml_file, temp_path)
+        # Then copy ownership
+        st = os.stat(yaml_file)
+        os.chown(temp_path, st.st_uid, st.st_gid)
+        print(f"Backed up: {yaml_file} -> {temp_path}")
+
+    print(f"Netplan files backed up to: {backup_dir}")
+    return True
+
+
+def restore_netplan_files(backup_dir: str, netplan_dir: str) -> bool:
+    """
+    Restore netplan YAML files from backup directory to /etc/netplan/.
+
+    Returns:
+        bool: True if restoration successful, False otherwise
+    """
+    if not backup_dir or not os.path.exists(backup_dir):
+        print(f"Backup directory does not exist: {netplan_dir}")
+        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_dir, "*.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)
+            # Then copy ownership
+            st = os.stat(backup_file)
+            os.chown(target_path, st.st_uid, st.st_gid)
+            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_netplan_backup(backup_dir: str) -> bool:
+    """
+    Clean up temporary backup directory.
+    """
+    if not os.path.exists(backup_dir):
+        return True
+
+    try:
+        shutil.rmtree(backup_dir)
+        print(f"Cleaned up backup directory: {backup_dir}")
+        return True
+    except Exception as e:
+        print(f"Error cleaning up backup: {e}")
+        return False
+
+
 @retry(max_attempts=5, delay=60)
 def main():
     args = parser_args()
@@ -408,6 +507,11 @@ def main():
         )
 
     if args.func:
+        # backup the test plans, because nmcli corrupts them
+        # and debsums will complain afterwards
+        # This is ugly. Ideally, nmcli should be patched instead
+        backup_netplan_files(BACKUP_DIR, NETPLAN_DIR)
+
         delete_test_ap_ssid_connection()
         activated_uuid = get_nm_activate_connection()
         turn_down_nm_connections()
@@ -423,6 +527,8 @@ def main():
         finally:
             turn_up_connection(activated_uuid)
             delete_test_ap_ssid_connection()
+            restore_netplan_files(BACKUP_DIR, NETPLAN_DIR)
+            cleanup_netplan_backup(BACKUP_DIR)
 
 
 if __name__ == "__main__":

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,
@@ -40,7 +43,6 @@
     get_interface_info,
 )
 
-
 class WifiClientTestNetplanTests(TestCase):
     @patch(
         "wifi_client_test_netplan.get_series",

providers/base/tests/test_wifi_nmcli_test.py

@@ -42,6 +42,9 @@
     perform_ping_test,
     parser_args,
     main,
+    restore_netplan_files,
+    backup_netplan_files,
+    cleanup_netplan_backup,
 )
 
 
@@ -606,6 +609,9 @@ def test_main_open_no_aps_found(
             "TestSSID": {"Chan": "11", "Freq": "2462", "Signal": "80"},
         },
     )
+    @patch("wifi_nmcli_test.backup_netplan_files")
+    @patch("wifi_nmcli_test.restore_netplan_files")
+    @patch("wifi_nmcli_test.cleanup_netplan_backup")
     @patch("wifi_nmcli_test.open_connection", return_value=0)
     @patch(
         "wifi_nmcli_test.sys.argv",
@@ -616,5 +622,203 @@ def test_main_open_aps_found(
         list_aps_mock,
         get_nm_activate_connection_mock,
         mock_open_connection,
+        mock_cleanup_back,
+        mock_rest_back,
+        mock_cr_back,
     ):
         main()
+
+
+class TestNetplanBackupFunctions(unittest.TestCase):
+    def setUp(self):
+        self.TEST_BACKUP_DIR = "/tmp/test_netplan_backup"
+        self.TEST_NETPLAN_DIR = "/tmp/etc/netplan"
+        """Set up test fixtures before each test method."""
+        Path(self.TEST_BACKUP_DIR).mkdir(parents=True, exist_ok=True)
+        Path(self.TEST_NETPLAN_DIR).mkdir(parents=True, exist_ok=True)
+
+    def tearDown(self):
+        """Clean up after each test method."""
+        # Clean up test directories
+        shutil.rmtree(Path(self.TEST_BACKUP_DIR), ignore_errors=True)
+        shutil.rmtree(Path(self.TEST_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.TEST_BACKUP_DIR, self.TEST_NETPLAN_DIR
+        )
+        self.assertTrue(result)
+
+    @patch("os.chown")
+    @patch("os.stat")
+    @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,
+        mock_stat,
+        mock_chown,
+    ):
+        """Test successful backup of netplan files."""
+        mock_glob.return_value = [
+            self.TEST_NETPLAN_DIR + "/config1.yaml",
+            self.TEST_NETPLAN_DIR + "/config2.yaml",
+        ]
+
+        result = backup_netplan_files(
+            self.TEST_BACKUP_DIR, self.TEST_NETPLAN_DIR
+        )
+
+        self.assertTrue(result)
+        self.assertEqual(mock_copy2.call_count, 2)
+        mock_mkdir.assert_called_once_with(parents=True, exist_ok=True)
+
+    @patch("os.chown")
+    @patch("os.stat")
+    @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,
+        mock_stat,
+        mock_chown,
+    ):
+        """Test successful restore of netplan files."""
+        mock_exists.return_value = True
+        mock_glob.side_effect = [
+            [self.TEST_NETPLAN_DIR + "/old1.yaml"],  # Existing files to remove
+            [
+                f"{self.TEST_BACKUP_DIR}/config1.yaml",
+                f"{self.TEST_BACKUP_DIR}/config2.yaml",
+            ],  # Backup files
+        ]
+
+        result = restore_netplan_files(
+            self.TEST_BACKUP_DIR, self.TEST_NETPLAN_DIR
+        )
+
+        self.assertTrue(result)
+        mock_remove.assert_called_once_with(
+            self.TEST_NETPLAN_DIR + "/old1.yaml"
+        )
+        self.assertEqual(mock_copy2.call_count, 2)
+
+    @patch("os.chown")
+    @patch("os.stat")
+    @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,
+        mock_stat,
+        mock_chown,
+    ):
+        """Test restore when copy operation fails."""
+        mock_exists.return_value = True
+        mock_glob.side_effect = [[], [f"{self.TEST_BACKUP_DIR}/config1.yaml"]]
+        mock_copy2.side_effect = OSError("Permission denied")
+
+        result = restore_netplan_files(
+            self.TEST_BACKUP_DIR, self.TEST_NETPLAN_DIR
+        )
+
+        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_netplan_backup(self.TEST_BACKUP_DIR)
+
+        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_netplan_backup(self.TEST_BACKUP_DIR)
+
+        self.assertTrue(result)
+        mock_rmtree.assert_called_once_with(self.TEST_BACKUP_DIR)
+
+    @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_netplan_backup(self.TEST_BACKUP_DIR)
+
+        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 = [
+            [self.TEST_NETPLAN_DIR + "/old1.yaml"],  # Existing files to remove
+            [f"{self.TEST_BACKUP_DIR}/config1.yaml"],  # Backup files
+        ]
+        mock_remove.side_effect = OSError("Permission denied")
+        with self.assertRaises(OSError):
+            result = restore_netplan_files(
+                self.TEST_BACKUP_DIR, self.TEST_NETPLAN_DIR
+            )
+
+    @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"{self.TEST_BACKUP_DIR}/config1.yaml"]]
+        mock_makedirs.side_effect = OSError("Permission denied")
+
+        result = restore_netplan_files(
+            self.TEST_BACKUP_DIR, self.TEST_NETPLAN_DIR
+        )
+
+        self.assertFalse(result)