apply thread locking to maybe_install

We need to protect the virtualenv where fromager runs and where we
install build tools. This change refactors the thread locking in another
function to create a reusable decorator which is then applied to the old
function and also to _safe_install().

Cursor logs: https://gist.github.com/dhellmann/b95c1545e462123904cb700793c18ec3

Signed-off-by: Doug Hellmann <dhellmann@redhat.com>

Author: dhellmann

src/fromager/build_environment.py

@@ -14,6 +14,7 @@
 
 from . import dependencies, external_commands, metrics, resolver
 from .requirements_file import RequirementType
+from .threading_utils import with_thread_lock
 
 if typing.TYPE_CHECKING:
     from . import context
@@ -268,6 +269,7 @@ def prepare_build_environment(
     return build_env
 
 
+@with_thread_lock()
 def _safe_install(
     ctx: context.WorkContext,
     req: Requirement,

src/fromager/server.py

@@ -9,6 +9,8 @@
 
 from packaging.utils import parse_wheel_filename
 
+from .threading_utils import with_thread_lock
+
 if typing.TYPE_CHECKING:
     from . import context
 
@@ -59,28 +61,24 @@ def serve_forever(server: http.server.ThreadingHTTPServer) -> None:
     return t
 
 
-# Lock for thread-safe wheel mirror updates
-_wheel_mirror_lock = threading.Lock()
-
-
+@with_thread_lock()
 def update_wheel_mirror(ctx: context.WorkContext) -> None:
-    with _wheel_mirror_lock:
-        for wheel in ctx.wheels_build.glob("*.whl"):
-            logger.info("adding %s to local wheel server", wheel.name)
-            downloads_dest_filename = ctx.wheels_downloads / wheel.name
-            # Always move the file so the code managing the timer for the
-            # wheels does not find more than one wheel in the build
-            # directory.
-            shutil.move(wheel, downloads_dest_filename)
-
-        for wheel in ctx.wheels_downloads.glob("*.whl"):
-            # Now also symlink the files into the simple hierarchy. We always
-            # process all files to be safe.
-            (normalized_name, _, _, _) = parse_wheel_filename(wheel.name)
-            simple_dest_filename = ctx.wheel_server_dir / normalized_name / wheel.name
-            if simple_dest_filename.exists():
-                logger.debug("already have %s", simple_dest_filename)
-                continue
-            logger.debug("linking %s into local index", wheel.name)
-            simple_dest_filename.parent.mkdir(parents=True, exist_ok=True)
-            simple_dest_filename.symlink_to(wheel)
+    for wheel in ctx.wheels_build.glob("*.whl"):
+        logger.info("adding %s to local wheel server", wheel.name)
+        downloads_dest_filename = ctx.wheels_downloads / wheel.name
+        # Always move the file so the code managing the timer for the
+        # wheels does not find more than one wheel in the build
+        # directory.
+        shutil.move(wheel, downloads_dest_filename)
+
+    for wheel in ctx.wheels_downloads.glob("*.whl"):
+        # Now also symlink the files into the simple hierarchy. We always
+        # process all files to be safe.
+        (normalized_name, _, _, _) = parse_wheel_filename(wheel.name)
+        simple_dest_filename = ctx.wheel_server_dir / normalized_name / wheel.name
+        if simple_dest_filename.exists():
+            logger.debug("already have %s", simple_dest_filename)
+            continue
+        logger.debug("linking %s into local index", wheel.name)
+        simple_dest_filename.parent.mkdir(parents=True, exist_ok=True)
+        simple_dest_filename.symlink_to(wheel)

src/fromager/threading_utils.py

@@ -0,0 +1,27 @@
+"""Threading utilities for the fromager package."""
+
+import functools
+import threading
+import typing
+
+
+def with_thread_lock() -> typing.Callable[[typing.Callable], typing.Callable]:
+    """Decorator factory that creates a thread-safe wrapper for a function.
+
+    Each decorated function gets its own lock instance, ensuring that different
+    functions using this decorator don't block each other.
+
+    Returns:
+        A decorator that wraps the target function with thread-safe execution
+    """
+    lock = threading.Lock()
+
+    def decorator(func: typing.Callable) -> typing.Callable:
+        @functools.wraps(func)
+        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            with lock:
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator