redis-allocator 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

redis_allocator/_version.py

@@ -1 +1 @@
-__version__ = '0.3.3'
+__version__ = '0.4.1'

redis_allocator/allocator.py

@@ -175,21 +175,42 @@ class RedisAllocatorObject(Generic[U]):
             return self.obj.is_healthy()
         return True
 
-    def set_unhealthy(self, duration: int = 3600):
+    def set_healthy(self, duration: Timeout = 3600):
+        """Set the object as healthy."""
+        if self.obj is not None and self.obj.name is not None:
+            self.allocator.update_soft_bind(self.obj.name, self.key, duration)
+        if self.allocator.shared:
+            self.allocator.unlock(self.key)
+
+    def set_unhealthy(self, duration: Timeout = 3600):
         """Set the object as unhealthy."""
         if self.obj is not None and self.obj.name is not None:
             self.allocator.unbind_soft_bind(self.obj.name)
         self.allocator.update(self.key, timeout=duration)
 
-    def refresh(self, timeout: Timeout = 120):
+    def refresh(self, timeout: Timeout = 120, cache_timeout: Timeout = 3600):
         """Refresh the object."""
         self.close()
         new_obj = self.allocator.policy.malloc(self.allocator, timeout=timeout,
-                                               obj=self.obj, params=self.params)
+                                               obj=self.obj, params=self.params,
+                                               cache_timeout=cache_timeout)
         if new_obj is not None:
             self.obj = new_obj.obj
             self.key = new_obj.key
             self.params = new_obj.params
+            self.open()
+
+    def refresh_until_healthy(self, timeout: Timeout = 120, max_attempts: int = 10, lock_duration: Timeout = 3600, cache_timeout: Timeout = 3600):
+        """Refresh the object until it is healthy."""
+        for _ in range(max_attempts):
+            try:
+                if self.is_healthy():
+                    return
+            except Exception as e:
+                logger.error(f"Error checking health of {self.key}: {e}")
+            self.set_unhealthy(lock_duration)
+            self.refresh(timeout, cache_timeout)
+        raise RuntimeError("the objects is still unhealthy after %d attempts", max_attempts)
 
     @property
     def unique_id(self) -> str:
@@ -236,14 +257,14 @@ class RedisAllocatorUpdater:
         return len(self.params)
 
 
-class RedisAllocatorPolicy(ABC):
+class RedisAllocatorPolicy(ABC, Generic[U]):
     """Abstract base class for Redis allocator policies.
 
     This class defines the interface for allocation policies that can be used
     with RedisAllocator to control allocation behavior.
     """
 
-    def initialize(self, allocator: 'RedisAllocator'):
+    def initialize(self, allocator: 'RedisAllocator[U]'):
         """Initialize the policy with an allocator instance.
 
         Args:
@@ -252,9 +273,9 @@ class RedisAllocatorPolicy(ABC):
         pass
 
     @abstractmethod
-    def malloc(self, allocator: 'RedisAllocator', timeout: Timeout = 120,
-               obj: Optional[Any] = None, params: Optional[dict] = None,
-               cache_timeout: Timeout = 3600) -> Optional[RedisAllocatorObject]:
+    def malloc(self, allocator: 'RedisAllocator[U]', timeout: Timeout = 120,
+               obj: Optional[U] = None, params: Optional[dict] = None,
+               cache_timeout: Timeout = 3600) -> Optional[RedisAllocatorObject[U]]:
         """Allocate a resource according to the policy.
 
         Args:
@@ -271,7 +292,7 @@ class RedisAllocatorPolicy(ABC):
         pass
 
     @abstractmethod
-    def refresh_pool(self, allocator: 'RedisAllocator'):
+    def refresh_pool(self, allocator: 'RedisAllocator[U]'):
         """Refresh the allocation pool.
 
         This method is called periodically to update the pool with new resources.
@@ -281,7 +302,7 @@ class RedisAllocatorPolicy(ABC):
         """
         pass
 
-    def check_health_once(self, r_obj: RedisAllocatorObject, duration: int = 3600) -> bool:
+    def check_health_once(self, r_obj: RedisAllocatorObject[U], duration: int = 3600) -> bool:
         """Check the health of the object."""
         with contextlib.closing(r_obj.open()):
             try:
@@ -297,8 +318,8 @@ class RedisAllocatorPolicy(ABC):
                 r_obj.set_unhealthy(duration)
                 raise
 
