git-p4son 0.4.1__tar.gz → 0.4.2__tar.gz

{git_p4son-0.4.1 → git_p4son-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.4.1
+Version: 0.4.2
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -298,7 +298,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force] [--dry-run]
+git p4son sync [changelist ...] [--force] [--dry-run] [--ignore-blocking-processes]
 ```
 
 **Arguments:**
@@ -311,6 +311,7 @@ git p4son sync [changelist ...] [--force] [--dry-run]
 - `-f, --force`: Allow syncing to changelists older than the current one.
 - `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
   real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -324,6 +325,24 @@ git p4son sync 12345 --force
 git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
+#### Blocking processes
+
+Syncing while e.g. the Unreal editor is open lets p4 replace assets the editor still has loaded, so the editor
+keeps working against files that no longer match what is on disk. List such processes in `.git-p4son/config.toml`
+and `sync` refuses to start while any of them is running:
+
+```toml
+[sync]
+blocking-processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers `UnrealEditor.exe` on
+Windows and `UnrealEditor` on macOS. The check runs before the clean-workspace checks and the pre-sync hooks. A
+setting that is present but malformed, or a process list that cannot be read, aborts the sync rather than silently
+skipping the check.
+
+Pass `--ignore-blocking-processes` to sync once without the check, or remove the setting to turn it off for good.
+
 #### pre-sync hook
 
 Before `git-p4son sync` syncs any changelist, git-p4son runs [hooks](#hooks) from
@@ -340,7 +359,7 @@ from `.git-p4son/hooks/post-sync/`.
 Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
 
 ```sh
-git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run] [--ignore-blocking-processes]
 ```
 
 Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
@@ -354,11 +373,12 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
-resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
-thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
-dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
-and not at all for a `--dry-run` or when there is nothing to sync.
+resolved, so [pre-sync and post-sync hooks](#hooks), [blocking processes](#blocking-processes), writable-file
+merging, and the clean-workspace checks all behave exactly as they do for `sync`. The blocking processes check,
+the clean-workspace checks and the pre-sync hooks are the one thing that runs earlier: resolving the sequence
+costs several Perforce queries, so they go first, and a running blocking process, a dirty workspace or a hook
+that aborts the sync says so before that work. They run once for the whole sync, and not at all for a
+`--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -368,6 +388,7 @@ and not at all for a `--dry-run` or when there is nothing to sync.
 - `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
   select several users. Defaults to the current p4 user (from `p4 info`).
 - `-n, --dry-run`: Print the resolved sync sequence without syncing.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -714,49 +735,6 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
-### Example hooks
-
-The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
-symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
-up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
-clone, so no `chmod` is needed.
-
-#### block-while-running (pre-sync)
-
-Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
-
-```sh
-ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
-```
-
-On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
-reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
-against the current directory and quietly produces a broken link.
-
-```powershell
-New-Item -ItemType SymbolicLink `
-  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
-  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
-```
-
-Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
-For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
-
-Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
-stays per-project:
-
-```toml
-[hooks.block-while-running]
-processes = ["UnrealEditor", "UnrealLightmass"]
-```
-
-Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
-`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
-sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
-
-Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
-
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

{git_p4son-0.4.1 → git_p4son-0.4.2}/README.md

@@ -275,7 +275,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force] [--dry-run]
+git p4son sync [changelist ...] [--force] [--dry-run] [--ignore-blocking-processes]
 ```
 
 **Arguments:**
@@ -288,6 +288,7 @@ git p4son sync [changelist ...] [--force] [--dry-run]
 - `-f, --force`: Allow syncing to changelists older than the current one.
 - `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
   real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -301,6 +302,24 @@ git p4son sync 12345 --force
 git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
+#### Blocking processes
+
+Syncing while e.g. the Unreal editor is open lets p4 replace assets the editor still has loaded, so the editor
+keeps working against files that no longer match what is on disk. List such processes in `.git-p4son/config.toml`
+and `sync` refuses to start while any of them is running:
+
+```toml
+[sync]
+blocking-processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers `UnrealEditor.exe` on
+Windows and `UnrealEditor` on macOS. The check runs before the clean-workspace checks and the pre-sync hooks. A
+setting that is present but malformed, or a process list that cannot be read, aborts the sync rather than silently
+skipping the check.
+
+Pass `--ignore-blocking-processes` to sync once without the check, or remove the setting to turn it off for good.
+
 #### pre-sync hook
 
 Before `git-p4son sync` syncs any changelist, git-p4son runs [hooks](#hooks) from
@@ -317,7 +336,7 @@ from `.git-p4son/hooks/post-sync/`.
 Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
 
 ```sh
-git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run] [--ignore-blocking-processes]
 ```
 
 Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
@@ -331,11 +350,12 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
-resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
-thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
-dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
-and not at all for a `--dry-run` or when there is nothing to sync.
+resolved, so [pre-sync and post-sync hooks](#hooks), [blocking processes](#blocking-processes), writable-file
+merging, and the clean-workspace checks all behave exactly as they do for `sync`. The blocking processes check,
+the clean-workspace checks and the pre-sync hooks are the one thing that runs earlier: resolving the sequence
+costs several Perforce queries, so they go first, and a running blocking process, a dirty workspace or a hook
+that aborts the sync says so before that work. They run once for the whole sync, and not at all for a
+`--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -345,6 +365,7 @@ and not at all for a `--dry-run` or when there is nothing to sync.
 - `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
   select several users. Defaults to the current p4 user (from `p4 info`).
 - `-n, --dry-run`: Print the resolved sync sequence without syncing.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -691,49 +712,6 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
-### Example hooks
-
-The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
-symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
-up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
-clone, so no `chmod` is needed.
-
-#### block-while-running (pre-sync)
-
-Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
-
-```sh
-ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
-```
-
-On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
-reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
-against the current directory and quietly produces a broken link.
-
-```powershell
-New-Item -ItemType SymbolicLink `
-  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
-  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
-```
-
-Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
-For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
-
-Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
-stays per-project:
-
-```toml
-[hooks.block-while-running]
-processes = ["UnrealEditor", "UnrealLightmass"]
-```
-
-Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
-`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
-sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
-
-Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
-
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

{git_p4son-0.4.1 → git_p4son-0.4.2}/git_p4son/__init__.py

@@ -7,6 +7,6 @@ creating and updating changelists, and managing Swarm reviews.
 
 CONFIG_DIR = '.git-p4son'
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"
 __author__ = "Andreas Andersson"
 __email__ = "andreas@neoboid.com"

{git_p4son-0.4.1 → git_p4son-0.4.2}/git_p4son/cli.py

@@ -109,6 +109,11 @@ Examples:
         action='store_true',
         help='Print the resolved sync sequence without syncing'
     )
+    sync_parser.add_argument(
+        '--ignore-blocking-processes',
+        action='store_true',
+        help='Sync even while a configured blocking process is running'
+    )
 
     # Sync-split subcommand
     sync_split_parser = subparsers.add_parser(
@@ -141,6 +146,11 @@ Examples:
         action='store_true',
         help='Print the resolved sync sequence without syncing'
     )
+    sync_split_parser.add_argument(
+        '--ignore-blocking-processes',
+        action='store_true',
+        help='Sync even while a configured blocking process is running'
+    )
 
     # New subcommand
     new_parser = subparsers.add_parser(

git_p4son-0.4.2/git_p4son/processes.py

@@ -0,0 +1,98 @@
+"""
+Blocking processes for git-p4son.
+
+A sync is refused while any of the configured blocking processes is running.
+Syncing while e.g. the Unreal editor is open lets p4 replace assets the editor
+still has loaded, so the editor keeps working against files that no longer
+match what is on disk.
+"""
+
+import csv
+import os
+
+from .common import RunError, run
+from .config import load_config
+from .log import log
+
+IGNORE_FLAG = '--ignore-blocking-processes'
+
+
+def get_blocking_processes(workspace_dir: str) -> list[str]:
+    """Return the configured blocking process names; raise ValueError if malformed."""
+    sync = load_config(workspace_dir).get('sync', {})
+    if not isinstance(sync, dict):
+        raise ValueError('sync in config.toml is not a table')
+    names = sync.get('blocking-processes', [])
+    if (not isinstance(names, list)
+            or not all(isinstance(name, str) for name in names)):
+        raise ValueError(
+            'sync.blocking-processes in config.toml must be a list of strings')
+    return names
+
+
+def normalize_process_name(name: str) -> str:
+    """Reduce a process name to a form comparable across platforms.
+
+    Any directory and .exe suffix are dropped and case is ignored, so
+    "UnrealEditor" matches "UnrealEditor.exe" on Windows and a full path in
+    ps output."""
+    name = os.path.basename(name.strip())
+    if name.lower().endswith('.exe'):
+        name = name[:-len('.exe')]
+    return name.lower()
+
+
+def get_running_processes() -> set[str]:
+    """Return the normalized names of all currently running processes."""
+    if os.name == 'nt':
+        # /NH drops the header row. CSV output keeps an image name that
+        # contains spaces or commas inside one quoted field.
+        result = run(['tasklist', '/NH', '/FO', 'CSV'])
+        lines = [line for line in result.stdout if line.strip()]
+        return {normalize_process_name(row[0])
+                for row in csv.reader(lines) if row}
+    # -ww stops ps truncating output to the terminal width, which would
+    # otherwise cut long process names short.
+    result = run(['ps', '-A', '-ww', '-o', 'comm='])
+    return {normalize_process_name(line)
+            for line in result.stdout if line.strip()}
+
+
+def check_no_blocking_processes(workspace_dir: str, ignore: bool) -> bool:
+    """Report whether the sync may go ahead as far as running processes go.
+
+    Nothing configured means nothing to check, so no process listing is
+    made. A malformed config or a process list that cannot be read fails
+    the check: going ahead would silently drop the protection. ignore skips
+    all of it, config included."""
+    if ignore:
+        log.heading('Checking for blocking processes')
+        log.warning(f'Skipped ({IGNORE_FLAG})')
+        return True
+
+    try:
+        names = get_blocking_processes(workspace_dir)
+    except ValueError as error:
+        log.error(f'Could not read the blocking processes: {error}')
+        return False
+    if not names:
+        return True
+
+    log.heading('Checking for blocking processes')
+    try:
+        running = get_running_processes()
+    except (OSError, RunError) as error:
+        log.error(f'Could not list running processes: {error}')
+        return False
+
+    blocking = sorted(name for name in names
+                      if normalize_process_name(name) in running)
+    if not blocking:
+        log.success('None running')
+        return True
+
+    for name in blocking:
+        log.info(name)
+    log.error('Refusing to sync while these blocking processes are running. '
+              f'Close them and sync again, or pass {IGNORE_FLAG}')
+    return False

{git_p4son-0.4.1 → git_p4son-0.4.2}/git_p4son/sync.py

@@ -23,6 +23,7 @@ from .hooks import run_hooks
 from .lib import check_git_workspace_clean
 from .depot import resolve_depot_root
 from .log import log
+from .processes import check_no_blocking_processes
 from .writable import is_writable_mode, make_writable
 from .perforce import (
     get_latest_changelist,
@@ -645,8 +646,10 @@ def _run_pre_sync_hooks(workspace_dir: str, invocation_dir: str) -> bool:
 
 
 def sync_preflight(depot_root: str, workspace_dir: str, invocation_dir: str,
-                   already_done: bool = False) -> bool:
-    """Gate a sync: both workspaces clean, then the pre-sync hooks.
+                   already_done: bool = False,
+                   ignore_blocking_processes: bool = False) -> bool:
+    """Gate a sync: no blocking processes, both workspaces clean, then the
+    pre-sync hooks.
 
     Returns False when the sync must not go ahead. Callers run this once they
     know a sync will actually be attempted, so that a run with nothing to sync
@@ -657,6 +660,11 @@ def sync_preflight(depot_root: str, workspace_dir: str, invocation_dir: str,
     """
     if already_done:
         return True
+    # First: it is the cheapest check, and an editor left open is the most
+    # common reason not to sync.
+    if not check_no_blocking_processes(workspace_dir,
+                                       ignore_blocking_processes):
+        return False
     if not check_git_workspace_clean(workspace_dir):
         return False
     if not _check_p4_workspace_clean(depot_root, workspace_dir):
@@ -776,6 +784,8 @@ def sync_command(args: argparse.Namespace) -> int:
     workspace_dir = args.workspace_dir
     invocation_dir = vars(args).get('invocation_dir', workspace_dir)
     preflight_done = vars(args).get('preflight_done', False)
+    ignore_blocking_processes = vars(args).get('ignore_blocking_processes',
+                                               False)
 
     # sync-split resolves the depot root before handing over, so it passes
     # the result on rather than having the client spec queried twice.
@@ -846,11 +856,12 @@ def sync_command(args: argparse.Namespace) -> int:
     if not _handle_clobber_warning(clobber, workspace_dir):
         return 1
 
-    # The single gate: both workspaces clean, then the pre-sync hooks. Runs
-    # once for the whole sync, covering the catch-up pass as well, and is
-    # skipped outright when the caller (sync-split) already ran it.
+    # The single gate: no blocking processes, both workspaces clean, then
+    # the pre-sync hooks. Runs once for the whole sync, covering the
+    # catch-up pass as well, and is skipped outright when the caller
+    # (sync-split) already ran it.
     if not sync_preflight(depot_root, workspace_dir, invocation_dir,
-                          preflight_done):
+                          preflight_done, ignore_blocking_processes):
         return 1
 
     log.heading('Finding HEAD commit')

{git_p4son-0.4.1 → git_p4son-0.4.2}/git_p4son/sync_split.py

@@ -117,7 +117,9 @@ def sync_split_command(args: argparse.Namespace) -> int:
     # sync_command is told it is done so none of it happens twice, and a dry
     # run syncs nothing, so it skips the gate entirely.
     if not args.dry_run:
-        if not sync_preflight(depot_root, workspace_dir, invocation_dir):
+        if not sync_preflight(
+                depot_root, workspace_dir, invocation_dir,
+                ignore_blocking_processes=args.ignore_blocking_processes):
             return 1
         args.preflight_done = True
 

{git_p4son-0.4.1 → git_p4son-0.4.2}/git_p4son.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.4.1
+Version: 0.4.2
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -298,7 +298,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force] [--dry-run]
+git p4son sync [changelist ...] [--force] [--dry-run] [--ignore-blocking-processes]
 ```
 
 **Arguments:**
@@ -311,6 +311,7 @@ git p4son sync [changelist ...] [--force] [--dry-run]
 - `-f, --force`: Allow syncing to changelists older than the current one.
 - `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
   real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -324,6 +325,24 @@ git p4son sync 12345 --force
 git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
+#### Blocking processes
+
+Syncing while e.g. the Unreal editor is open lets p4 replace assets the editor still has loaded, so the editor
+keeps working against files that no longer match what is on disk. List such processes in `.git-p4son/config.toml`
+and `sync` refuses to start while any of them is running:
+
+```toml
+[sync]
+blocking-processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers `UnrealEditor.exe` on
+Windows and `UnrealEditor` on macOS. The check runs before the clean-workspace checks and the pre-sync hooks. A
+setting that is present but malformed, or a process list that cannot be read, aborts the sync rather than silently
+skipping the check.
+
+Pass `--ignore-blocking-processes` to sync once without the check, or remove the setting to turn it off for good.
+
 #### pre-sync hook
 
 Before `git-p4son sync` syncs any changelist, git-p4son runs [hooks](#hooks) from
@@ -340,7 +359,7 @@ from `.git-p4son/hooks/post-sync/`.
 Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
 
 ```sh
-git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run] [--ignore-blocking-processes]
 ```
 
 Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
@@ -354,11 +373,12 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
-resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
-thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
-dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
-and not at all for a `--dry-run` or when there is nothing to sync.
+resolved, so [pre-sync and post-sync hooks](#hooks), [blocking processes](#blocking-processes), writable-file
+merging, and the clean-workspace checks all behave exactly as they do for `sync`. The blocking processes check,
+the clean-workspace checks and the pre-sync hooks are the one thing that runs earlier: resolving the sequence
+costs several Perforce queries, so they go first, and a running blocking process, a dirty workspace or a hook
+that aborts the sync says so before that work. They run once for the whole sync, and not at all for a
+`--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -368,6 +388,7 @@ and not at all for a `--dry-run` or when there is nothing to sync.
 - `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
   select several users. Defaults to the current p4 user (from `p4 info`).
 - `-n, --dry-run`: Print the resolved sync sequence without syncing.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -714,49 +735,6 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
-### Example hooks
-
-The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
-symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
-up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
-clone, so no `chmod` is needed.
-
-#### block-while-running (pre-sync)
-
-Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
-
-```sh
-ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
-```
-
-On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
-reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
-against the current directory and quietly produces a broken link.
-
-```powershell
-New-Item -ItemType SymbolicLink `
-  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
-  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
-```
-
-Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
-For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
-
-Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
-stays per-project:
-
-```toml
-[hooks.block-while-running]
-processes = ["UnrealEditor", "UnrealLightmass"]
-```
-
-Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
-`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
-sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
-
-Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
-
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

{git_p4son-0.4.1 → git_p4son-0.4.2}/git_p4son.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ git_p4son/list_changes.py
 git_p4son/log.py
 git_p4son/new.py
 git_p4son/perforce.py
+git_p4son/processes.py
 git_p4son/review.py
 git_p4son/state.py
 git_p4son/sync.py
@@ -50,6 +51,7 @@ tests/test_list_changes.py
 tests/test_log.py
 tests/test_new.py
 tests/test_perforce.py
+tests/test_processes.py
 tests/test_review.py
 tests/test_state.py
 tests/test_sync.py

{git_p4son-0.4.1 → git_p4son-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "git-p4son"
-version = "0.4.1"
+version = "0.4.2"
 description = "Utility for keeping a Perforce workspace and local git repo in sync"
 readme = "README.md"
 requires-python = ">=3.11"

{git_p4son-0.4.1 → git_p4son-0.4.2}/tests/test_cli.py

@@ -53,6 +53,14 @@ class TestCreateParser(unittest.TestCase):
             args = self.parser.parse_args(['sync', flag])
             self.assertTrue(args.dry_run)
 
+    def test_ignore_blocking_processes(self):
+        for command in ('sync', 'sync-split'):
+            self.assertFalse(self.parser.parse_args(
+                [command]).ignore_blocking_processes)
+            self.assertTrue(self.parser.parse_args(
+                [command, '--ignore-blocking-processes'])
+                .ignore_blocking_processes)
+
     def test_new_command_no_message(self):
         args = self.parser.parse_args(['new'])
         self.assertEqual(args.command, 'new')

git_p4son-0.4.2/tests/test_processes.py

@@ -0,0 +1,153 @@
+"""Tests for git_p4son.processes module."""
+
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+from git_p4son.common import RunError
+from git_p4son.processes import (
+    check_no_blocking_processes, get_blocking_processes,
+    get_running_processes, normalize_process_name,
+)
+from tests.helpers import make_run_result
+
+
+class _WorkspaceTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.workspace = self._tmp.name
+
+    def write_config(self, text):
+        config_dir = os.path.join(self.workspace, '.git-p4son')
+        os.makedirs(config_dir, exist_ok=True)
+        with open(os.path.join(config_dir, 'config.toml'), 'w',
+                  encoding='utf-8') as f:
+            f.write(text)
+
+
+class TestGetBlockingProcesses(_WorkspaceTestCase):
+
+    def test_no_config_file(self):
+        self.assertEqual(get_blocking_processes(self.workspace), [])
+
+    def test_no_sync_table(self):
+        self.write_config('[depot]\nroot = "//ws"\n')
+        self.assertEqual(get_blocking_processes(self.workspace), [])
+
+    def test_no_key(self):
+        self.write_config('[sync]\nother = 1\n')
+        self.assertEqual(get_blocking_processes(self.workspace), [])
+
+    def test_names(self):
+        self.write_config(
+            '[sync]\nblocking-processes = ["UnrealEditor", "Lightmass"]\n')
+        self.assertEqual(get_blocking_processes(self.workspace),
+                         ['UnrealEditor', 'Lightmass'])
+
+    def test_not_a_list(self):
+        self.write_config('[sync]\nblocking-processes = "UnrealEditor"\n')
+        with self.assertRaises(ValueError):
+            get_blocking_processes(self.workspace)
+
+    def test_non_string_entry(self):
+        self.write_config('[sync]\nblocking-processes = ["a", 1]\n')
+        with self.assertRaises(ValueError):
+            get_blocking_processes(self.workspace)
+
+    def test_sync_not_a_table(self):
+        self.write_config('sync = 1\n')
+        with self.assertRaises(ValueError):
+            get_blocking_processes(self.workspace)
+
+
+class TestNormalizeProcessName(unittest.TestCase):
+
+    def test_strips_exe_and_case(self):
+        self.assertEqual(normalize_process_name('UnrealEditor.EXE'),
+                         'unrealeditor')
+
+    def test_strips_directory_and_whitespace(self):
+        self.assertEqual(
+            normalize_process_name(
+                '  /Applications/Foo.app/Contents/MacOS/Foo \n'),
+            'foo')
+
+    def test_exe_only_stripped_as_suffix(self):
+        self.assertEqual(normalize_process_name('exeditor'), 'exeditor')
+
+
+class TestGetRunningProcesses(unittest.TestCase):
+
+    @mock.patch('git_p4son.processes.os.name', 'posix')
+    @mock.patch('git_p4son.processes.run')
+    def test_ps(self, mock_run):
+        mock_run.return_value = make_run_result(
+            stdout=['/usr/bin/zsh', '', 'UnrealEditor'])
+        self.assertEqual(get_running_processes(), {'zsh', 'unrealeditor'})
+        self.assertEqual(mock_run.call_args.args[0][0], 'ps')
+
+    @mock.patch('git_p4son.processes.os.name', 'nt')
+    @mock.patch('git_p4son.processes.run')
+    def test_tasklist(self, mock_run):
+        mock_run.return_value = make_run_result(stdout=[
+            '',
+            '"UnrealEditor.exe","1234","Console","1","2,000 K"',
+            '"My, App.exe","42","Console","1","100 K"',
+        ])
+        self.assertEqual(get_running_processes(),
+                         {'unrealeditor', 'my, app'})
+        self.assertEqual(mock_run.call_args.args[0][0], 'tasklist')
+
+
+class TestCheckNoBlockingProcesses(_WorkspaceTestCase):
+
+    def setUp(self):
+        super().setUp()
+        patcher = mock.patch('git_p4son.processes.log')
+        self.mock_log = patcher.start()
+        self.addCleanup(patcher.stop)
+        patcher = mock.patch('git_p4son.processes.get_running_processes',
+                             return_value={'zsh', 'unrealeditor'})
+        self.mock_running = patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_nothing_configured_lists_nothing(self):
+        self.assertTrue(check_no_blocking_processes(self.workspace, False))
+        self.mock_running.assert_not_called()
+
+    def test_none_running(self):
+        self.write_config('[sync]\nblocking-processes = ["Lightmass"]\n')
+        self.assertTrue(check_no_blocking_processes(self.workspace, False))
+
+    def test_running_blocks(self):
+        self.write_config(
+            '[sync]\nblocking-processes = ["UnrealEditor.exe", "Lightmass"]\n')
+        self.assertFalse(check_no_blocking_processes(self.workspace, False))
+        self.mock_log.info.assert_called_once_with('UnrealEditor.exe')
+
+    def test_ignore_skips_listing(self):
+        self.write_config('[sync]\nblocking-processes = ["UnrealEditor"]\n')
+        self.assertTrue(check_no_blocking_processes(self.workspace, True))
+        self.mock_running.assert_not_called()
+
+    def test_ignore_skips_malformed_config(self):
+        self.write_config('[sync]\nblocking-processes = "UnrealEditor"\n')
+        self.assertTrue(check_no_blocking_processes(self.workspace, True))
+
+    def test_malformed_config_fails(self):
+        self.write_config('[sync]\nblocking-processes = "UnrealEditor"\n')
+        self.assertFalse(check_no_blocking_processes(self.workspace, False))
+
+    def test_invalid_toml_fails(self):
+        self.write_config('[sync\n')
+        self.assertFalse(check_no_blocking_processes(self.workspace, False))
+
+    def test_listing_failure_fails(self):
+        self.write_config('[sync]\nblocking-processes = ["UnrealEditor"]\n')
+        for error in (OSError('no ps'), RunError('ps failed')):
+            self.mock_running.side_effect = error
+            self.assertFalse(
+                check_no_blocking_processes(self.workspace, False))

{git_p4son-0.4.1 → git_p4son-0.4.2}/tests/test_sync_split.py

@@ -117,7 +117,7 @@ class TestSyncSplitCommand(unittest.TestCase):
 
     def _args(self, **overrides):
         values = dict(changelist=None, user=None, dry_run=False,
-                      workspace_dir='/ws')
+                      ignore_blocking_processes=False, workspace_dir='/ws')
         values.update(overrides)
         return mock.Mock(**values)
 
@@ -244,7 +244,7 @@ class TestSyncSplitPreSyncHooks(unittest.TestCase):
 
     def _args(self, **overrides):
         values = dict(changelist=None, user=None, dry_run=False,
-                      workspace_dir='/ws', invocation_dir='/invoked')
+                      ignore_blocking_processes=False, workspace_dir='/ws', invocation_dir='/invoked')
         values.update(overrides)
         return argparse.Namespace(**values)
 
@@ -281,6 +281,19 @@ class TestSyncSplitPreSyncHooks(unittest.TestCase):
         sync_split_command(args)
         self.assertTrue(args.preflight_done)
 
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes', return_value=[])
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    @mock.patch('git_p4son.sync_split.sync_preflight', return_value=True)
+    def test_ignore_blocking_processes_reaches_the_gate(
+            self, mock_gate, _last_sync, _latest, _user, _changes, _sync):
+        sync_split_command(self._args(ignore_blocking_processes=True))
+        self.assertTrue(
+            mock_gate.call_args.kwargs['ignore_blocking_processes'])
+
     @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
     @mock.patch('git_p4son.sync_split.get_submitted_changes', return_value=[])
     @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
@@ -348,15 +361,42 @@ class TestSyncSplitPreSyncHooks(unittest.TestCase):
 
 
 class TestSyncPreflight(unittest.TestCase):
-    """The one gate both commands share: workspace checks then hooks, in
-    that order, and skipped wholesale when a caller already ran it."""
+    """The one gate both commands share: blocking processes, workspace
+    checks then hooks, in that order, and skipped wholesale when a caller
+    already ran it."""
+
+    @mock.patch('git_p4son.sync.run_hooks')
+    @mock.patch('git_p4son.sync.p4_get_opened_files')
+    @mock.patch('git_p4son.lib.get_dirty_files')
+    @mock.patch('git_p4son.sync.check_no_blocking_processes',
+                return_value=False)
+    def test_blocking_process_stops_before_everything_else(
+            self, mock_blocking, mock_dirty, mock_opened, mock_run_hooks):
+        self.assertFalse(sync_preflight('//ws', '/ws', '/invoked'))
+        mock_blocking.assert_called_once_with('/ws', False)
+        mock_dirty.assert_not_called()
+        mock_opened.assert_not_called()
+        mock_run_hooks.assert_not_called()
+
+    @mock.patch('git_p4son.sync.run_hooks', return_value=[])
+    @mock.patch('git_p4son.sync.p4_get_opened_files', return_value=[])
+    @mock.patch('git_p4son.lib.get_dirty_files', return_value=[])
+    @mock.patch('git_p4son.sync.check_no_blocking_processes',
+                return_value=True)
+    def test_ignore_blocking_processes_is_passed_on(
+            self, mock_blocking, _dirty, _opened, _hooks):
+        self.assertTrue(sync_preflight('//ws', '/ws', '/invoked',
+                                       ignore_blocking_processes=True))
+        mock_blocking.assert_called_once_with('/ws', True)
 
     @mock.patch('git_p4son.sync.run_hooks')
     @mock.patch('git_p4son.sync.p4_get_opened_files')
     @mock.patch('git_p4son.lib.get_dirty_files')
+    @mock.patch('git_p4son.sync.check_no_blocking_processes')
     def test_already_done_skips_everything(
-            self, mock_dirty, mock_opened, mock_run_hooks):
+            self, mock_blocking, mock_dirty, mock_opened, mock_run_hooks):
         self.assertTrue(sync_preflight('//ws', '/ws', '/invoked', True))
+        mock_blocking.assert_not_called()
         mock_dirty.assert_not_called()
         mock_opened.assert_not_called()
         mock_run_hooks.assert_not_called()
@@ -414,7 +454,7 @@ class TestSyncSplitCommandMultiUser(unittest.TestCase):
 
     def _args(self, **overrides):
         values = dict(changelist=None, user=None, dry_run=False,
-                      workspace_dir='/ws')
+                      ignore_blocking_processes=False, workspace_dir='/ws')
         values.update(overrides)
         return mock.Mock(**values)