Add the 'Multiple' backend. As in Resque we delegate all queries to

the first backend in the list.

To use:

from pyres import failure

from pyres.failure.base import BaseBackend
from pyres.failure.multiple import MultipleBackend
from pyres.failure.redis import RedisBackend

class CustomBackend(BaseBackend):
    def save(self, resq):
        print('Custom backend')

failure.backend = MultipleBackend
failure.backend.classes = [RedisBackend, CustomBackend]

Author: chawco

pyres/failure/__init__.py

@@ -1,32 +1,28 @@
-import datetime
-from pyres import ResQ 
-import sys, traceback
 from pyres.failure.redis import RedisBackend
 
-_backend = RedisBackend
+backend = RedisBackend
 
 def create(*args, **kwargs):
-    return _backend(*args, **kwargs)
+    return backend(*args, **kwargs)
 
 def count(resq):
-    return _backend.count(resq)
+    return backend.count(resq)
 
 def all(resq, start, count):
-    return _backend.all(resq, start, count)
+    return backend.all(resq, start, count)
 
 def clear(resq):
-    return _backend.clear(resq)
+    return backend.clear(resq)
 
 def requeue(resq, failure_object):
     queue = failure_object._queue
     payload = failure_object._payload
     return resq.push(queue, payload)
-    
+
 def retry(resq, queue, payload):
     job = resq.decode(payload)
     resq.push(queue, job['payload'])
     return delete(resq, payload)
-    
+
 def delete(resq, payload):
-    return resq.redis.lrem(name = 'resque:failed', num = 1, value = payload)
-    
+    return resq.redis.lrem(name='resque:failed', num=1, value=payload)

pyres/failure/multiple.py

@@ -0,0 +1,30 @@
+from base import BaseBackend
+from redis import RedisBackend
+
+class MultipleBackend(BaseBackend):
+    classes = []
+
+    def __init__(self, *args):
+        if not self.classes:
+            self.classes = [RedisBackend]
+
+        self.backends = [klass(*args) for klass in self.classes]
+        BaseBackend.__init__(self, *args)
+
+    @classmethod
+    def count(cls, resq):
+        first = MultipleBackend.classes[0]
+        return first.count(resq)
+
+    @classmethod
+    def all(cls, resq, start=0, count=1):
+        first = MultipleBackend.classes[0]
+        return first.all(resq, start, count)
+
+    @classmethod
+    def clear(cls, resq):
+        first = MultipleBackend.classes[0]
+        return first.clear(resq)
+
+    def save(self, resq=None):
+        map(lambda x: x.save(resq), self.backends)

tests/test_failure.py

@@ -1,31 +1,35 @@
 from tests import PyResTests, Basic, TestProcess, ErrorObject
 from pyres import failure
+from pyres.failure.base import BaseBackend
+from pyres.failure.multiple import MultipleBackend
+from pyres.failure.redis import RedisBackend
 from pyres.job import Job
+
 class FailureTests(PyResTests):
     def test_count(self):
         self.resq.enqueue(Basic,"test1")
         job = Job.reserve('basic',self.resq)
         job.fail("problem")
         assert failure.count(self.resq) == 1
         assert self.redis.llen('resque:failed') == 1
-    
+
     def test_create(self):
         self.resq.enqueue(Basic,"test1")
         job = Job.reserve('basic',self.resq)
         e = Exception('test')
         fail = failure.create(e, 'basic', job._payload)
         assert isinstance(fail._payload, dict)
-        fail.save()
+        fail.save(self.resq)
         assert failure.count(self.resq) == 1
         assert self.redis.llen('resque:failed') == 1
-    
+
     def test_all(self):
         self.resq.enqueue(Basic,"test1")
         job = Job.reserve('basic',self.resq)
         e = Exception('problem')
         job.fail(e)
         assert len(failure.all(self.resq, 0, 20)) == 1
-    
+
     def test_clear(self):
         self.resq.enqueue(Basic,"test1")
         job = Job.reserve('basic',self.resq)
@@ -34,7 +38,7 @@ def test_clear(self):
         assert self.redis.llen('resque:failed') == 1
         failure.clear(self.resq)
         assert self.redis.llen('resque:failed') == 0
-    
+
     def test_requeue(self):
         self.resq.enqueue(Basic,"test1")
         job = Job.reserve('basic',self.resq)
@@ -45,4 +49,21 @@ def test_requeue(self):
         assert self.resq.size('basic') == 1
         job = Job.reserve('basic',self.resq)
         assert job._queue == 'basic'
-        assert job._payload == {'class':'tests.Basic','args':['test1']}
+        assert job._payload == {'class':'tests.Basic','args':['test1']}
+
+# Test the MultipleBackend, basically just repeat the above tests, ensuring that
+# we've delegated to the methods appropriately
+
+class TestBackend(BaseBackend):
+    def save(self, resq):
+        resq.redis.set('testbackend:called', 1)
+
+failure.backend = MultipleBackend
+failure.backend.classes = [RedisBackend, TestBackend]
+
+class MultipleFailureTests(FailureTests):
+    def test_create(self):
+        # Run the parent test
+        FailureTests.test_create(self)
+        # But also ensure the other backends were called
+        assert int(self.redis.get('testbackend:called')) == 1