test: add service locator unit tests and changelog fragment

- 7 unit tests covering get_service, set_service, replacement lifecycle,
  close-on-clear_instance, multiple service types, and idempotent re-registration
- Changelog entry for the new service locator API

Author: Horde

source/isaaclab/changelog.d/service-locator.rst

@@ -0,0 +1,9 @@
+Added
+^^^^^
+
+* Added :class:`~isaaclab.sim.ServiceLocator` and exposed it as
+  :attr:`~isaaclab.sim.SimulationContext.services`.
+
+  Backend-specific caches can be registered and retrieved using subscript
+  syntax (``services[cls] = instance``, ``services[cls]``).  Services with
+  a ``close()`` method are automatically closed on ``clear_instance()``.

source/isaaclab/isaaclab/sim/service_locator.py

@@ -0,0 +1,87 @@
+# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Typed service locator for lifecycle-managed singletons."""
+
+from __future__ import annotations
+
+from typing import TypeVar
+
+_T = TypeVar("_T")
+
+
+def _try_close(service: object) -> None:
+    """Call close() on *service* if it exists and is callable."""
+    close = getattr(service, "close", None)
+    if close is not None and callable(close):
+        close()
+
+
+class ServiceLocator:
+    """A typed service registry keyed by class, interface, or abstract base class.
+
+    Services are registered and retrieved using subscript syntax::
+
+        locator[FabricStageCache] = FabricStageCache(stage)
+        cache = locator[FabricStageCache]
+
+    Deleting a service calls ``close()`` on it if available::
+
+        del locator[FabricStageCache]
+
+    All registered services are closed and cleared via :meth:`close_all`.
+    """
+
+    def __init__(self) -> None:
+        self._services: dict[type, object] = {}
+
+    def __getitem__(self, cls: type[_T]) -> _T | None:
+        """Retrieve a service by its key class, or ``None`` if not registered."""
+        return self._services.get(cls)  # type: ignore[return-value]
+
+    def __setitem__(self, cls: type[_T], instance: _T) -> None:
+        """Register a service under the given key.
+
+        The key can be the concrete class of *instance*, a parent class,
+        or an abstract base class / protocol — allowing retrieval by
+        interface rather than implementation.
+
+        Does *not* close a previously registered service — the caller is
+        responsible for closing the old instance before replacing it.
+        Use ``del locator[cls]`` or :meth:`pop` to close and remove.
+        """
+        self._services[cls] = instance
+
+    def __delitem__(self, cls: type) -> None:
+        """Close and remove a service.
+
+        Calls ``close()`` on the instance if it has one, then removes it.
+
+        Raises:
+            KeyError: If no service is registered under *cls*.
+        """
+        instance = self._services.pop(cls)
+        _try_close(instance)
+
+    def __contains__(self, cls: type) -> bool:
+        """Check if a service is registered under *cls*."""
+        return cls in self._services
+
+    def pop(self, cls: type[_T]) -> _T | None:
+        """Remove and return a service without closing it.
+
+        Returns:
+            The previously registered instance, or ``None`` if not registered.
+        """
+        return self._services.pop(cls, None)  # type: ignore[return-value]
+
+    def close_all(self) -> None:
+        """Close all registered services and clear the registry.
+
+        Calls ``close()`` on each service that has one.
+        """
+        for service in self._services.values():
+            _try_close(service)
+        self._services.clear()

source/isaaclab/isaaclab/sim/simulation_context.py

@@ -11,7 +11,7 @@
 import traceback
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any
 
 import toml
 import torch
@@ -30,6 +30,7 @@
 )
 from isaaclab.renderers.render_context import RenderContext
 from isaaclab.scene.scene_data_provider import SceneDataProvider
+from isaaclab.sim.service_locator import ServiceLocator
 from isaaclab.sim.utils import create_new_stage
 from isaaclab.utils.string import clear_resolve_matching_names_cache
 from isaaclab.utils.version import has_kit
@@ -38,7 +39,6 @@
 if TYPE_CHECKING:
     from isaaclab.cloner.clone_plan import ClonePlan
 
-_T = TypeVar("_T")
 
 from .simulation_cfg import SimulationCfg
 from .spawners import DomeLightCfg, GroundPlaneCfg
@@ -216,10 +216,7 @@ def __init__(self, cfg: SimulationCfg | None = None):
             order=5,
         )
 
-        # Singleton service registry — backend-specific caches register themselves
-        # here, keyed by their class.  Services with a ``close()`` method are closed
-        # when the SimulationContext is torn down via ``clear_instance()``.
-        self._services: dict[type, object] = {}
+        self._services = ServiceLocator()
 
         type(self)._instance = self  # Mark as valid singleton only after successful init
 
@@ -863,33 +860,17 @@ def get_setting(self, name: str) -> Any:
     # Service locator
     # ------------------------------------------------------------------
 
