resque_admin 0.2.0 → 1.0.2

data/lib/{resque_admin → resque}/server/views/workers.erb

@@ -1,6 +1,6 @@
 <% @subtabs = worker_hosts.keys.sort unless worker_hosts.size == 1 %>
 
-<% if params[:id] && worker = ResqueAdmin::Worker.find(params[:id]) %>
+<% if params[:id] && worker = Resque::Worker.find(params[:id]) %>
 
   <h1>Worker <%= worker %></h1>
   <table class='workers'>
@@ -44,9 +44,9 @@
 <% elsif worker_hosts.size == 1 || params[:id] %>
 
   <% if worker_hosts.size == 1 || params[:id] == 'all' %>
-    <% workers = ResqueAdmin.workers %>
+    <% workers = Resque.workers %>
   <% else %>
-    <% workers = worker_hosts[params[:id]].map { |id| ResqueAdmin::Worker.find(id) } %>
+    <% workers = worker_hosts[params[:id]].map { |id| Resque::Worker.find(id) } %>
   <% end %>
 
   <h1 class='wi'><%= workers.size %> Workers</h1>
@@ -101,7 +101,7 @@
     <% end %>
     <tr class="failed">
       <td class='queue failed'><a class="queue" href="<%= u "workers/all" %>">all workers</a></td>
-      <td class='size'><%= ResqueAdmin.workers.size %></td>
+      <td class='size'><%= Resque.workers.size %></td>
     </tr>
   </table>
 

data/lib/{resque_admin → resque}/server/views/working.erb

@@ -1,4 +1,4 @@
-<% if params[:id] && (worker = ResqueAdmin::Worker.find(params[:id])) && (data = worker.job) %>
+<% if params[:id] && (worker = Resque::Worker.find(params[:id])) && (data = worker.job) %>
   <h1><%= worker %>'s job</h1>
 
   <table>

data/lib/{resque_admin → resque}/server.rb

@@ -9,7 +9,7 @@ if defined? Encoding
   Encoding.default_external = Encoding::UTF_8
 end
 
-module ResqueAdmin
+module Resque
   class Server < Sinatra::Base
     require 'resque/server/helpers'
 
@@ -61,40 +61,40 @@ module ResqueAdmin
       end
 
       def tabs
-        ResqueAdmin::Server.tabs
+        Resque::Server.tabs
       end
 
       def url_prefix
-        ResqueAdmin::Server.url_prefix
+        Resque::Server.url_prefix
       end
 
       def redis_get_size(key)
-        case ResqueAdmin.redis.type(key)
+        case Resque.redis.type(key)
         when 'none'
           []
         when 'list'
-          ResqueAdmin.redis.llen(key)
+          Resque.redis.llen(key)
         when 'set'
-          ResqueAdmin.redis.scard(key)
+          Resque.redis.scard(key)
         when 'string'
-          ResqueAdmin.redis.get(key).length
+          Resque.redis.get(key).length
         when 'zset'
-          ResqueAdmin.redis.zcard(key)
+          Resque.redis.zcard(key)
         end
       end
 
       def redis_get_value_as_array(key, start=0)
-        case ResqueAdmin.redis.type(key)
+        case Resque.redis.type(key)
         when 'none'
           []
         when 'list'
-          ResqueAdmin.redis.lrange(key, start, start + 20)
+          Resque.redis.lrange(key, start, start + 20)
         when 'set'
-          ResqueAdmin.redis.smembers(key)[start..(start + 20)]
+          Resque.redis.smembers(key)[start..(start + 20)]
         when 'string'
-          [ResqueAdmin.redis.get(key)]
+          [Resque.redis.get(key)]
         when 'zset'
-          ResqueAdmin.redis.zrange(key, start, start + 20)
+          Resque.redis.zrange(key, start, start + 20)
         end
       end
 
@@ -113,7 +113,7 @@ module ResqueAdmin
       def worker_hosts!
         hosts = Hash.new { [] }
 
-        ResqueAdmin.workers.each do |worker|
+        Resque.workers.each do |worker|
           host, _ = worker.to_s.split(':')
           hosts[host] += [worker.to_s]
         end
@@ -146,9 +146,9 @@ module ResqueAdmin
     def show(page, layout = true)
       response["Cache-Control"] = "max-age=0, private, must-revalidate"
       begin
