fmu-settings 0.2.0__tar.gz → 0.3.1__tar.gz

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-settings
-Version: 0.2.0
+Version: 0.3.1
 Summary: A library for managing FMU settings
 Author-email: Equinor <fg-fmu_atlas@equinor.com>
 License: GPL-3.0

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu/settings/__init__.py

@@ -3,7 +3,7 @@
 try:
     from ._version import version
 
-    __version__ = version
+    __version__: str = version
 except ImportError:
     __version__ = version = "0.0.0"
 

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu/settings/_fmu_dir.py

@@ -8,6 +8,7 @@ from ._resources.config_managers import (
     ProjectConfigManager,
     UserConfigManager,
 )
+from ._resources.lock_manager import LockManager
 from .models.project_config import ProjectConfig
 from .models.user_config import UserConfig
 
@@ -20,6 +21,7 @@ class FMUDirectoryBase:
     """Provides access to a .fmu directory and operations on its contents."""
 
     config: FMUConfigManager
+    _lock: LockManager
 
     def __init__(self: Self, base_path: str | Path) -> None:
         """Initializes access to a .fmu directory.
@@ -35,6 +37,7 @@ class FMUDirectoryBase:
         """
         self.base_path = Path(base_path).resolve()
         logger.debug(f"Initializing FMUDirectory from '{base_path}'")
+        self._lock = LockManager(self)
 
         fmu_dir = self.base_path / ".fmu"
         if fmu_dir.exists():

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu/settings/_resources/config_managers.py

@@ -4,14 +4,13 @@ from __future__ import annotations
 
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final, Self, TypeVar
-from uuid import UUID  # noqa TC003
 
 from pydantic import ValidationError
 
 from fmu.settings._logging import null_logger
 from fmu.settings.models.project_config import ProjectConfig
 from fmu.settings.models.user_config import UserConfig
-from fmu.settings.types import ResettableBaseModel, VersionStr  # noqa TC001
+from fmu.settings.types import ResettableBaseModel  # noqa: TC001
 
 from .pydantic_resource_manager import PydanticResourceManager
 

fmu_settings-0.3.1/src/fmu/settings/_resources/lock_manager.py

