[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 TestIsAnyRepositoryLocked(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", output)
+            self.assertIn("  - repo_2", 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 run_status
+
+__all__ = ["run_status"]

utils/update_checkout/update_checkout/commands/status.py

@@ -0,0 +1,65 @@
+from typing import List
+
+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,
+)
+
+
+def run_status(args: CliArguments) -> int:
+    skipped_repositories = []
+    pool_args: List[UpdateArguments] = []
+    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,
+        )
+        pool_args.append(my_args)
+
+    locked_repositories = is_any_repository_locked(pool_args)
+    if len(locked_repositories) > 0:
+        return skipped_repositories, [
+            Exception(f"'{repo_name}' is locked by git. Cannot update it.")
+            for repo_name in locked_repositories
+        ]
+
+    results = ParallelRunner(
+        _get_uncommitted_changes_of_repository, pool_args, args.n_processes
+    ).run()
+
+    ret = ParallelRunner.check_results(results, "Status command")
+    if ret > 0:
+        return ret
+
+    repos_with_active_changes: List[str] = []
+    for result, pool_arg in zip(results, pool_args):
+        if results is None or result[0] == "":
+            continue
+        repos_with_active_changes.append(pool_arg.repo_name)
+
+    if len(repos_with_active_changes) == 0:
+        print("No repositories have active changes.")
+    else:
+        print("The following repositories have active changes:")
+        for repo_name in repos_with_active_changes:
+            print(f"  - {repo_name}")
+
+    return 0
+
+
+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,36 @@ 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:
+    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

@@ -84,7 +84,7 @@ def __init__(
     ):
         def run_safely(*args, **kwargs):
             try:
-                fn(*args, **kwargs)
+                return fn(*args, **kwargs)
             except GitException as e:
                 return e
 
@@ -158,6 +158,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

utils/update_checkout/update_checkout/update_checkout.py

@@ -16,12 +16,13 @@
 import sys
 import traceback
 from multiprocessing import freeze_support
-from typing import Any, Dict, Hashable, Optional, Set, List, Tuple, Union
+from typing import Any, Dict, Hashable, Optional, List, Tuple, Union
 
 from .cli_arguments import CliArguments
-from .git_command import Git, GitException
+from .git_command import Git, GitException, is_any_repository_locked
 from .runner_arguments import AdditionalSwiftSourcesArguments, UpdateArguments
 from .parallel_runner import ParallelRunner
+from .commands import status
 
 
 SCRIPT_FILE = Path(__file__).absolute()
@@ -351,32 +352,6 @@ def get_scheme_map(
     return None
 
 
-def _is_any_repository_locked(pool_args: List[UpdateArguments]) -> 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[Any]): 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
-
-
 def _move_llvm_project_to_first_index(
     pool_args: Union[List[UpdateArguments], List[AdditionalSwiftSourcesArguments]],
 ):
@@ -438,7 +413,7 @@ def update_all_repositories(
         )
         pool_args.append(my_args)
 
-    locked_repositories: set[str] = _is_any_repository_locked(pool_args)
+    locked_repositories = is_any_repository_locked(pool_args)
     if len(locked_repositories) > 0:
         return skipped_repositories, [
             Exception(f"'{repo_name}' is locked by git. Cannot update it.")
@@ -585,6 +560,7 @@ def obtain_all_additional_swift_sources(
 
         new_args = AdditionalSwiftSourcesArguments(
             args=args,
+            source_root=args.source_root,
             repo_name=repo_name,
             repo_info=repo_info,
             repo_branch=repo_branch,
@@ -771,6 +747,9 @@ def main() -> int:
     freeze_support()
     args = CliArguments.parse_args()
 
+    if args.command == "status":
+        return status.run_status(args)
+
     if not args.scheme:
         if args.reset_to_remote:
             print(