-        erb page.to_sym, {:layout => layout}, :resque => ResqueAdmin
+        erb page.to_sym, {:layout => layout}, :resque => Resque
       rescue Errno::ECONNREFUSED
-        erb :error, {:layout => false}, :error => "Can't connect to Redis! (#{ResqueAdmin.redis_id})"
+        erb :error, {:layout => false}, :error => "Can't connect to Redis! (#{Resque.redis_id})"
       end
     end
 
@@ -184,71 +184,71 @@ module ResqueAdmin
     end
 
     post "/queues/:id/remove" do
-      ResqueAdmin.remove_queue(params[:id])
+      Resque.remove_queue(params[:id])
       redirect u('queues')
     end
 
     get "/failed/?" do
-      if ResqueAdmin::Failure.url
-        redirect ResqueAdmin::Failure.url
+      if Resque::Failure.url
+        redirect Resque::Failure.url
       else
         show :failed
       end
     end
 
     get "/failed/:queue" do
-      if ResqueAdmin::Failure.url
-        redirect ResqueAdmin::Failure.url
+      if Resque::Failure.url
+        redirect Resque::Failure.url
       else
         show :failed
       end
     end
 
     post "/failed/clear" do
-      ResqueAdmin::Failure.clear
+      Resque::Failure.clear
       redirect u('failed')
     end
 
     post "/failed/:queue/clear" do
-      ResqueAdmin::Failure.clear params[:queue]
+      Resque::Failure.clear params[:queue]
       redirect u('failed')
     end
 
     post "/failed/requeue/all" do
-      ResqueAdmin::Failure.requeue_all
+      Resque::Failure.requeue_all
       redirect u('failed')
     end
 
     post "/failed/:queue/requeue/all" do
-      ResqueAdmin::Failure.requeue_queue ResqueAdmin::Failure.job_queue_name(params[:queue])
+      Resque::Failure.requeue_queue Resque::Failure.job_queue_name(params[:queue])
       redirect redirect_url_path("/failed/#{params[:queue]}")
     end
 
     get "/failed/requeue/:index/?" do
-      ResqueAdmin::Failure.requeue(params[:index])
+      Resque::Failure.requeue(params[:index])
       if request.xhr?
-        return ResqueAdmin::Failure.all(params[:index])['retried_at']
+        return Resque::Failure.all(params[:index])['retried_at']
       else
         redirect u('failed')
       end
     end
 
     get "/failed/:queue/requeue/:index/?" do
-      ResqueAdmin::Failure.requeue(params[:index], params[:queue])
+      Resque::Failure.requeue(params[:index], params[:queue])
       if request.xhr?
-        return ResqueAdmin::Failure.all(params[:index],1,params[:queue])['retried_at']
+        return Resque::Failure.all(params[:index],1,params[:queue])['retried_at']
       else
         redirect url_path("/failed/#{params[:queue]}")
       end
     end
 
     get "/failed/remove/:index/?" do
-      ResqueAdmin::Failure.remove(params[:index])
+      Resque::Failure.remove(params[:index])
       redirect u('failed')
     end
 
     get "/failed/:queue/remove/:index/?" do
-      ResqueAdmin::Failure.remove(params[:index], params[:queue])
+      Resque::Failure.remove(params[:index], params[:queue])
       redirect url_path("/failed/#{params[:queue]}")
     end
 
@@ -265,7 +265,7 @@ module ResqueAdmin
     end
 
     get "/stats.txt/?" do
-      info = ResqueAdmin.info
+      info = Resque.info
 
       stats = []
       stats << "resque.pending=#{info[:pending]}"
@@ -274,8 +274,8 @@ module ResqueAdmin
       stats << "resque.workers=#{info[:workers]}"
       stats << "resque.working=#{info[:working]}"
 
-      ResqueAdmin.queues.each do |queue|
-        stats << "queues.#{queue}=#{ResqueAdmin.size(queue)}"
+      Resque.queues.each do |queue|
+        stats << "queues.#{queue}=#{Resque.size(queue)}"
       end
 
       content_type 'text/html'
@@ -283,7 +283,7 @@ module ResqueAdmin
     end
 
     def resque
-      ResqueAdmin
+      Resque
     end
 
     def self.tabs

data/lib/{resque_admin → resque}/stat.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   # The stat subsystem. Used to keep track of integer counts.
   #
   #   Get a stat:  Stat[name]
@@ -10,7 +10,7 @@ module ResqueAdmin
     
     # Direct access to the Redis instance.
     def redis
