replace instances of redis with backend.store

Now we don't have a global Redis reference any more.

lib/resque.rb

@@ -58,18 +58,18 @@ def backend
 
   def redis=(server)
     config.redis = server
-    @backend = Backend.new(config.redis, Resque.logger)
 
     @queues = Hash.new do |h,name|
       h[name] = Resque::Queue.new(name, config.redis, coder)
     end
+
+    @backend = Backend.new(config.redis, Resque.logger)
+
+    config.redis
   end
 
   # Returns the current Redis connection. If none has been created, will
   # create a new one.
-  def redis
-    backend.store
-  end
 
   def redis_id
     config.redis_id
@@ -199,17 +199,17 @@ def peek(queue, start = 0, count = 1)
   # and converting them into Ruby objects.
   def list_range(key, start = 0, count = 1)
     if count == 1
-      decode(redis.lindex(key, start))
+      decode(backend.store.lindex(key, start))
     else
-      Array(redis.lrange(key, start, start+count-1)).map do |item|
+      Array(backend.store.lrange(key, start, start+count-1)).map do |item|
         decode(item)
       end
     end
   end
 
   # Returns an array of all known Resque queues as strings.
   def queues
-    Array(redis.smembers(:queues))
+    Array(backend.store.smembers(:queues))
   end
 
   # Given a queue name, completely deletes the queue.
@@ -381,7 +381,7 @@ def info
       :queues    => queues.size,
       :workers   => Resque::WorkerRegistry.all.size.to_i,
       :working   => Resque::WorkerRegistry.working.size,
-      :failed    => Resque.redis.llen(:failed).to_i,
+      :failed    => Resque.backend.store.llen(:failed).to_i,
       :servers   => [redis_id],
       :environment  => ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     }
@@ -390,8 +390,8 @@ def info
   # Returns an array of all known Resque keys in Redis. Redis' KEYS operation
   # is O(N) for the keyspace, so be careful - this can be slow for big databases.
   def keys
-    redis.keys("*").map do |key|
-      key.sub("#{redis.namespace}:", '')
+    backend.store.keys("*").map do |key|
+      key.sub("#{backend.store.namespace}:", '')
     end
   end
 end

lib/resque/cli.rb

@@ -86,7 +86,7 @@ def sort_failures
       warn "Sorting #{Resque::Failure.count} failures..."
       Resque::Failure.each(0, Resque::Failure.count) do |_, failure|
         data = Resque.encode(failure)
-        Resque.redis.rpush(Resque::Failure.failure_queue_name(failure['queue']), data)
+        Resque.backend.store.rpush(Resque::Failure.failure_queue_name(failure['queue']), data)
       end
       warn "done!"
     end

lib/resque/failure.rb

@@ -41,7 +41,7 @@ def self.backend
     # Obtain the failure queue name for a given job queue
     def self.failure_queue_name(job_queue_name)
       name = "#{job_queue_name}_failed"
-      Resque.redis.sadd(:failed_queues, name)
+      Resque.backend.store.sadd(:failed_queues, name)
       name
     end
 

lib/resque/failure/redis.rb

@@ -17,7 +17,7 @@ def save
           :queue     => queue
         }
         data = Resque.encode(data)
-        Resque.redis.rpush(:failed, data)
+        Resque.backend.store.rpush(:failed, data)
       end
 
       def self.count(queue = nil, class_name = nil)
@@ -28,7 +28,7 @@ def self.count(queue = nil, class_name = nil)
           each(0, count(queue), queue, class_name) { n += 1 } 
           n
         else
-          Resque.redis.llen(:failed).to_i
+          Resque.backend.store.llen(:failed).to_i
         end
       end
 
@@ -45,27 +45,27 @@ def self.all(offset = 0, limit = 1, queue = nil)
 
       def self.clear(queue = nil)
         check_queue(queue)
-        Resque.redis.del(:failed)
+        Resque.backend.store.del(:failed)
       end
 
       def self.requeue(id)
         item = all(id)
         item['retried_at'] = Time.now.rfc2822
-        Resque.redis.lset(:failed, id, Resque.encode(item))
+        Resque.backend.store.lset(:failed, id, Resque.encode(item))
         Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
       end
 
       def self.requeue_to(id, queue_name)
         item = all(id)
         item['retried_at'] = Time.now.rfc2822