-    def check_health(self, allocator: 'RedisAllocator', lock_duration: Timeout = 3600, max_threads: int = 8,
-                     obj_fn: Optional[Callable[[str], Any]] = None,
+    def check_health(self, allocator: 'RedisAllocator[U]', lock_duration: Timeout = 3600, max_threads: int = 8,
+                     obj_fn: Optional[Callable[[str], U]] = None,
                      params_fn: Optional[Callable[[str], dict]] = None) -> tuple[int, int]:
         """Check the health of the allocator.
 
@@ -311,6 +332,7 @@ class RedisAllocatorPolicy(ABC):
             A tuple containing the number of healthy and unhealthy items in the allocator
         """
         with ThreadPoolExecutor(max_workers=max_threads) as executor:
+            inputs = []
             for key in allocator.keys():
                 if params_fn is not None:
                     params = params_fn(key)
@@ -320,12 +342,14 @@ class RedisAllocatorPolicy(ABC):
                     obj = obj_fn(key)
                 else:
                     obj = None
-                alloc_obj = RedisAllocatorObject(allocator, key, obj, params)
-                executor.submit(self.check_health_once, alloc_obj, lock_duration)
-            executor.shutdown(wait=True)
+                inputs.append(RedisAllocatorObject(allocator, key, obj, params))
+            results = list(executor.map(self.check_health_once, inputs, timeout=max_threads * lock_duration / (len(inputs) + 1)))
+            healthy = sum(results)
+            unhealthy = len(results) - healthy
+            return healthy, unhealthy
 
 
-class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
+class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy[U]):
     """Default implementation of RedisAllocatorPolicy.
 
     This policy provides the following features:
@@ -349,7 +373,8 @@ class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
     """
 
     def __init__(self, gc_count: int = 5, update_interval: int = 300,
-                 expiry_duration: int = -1, updater: Optional[RedisAllocatorUpdater] = None):
+                 expiry_duration: int = -1, updater: Optional[RedisAllocatorUpdater] = None,
+                 auto_close: bool = False):
         """Initialize the default allocation policy.
 
         Args:
@@ -357,6 +382,7 @@ class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
             update_interval: Interval in seconds between pool updates
             expiry_duration: Default timeout for pool items (-1 means no timeout)
             updater: Optional updater for refreshing the pool's keys
+            auto_close: If True, the allocator will automatically close the object when it is not unique
         """
         self.gc_count = gc_count
         self.update_interval: float = update_interval
@@ -365,8 +391,9 @@ class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
         self._allocator: Optional[weakref.ReferenceType['RedisAllocator']] = None
         self._update_lock_key: Optional[str] = None
         self.objects: weakref.WeakValueDictionary[str, RedisAllocatorObject] = weakref.WeakValueDictionary()
+        self.auto_close = auto_close
 
-    def initialize(self, allocator: 'RedisAllocator'):
+    def initialize(self, allocator: 'RedisAllocator[U]'):
         """Initialize the policy with an allocator instance.
 
         Args:
@@ -376,9 +403,9 @@ class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
         self._update_lock_key = f"{allocator._pool_str()}|policy_update_lock"
         atexit.register(lambda: self.finalize(self._allocator()))
 
-    def malloc(self, allocator: 'RedisAllocator', timeout: Timeout = 120,
-               obj: Optional[Any] = None, params: Optional[dict] = None,
-               cache_timeout: Timeout = 3600) -> Optional[RedisAllocatorObject]:
+    def malloc(self, allocator: 'RedisAllocator[U]', timeout: Timeout = 120,
+               obj: Optional[U] = None, params: Optional[dict] = None,
+               cache_timeout: Timeout = 3600) -> Optional[RedisAllocatorObject[U]]:
         """Allocate a resource according to the policy.
 
         This implementation:
@@ -410,14 +437,15 @@ class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
         key = allocator.malloc_key(timeout, obj_name,
                                    cache_timeout=cache_timeout)
         alloc_obj = RedisAllocatorObject(allocator, key, obj, params)
-        old_obj = self.objects.get(alloc_obj.unique_id, None)
-        if old_obj is not None:
-            old_obj.close()
+        if self.auto_close:
+            old_obj = self.objects.get(alloc_obj.unique_id, None)
+            if old_obj is not None:
+                old_obj.close()
         self.objects[alloc_obj.unique_id] = alloc_obj
         return alloc_obj
 
     @cached(TTLCache(maxsize=64, ttl=5))
-    def _try_refresh_pool(self, allocator: 'RedisAllocator'):
+    def _try_refresh_pool(self, allocator: 'RedisAllocator[U]'):
         """Try to refresh the pool if necessary and if we can acquire the lock.
 
         Args:
@@ -429,7 +457,7 @@ class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
             # If we got here, we acquired the lock, so we can update the pool
             self.refresh_pool(allocator)
 
-    def refresh_pool(self, allocator: 'RedisAllocator'):
+    def refresh_pool(self, allocator: 'RedisAllocator[U]'):
         """Refresh the allocation pool using the updater.
 
         Args:
@@ -450,7 +478,7 @@ class DefaultRedisAllocatorPolicy(RedisAllocatorPolicy):
         else:
             allocator.extend(keys, timeout=self.expiry_duration)
 
-    def finalize(self, allocator: 'RedisAllocator'):
+    def finalize(self, allocator: 'RedisAllocator[U]'):
         """Finalize the policy."""
         for obj in self.objects.values():
             obj.close()
