[update-checkout] add the 'status' subcommand

Author: charles-zablit

utils/update_checkout/tests/test_locked_repository.py

@@ -2,7 +2,8 @@
 import unittest
 from unittest.mock import patch
 
-from update_checkout.update_checkout import UpdateArguments, _is_any_repository_locked
+from update_checkout.update_checkout import UpdateArguments
+from update_checkout.git_command import is_any_repository_locked
 
 FAKE_PATH = Path("/fake_path")
 
@@ -46,7 +47,7 @@ def iterdir_side_effect(path: Path):
         mock_is_dir.return_value = True
         mock_iterdir.side_effect = iterdir_side_effect
 
-        result = _is_any_repository_locked(pool_args)
+        result = is_any_repository_locked(pool_args)
         self.assertEqual(result, {"repo1"})
 
     @patch("pathlib.Path.exists")
@@ -61,7 +62,7 @@ def test_repository_without_git_dir(self, mock_iterdir, mock_is_dir, mock_exists
         mock_is_dir.return_value = False
         mock_iterdir.return_value = []
 
-        result = _is_any_repository_locked(pool_args)
+        result = is_any_repository_locked(pool_args)
         self.assertEqual(result, set())
 
     @patch("pathlib.Path.exists")
@@ -76,7 +77,7 @@ def test_repository_with_git_file(self, mock_iterdir, mock_is_dir, mock_exists):
         mock_is_dir.return_value = False
         mock_iterdir.return_value = []
 
-        result = _is_any_repository_locked(pool_args)
+        result = is_any_repository_locked(pool_args)
         self.assertEqual(result, set())
 
     @patch("pathlib.Path.exists")
@@ -95,7 +96,7 @@ def test_repository_with_multiple_lock_files(
             FAKE_PATH.joinpath(x) for x in ("index.lock", "merge.lock", "HEAD")
         ]
 
-        result = _is_any_repository_locked(pool_args)
+        result = is_any_repository_locked(pool_args)
         self.assertEqual(result, {"repo1"})
 
     @patch("pathlib.Path.exists")
@@ -114,5 +115,5 @@ def test_repository_with_no_lock_files(
             FAKE_PATH.joinpath(x) for x in ("HEAD", "config", "logs")
         ]
 
-        result = _is_any_repository_locked(pool_args)
+        result = is_any_repository_locked(pool_args)
         self.assertEqual(result, set())

utils/update_checkout/tests/test_status_command.py

@@ -0,0 +1,78 @@
+import subprocess
+import tempfile
+from typing import List
+import unittest
+from pathlib import Path
+
+from .scheme_mock import UPDATE_CHECKOUT_PATH
+
+
+class TestStatusCommand(unittest.TestCase):
+    def call(self, args: List[str], cwd: Path):
+        subprocess.check_call(
+            args, cwd=cwd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+        )
+
+    def init_repo(self, path: Path, with_changes: bool):
+        self.call(args=["git", "init"], cwd=path)
+        self.call(
+            args=["git", "config", "--local", "user.name", "swift_test"], cwd=path
+        )
+        self.call(
+            args=["git", "config", "--local", "user.email", "[email protected]"],
+            cwd=path,
+        )
+        self.call(args=["git", "config", "commit.gpgsign", "false"], cwd=path)
+
+        (path / "file.txt").write_text("initial\n")
+        self.call(args=["git", "add", "file.txt"], cwd=path)
+        self.call(args=["git", "commit", "-m", "initial commit"], cwd=path)
+
+        if with_changes:
+            (path / "file.txt").write_text("modified\n")
+
+    def test_repositories_with_active_changes(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+
+            repo_1 = root / "repo_1"
+            repo_2 = root / "repo_2"
+            repo_1.mkdir()
+            repo_2.mkdir()
+
+            self.init_repo(repo_1, True)
+            self.init_repo(repo_2, True)
+
+            output = subprocess.run(
+                [UPDATE_CHECKOUT_PATH, "--source-root", str(root), "status"],
+                capture_output=True,
+                text=True,
+            ).stdout
+
+            self.assertIn("The following repositories have active changes:", output)
+            self.assertIn("  - [repo_1] 1 active change", output)
+            self.assertIn("  - [repo_2] 1 active change", output)
+
+    def test_repositories_without_active_changes(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+
+            repo_1 = root / "repo_1"
+            repo_2 = root / "repo_2"
+            repo_1.mkdir()
+            repo_2.mkdir()
+
+            self.init_repo(repo_1, False)
+            self.init_repo(repo_2, False)
+
+            output = subprocess.run(
+                [UPDATE_CHECKOUT_PATH, "--source-root", str(root), "status"],
+                capture_output=True,
+                text=True,
+            ).stdout
+
+            self.assertIn("No repositories have active changes.", output)
+
+
+if __name__ == "__main__":
+    unittest.main()

utils/update_checkout/update_checkout/cli_arguments.py

@@ -1,6 +1,6 @@
 import argparse
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, List, Optional
 
 from build_swift.build_swift.constants import SWIFT_SOURCE_ROOT
 
@@ -26,6 +26,7 @@ class CliArguments(argparse.Namespace):
     source_root: Path
     use_submodules: bool
     verbose: bool
+    command: Optional[Any]
 
     @staticmethod
     def parse_args() -> "CliArguments":
@@ -153,4 +154,8 @@ def parse_args() -> "CliArguments":
             help="Increases the script's verbosity.",
             action="store_true",
         )
+
+        subparsers = parser.add_subparsers(dest='command')
+        subparsers.add_parser('status', help='Print the status of all the repositories')
+
         return parser.parse_args()

utils/update_checkout/update_checkout/commands/__init__.py

@@ -0,0 +1,3 @@
+from .status import StatusCommand
+
+__all__ = ["StatusCommand"]

utils/update_checkout/update_checkout/commands/status.py

@@ -0,0 +1,80 @@
+from typing import List, Tuple
+
+from ..parallel_runner import (
+    ParallelRunner,
+    RunnerArguments,
+)
+from ..runner_arguments import UpdateArguments
+from ..cli_arguments import CliArguments
+from ..git_command import (
+    Git,
+    is_any_repository_locked,
+    is_git_repository,
+)
+
+
+class StatusCommand:
+    _args: CliArguments
+    _pool_args: List[UpdateArguments]
+
+    def __init__(self, args: CliArguments):
+        self._args = args
+        self._pool_args = []
+        for repo_path in args.source_root.iterdir():
+            if not is_git_repository(repo_path):
+                continue
+            repo_name = repo_path.name
+
+            my_args = RunnerArguments(
+                repo_name=repo_name,
+                output_prefix="Checking the status of",
+                source_root=args.source_root,
+                verbose=args.verbose,
+            )
+            self._pool_args.append(my_args)
+
+    def run(self):
+        # TODO: If we add more commands, make error handling more generic
+        locked_repositories = is_any_repository_locked(self._pool_args)
+        if len(locked_repositories) > 0:
+            results = [
+                Exception(f"'{repo_name}' is locked by git. Cannot update it.")
+                for repo_name in locked_repositories
+            ]
+        else:
+            results = ParallelRunner(
+                self._get_uncommitted_changes_of_repository,
+                self._pool_args,
+                self._args.n_processes,
+            ).run()
+
+        return self._handle_results(results)
+
+    def _handle_results(self, results) -> int:
+        ret = ParallelRunner.check_results(results, "STATUS")
+        if ret > 0:
+            return ret
+
+        repos_with_active_changes: List[Tuple[str, int]] = []
+        for result, pool_arg in zip(results, self._pool_args):
+            if result is None or result[0] == "":
+                continue
+            status_output: str = result[0]
+            repos_with_active_changes.append((pool_arg.repo_name, len(status_output.splitlines())))
+
+        if len(repos_with_active_changes) == 0:
+            print("No repositories have active changes.")
+        else:
+            print("The following repositories have active changes:")
+            for repo_name, file_count in repos_with_active_changes:
+                msg = f"  - [{repo_name}] {file_count} active change"
+                if file_count > 1:
+                    msg += "s"
+                print(msg)
+
+        return 0
+
+    @staticmethod
+    def _get_uncommitted_changes_of_repository(pool_args: RunnerArguments):
+        repo_path = pool_args.source_root.joinpath(pool_args.repo_name)
+        return Git.run(repo_path, ["status", "--short"], fatal=True)

utils/update_checkout/update_checkout/git_command.py

@@ -1,9 +1,10 @@
-import os
 from pathlib import Path
 import shlex
 import subprocess
 import sys
-from typing import List, Any, Optional, Dict, Tuple
+from typing import List, Any, Optional, Dict, Set, Tuple
+
+from .runner_arguments import RunnerArguments
 
 
 class GitException(Exception):
@@ -119,3 +120,45 @@ def _quote(arg: Any) -> str:
     @staticmethod
     def _quote_command(command: List[Any]) -> str:
         return " ".join(Git._quote(arg) for arg in command)
+
+
+def is_git_repository(path: Path) -> bool:
+    """Returns whether a Path object is a Git repository.
+
+    Args:
+        path (Path): The path object to check.
+
+    Returns:
+        bool: Whether the path is a Git repository.
+    """
+
+    if not path.is_dir():
+        return False
+    git_dir_path = path.joinpath(".git")
+    return git_dir_path.exists() and git_dir_path.is_dir()
+
+
+def is_any_repository_locked(pool_args: List[RunnerArguments]) -> Set[str]:
+    """Returns the set of locked repositories.
+
+    A repository is considered to be locked if its .git directory contains a
+    file ending in ".lock".
+
+    Args:
+        pool_args (List[RunnerArguments]): List of arguments passed to the
+        `update_single_repository` function.
+
+    Returns:
+        Set[str]: The names of the locked repositories if any.
+    """
+
+    repos = [(x.source_root, x.repo_name) for x in pool_args]
+    locked_repositories = set()
+    for source_root, repo_name in repos:
+        dot_git_path = source_root.joinpath(repo_name, ".git")
+        if not dot_git_path.exists() or not dot_git_path.is_dir():
+            continue
+        for file in dot_git_path.iterdir():
+            if file.suffix == ".lock":
+                locked_repositories.add(repo_name)
+    return locked_repositories

utils/update_checkout/update_checkout/parallel_runner.py

@@ -7,7 +7,6 @@
 import shutil
 
 from .git_command import GitException
-
 from .runner_arguments import (
     RunnerArguments,
     AdditionalSwiftSourcesArguments,
@@ -84,7 +83,7 @@ def __init__(
     ):
         def run_safely(*args, **kwargs):
             try:
-                fn(*args, **kwargs)
+                return fn(*args, **kwargs)
             except GitException as e:
                 return e
 
@@ -158,6 +157,9 @@ def check_results(
         for r in results:
             if r is None:
                 continue
+            if isinstance(r, tuple) and len(r) == 3:
+                if r[1] == 0:
+                    continue
             if fail_count == 0:
                 print(f"======{operation} FAILURES======")
             fail_count += 1

utils/update_checkout/update_checkout/runner_arguments.py

@@ -8,14 +8,14 @@
 @dataclass
 class RunnerArguments:
     repo_name: str
-    scheme_name: str
     output_prefix: str
+    source_root: Path
     verbose: bool
 
 
 @dataclass
 class UpdateArguments(RunnerArguments):
-    source_root: Path
+    scheme_name: str
     config: Dict[str, Any]
     scheme_map: Any
     tag: Optional[str]
@@ -28,6 +28,7 @@ class UpdateArguments(RunnerArguments):
 
 @dataclass
 class AdditionalSwiftSourcesArguments(RunnerArguments):
+    scheme_name: str
     args: CliArguments
     repo_info: str
     repo_branch: str