-        Resque.redis.lset(:failed, id, Resque.encode(item))
+        Resque.backend.store.lset(:failed, id, Resque.encode(item))
         Job.create(queue_name, item['payload']['class'], *item['payload']['args'])
       end
 
       def self.remove(id)
         sentinel = ""
-        Resque.redis.lset(:failed, id, sentinel)
-        Resque.redis.lrem(:failed, 1,  sentinel)
+        Resque.backend.store.lset(:failed, id, sentinel)
+        Resque.backend.store.lrem(:failed, 1,  sentinel)
       end
 
       def self.requeue_queue(queue)

lib/resque/failure/redis_multi_queue.rb

@@ -16,7 +16,7 @@ def save
           :queue     => queue
         }
         data = Resque.encode(data)
-        Resque.redis.rpush(Resque::Failure.failure_queue_name(queue), data)
+        Resque.backend.store.rpush(Resque::Failure.failure_queue_name(queue), data)
       end
 
       def self.count(queue = nil, class_name = nil)
@@ -26,7 +26,7 @@ def self.count(queue = nil, class_name = nil)
             each(0, count(queue), queue, class_name) { n += 1 } 
             n
           else
-            Resque.redis.llen(queue).to_i
+            Resque.backend.store.llen(queue).to_i
           end
         else
           total = 0
@@ -40,26 +40,26 @@ def self.all(offset = 0, limit = 1, queue = :failed)
       end
 
       def self.queues
-        Array(Resque.redis.smembers(:failed_queues))
+        Array(Resque.backend.store.smembers(:failed_queues))
       end
 
       include Each
 
       def self.clear(queue = :failed)
-        Resque.redis.del(queue)
+        Resque.backend.store.del(queue)
       end
 
       def self.requeue(id, queue = :failed)
         item = all(id, 1, queue)
         item['retried_at'] = Time.now.strftime("%Y/%m/%d %H:%M:%S")
-        Resque.redis.lset(queue, id, Resque.encode(item))
+        Resque.backend.store.lset(queue, id, Resque.encode(item))
         Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
       end
 
       def self.remove(id, queue = :failed)
         sentinel = ""
-        Resque.redis.lset(queue, id, sentinel)
-        Resque.redis.lrem(queue, 1,  sentinel)
+        Resque.backend.store.lset(queue, id, sentinel)
+        Resque.backend.store.lrem(queue, 1,  sentinel)
       end
 
       def self.requeue_queue(queue)
@@ -68,7 +68,7 @@ def self.requeue_queue(queue)
       end
 
       def self.remove_queue(queue)
-        Resque.redis.del(Resque::Failure.failure_queue_name(queue))
+        Resque.backend.store.del(Resque::Failure.failure_queue_name(queue))
       end
 
       def filter_backtrace(backtrace)

lib/resque/job.rb

@@ -75,7 +75,7 @@ def self.create(queue, klass, *args)
     #   Resque::Job.destroy(queue, 'UpdateGraph', 'mojombo')
     def self.destroy(queue, klass, *args)
       coder = Resque.coder
-      redis = Resque.redis
+      redis = Resque.backend.store
       klass = klass.to_s
 
       destroyed_count = 0
@@ -109,7 +109,7 @@ def self.destroy(queue, klass, *args)
     #   Resque::Job.queued(queue, 'UpdateGraph', 'mojombo')
     def self.queued(queue, klass, *args)
       coder = Resque.coder
-      redis = Resque.redis
+      redis = Resque.backend.store
       klass = klass.to_s
 
       jobs = process_queue(queue, coder, redis, klass, args) do |decoded, new_queue, temp_queue, requeue_queue|

lib/resque/multi_queue.rb

@@ -29,10 +29,10 @@ def initialize(queues, redis)
     # multiqueue
     def self.from_queues(queues)
       new_queues = queues.map do |queue|
-        Queue.new(queue, Resque.redis, Resque.coder)
+        Queue.new(queue, Resque.backend.store, Resque.coder)
       end
 
-      new(new_queues, Resque.redis)
+      new(new_queues, Resque.backend.store)
     end
 
     # Pop an item off one of the queues.  This method will block until an item

lib/resque/stat.rb

@@ -10,7 +10,7 @@ module Stat
 
     # Direct access to the Redis instance.
     def redis
-      Resque.redis
+      Resque.backend.store
     end
 
     # Returns the int value of a stat, given a string stat name.

