Add rsync-based "copy tree" strategy

It is the preferred strategy, because, in the future, it will allow
excluding files and directories (think ".gitignore"). However, since
`rsync` requires a temporary directory to play correctly with runners
like Testing Farm, the strategy will do nothing when caller provides no
way to create such a temporary directory.

Author: happz

tests/unit/test_filesystem.py

@@ -106,7 +106,7 @@ def _run_metadata_test_for_item(
 def test_copy_tree_basic(copy_tree_paths: CopyTreePathConfig, root_logger: tmt.log.Logger):
     """Test basic copy operation with default parameters."""
     source_dir, dest_dir, symlinks_supported = copy_tree_paths
-    tmt.utils.filesystem.copy_tree(source_dir, dest_dir, root_logger)
+    tmt.utils.filesystem.copy_tree(src=source_dir, dst=dest_dir, logger=root_logger)
 
     # Check if all files were copied and their content is correct
     for path, content in _EXPECTED_TEST_FILES.items():
@@ -128,7 +128,7 @@ def test_copy_empty_source_directory(tmppath: Path, root_logger: tmt.log.Logger)
     empty_dst = tmppath / "empty_dst"
     empty_src.mkdir()
 
-    tmt.utils.filesystem.copy_tree(empty_src, empty_dst, root_logger)
+    tmt.utils.filesystem.copy_tree(src=empty_src, dst=empty_dst, logger=root_logger)
 
     # Verify the destination directory exists and is empty
     assert empty_dst.exists()
@@ -149,7 +149,7 @@ def test_deeply_nested_directories(tmppath: Path, root_logger: tmt.log.Logger):
         current_dir.mkdir()
         (current_dir / f"file_at_level_{level}.txt").write_text(f"{test_content} at level {level}")
 
-    tmt.utils.filesystem.copy_tree(deep_src, deep_dst, root_logger)
+    tmt.utils.filesystem.copy_tree(src=deep_src, dst=deep_dst, logger=root_logger)
 
     # Check if the deepest directory and file exist in the copied structure
     deepest_path = Path(
@@ -179,7 +179,7 @@ def test_permission_error_handling(
     """Test handling of permission errors during copy."""
     source_dir, dest_dir, _ = copy_tree_paths
     with pytest.raises(tmt.utils.GeneralError) as excinfo:
-        tmt.utils.filesystem.copy_tree(source_dir, dest_dir, root_logger)
+        tmt.utils.filesystem.copy_tree(src=source_dir, dst=dest_dir, logger=root_logger)
 
     assert (
         "permission error" in str(excinfo.value).lower()
@@ -193,7 +193,7 @@ def test_nonexistent_source_directory(tmppath: Path, root_logger: tmt.log.Logger
     destination = tmppath / "destination"
 
     with pytest.raises(tmt.utils.GeneralError) as excinfo:
-        tmt.utils.filesystem.copy_tree(nonexistent_src, destination, root_logger)
+        tmt.utils.filesystem.copy_tree(src=nonexistent_src, dst=destination, logger=root_logger)
 
     assert "not a directory or does not exist" in str(excinfo.value)
 
@@ -213,7 +213,7 @@ def test_fallback_to_shutil_copy_from_cp_failure(
     source_dir, dest_dir, _ = copy_tree_paths
     mock_copy_tree_cp, mock_copy_tree_shutil = tmt.utils.filesystem._COPY_TREE_STRATEGIES
 
-    tmt.utils.filesystem.copy_tree(source_dir, dest_dir, root_logger)
+    tmt.utils.filesystem.copy_tree(src=source_dir, dst=dest_dir, logger=root_logger)
 
     mock_copy_tree_cp.assert_called_once_with(source_dir, dest_dir, mock.ANY)
     mock_copy_tree_shutil.assert_called_once_with(source_dir, dest_dir, mock.ANY)
@@ -235,7 +235,7 @@ def test_metadata_cp_reflink(copy_tree_paths: CopyTreePathConfig, root_logger: t
         source_dir, "meta_dir", is_dir=True, mode=0o750, atime=timestamp, mtime=timestamp
     )
 
-    tmt.utils.filesystem.copy_tree(source_dir, dest_dir, root_logger)
+    tmt.utils.filesystem.copy_tree(src=source_dir, dst=dest_dir, logger=root_logger)
 
     _run_metadata_test_for_item(dest_dir, test_file)
     _run_metadata_test_for_item(dest_dir, test_dir)
@@ -270,7 +270,7 @@ def test_metadata_preservation_on_cp_failure_fallback_to_shutil(
         source_dir, "meta_dir_shutil", is_dir=True, mode=0o500, atime=timestamp, mtime=timestamp
     )
 
-    tmt.utils.filesystem.copy_tree(source_dir, dest_dir, root_logger)
+    tmt.utils.filesystem.copy_tree(src=source_dir, dst=dest_dir, logger=root_logger)
 
     mock_copy_tree_cp.assert_called_once_with(source_dir, dest_dir, mock.ANY)
     mock_copy_tree_shutil.assert_called_once_with(source_dir, dest_dir, mock.ANY)
@@ -294,7 +294,7 @@ def test_all_strategies_fail(
     mock_copy_tree_cp, mock_copy_tree_shutil = tmt.utils.filesystem._COPY_TREE_STRATEGIES
 
     with pytest.raises(tmt.utils.GeneralError):
-        tmt.utils.filesystem.copy_tree(source_dir, dest_dir, root_logger)
+        tmt.utils.filesystem.copy_tree(src=source_dir, dst=dest_dir, logger=root_logger)
 
     mock_copy_tree_cp.assert_called_once()
     mock_copy_tree_shutil.assert_called_once()
@@ -312,7 +312,7 @@ def test_copy_to_existing_destination(
     (dest_dir / "subdir" / "existing_in_subdir.txt").write_text("pre-existing in subdir")
     (dest_dir / "file1.txt").write_text("old file1 content")
 
-    tmt.utils.filesystem.copy_tree(source_dir, dest_dir, root_logger)
+    tmt.utils.filesystem.copy_tree(src=source_dir, dst=dest_dir, logger=root_logger)
 
     # Check that source files were copied and overwrite conflicting ones
     assert (dest_dir / "file1.txt").read_text() == _EXPECTED_TEST_FILES["file1.txt"]

tmt/libraries/beakerlib.py

@@ -432,7 +432,9 @@ def _do_fetch(self, directory: Path) -> None:
             self.parent.debug(f"Failed to find library {self} at {self.url}")
             raise LibraryError
         self.parent.debug(f"Library {self} is copied into {directory}")
-        tmt.utils.filesystem.copy_tree(library_path, local_library_path, self._logger)
+        tmt.utils.filesystem.copy_tree(
+            src=library_path, dst=local_library_path, logger=self._logger
+        )
 
         self.parent.verbose(
             'using remote git library',
@@ -462,15 +464,15 @@ def _do_fetch(self, directory: Path) -> None:
 
         # Copy fmf metadata
         tmt.utils.filesystem.copy_tree(
-            clone_dir / '.fmf',
-            directory / '.fmf',
-            self._logger,
+            src=clone_dir / '.fmf',
+            dst=directory / '.fmf',
+            logger=self._logger,
         )
         if self.path:
             tmt.utils.filesystem.copy_tree(
-                clone_dir / self.path.unrooted() / '.fmf',
-                directory / self.path.unrooted() / '.fmf',
-                self._logger,
+                src=clone_dir / self.path.unrooted() / '.fmf',
+                dst=directory / self.path.unrooted() / '.fmf',
+                logger=self._logger,
             )
 
 
@@ -530,12 +532,14 @@ def _do_fetch(self, directory: Path) -> None:
 
         self.parent.debug(f"Copy local library '{self.fmf_node_path}' to '{directory}'.", level=3)
         # Copy only the required library
-        tmt.utils.filesystem.copy_tree(library_path, local_library_path, self._logger)
+        tmt.utils.filesystem.copy_tree(
+            src=library_path, dst=local_library_path, logger=self._logger
+        )
         # Remove metadata file(s) and create one with full data
         self._merge_metadata(library_path, local_library_path)
         # Copy fmf metadata
         tmt.utils.filesystem.copy_tree(
-            self.path / '.fmf',
-            directory / '.fmf',
-            self._logger,
+            src=self.path / '.fmf',
+            dst=directory / '.fmf',
+            logger=self._logger,
         )

tmt/steps/discover/__init__.py

@@ -386,9 +386,9 @@ def prune_tree(
         # Save fmf metadata
         for file_path in tmt.utils.filter_paths(tree_path, [r'\.fmf']):
             tmt.utils.filesystem.copy_tree(
-                file_path,
-                clone_tree_path / file_path.relative_to(tree_path),
-                self._logger,
+                src=file_path,
+                dst=clone_tree_path / file_path.relative_to(tree_path),
+                logger=self._logger,
             )
 
         # Save upgrade plan
@@ -405,9 +405,9 @@ def prune_tree(
             assert test.path is not None  # narrow type
             relative_test_path = test.path.unrooted()
             tmt.utils.filesystem.copy_tree(
-                tree_path / relative_test_path,
-                clone_tree_path / relative_test_path,
-                self._logger,
+                src=tree_path / relative_test_path,
+                dst=clone_tree_path / relative_test_path,
+                logger=self._logger,
             )
 
             # Copy all parent main.fmf files
@@ -425,7 +425,7 @@ def prune_tree(
         # Clean phase.test_dir and copy back only required tests and files from clone_dir
         # This is to have correct paths in tests
         shutil.rmtree(self.test_dir, ignore_errors=True)
-        tmt.utils.filesystem.copy_tree(clone_dir, self.test_dir, self._logger)
+        tmt.utils.filesystem.copy_tree(src=clone_dir, dst=self.test_dir, logger=self._logger)
 
         if self.clone_dirpath.exists():
             shutil.rmtree(self.clone_dirpath, ignore_errors=True)

tmt/steps/discover/fmf.py

@@ -627,7 +627,7 @@ def _fetch_local_repository(self) -> Optional[Path]:
             directory = fmf_root
         self.info('directory', directory, 'green')
         self.debug(f"Copy '{directory}' to '{self.test_dir}'.")
-        tmt.utils.filesystem.copy_tree(directory, self.test_dir, self._logger)
+        tmt.utils.filesystem.copy_tree(src=directory, dst=self.test_dir, logger=self._logger)
         return path
 
     def go(self, *, path: Optional[Path] = None, logger: Optional[tmt.log.Logger] = None) -> None:
@@ -676,9 +676,9 @@ def process_distgit_source(self, distgit_dir: Path) -> None:
 
         # Copy rest of files so TMT_SOURCE_DIR has patches, sources and spec file
         tmt.utils.filesystem.copy_tree(
-            distgit_dir,
-            self.source_dir,
-            self._logger,
+            src=distgit_dir,
+            dst=self.source_dir,
+            logger=self._logger,
         )
 
         # patch & rediscover will happen later in the prepare step
@@ -902,7 +902,9 @@ def post_dist_git(self, created_content: list[Path]) -> None:
                             f"Directory '{self.step.plan.node.root}' is not in a git repository."
                         ) from error
                     self.debug(f"Copy '{git_root}' to '{self.test_dir}'.")
-                    tmt.utils.filesystem.copy_tree(git_root, self.test_dir, self._logger)
+                    tmt.utils.filesystem.copy_tree(
+                        src=git_root, dst=self.test_dir, logger=self._logger
+                    )
             else:
                 if not dist_git_merge:
                     if self.data.path:
@@ -926,9 +928,9 @@ def post_dist_git(self, created_content: list[Path]) -> None:
             src = self.source_dir / to_copy
             if src.is_dir():
                 tmt.utils.filesystem.copy_tree(
-                    self.source_dir / to_copy,
-                    self.test_dir if flatten else self.test_dir / to_copy,
-                    self._logger,
+                    src=self.source_dir / to_copy,
+                    dst=self.test_dir if flatten else self.test_dir / to_copy,
+                    logger=self._logger,
                 )
             else:
                 shutil.copyfile(src, self.test_dir / to_copy)