@@ -0,0 +1,281 @@
+"""Manages a .lock file in a .fmu/ directory."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import socket
+import time
+import uuid
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, Literal, Self
+
+from fmu.settings._logging import null_logger
+from fmu.settings.models.lock_info import LockInfo
+
+from .pydantic_resource_manager import PydanticResourceManager
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    # Avoid circular dependency for type hint in __init__ only
+    from fmu.settings._fmu_dir import (
+        FMUDirectoryBase,
+    )
+
+logger: Final = null_logger(__name__)
+
+DEFAULT_LOCK_TIMEOUT: Final[int] = 1200  # 20 minutes
+
+
+class LockError(Exception):
+    """Raised when the lock cannot be acquired."""
+
+
+class LockManager(PydanticResourceManager[LockInfo]):
+    """Manages the .lock file."""
+
+    def __init__(
+        self: Self,
+        fmu_dir: FMUDirectoryBase,
+        timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+    ) -> None:
+        """Initializes the lock manager.
+
+        Args:
+            fmu_dir: The FMUDirectory instance
+            timeout_seconds: Lock expiration time in seconds (default 20 minutes)
+        """
+        super().__init__(fmu_dir, LockInfo)
+        self._timeout_seconds = timeout_seconds
+        self._acquired_at: float | None = None
+
+    @property
+    def relative_path(self: Self) -> Path:
+        """Returns the relative path to the .lock file."""
+        return Path(".lock")
+
+    def acquire(self: Self, wait: bool = False, wait_timeout: float = 5.0) -> None:
+        """Acquire the lock.
+
+        Args:
+            wait: If true, wait for lock to become available
+            wait_timeout: Maximum time to wait in seconds
+
+        Raises:
+            LockError: If lock cannot be acquired
+        """
+        if self._acquired_at is not None:
+            raise LockError("Lock already acquired")
+
+        if wait and wait_timeout <= 0:
+            raise ValueError("wait_timeout must be positive")
+
+        start_time = time.time()
+
+        while True:
+            if self.exists and self._is_stale():
+                with contextlib.suppress(OSError):
+                    self.path.unlink()
+
+            if self._try_acquire():
+                return
+
+            if not wait:
+                lock_info = self._safe_load()
+                if lock_info:
+                    raise LockError(
+                        f"Lock file is held by {lock_info.user}@{lock_info.hostname} "
+                        f"(PID: {lock_info.pid}). "
+                        f"Expires at: {time.ctime(lock_info.expires_at)}."
+                    )
+                raise LockError(
+                    f"Invalid lock file exists at {self.path}. "
+                    "This file should be removed."
+                )
+
+            if time.time() - start_time > wait_timeout:
+                raise LockError(f"Timeout waiting for lock after {wait_timeout}s")
+
+            time.sleep(0.5)
+
+    def _try_acquire(self: Self) -> bool:
+        """Try to acquire lock. Returns True if successful.
+
+        This method creates the lock as a temporary file first to avoid race conditions.
+        Because we are operating on networked filesystems (NFS) the situation is a bit
+        more complex, but os.link() is an atomic operation, so try to link the temp file
+        after creating it.
+
+        Returns:
+            True if acquiring the lock succeeded
+        """
+        acquired_at = time.time()
+        lock_info = LockInfo(
+            pid=os.getpid(),
+            hostname=socket.gethostname(),
+            user=os.getenv("USER", "unknown"),
+            acquired_at=acquired_at,
+            expires_at=acquired_at + self._timeout_seconds,
+        )
+
+        temp_path = (
+            self.path.parent
+            / f".lock.{lock_info.hostname}.{lock_info.pid}.{uuid.uuid4().hex[:8]}"
+        )
+        lock_fd: int | None = None
+        try:
+            # O_WRONLY will allow only this process to write to the lock file.
+            lock_fd = os.open(temp_path, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
+            try:
+                json_data = lock_info.model_dump_json(by_alias=True, indent=2)
+                os.write(lock_fd, json_data.encode())
+                os.fsync(lock_fd)
+            except Exception:
+                os.close(lock_fd)
+                raise
+
+            os.close(lock_fd)
+            lock_fd = None
+
+            try:
+                os.link(temp_path, self.path)
+                self._cache = lock_info
+                self._acquired_at = acquired_at
+                return True
+            except (OSError, FileExistsError):
+                return False
+        finally:  # Clean up temp file before we leave
+            if lock_fd is not None:
+                with contextlib.suppress(OSError):
+                    os.close(lock_fd)
+            with contextlib.suppress(OSError):
+                temp_path.unlink()
+
+    def is_locked(self: Self) -> bool:
+        """Returns whether or not the lock is locked by anyone.
+
+        This does a force load on the lock file.
+        """
+        lock_info = self._safe_load(force=True)
+        if not lock_info:
+            return False
+        return time.time() < lock_info.expires_at
+
+    def is_acquired(self: Self) -> bool:
+        """Returns whether or not the lock is currently acquired by this instance."""
+        if self._cache is None or self._acquired_at is None:
+            return False
+        return self._is_mine(self._cache) and not self._is_stale()
+
+    def refresh(self: Self) -> None:
+        """Refresh/extend the lock expiration time.
+
+        Raises:
+            LockError: If we don't hold the lock or it's invalid
+        """
+        if not self.exists:
+            raise LockError("Cannot refresh: lock file does not exist")
+
+        lock_info = self._safe_load()
+        if not lock_info or not self._is_mine(lock_info):
+            raise LockError(
+                "Cannot refresh: lock file is held by another process or host."
+            )
+
+        lock_info.expires_at = time.time() + self._timeout_seconds
+        self.save(lock_info)
+
+    def release(self: Self) -> None:
+        """Release the lock."""
+        if self.exists:
+            lock_info = self._safe_load()
+            if lock_info and self._is_mine(lock_info):
+                with contextlib.suppress(ValueError):
+                    self.path.unlink()
+
+        self._acquired_at = None
+        self._cache = None
+
+    def save(self: Self, data: LockInfo) -> None:
+        """Save the lockfile in an NFS-atomic manner.
+
+        This overrides save() from the Pydantic resource manager.
+        """
+        lock_info = self._safe_load()
+        if not lock_info or not self._is_mine(lock_info):
+            raise LockError(
+                "Failed to save lock: lock file is held by another process or host."
+            )
+
+        temp_path = Path(f"{self.path}.tmp.{uuid.uuid4().hex[:8]}")
+        try:
+            with open(temp_path, "w", encoding="utf-8") as f:
+                f.write(data.model_dump_json(indent=2))
+                f.flush()
+                os.fsync(f.fileno())
+            temp_path.replace(self.path)
+            self._cache = data
+        except Exception as e:
+            with contextlib.suppress(OSError):
+                temp_path.unlink()
+            raise LockError(f"Failed to save lock: {e}") from e
+
+    def _is_mine(self: Self, lock_info: LockInfo) -> bool:
+        """Verifies if the calling process owns the lock."""
+        return (
+            lock_info.pid == os.getpid()
+            and lock_info.hostname == socket.gethostname()
+            and lock_info.acquired_at == self._acquired_at
+        )
+
+    def _safe_load(self: Self, force: bool = False) -> LockInfo | None:
+        """Load lock info, returning None if corrupted.
+
+        Because this file does not exist in a static state, wrap around loading it.
+        """
+        try:
+            return self.load(force=force)
+        except Exception:
+            return None
+
+    def _is_stale(self: Self) -> bool:
+        """Check if existing lock is stale (expired or process dead)."""
+        lock_info = self._safe_load()
+        if not lock_info:
+            return True
+
+        if time.time() > lock_info.expires_at:
+            return True
+
+        # If we aren't on the same host, we can't check the PID, so assume it's
+        # not stale.
+        if lock_info.hostname != socket.gethostname():
+            return False
+
+        try:
+            # Doesn't actually kill, just checks if it exists
+            os.kill(lock_info.pid, 0)
+            return False
+        except OSError:
+            return True
+
+    def __enter__(self: Self) -> Self:
+        """Context manager entry."""
+        self.acquire()
+        return self
+
+    def __exit__(
+        self: Self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> Literal[False]:
+        """Context manager exit."""
+        self.release()
+        return False
+
+    def __del__(self: Self) -> None:
+        """Clean-up if garbage collected."""
+        if self._acquired_at is not None:
+            self.release()

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu/settings/_resources/pydantic_resource_manager.py

@@ -58,8 +58,8 @@ class PydanticResourceManager(Generic[T]):
             Validated Pydantic model
 
         Raises:
-            FileNotFoundError: If the resource file doesn't exist
-            ValidationError: If the data doesn't match the model schema
+            ValueError: If the resource file is missing or data does not match the
+            model schema
         """
         if self._cache is None or force:
             if not self.exists:

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu/settings/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)
 