-    def get_service(self, cls: type[_T]) -> _T | None:
-        """Retrieve a registered singleton service by its class.
-
-        Args:
-            cls: The service class used as key.
-
-        Returns:
-            The registered instance, or ``None`` if not registered.
-        """
-        return self._services.get(cls)  # type: ignore[return-value]
-
-    def set_service(self, cls: type[_T], instance: _T) -> None:
-        """Register a singleton service, keyed by its class.
+    @property
+    def services(self) -> ServiceLocator:
+        """Typed service registry for backend-specific singletons.
 
-        Overwrites any previously registered instance for the same class.
-        If the old instance has a ``close()`` method it is called before
-        replacement.  Services are automatically closed and cleared when
-        :meth:`clear_instance` is called.
+        Usage::
 
-        Args:
-            cls: The service class used as key.
-            instance: The service instance to register.
+            sim_context.services[FabricStageCache] = cache
+            cache = sim_context.services[FabricStageCache]
+            del sim_context.services[FabricStageCache]  # closes and removes
         """
-        old = self._services.get(cls)
-        if old is not None and old is not instance and hasattr(old, "close"):
-            old.close()
-        self._services[cls] = instance
+        return self._services
 
     @classmethod
     def clear_instance(cls) -> None:
@@ -905,10 +886,7 @@ def clear_instance(cls) -> None:
             cls._instance._visualizers.clear()
 
             # Close and drop all registered singleton services
-            for service in cls._instance._services.values():
-                if hasattr(service, "close"):
-                    service.close()
-            cls._instance._services.clear()
+            cls._instance._services.close_all()
 
             # Tear down the stage. We skip clear_stage() (prim-by-prim deletion) since
             # close_stage() + app shutdown destroy the entire stage at once.

source/isaaclab/test/sim/test_service_locator.py

@@ -0,0 +1,113 @@
+# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Tests for ServiceLocator."""
+
+import pytest
+
+from isaaclab.sim.service_locator import ServiceLocator
+
+
+class _DummyService:
+    """Minimal service with a close() method for testing lifecycle."""
+
+    def __init__(self):
+        self.closed = False
+
+    def close(self):
+        self.closed = True
+
+
+class _ServiceNoClose:
+    """Service without a close() method."""
+
+    pass
+
+
+class TestServiceLocator:
+    """Test ServiceLocator subscript API."""
+
+    def test_get_returns_none_when_unregistered(self):
+        loc = ServiceLocator()
+        assert loc[_DummyService] is None
+
+    def test_set_and_get(self):
+        loc = ServiceLocator()
+        svc = _DummyService()
+        loc[_DummyService] = svc
+        assert loc[_DummyService] is svc
+
+    def test_contains(self):
+        loc = ServiceLocator()
+        assert _DummyService not in loc
+        loc[_DummyService] = _DummyService()
+        assert _DummyService in loc
+
+    def test_del_closes_service(self):
+        loc = ServiceLocator()
+        svc = _DummyService()
+        loc[_DummyService] = svc
+        del loc[_DummyService]
+        assert svc.closed
+        assert loc[_DummyService] is None
+
+    def test_del_without_close_method(self):
+        """del on a service without close() should not raise."""
+        loc = ServiceLocator()
+        loc[_ServiceNoClose] = _ServiceNoClose()
+        del loc[_ServiceNoClose]
+        assert loc[_ServiceNoClose] is None
+
+    def test_del_missing_raises_key_error(self):
+        loc = ServiceLocator()
+        with pytest.raises(KeyError):
+            del loc[_DummyService]
+
+    def test_pop_returns_without_closing(self):
+        loc = ServiceLocator()
+        svc = _DummyService()
+        loc[_DummyService] = svc
+        popped = loc.pop(_DummyService)
+        assert popped is svc
+        assert not svc.closed
+        assert loc[_DummyService] is None
+
+    def test_pop_missing_returns_none(self):
+        loc = ServiceLocator()
+        assert loc.pop(_DummyService) is None
+
+    def test_close_all(self):
+        loc = ServiceLocator()
+        svc1 = _DummyService()
+        svc2 = _ServiceNoClose()
+        loc[_DummyService] = svc1
+        loc[_ServiceNoClose] = svc2
+        loc.close_all()
+        assert svc1.closed
+        assert loc[_DummyService] is None
+        assert loc[_ServiceNoClose] is None
+
+    def test_multiple_service_types(self):
+        loc = ServiceLocator()
+        svc1 = _DummyService()
+        svc2 = _ServiceNoClose()
+        loc[_DummyService] = svc1
+        loc[_ServiceNoClose] = svc2
+        assert loc[_DummyService] is svc1
+        assert loc[_ServiceNoClose] is svc2
+
+    def test_base_class_key(self):
+        """Can register under a base class and retrieve by it."""
+
+        class Base:
+            pass
+
+        class Impl(Base):
+            pass
+
+        loc = ServiceLocator()
+        impl = Impl()
+        loc[Base] = impl
+        assert loc[Base] is impl