-      ResqueAdmin.redis
+      Resque.redis
     end
     alias :data_store :redis
 

data/lib/{resque_admin → resque}/tasks.rb

@@ -5,13 +5,13 @@
 namespace :resque do
   task :setup
 
-  desc "Start a ResqueAdmin worker"
+  desc "Start a Resque worker"
   task :work => [ :preload, :setup ] do
-    require 'resque_admin'
+    require 'resque'
 
     begin
-      worker = ResqueAdmin::Worker.new
-    rescue ResqueAdmin::NoQueueError
+      worker = Resque::Worker.new
+    rescue Resque::NoQueueError
       abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque:work"
     end
 
@@ -20,7 +20,7 @@ namespace :resque do
     worker.work(ENV['INTERVAL'] || 5) # interval, will block
   end
 
-  desc "Start multiple ResqueAdmin workers. Should only be used in dev mode."
+  desc "Start multiple Resque workers. Should only be used in dev mode."
   task :workers do
     threads = []
 
@@ -58,13 +58,13 @@ namespace :resque do
   namespace :failures do
     desc "Sort the 'failed' queue for the redis_multi_queue failure backend"
     task :sort do
-      require 'resque_admin'
-      require 'resque_admin/failure/redis'
+      require 'resque'
+      require 'resque/failure/redis'
 
-      warn "Sorting #{ResqueAdmin::Failure.count} failures..."
-      ResqueAdmin::Failure.each(0, ResqueAdmin::Failure.count) do |_, failure|
-        data = ResqueAdmin.encode(failure)
-        ResqueAdmin.redis.rpush(ResqueAdmin::Failure.failure_queue_name(failure['queue']), data)
+      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)
       end
       warn "done!"
     end

data/lib/{resque_admin → resque}/thread_signal.rb

@@ -1,4 +1,4 @@
-class ResqueAdmin::ThreadSignal
+class Resque::ThreadSignal
   def initialize
     @mutex = Mutex.new
     @signaled = false

data/lib/resque/version.rb

@@ -0,0 +1,3 @@
+module Resque
+  Version = VERSION = '1.0.2'
+end

data/lib/{resque_admin → resque}/worker.rb

@@ -2,8 +2,8 @@ require 'time'
 require 'set'
 require 'redis/distributed'
 
-module ResqueAdmin
-  # A ResqueAdmin Worker processes jobs. On platforms that support fork(2),
+module Resque
+  # A Resque Worker processes jobs. On platforms that support fork(2),
   # the worker will fork off a child to process each job. This ensures
   # a clean slate when beginning the next job and cuts down on gradual
   # memory growth as well as low level failures.
@@ -11,9 +11,9 @@ module ResqueAdmin
   # It also ensures workers are always listening to signals from you,
   # their master, and can react accordingly.
   class Worker
-    include ResqueAdmin::Helpers
-    extend ResqueAdmin::Helpers
-    include ResqueAdmin::Logging
+    include Resque::Helpers
+    extend Resque::Helpers
+    include Resque::Logging
 
     @@all_heartbeat_threads = []
     def self.kill_all_heartbeat_threads
@@ -22,12 +22,12 @@ module ResqueAdmin
     end
 
     def redis
-      ResqueAdmin.redis
+      Resque.redis
     end
     alias :data_store :redis
 
     def self.redis
-      ResqueAdmin.redis
+      Resque.redis
     end
 
     def self.data_store
@@ -37,12 +37,12 @@ module ResqueAdmin
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
     def encode(object)
-      ResqueAdmin.encode(object)
+      Resque.encode(object)
     end
 
     # Given a string, returns a Ruby object.
     def decode(object)
-      ResqueAdmin.decode(object)
+      Resque.decode(object)
     end
 
     attr_accessor :term_timeout
@@ -200,7 +200,7 @@ module ResqueAdmin
     end
 
     def glob_match(pattern)
-      ResqueAdmin.queues.select do |queue|
+      Resque.queues.select do |queue|
         File.fnmatch?(pattern, queue)
       end.sort
     end
@@ -313,7 +313,7 @@ module ResqueAdmin
     def reserve
       queues.each do |queue|
         log_with_severity :debug, "Checking #{queue}"
-        if job = ResqueAdmin.reserve(queue)
+        if job = Resque.reserve(queue)
           log_with_severity :debug, "Found job on #{queue}"
           return job
         end