-__commit_id__ = commit_id = 'g944134f32'
+__commit_id__ = commit_id = 'g7197724f6'

fmu_settings-0.3.1/src/fmu/settings/models/lock_info.py

@@ -0,0 +1,30 @@
+"""Models related to locking a .fmu directory against writes."""
+
+from pydantic import BaseModel, Field
+
+from fmu.settings import __version__
+from fmu.settings.types import VersionStr
+
+
+class LockInfo(BaseModel):
+    """Represents a .fmu directory lock file."""
+
+    pid: int
+    """Process ID of the lock holder."""
+
+    hostname: str
+    """Hostname where the lock was acquired."""
+
+    user: str
+    """User who acquired the lock."""
+
+    acquired_at: float
+    """Unix timestamp when lock was acquired."""
+
+    expires_at: float
+    """Unix timestamp when lock expires."""
+
+    version: VersionStr = Field(default=__version__)
+    """The fmu-settings version acquiring the lock.
+
+    Used for debugging."""

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu/settings/models/project_config.py

@@ -8,7 +8,7 @@ from pydantic import AwareDatetime, Field
 
 from fmu.datamodels.fmu_results.fields import Access, Masterdata, Model
 from fmu.settings import __version__
-from fmu.settings.types import ResettableBaseModel, VersionStr  # noqa TC001
+from fmu.settings.types import ResettableBaseModel, VersionStr  # noqa: TC001
 
 
 class ProjectConfig(ResettableBaseModel):

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu/settings/models/user_config.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Annotated, Self
-from uuid import UUID  # noqa TC003
 
 import annotated_types
 from pydantic import (
@@ -17,7 +16,7 @@ from pydantic import (
 )
 
 from fmu.settings import __version__
-from fmu.settings.types import ResettableBaseModel, VersionStr  # noqa TC001
+from fmu.settings.types import ResettableBaseModel, VersionStr  # noqa: TC001
 
 RecentProjectDirectories = Annotated[list[Path], annotated_types.Len(0, 5)]
 

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu_settings.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-settings
-Version: 0.2.0
+Version: 0.3.1
 Summary: A library for managing FMU settings
 Author-email: Equinor <fg-fmu_atlas@equinor.com>
 License: GPL-3.0

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/src/fmu_settings.egg-info/SOURCES.txt

@@ -19,10 +19,12 @@ src/fmu/settings/py.typed
 src/fmu/settings/types.py
 src/fmu/settings/_resources/__init__.py
 src/fmu/settings/_resources/config_managers.py
+src/fmu/settings/_resources/lock_manager.py
 src/fmu/settings/_resources/pydantic_resource_manager.py
 src/fmu/settings/models/__init__.py
 src/fmu/settings/models/_enums.py
 src/fmu/settings/models/_mappings.py
+src/fmu/settings/models/lock_info.py
 src/fmu/settings/models/project_config.py
 src/fmu/settings/models/user_config.py
 src/fmu_settings.egg-info/PKG-INFO
@@ -33,6 +35,7 @@ src/fmu_settings.egg-info/top_level.txt
 tests/conftest.py
 tests/test_fmu_dir.py
 tests/test_init.py
+tests/test_resources/test_lock_manager.py
 tests/test_resources/test_project_config.py
 tests/test_resources/test_resource_managers.py
 tests/test_resources/test_user_config.py

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/tests/conftest.py

@@ -136,7 +136,7 @@ def user_config_model(user_config_dict: dict[str, Any]) -> UserConfig:
     return UserConfig.model_validate(user_config_dict)
 
 
-@pytest.fixture
+@pytest.fixture(scope="function")
 def fmu_dir(tmp_path: Path, unix_epoch_utc: datetime) -> ProjectFMUDirectory:
     """Create an ProjectFMUDirectory instance for testing."""
     with (

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/tests/test_fmu_dir.py

@@ -326,3 +326,23 @@ def test_update_user_config_non_unique_recent_projects(
     updates = {"recent_project_directories": [Path("/foo/bar"), Path("/foo/bar")]}
     with pytest.raises(ValueError, match="unique entries"):
         user_fmu_dir.update_config(updates)
+
+
+def test_acquire_lock_on_project_fmu(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests that a lock can be acquired on the project dir."""
+    fmu_dir._lock.acquire()
+    assert fmu_dir._lock.is_acquired()
+    assert fmu_dir._lock.exists
+    assert (fmu_dir.path / ".lock").exists()
+
+
+def test_acquire_lock_on_user_fmu(
+    user_fmu_dir: UserFMUDirectory,
+) -> None:
+    """Tests that a lock can be acquired on the user dir."""
+    user_fmu_dir._lock.acquire()
+    assert user_fmu_dir._lock.is_acquired()
+    assert user_fmu_dir._lock.exists
+    assert (user_fmu_dir.path / ".lock").exists()

fmu_settings-0.3.1/tests/test_resources/test_lock_manager.py

@@ -0,0 +1,585 @@
+"""Tests for LockManager."""
+
+import json
+import multiprocessing
+import multiprocessing.queues
+import os
+import socket
+import threading
+import time
+import uuid
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from pytest import MonkeyPatch
+
+from fmu.settings._fmu_dir import ProjectFMUDirectory
+from fmu.settings._resources.lock_manager import (
+    DEFAULT_LOCK_TIMEOUT,
+    LockError,
+    LockManager,
+)
+from fmu.settings.models.lock_info import LockInfo
+
+
+def test_lock_manager_instantiation(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests basic facts about the LockManager."""
+    lock = LockManager(fmu_dir)
+
+    assert lock.fmu_dir == fmu_dir
+    assert lock.model_class == LockInfo
+    assert lock._cache is None
+    assert lock._timeout_seconds == DEFAULT_LOCK_TIMEOUT
+    assert lock._acquired_at is None
+
+    # Resource manager requires this to be implemented
+    assert lock.relative_path == Path(".lock")
+    assert lock.path == fmu_dir.path / lock.relative_path
+
+
+def test_lock_acquire_creates_lock_file(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that acquiring a lock creates a correct lock file."""
+    monkeypatch.setenv("USER", "user")
+
+    lock = LockManager(fmu_dir)
+
+    assert lock.exists is False
+    with pytest.raises(
+        FileNotFoundError, match="Resource file for 'LockManager' not found"
+    ):
+        lock.load()
+
+    lock.acquire()
+    assert lock.exists
+    assert lock._acquired_at is not None
+
+    lock_info = lock.load()
+    assert lock._cache == lock_info
+    assert lock._acquired_at == lock_info.acquired_at
+    assert lock_info.pid == os.getpid()
+    assert lock_info.hostname == socket.gethostname()
+    assert lock_info.user == "user"
+    assert lock_info.expires_at == pytest.approx(
+        lock_info.acquired_at + DEFAULT_LOCK_TIMEOUT, rel=1e-05
+    )
+
+
+def test_lock_as_context_manager(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that acquiring a ctx manager lock creates a correct lock file."""
+    monkeypatch.setenv("USER", "user")
+
+    with LockManager(fmu_dir) as lock:
+        assert lock.exists
+        assert lock._acquired_at is not None
+
+        lock_info = lock.load()
+        assert lock._cache == lock_info
+        assert lock._acquired_at == lock_info.acquired_at
+        assert lock_info.pid == os.getpid()
+        assert lock_info.hostname == socket.gethostname()
+        assert lock_info.user == "user"
+        assert lock_info.expires_at == pytest.approx(
+            lock_info.acquired_at + DEFAULT_LOCK_TIMEOUT, rel=1e-05
+        )
+
+    assert (fmu_dir.path / ".lock").exists() is False
+
+
+def test_lock_acquire_raises_if_already_acquired(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests that a lock cannot be acquired twice."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    assert lock.is_locked()
+    assert lock.is_acquired()
+    with pytest.raises(LockError, match="Lock already acquired"):
+        lock.acquire()
+
+
+@pytest.mark.xfail(reason="Lock is not race consistent yet")
+def test_lock_acquire_race_in_threads(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests that under thread race conditions one lock succeeds, one fails."""
+    results = []
+    errors = []
+
+    def acquire_lock() -> None:
+        """Creates, acquires, and releases a lock."""
+        try:
+            lock = LockManager(fmu_dir)
+            lock.acquire()
+            results.append("success")
+        except LockError as e:
+            errors.append(e)
+
+    thread1 = threading.Thread(target=acquire_lock)
+    thread2 = threading.Thread(target=acquire_lock)
+
+    thread1.start()
+    thread2.start()
+
+    thread1.join()
+    thread2.join()
+
+    assert len(results) == 1
+    assert len(errors) == 1
+
+
+def _acquire_lock(
+    fmu_dir: ProjectFMUDirectory,
+    result_queue: multiprocessing.queues.Queue,  # type: ignore
+) -> None:
+    """Creates, acquires, and releases a lock.
+
+    This is at the module level so it can be pickled by the process test.
+    """
+    try:
+        lock = LockManager(fmu_dir)
+        lock.acquire()
+        result_queue.put(("success", None))
+    except LockError as e:
+        result_queue.put(("error", str(e)))
+
+
+@pytest.mark.xfail(reason="Lock is not race consistent yet")
+def test_lock_acquire_race_in_processes(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests that under same process race conditions, one lock succeeds, one fails."""
+    # See https://github.com/python/cpython/issues/99509 for type ignore
+    result_queue = multiprocessing.Queue()  # type: ignore
+    process1 = multiprocessing.Process(
+        target=_acquire_lock, args=(fmu_dir, result_queue)
+    )
+    process2 = multiprocessing.Process(
+        target=_acquire_lock, args=(fmu_dir, result_queue)
+    )
+
+    process1.start()
+    process2.start()
+    process1.join()
+    process2.join()
+
+    results = []
+    while not result_queue.empty():
+        results.append(result_queue.get())
+
+    successes = [r for r in results if r[0] == "success"]
+    errors = [r for r in results if r[0] == "error"]
+
+    assert len(successes) == 1
+    assert len(errors) == 1
+
+
+def test_lock_acquire_raises_if_invalid_wait_period(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests that a lock acquire requires a positive timeout."""
+    lock = LockManager(fmu_dir)
+    with pytest.raises(ValueError, match="wait_timeout must be positive"):
+        lock.acquire(wait=True, wait_timeout=-1)
+    lock.acquire(wait=True, wait_timeout=0.01)
+
+
+def test_lock_acquire_over_expired_lock(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests that a stale lock file will be unlinked and overwritten."""
+    stale_lock = LockManager(fmu_dir, timeout_seconds=-1)  # Expired
+    stale_lock.acquire()
+    assert stale_lock.is_locked() is False
+    assert stale_lock.is_acquired() is False
+    assert stale_lock._is_stale() is True
+    stale_lock_info = stale_lock.load()
+
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    lock_info = lock.load()
+
+    assert lock.is_locked()
+    assert lock.is_acquired()
+    assert stale_lock.path == lock.path
+    assert lock_info != stale_lock_info
+
+
+def test_no_wait_invalid_lock_file_exists(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests that an existing, invalid .lock file raises.
+
+    This should not really occur, but it's theoretically possible the lock file is
+    overwritten to an invalid state between its stale check.
+    """
+    fmu_dir.write_text_file(".lock", "")
+    lock = LockManager(fmu_dir)
+
+    # This shouldn't be possible, but test that it's caught anyway
+    with (
+        patch.object(lock, "_is_stale", return_value=False),
+        pytest.raises(LockError, match="Invalid lock file exists"),
+    ):
+        lock.acquire()
+
+
+def test_lock_acquire_when_fresh_lock_exists_without_timeout(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that trying to acquire a fresh lock without timeout fails."""
+    monkeypatch.setenv("USER", "user")
+
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+
+    bad_lock = LockManager(fmu_dir)
+    with pytest.raises(LockError, match="Lock file is held by user@"):
+        bad_lock.acquire()
+
+
+def test_lock_with_wait_timeout_raises_after_timeout(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that trying to acquire a fresh lock with timeout succeeds."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+
+    wait_lock = LockManager(fmu_dir)
+    with pytest.raises(LockError, match="Timeout waiting for lock"):
+        wait_lock.acquire(wait=True, wait_timeout=0.25)
+
+
+def test_lock_with_wait_timeout_succeeds_after_release(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that trying to acquire a fresh lock with timeout succeeds."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+
+    def try_acquire_second_lock() -> LockManager:
+        wait_lock = LockManager(fmu_dir)
+        wait_lock.acquire(wait=True, wait_timeout=1.0)
+        return wait_lock
+
+    thread = threading.Thread(target=try_acquire_second_lock)
+    thread.start()
+
+    time.sleep(0.15)
+    lock.release()
+    thread.join()
+    assert not thread.is_alive()
+
+
+def test_is_stale_expired(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests is_stale if lock has expired."""
+    lock = LockManager(fmu_dir, timeout_seconds=-1)  # Expired
+    lock.acquire()
+    assert lock._is_stale() is True
+
+
+def test_is_stale_not_expired(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests is_stale if lock has not expired."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    assert lock._is_stale() is False
+
+
+def test_is_stale_load_fails(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests is_stale if loading the lock file fails."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    with patch.object(lock, "_safe_load", return_value=None):
+        assert lock._is_stale() is True
+
+
+def test_is_stale_bad_hostname(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests is_stale if lock check occurs from different host."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    assert lock._is_stale() is False
+    with patch(
+        "fmu.settings._resources.lock_manager.socket.gethostname", return_value="foo"
+    ):
+        assert lock._is_stale() is False
+
+
+def test_is_stale_invalid_pid(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests helper method check if lock pid does not exist."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    assert lock._is_stale() is False
+    assert lock._cache is not None
+    lock._cache.pid = 99999999  # Should be an impossible pid
+    assert lock._is_stale() is True
+
+
+def test_try_acquire_succeeds_as_expected(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that try_acquire creates a correct lock file."""
+    monkeypatch.setenv("USER", "user")
+    time_time = 1234.5
+    temp_uuid = uuid.uuid4()
+    lock = LockManager(fmu_dir)
+    with (
+        patch("time.time", return_value=time_time),
+        patch("os.getpid", return_value=123),
+        patch("socket.gethostname", return_value="foo"),
+        patch("pathlib.Path.unlink") as mock_unlink,
+        patch("uuid.uuid4", return_value=temp_uuid),
+    ):
+        assert lock._try_acquire() is True
+        assert lock._acquired_at == time_time
+        assert lock._cache == LockInfo(
+            pid=123,
+            hostname="foo",
+            user="user",
+            acquired_at=time_time,
+            expires_at=time_time + DEFAULT_LOCK_TIMEOUT,
+        )
+        mock_unlink.assert_called_once()
+
+    lock_info = lock._cache
+    temp_lockfile = (
+        fmu_dir.path / f".lock.{lock_info.hostname}.{lock_info.pid}.{temp_uuid.hex[:8]}"
+    )
+    # We mocked unlink(), so the temporary lockfile should still exist.
+    assert temp_lockfile.exists()
+    assert LockInfo.model_validate(json.loads(temp_lockfile.read_text())) == lock_info
+
+    assert lock.path.exists()
+    assert LockInfo.model_validate(json.loads(lock.path.read_text())) == lock_info
+
+
+def test_try_acquire_fails_when_writing_temp_file(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that try_acquire raises when failing to write the lock file.."""
+    lock = LockManager(fmu_dir)
+    with (
+        patch("os.write", side_effect=OSError("oops")),
+        patch("os.close") as mock_close,
+        patch("pathlib.Path.unlink") as mock_unlink,
+        pytest.raises(OSError, match="oops"),
+    ):
+        lock._try_acquire()
+        mock_close.assert_called_twice()
+        mock_unlink.assert_called_once()
+
+
+def test_try_acquire_fails_when_linking_temp_file(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that try_acquire raises when failing to link the lock file.."""
+    lock = LockManager(fmu_dir)
+    with (
+        patch("os.link") as mock_link,
+        patch("os.close", side_effect=FileExistsError) as mock_close,
+        patch("pathlib.Path.unlink") as mock_unlink,
+        pytest.raises(FileExistsError),
+    ):
+        assert lock._try_acquire() is False
+        mock_link.assert_called_once_with(lock.path)
+        mock_close.assert_called_twice()
+        mock_unlink.assert_called_once()
+
+
+def test_is_locked_expected(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests is_locked under expected, simple conditions."""
+    lock = LockManager(fmu_dir)
+    assert lock.is_locked() is False
+    lock.acquire()
+    assert lock.is_locked() is True
+    lock.release()
+    assert lock.is_locked() is False
+
+
+def test_is_locked_by_other_process(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests is_locked when another process has the lock."""
+    lock = LockManager(fmu_dir)
+    assert lock.is_locked() is False
+    with patch("os.getpid", return_value=-1234):
+        lock.acquire()
+
+    assert lock.is_locked() is True
+
+    with patch("os.getpid", return_value=-1234):
+        lock.release()
+    assert lock.is_locked() is False
+
+
+def test_is_acquired_expected(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests is_acquired under expected conditions."""
+    lock = LockManager(fmu_dir)
+    assert lock.is_acquired() is False
+    lock.acquire()
+    assert lock.is_acquired() is True
+
+
+def test_is_acquired_unexpected_members(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests is_acquired under expected member conditions."""
+    lock = LockManager(fmu_dir)
+    assert lock.is_acquired() is False
+    lock.acquire()
+    assert lock.is_acquired() is True
+    lock_info = lock._cache
+    lock._cache = None
+    assert lock.is_acquired() is False
+    lock._cache = lock_info
+    lock._acquired_at = None
+    assert lock.is_acquired() is False
+
+
+@pytest.mark.parametrize(
+    "is_mine, is_stale, expected",
+    [
+        (True, True, False),
+        (True, False, True),
+        (False, True, False),
+        (False, False, False),
+    ],
+)
+def test_is_acquired_unexpected_methods(
+    fmu_dir: ProjectFMUDirectory,
+    monkeypatch: MonkeyPatch,
+    is_mine: bool,
+    is_stale: bool,
+    expected: bool,
+) -> None:
+    """Tests is_acquired under expected method conditions."""
+    lock = LockManager(fmu_dir)
+    assert lock.is_acquired() is False
+    lock.acquire()
+
+    with (
+        patch.object(lock, "_is_mine", return_value=is_mine),
+        patch.object(lock, "_is_stale", return_value=is_stale),
+    ):
+        assert lock.is_acquired() is expected
+
+
+def test_refresh_works_as_expected(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests refresh works as expected."""
+    lock = LockManager(fmu_dir)
+
+    start_time = 1234.5
+    refresh_time = 2345.6
+    with patch("time.time", return_value=start_time):
+        lock.acquire()
+    assert lock._cache is not None
+    assert lock._cache.expires_at == start_time + DEFAULT_LOCK_TIMEOUT
+
+    with patch("time.time", return_value=refresh_time):
+        lock.refresh()
+    assert lock._acquired_at == start_time
+    assert lock._cache.expires_at == refresh_time + DEFAULT_LOCK_TIMEOUT
+
+    lock_info = LockInfo.model_validate(json.loads(lock.path.read_text()))
+    assert lock_info.expires_at == refresh_time + DEFAULT_LOCK_TIMEOUT
+
+
+def test_refresh_without_lock_file(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests refresh when lock file is not present."""
+    lock = LockManager(fmu_dir)
+    with pytest.raises(LockError, match="does not exist"):
+        lock.refresh()
+
+    lock.acquire()
+    lock.path.unlink()  # It was deleted or something.
+    with pytest.raises(LockError, match="does not exist"):
+        lock.refresh()
+
+
+def test_refresh_without_owning_lock(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests refresh when lock file is not owned by the process."""
+    lock = LockManager(fmu_dir)
+    with patch("os.getpid", return_value=-1234):
+        lock.acquire()
+    with pytest.raises(LockError, match="held by another process"):
+        lock.refresh()
+
+
+def test_lock_release_unlinks_lock_file(fmu_dir: ProjectFMUDirectory) -> None:
+    """Tests that releasing a lock removes the lock file."""
+    lock = LockManager(fmu_dir)
+
+    assert lock.exists is False
+    lock.acquire()
+    assert lock.exists
+    lock.release()
+    assert lock.exists is False
+    assert lock._cache is None
+    assert lock.path.exists() is False
+
+
+def test_safe_load(fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch) -> None:
+    """Tests the safe load helper method."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    assert lock._cache is not None
+    assert lock._safe_load() == lock._cache
+
+    lock.release()
+    lock.path.write_text("a")
+    assert lock._safe_load() is None
+
+
+def test_save_expected(fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch) -> None:
+    """Tests that save works as expected."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+
+    lock_info = lock.load()
+    new_expires_at = 123.4
+    lock_info.expires_at = new_expires_at
+
+    temp_uuid = uuid.uuid4()
+    with patch("uuid.uuid4", return_value=temp_uuid):
+        lock.save(lock_info)
+
+    lock_info = lock.load()
+    assert lock_info.expires_at == new_expires_at
+    assert Path(f"{lock.path}.tmp.{temp_uuid.hex[:8]}").exists() is False
+    assert LockInfo.model_validate(json.loads(lock.path.read_text())) == lock_info
+
+
+def test_save_raises(fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch) -> None:
+    """Tests that save fails as expected under failing conditions."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+
+    lock_info = lock.load()
+    with (
+        patch("pathlib.Path.replace", side_effect=OSError("oops")) as mock_replace,
+        pytest.raises(LockError, match="oops"),
+    ):
+        lock.save(lock_info)
+        mock_replace.assert_called_once_with(lock.path)
+
+
+def test_save_not_owned(fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch) -> None:
+    """Tests that save fails when lock is not owned by process."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+
+    lock_info = lock.load()
+    with (
+        patch.object(lock, "_is_mine", return_value=False),
+        pytest.raises(LockError, match="lock file is held by another"),
+    ):
+        lock.save(lock_info)

{fmu_settings-0.2.0 → fmu_settings-0.3.1}/tests/test_resources/test_project_config.py

@@ -6,8 +6,8 @@ from pathlib import Path
 from typing import Any
 
 import pytest
-
 from fmu.datamodels.fmu_results.fields import Access, Model, Smda
+
 from fmu.settings._fmu_dir import ProjectFMUDirectory, UserFMUDirectory
 from fmu.settings._resources.config_managers import (
     ProjectConfigManager,