lib/resque/worker.rb

@@ -62,7 +62,7 @@ def initialize(queues = [], options = {})
       @paused = nil
       @cant_fork = false
 
-      @client = @options.fetch(:client) { Backend.new(Resque.redis, Resque.logger) }
+      @client = @options.fetch(:client) { Backend.new(Resque.backend.store, Resque.logger) }
 
       validate_queues
     end

lib/resque/worker_registry.rb

@@ -6,11 +6,11 @@ class WorkerRegistry
 
     # Direct access to the Redis instance.
     def redis
-      Resque.redis
+      Resque.backend.store
     end
 
     def self.redis
-      Resque.redis
+      Resque.backend.store
     end
 
     def encode(object)

test/legacy/job_hooks_test.rb

@@ -255,7 +255,7 @@ def self.perform(history)
 
 
   describe "before_enqueue" do
-    before{ Resque.redis.flushall }
+    before{ Resque.backend.store.flushall }
 
     include PerformJob
 

test/legacy/multi_queue_test.rb

@@ -1,7 +1,7 @@
 require "test_helper"
 
 describe "Resque::MultiQueue" do
-  let(:redis) { Resque.redis }
+  let(:redis) { Resque.backend.store }
   let(:coder) { Resque::JsonCoder.new }
 
   before do

test/legacy/redis_queue_test.rb

@@ -15,7 +15,7 @@ def == other
   end
 
   before do
-    Resque.redis.flushall
+    Resque.backend.store.flushall
   end
 
   it "generates a redis_name" do
@@ -101,7 +101,7 @@ def == other
     q.destroy
 
     assert_equal [], Resque.queues
-    assert !Resque.redis.exists(queue.redis_name)
+    assert !Resque.backend.store.exists(queue.redis_name)
   end
 
   it "returns false if a queue is not destroyed" do
@@ -126,6 +126,6 @@ def == other
   end
 
   def q
-    Resque::Queue.new 'foo', Resque.redis
+    Resque::Queue.new 'foo', Resque.backend.store
   end
 end

test/legacy/resque_hook_test.rb

@@ -2,7 +2,7 @@
 
 describe "Resque Hooks" do
   before do
-    Resque.redis.flushall
+    Resque.backend.store.flushall
 
     Resque.before_first_fork = nil
     Resque.before_fork = nil

test/legacy/resque_invalid_characters_test.rb

@@ -4,8 +4,8 @@
 
 describe "Resque" do
   before do
-    Resque.redis.flushall
-    @original_redis = Resque.redis
+    Resque.backend.store.flushall
+    @original_redis = Resque.backend.store
   end
 
   after do

test/legacy/resque_test.rb

@@ -2,14 +2,14 @@
 
 describe "Resque" do
   before do
-    Resque.redis.flushall
+    Resque.backend.store.flushall
 
     Resque.push(:people, { 'name' => 'chris' })
     Resque.push(:people, { 'name' => 'bob' })
     Resque.push(:people, { 'name' => 'mark' })
     Resque::Worker.__send__(:public, :reserve)
     Resque::Worker.__send__(:public, :done_working)
-    @original_redis = Resque.redis
+    @original_redis = Resque.backend.store
   end
 
   after do
@@ -206,7 +206,7 @@
   end
 
   it "queues are always a list" do
-    Resque.redis.flushall
+    Resque.backend.store.flushall
     assert_equal [], Resque.queues
   end
 
@@ -259,9 +259,9 @@
     assert_equal 3, stats[:processed]
     assert_equal 1, stats[:failed]
     if ENV.key? 'RESQUE_DISTRIBUTED'
-      assert_equal [Resque.redis.respond_to?(:server) ? 'localhost:9736, localhost:9737' : 'redis://localhost:9736/0, redis://localhost:9737/0'], stats[:servers]
+      assert_equal [Resque.backend.store.respond_to?(:server) ? 'localhost:9736, localhost:9737' : 'redis://localhost:9736/0, redis://localhost:9737/0'], stats[:servers]
     else
-      assert_equal [Resque.redis.respond_to?(:server) ? 'localhost:9736' : 'redis://localhost:9736/0'], stats[:servers]
+      assert_equal [Resque.backend.store.respond_to?(:server) ? 'localhost:9736' : 'redis://localhost:9736/0'], stats[:servers]
     end
   end