@@ -489,7 +489,7 @@ module ResqueAdmin
 
         if heartbeat
           seconds_since_heartbeat = (now - Time.parse(heartbeat)).to_i
-          seconds_since_heartbeat > ResqueAdmin.prune_interval
+          seconds_since_heartbeat > Resque.prune_interval
         else
           false
         end
@@ -499,12 +499,12 @@ module ResqueAdmin
     def start_heartbeat
       remove_heartbeat
 
-      @heartbeat_thread_signal = ResqueAdmin::ThreadSignal.new
+      @heartbeat_thread_signal = Resque::ThreadSignal.new
 
       @heartbeat_thread = Thread.new do
         loop do
           heartbeat!
-          signaled = @heartbeat_thread_signal.wait_for_signal(ResqueAdmin.heartbeat_interval)
+          signaled = @heartbeat_thread_signal.wait_for_signal(Resque.heartbeat_interval)
           break if signaled
         end
       end
@@ -579,7 +579,7 @@ module ResqueAdmin
     #
     # This is a form of garbage collection. If a server is killed by a
     # hard shutdown, power failure, or something else beyond our
-    # control, the ResqueAdmin workers will not die gracefully and therefore
+    # control, the Resque workers will not die gracefully and therefore
     # will leave stale state information in Redis.
     #
     # By checking the current Redis state against the actual
@@ -598,7 +598,7 @@ module ResqueAdmin
         # If the worker hasn't ever sent a heartbeat, we won't remove it since
         # the first heartbeat is sent before the worker is registred it means
         # that this is a worker that doesn't support heartbeats, e.g., another
-        # client library or an older version of ResqueAdmin. We won't touch these.
+        # client library or an older version of Resque. We won't touch these.
         if all_workers_with_expired_heartbeats.include?(worker)
           log_with_severity :info, "Pruning dead worker: #{worker}"
           worker.unregister_worker(PruneDeadWorkerDirtyExit.new(worker.to_s))
@@ -632,7 +632,7 @@ module ResqueAdmin
 
     # Runs a named hook, passing along any arguments.
     def run_hook(name, *args)
-      return unless hooks = ResqueAdmin.send(name)
+      return unless hooks = Resque.send(name)
       return if name == :before_first_fork && @before_first_fork_hook_ran
       msg = "Running #{name} hooks"
       msg << " with #{args.inspect}" if args.any?
@@ -808,7 +808,7 @@ module ResqueAdmin
       tasklist_output.split($/).select { |line| line =~ /^PID:/}.collect{ |line| line.gsub /PID:\s+/, '' }
     end
 
-    # Find ResqueAdmin worker pids on Linux and OS X.
+    # Find Resque worker pids on Linux and OS X.
     #
     def linux_worker_pids
       `ps -A -o pid,command | grep -E "[r]esque:work|[r]esque:\sStarting|[r]esque-[0-9]" | grep -v "resque-web"`.split("\n").map do |line|
@@ -816,7 +816,7 @@ module ResqueAdmin
       end
     end
 
-    # Find ResqueAdmin worker pids on Solaris.
+    # Find Resque worker pids on Solaris.
     #
     # Returns an Array of string pids of all the other workers on this
     # machine. Useful when pruning dead workers on startup.
@@ -824,7 +824,7 @@ module ResqueAdmin
       `ps -A -o pid,comm | grep "[r]uby" | grep -v "resque-web"`.split("\n").map do |line|
         real_pid = line.split(' ')[0]
         pargs_command = `pargs -a #{real_pid} 2>/dev/null | grep [r]esque | grep -v "resque-web"`
-        if pargs_command.split(':')[1] == " resque-#{ResqueAdmin::Version}"
+        if pargs_command.split(':')[1] == " resque-#{Resque::Version}"
           real_pid
         end
       end.compact
@@ -834,7 +834,7 @@ module ResqueAdmin
     # Procline is always in the format of:
     #   RESQUE_PROCLINE_PREFIXresque-VERSION: STRING
     def procline(string)
-      $0 = "#{ENV['RESQUE_PROCLINE_PREFIX']}resque-#{ResqueAdmin::Version}: #{string}"
+      $0 = "#{ENV['RESQUE_PROCLINE_PREFIX']}resque-#{Resque::Version}: #{string}"
       log_with_severity :debug, $0
     end
 