@@ -493,7 +521,7 @@ class RedisAllocator(RedisLockPool, Generic[U]):
     """
 
     def __init__(self, redis: Redis, prefix: str, suffix='allocator', eps=1e-6,
-                 shared=False, policy: Optional[RedisAllocatorPolicy] = None):
+                 shared=False, policy: Optional[RedisAllocatorPolicy[U]] = None):
         """Initializes the RedisAllocator.
 
         Args:

{redis_allocator-0.3.3.dist-info → redis_allocator-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redis-allocator
-Version: 0.3.3
+Version: 0.4.1
 Summary: Redis-based resource allocation system.
 Home-page: https://github.com/invoker-bot/RedisAllocator-python
 Author: Invoker Bot
@@ -230,7 +230,7 @@ if allocated_obj:
 
 # Using soft binding (associates a name with a resource)
 allocator.update_soft_bind("worker-1", "resource-1")
-# Later...
+# Unbind soft binding
 allocator.unbind_soft_bind("worker-1")
 
 # Garbage collection (reclaims unused resources)
@@ -291,9 +291,9 @@ graph TD
 
     subgraph "PoolHash Contents (Doubly-Linked Free List)"
         Key1 --> Key2["Key2: Key1||Key3||Expiry"]
-        Key2 --> Key3["Key3: Key2||...||Expiry"]
-        Key3 --> ...
-        KeyN_1[...] --> KeyN
+        Key2 --> Key3["Key3: Key2||Key4||Expiry"]
+        Key3 --> Key4["Key4: Key3||Key5||Expiry"]
+        KeyN_1["KeyN: KeyN-1||""||Expiry"] --> KeyN
     end
 
     subgraph "Allocated Keys (Non-Shared Mode)"

{redis_allocator-0.3.3.dist-info → redis_allocator-0.4.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 redis_allocator/__init__.py,sha256=TVjUm-8YEu_MQD_PkfeIKiVknpCJBrUY9cWN1LlaZcU,1016
-redis_allocator/_version.py,sha256=on4Bj4mGEjEjyUkQExxprhOoEopcv_sPapsEnNxyelE,22
-redis_allocator/allocator.py,sha256=oFJSRAhFJsBbeho5TibY81_3Vy07glrAuEhpIOYfeJI,47282
+redis_allocator/_version.py,sha256=qBs4HqYsPn6yUHWEuCN4rGUC05gABbl800d8LBd8h9w,22
+redis_allocator/allocator.py,sha256=AerjK6B5-qaAsMn_ivJjRSn4GXWop27x4UDc1rlKP34,48778
 redis_allocator/lock.py,sha256=fqf6WUWHKYenEArWopMIF6kWEnDfADC-bZvnQImsQVo,27400
 redis_allocator/task_queue.py,sha256=8DjNr2uxhzCsHatV_CHOeGh7_K9pqQZFApSbe2blRO0,14989
-redis_allocator-0.3.3.dist-info/licenses/LICENSE,sha256=Wt4X1rHpffQfEiyWcDUx8BMLjXxfPqaiYZ7Lgsj7L4c,1068
+redis_allocator-0.4.1.dist-info/licenses/LICENSE,sha256=Wt4X1rHpffQfEiyWcDUx8BMLjXxfPqaiYZ7Lgsj7L4c,1068
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=Ts82uylQSzP_GcaN0E02o3xcFdjw20cXNzh3RAdYKW4,3967
 tests/test_allocator.py,sha256=hFKgLe_yONtEjjm6zssUnhK0tzihG_1xZMziztHmqqA,22404
 tests/test_lock.py,sha256=MDMRNN46VhWqkHUIhYOMEDgZkFFCW_WjwRLTOjkFF-Q,46952
 tests/test_task_queue.py,sha256=Fh5naikFajfOvL6GngEy_TPfOYCYZolZfVwtR6T4dTY,31710
-redis_allocator-0.3.3.dist-info/METADATA,sha256=oEPcsqP1oiKP_HaZgIgfEEqIxuY6c9aoapC5ecLrP8w,21653
-redis_allocator-0.3.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-redis_allocator-0.3.3.dist-info/top_level.txt,sha256=0hXzU7sK5FCeSolTEYxThOt3HOybnwaXv1FLRJvHVgI,22
-redis_allocator-0.3.3.dist-info/RECORD,,
+redis_allocator-0.4.1.dist-info/METADATA,sha256=K0lLGpDplwpwCMMuzUiA8CkkRfTPAIyswx4anbo0O-Y,21727
+redis_allocator-0.4.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+redis_allocator-0.4.1.dist-info/top_level.txt,sha256=0hXzU7sK5FCeSolTEYxThOt3HOybnwaXv1FLRJvHVgI,22
+redis_allocator-0.4.1.dist-info/RECORD,,