redis-allocator 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

redis_allocator/_version.py

@@ -1 +1 @@
-__version__ = '0.3.2'
+__version__ = '0.4.0'

redis_allocator/allocator.py

@@ -97,7 +97,7 @@ class RedisAllocatableClass(ABC):
 
     def open(self):
         """Open the object."""
-        pass
+        return self
 
     def close(self):
         """close the object."""
@@ -162,6 +162,7 @@ class RedisAllocatorObject(Generic[U]):
         """Open the object."""
         if self.obj is not None:
             self.obj.open()
+        return self
 
     def close(self):
         """Kill the object."""
@@ -174,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:
@@ -282,9 +304,11 @@ class RedisAllocatorPolicy(ABC):
 
     def check_health_once(self, r_obj: RedisAllocatorObject, duration: int = 3600) -> bool:
         """Check the health of the object."""
-        with contextlib.closing(r_obj):
+        with contextlib.closing(r_obj.open()):
             try:
                 if r_obj.is_healthy():
+                    if r_obj.allocator.shared:
+                        r_obj.allocator.unlock(r_obj.key)  # set the key as free
                     return True
                 else:
                     r_obj.set_unhealthy(duration)
@@ -308,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)
@@ -317,9 +342,11 @@ 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):
@@ -346,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:
@@ -354,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
@@ -362,6 +391,7 @@ 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'):
         """Initialize the policy with an allocator instance.
@@ -407,9 +437,10 @@ 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
 

{redis_allocator-0.3.2.dist-info → redis_allocator-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redis-allocator
-Version: 0.3.2
+Version: 0.4.0
 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.2.dist-info → redis_allocator-0.4.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
 redis_allocator/__init__.py,sha256=TVjUm-8YEu_MQD_PkfeIKiVknpCJBrUY9cWN1LlaZcU,1016
-redis_allocator/_version.py,sha256=bqu4G7Is-8Were-hMi-SthEalL7QW-PAbKWGZ9pVB6U,22
-redis_allocator/allocator.py,sha256=Q0oDhUyjlpk6WoibvmlFS0pEmxk3qwLUHB277P3EMrE,47120
+redis_allocator/_version.py,sha256=2eiWQI55fd-roDdkt4Hvl9WzrTJ4xQo33VzFud6D03U,22
+redis_allocator/allocator.py,sha256=Bo4Ck7mqg-Z8KdQH-iqeHfdEbyhMqBD0c2g5T3E5sBU,48730
 redis_allocator/lock.py,sha256=fqf6WUWHKYenEArWopMIF6kWEnDfADC-bZvnQImsQVo,27400
 redis_allocator/task_queue.py,sha256=8DjNr2uxhzCsHatV_CHOeGh7_K9pqQZFApSbe2blRO0,14989
-redis_allocator-0.3.2.dist-info/licenses/LICENSE,sha256=Wt4X1rHpffQfEiyWcDUx8BMLjXxfPqaiYZ7Lgsj7L4c,1068
+redis_allocator-0.4.0.dist-info/licenses/LICENSE,sha256=Wt4X1rHpffQfEiyWcDUx8BMLjXxfPqaiYZ7Lgsj7L4c,1068
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=1QA3fxdX2XmVDEXY9L9D6NAWlAxlyifK8W9rnO24ig8,3947
+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.2.dist-info/METADATA,sha256=H_C0Um1MegEzuo6A_UhgWkIN0SsQA_CScHhfwqatfw0,21653
-redis_allocator-0.3.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-redis_allocator-0.3.2.dist-info/top_level.txt,sha256=0hXzU7sK5FCeSolTEYxThOt3HOybnwaXv1FLRJvHVgI,22
-redis_allocator-0.3.2.dist-info/RECORD,,
+redis_allocator-0.4.0.dist-info/METADATA,sha256=rXeA3Nsb6eie8H5G10HXLlLI8jCRs45I1C06seN-Sgs,21727
+redis_allocator-0.4.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+redis_allocator-0.4.0.dist-info/top_level.txt,sha256=0hXzU7sK5FCeSolTEYxThOt3HOybnwaXv1FLRJvHVgI,22
+redis_allocator-0.4.0.dist-info/RECORD,,

tests/conftest.py

@@ -66,6 +66,7 @@ class _TestObject(RedisAllocatableClass):
     def open(self):
         """Open the object."""
         self.closed = False
+        return self
 
     def close(self):
         """Mark the object as closed."""