@@ -857,10 +857,10 @@ module ResqueAdmin
 
     def verbose=(value);
       if value && !very_verbose
-        ResqueAdmin.logger.formatter = VerboseFormatter.new
-        ResqueAdmin.logger.level = Logger::INFO
+        Resque.logger.formatter = VerboseFormatter.new
+        Resque.logger.level = Logger::INFO
       elsif !value
-        ResqueAdmin.logger.formatter = QuietFormatter.new
+        Resque.logger.formatter = QuietFormatter.new
       end
 
       @verbose = value
@@ -868,13 +868,13 @@ module ResqueAdmin
 
     def very_verbose=(value)
       if value
-        ResqueAdmin.logger.formatter = VeryVerboseFormatter.new
-        ResqueAdmin.logger.level = Logger::DEBUG
+        Resque.logger.formatter = VeryVerboseFormatter.new
+        Resque.logger.level = Logger::DEBUG
       elsif !value && verbose
-        ResqueAdmin.logger.formatter = VerboseFormatter.new
-        ResqueAdmin.logger.level = Logger::INFO
+        Resque.logger.formatter = VerboseFormatter.new
+        Resque.logger.level = Logger::INFO
       else
-        ResqueAdmin.logger.formatter = QuietFormatter.new
+        Resque.logger.formatter = QuietFormatter.new
       end
 
       @very_verbose = value

data/lib/{resque_admin.rb → resque.rb}

@@ -23,7 +23,7 @@ require 'resque/thread_signal'
 
 require 'resque/vendor/utf8_util'
 
-module ResqueAdmin
+module Resque
   include Helpers
   extend self
 
@@ -122,15 +122,15 @@ module ResqueAdmin
       end
       namespace ||= :resque
 
-      @data_store = ResqueAdmin::DataStore.new(Redis::Namespace.new(namespace, :redis => redis))
+      @data_store = Resque::DataStore.new(Redis::Namespace.new(namespace, :redis => redis))
     when Redis::Namespace
-      @data_store = ResqueAdmin::DataStore.new(server)
-    when ResqueAdmin::DataStore
+      @data_store = Resque::DataStore.new(server)
+    when Resque::DataStore
       @data_store = server
     when Hash
-      @data_store = ResqueAdmin::DataStore.new(Redis::Namespace.new(:resque, :redis => Redis.new(server)))
+      @data_store = Resque::DataStore.new(Redis::Namespace.new(:resque, :redis => Redis.new(server)))
     else
-      @data_store = ResqueAdmin::DataStore.new(Redis::Namespace.new(:resque, :redis => server))
+      @data_store = Resque::DataStore.new(Redis::Namespace.new(:resque, :redis => server))
     end
   end
 
@@ -238,14 +238,14 @@ module ResqueAdmin
   end
 
   def to_s
-    "ResqueAdmin Client connected to #{redis_id}"
+    "Resque Client connected to #{redis_id}"
   end
 
   attr_accessor :inline
 
-  # If 'inline' is true ResqueAdmin will call #perform method inline
-  # without queuing it into Redis and without any ResqueAdmin callbacks.
-  # The 'inline' is false ResqueAdmin jobs will be put in queue regularly.
+  # If 'inline' is true Resque will call #perform method inline
+  # without queuing it into Redis and without any Resque callbacks.
+  # The 'inline' is false Resque jobs will be put in queue regularly.
   alias :inline? :inline
 
   #
@@ -255,7 +255,7 @@ module ResqueAdmin
   # Pushes a job onto a queue. Queue name should be a string and the
   # item should be any JSON-able Ruby object.
   #
-  # ResqueAdmin works generally expect the `item` to be a hash with the following
+  # Resque works generally expect the `item` to be a hash with the following
   # keys:
   #
   #   class - The String name of the job to run.
@@ -264,7 +264,7 @@ module ResqueAdmin
   #
   # Example
   #
-  #   ResqueAdmin.push('archive', :class => 'Archive', :args => [ 35, 'tar' ])
+  #   Resque.push('archive', :class => 'Archive', :args => [ 35, 'tar' ])
   #
   # Returns nothing
   def push(queue, item)
@@ -291,7 +291,7 @@ module ResqueAdmin
   # start is the item to begin, count is how many items to return.
   #
   # To get the 3rd page of a 30 item, paginatied list one would use:
-  #   ResqueAdmin.peek('my_list', 59, 30)
+  #   Resque.peek('my_list', 59, 30)
   def peek(queue, start = 0, count = 1)
     results = data_store.peek_in_queue(queue,start,count)
     if count == 1
@@ -312,7 +312,7 @@ module ResqueAdmin
     end
   end
 
-  # Returns an array of all known ResqueAdmin queues as strings.
+  # Returns an array of all known Resque queues as strings.
   def queues
     data_store.queue_names
   end
@@ -343,7 +343,7 @@ module ResqueAdmin
   # If either of those conditions are met, it will use the value obtained
   # from performing one of the above operations to determine the queue.
   #
-  # If no queue can be inferred this method will raise a `ResqueAdmin::NoQueueError`
+  # If no queue can be inferred this method will raise a `Resque::NoQueueError`
   #
   # Returns true if the job was queued, nil if the job was rejected by a
   # before_enqueue hook.
@@ -388,10 +388,10 @@ module ResqueAdmin
   # If either of those conditions are met, it will use the value obtained
   # from performing one of the above operations to determine the queue.
   #
-  # If no queue can be inferred this method will raise a `ResqueAdmin::NoQueueError`
+  # If no queue can be inferred this method will raise a `Resque::NoQueueError`
   #
   # If no args are given, this method will dequeue *all* jobs matching
-  # the provided class. See `ResqueAdmin::Job.destroy` for more
+  # the provided class. See `Resque::Job.destroy` for more
   # information.
   #
   # Returns the number of jobs destroyed.
@@ -399,10 +399,10 @@ module ResqueAdmin
   # Example:
   #
   #   # Removes all jobs of class `UpdateNetworkGraph`
-  #   ResqueAdmin.dequeue(GitHub::Jobs::UpdateNetworkGraph)
+  #   Resque.dequeue(GitHub::Jobs::UpdateNetworkGraph)
   #
   #   # Removes all jobs of class `UpdateNetworkGraph` with matching args.
-  #   ResqueAdmin.dequeue(GitHub::Jobs::UpdateNetworkGraph, 'repo:135325')
+  #   Resque.dequeue(GitHub::Jobs::UpdateNetworkGraph, 'repo:135325')
   #
   # This method is considered part of the `stable` API.
   def dequeue(klass, *args)
@@ -428,7 +428,7 @@ module ResqueAdmin
       (klass.respond_to?(:queue) and klass.queue)
   end
 
-  # This method will return a `ResqueAdmin::Job` object or a non-true value
+  # This method will return a `Resque::Job` object or a non-true value
   # depending on whether a job can be obtained. You should pass it the
   # precise name of a queue: case matters.
   #
@@ -437,11 +437,11 @@ module ResqueAdmin
     Job.reserve(queue)
   end
 
-  # Validates if the given klass could be a valid ResqueAdmin job
+  # Validates if the given klass could be a valid Resque job
   #
-  # If no queue can be inferred this method will raise a `ResqueAdmin::NoQueueError`
+  # If no queue can be inferred this method will raise a `Resque::NoQueueError`
   #
-  # If given klass is nil this method will raise a `ResqueAdmin::NoClassError`
+  # If given klass is nil this method will raise a `Resque::NoClassError`
   def validate(klass, queue = nil)
     queue ||= queue_from_class(klass)
 
@@ -472,7 +472,7 @@ module ResqueAdmin
   # A shortcut to unregister_worker
   # useful for command line tool
   def remove_worker(worker_id)
-    worker = ResqueAdmin::Worker.find(worker_id)
+    worker = Resque::Worker.find(worker_id)
     worker.unregister_worker
   end
 
@@ -494,7 +494,7 @@ module ResqueAdmin
     }
   end
 
-  # Returns an array of all known ResqueAdmin keys in Redis. Redis' KEYS operation
+  # 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
     data_store.all_resque_keys
@@ -574,5 +574,5 @@ module ResqueAdmin
 end
 
 # Log to STDOUT by default
-ResqueAdmin.logger           = MonoLogger.new(STDOUT)
-ResqueAdmin.logger.formatter = ResqueAdmin::QuietFormatter.new
+Resque.logger           = MonoLogger.new(STDOUT)
+Resque.logger.formatter = Resque::QuietFormatter.new

data/lib/tasks/{resque_admin.rake → resque.rake}

@@ -1,2 +1,2 @@
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
-require 'resque_admin/tasks'
+require 'resque/tasks'