resque_admin 1.0.4 → 1.0.5

data/README.markdown

@@ -1,11 +1,11 @@
-Resque
+ResqueAdmin
 ======
 
 [![Gem Version](https://badge.fury.io/rb/resque.svg)](https://rubygems.org/gems/resque)
 [![Build Status](https://travis-ci.org/resque/resque.svg)](https://travis-ci.org/resque/resque)
 [![Coverage Status](https://coveralls.io/repos/github/resque/resque/badge.svg?branch=1-x-stable)](https://coveralls.io/r/resque/resque?branch=1-x-stable)
 
-Resque (pronounced like "rescue") is a Redis-backed library for creating
+ResqueAdmin (pronounced like "rescue") is a Redis-backed library for creating
 background jobs, placing those jobs on multiple queues, and processing
 them later.
 
@@ -14,44 +14,44 @@ Background jobs can be any Ruby class or module that responds to
 jobs or you can create new classes specifically to do work. Or, you
 can do both.
 
-Resque is heavily inspired by DelayedJob (which rocks) and comprises
+ResqueAdmin is heavily inspired by DelayedJob (which rocks) and comprises
 three parts:
 
 1. A Ruby library for creating, querying, and processing jobs
 2. A Rake task for starting a worker which processes jobs
 3. A Sinatra app for monitoring queues, jobs, and workers.
 
-Resque workers can be distributed between multiple machines,
+ResqueAdmin workers can be distributed between multiple machines,
 support priorities, are resilient to memory bloat / "leaks," are
 optimized for REE (but work on MRI and JRuby), tell you what they're
 doing, and expect failure.
 
-Resque queues are persistent; support constant time, atomic push and
+ResqueAdmin queues are persistent; support constant time, atomic push and
 pop (thanks to Redis); provide visibility into their contents; and
 store jobs as simple JSON packages.
 
-The Resque frontend tells you what workers are doing, what workers are
+The ResqueAdmin frontend tells you what workers are doing, what workers are
 not doing, what queues you're using, what's in those queues, provides
 general usage stats, and helps you track failures.
 
-Resque now supports Ruby 2.0.0 and above. Any future updates will not be
+ResqueAdmin now supports Ruby 2.0.0 and above. Any future updates will not be
 guaranteed to work without defects on any Rubies older than 2.0.0. We will also only be supporting Redis 3.0 and above going forward.
 
 
 The Blog Post
 -------------
 
-For the backstory, philosophy, and history of Resque's beginnings,
+For the backstory, philosophy, and history of ResqueAdmin's beginnings,
 please see [the blog post][0].
 
 
 Overview
 --------
 
-Resque allows you to create jobs and place them on a queue, then,
+ResqueAdmin allows you to create jobs and place them on a queue, then,
 later, pull those jobs off the queue and process them.
 
-Resque jobs are Ruby classes (or modules) which respond to the
+ResqueAdmin jobs are Ruby classes (or modules) which respond to the
 `perform` method. Here's an example:
 
 
@@ -76,7 +76,7 @@ to our application's pre-existing `Repository` class:
 ``` ruby
 class Repository
   def async_create_archive(branch)
-    Resque.enqueue(Archive, self.id, branch)
+    ResqueAdmin.enqueue(Archive, self.id, branch)
   end
 end
 ```
@@ -88,7 +88,7 @@ queue.
 Later, a worker will run something like this code to process the job:
 
 ``` ruby
-klass, args = Resque.reserve(:file_serve)
+klass, args = ResqueAdmin.reserve(:file_serve)
 klass.perform(*args) if klass.respond_to? :perform
 ```
 
@@ -103,9 +103,9 @@ Let's start a worker to run `file_serve` jobs:
     $ cd app_root
     $ QUEUE=file_serve rake resque:work
 
-This starts one Resque worker and tells it to work off the
+This starts one ResqueAdmin worker and tells it to work off the
 `file_serve` queue. As soon as it's ready it'll try to run the
-`Resque.reserve` code snippet above and process jobs until it can't
+`ResqueAdmin.reserve` code snippet above and process jobs until it can't
 find any more, at which point it will sleep for a small period and
 repeatedly poll the queue for more jobs.
 
@@ -120,7 +120,7 @@ Jobs
 What should you run in the background? Anything that takes any time at
 all. Slow INSERT statements, disk manipulating, data processing, etc.
 
-At GitHub we use Resque to process the following types of jobs:
+At GitHub we use ResqueAdmin to process the following types of jobs:
 
 * Warming caches
 * Counting disk usage
@@ -134,7 +134,7 @@ At GitHub we use Resque to process the following types of jobs:
 
 As of writing we have about 35 different types of background jobs.
 
-Keep in mind that you don't need a web app to use Resque - we just
+Keep in mind that you don't need a web app to use ResqueAdmin - we just
 mention "foreground" and "background" because they make conceptual
 sense. You could easily be spidering sites and sticking data which
 needs to be crunched later into a queue.
@@ -164,13 +164,13 @@ Because of this your jobs must only accept arguments that can be JSON encoded.
 So instead of doing this:
 
 ``` ruby
-Resque.enqueue(Archive, self, branch)
+ResqueAdmin.enqueue(Archive, self, branch)
 ```
 
 do this:
 
 ``` ruby
-Resque.enqueue(Archive, self.id, branch)
+ResqueAdmin.enqueue(Archive, self.id, branch)
 ```
 
 This is why our above example (and all the examples in `examples/`)
@@ -197,11 +197,11 @@ We plan to provide first class `async` support in a future release.
 ### Failure
 
 If a job raises an exception, it is logged and handed off to the
-`Resque::Failure` module. Failures are logged either locally in Redis
+`ResqueAdmin::Failure` module. Failures are logged either locally in Redis
 or using some different backend. To see exceptions while developing,
 use VERBOSE env variable, see details below under Logging.
 
-For example, Resque ships with Airbrake support. To configure it, put
+For example, ResqueAdmin ships with Airbrake support. To configure it, put
 the following into an initialisation file or into your rake job:
 
 ``` ruby
@@ -210,8 +210,8 @@ require 'resque_admin/failure/multiple'
 require 'resque_admin/failure/redis'
 require 'resque_admin/failure/airbrake'
 
-Resque::Failure::Multiple.classes = [Resque::Failure::Redis, Resque::Failure::Airbrake]
-Resque::Failure.backend = Resque::Failure::Multiple
+ResqueAdmin::Failure::Multiple.classes = [ResqueAdmin::Failure::Redis, ResqueAdmin::Failure::Airbrake]
+ResqueAdmin::Failure.backend = ResqueAdmin::Failure::Multiple
 ```
 
 Keep this in mind when writing your jobs: you may want to throw
@@ -221,7 +221,7 @@ exceptions you would not normally throw in order to assist debugging.
 Workers
 -------
 
-Resque workers are rake tasks that run forever. They basically do this:
+ResqueAdmin workers are rake tasks that run forever. They basically do this:
 
 ``` ruby
 start
@@ -239,11 +239,11 @@ Starting a worker is simple. Here's our example from earlier:
 
     $ QUEUE=file_serve rake resque:work
 
-By default Resque won't know about your application's
+By default ResqueAdmin won't know about your application's
 environment. That is, it won't be able to find and run your jobs - it
 needs to load your application into memory.
 
-If we've installed Resque as a Rails plugin, we might run this command
+If we've installed ResqueAdmin as a Rails plugin, we might run this command
 from our RAILS_ROOT:
 
     $ QUEUE=file_serve rake environment resque:work
@@ -265,7 +265,7 @@ end
 ```
 
 We don't want the `git_timeout` as high as 10 minutes in our web app,
-but in the Resque workers it's fine.
+but in the ResqueAdmin workers it's fine.
 
 
 ### Logging
@@ -277,11 +277,11 @@ variable.
 
     $ VVERBOSE=1 QUEUE=file_serve rake environment resque:work
 
-If you want Resque to log to a file, in Rails do:
+If you want ResqueAdmin to log to a file, in Rails do:
 
 ```ruby
 # config/initializers/resque.rb
-Resque.logger = Logger.new(Rails.root.join('log', "#{Rails.env}_resque.log"))
+ResqueAdmin.logger = Logger.new(Rails.root.join('log', "#{Rails.env}_resque.log"))
 ```
 
 ### Process IDs (PIDs)
@@ -310,7 +310,7 @@ The default is 5 seconds, but for a semi-active app you may want to use a smalle
 
 ### Priorities and Queue Lists
 
-Resque doesn't support numeric priorities but instead uses the order
+ResqueAdmin doesn't support numeric priorities but instead uses the order
 of queues you give it. We call this list of queues the "queue list."
 
 Let's say we add a `warm_cache` queue in addition to our `file_serve`
@@ -364,25 +364,25 @@ so using the `resque:workers` rake task:
 
     $ COUNT=5 QUEUE=* rake resque:workers
 
-This will spawn five Resque workers, each in its own process. Hitting
+This will spawn five ResqueAdmin workers, each in its own process. Hitting
 ctrl-c should be sufficient to stop them all.
 
 
 ### Forking
 
-On certain platforms, when a Resque worker reserves a job it
+On certain platforms, when a ResqueAdmin worker reserves a job it
 immediately forks a child process. The child processes the job then
 exits. When the child has exited successfully, the worker reserves
 another job and repeats the process.
 
 Why?
 
-Because Resque assumes chaos.
+Because ResqueAdmin assumes chaos.
 
-Resque assumes your background workers will lock up, run too long, or
+ResqueAdmin assumes your background workers will lock up, run too long, or
 have unwanted memory growth.
 
-If Resque workers processed jobs themselves, it'd be hard to whip them
+If ResqueAdmin workers processed jobs themselves, it'd be hard to whip them
 into shape. Let's say one is using too much memory: you send it a
 signal that says "shutdown after you finish processing the current
 job," and it does so. It then starts up again - loading your entire
@@ -392,11 +392,11 @@ delay in queue processing.
 Plus, what if it's using too much memory and has stopped responding to
 signals?
 
-Thanks to Resque's parent / child architecture, jobs that use too much memory
+Thanks to ResqueAdmin's parent / child architecture, jobs that use too much memory
 release that memory upon completion. No unwanted growth.
 
 And what if a job is running too long? You'd need to `kill -9` it then
-start the worker again. With Resque's parent / child architecture you
+start the worker again. With ResqueAdmin's parent / child architecture you
 can tell the parent to forcefully kill the child then immediately
 start processing more jobs. No startup delay or wasted cycles.
 
@@ -433,7 +433,7 @@ waiting for work on:
 
 ### Signals
 
-Resque workers respond to a few different signals:
+ResqueAdmin workers respond to a few different signals:
 
 * `QUIT` - Wait for child to finish processing then exit
 * `TERM` / `INT` - Immediately kill child then exit
@@ -441,11 +441,11 @@ Resque workers respond to a few different signals:
 * `USR2` - Don't start to process any new jobs
 * `CONT` - Start to process new jobs again after a USR2
 
-If you want to gracefully shutdown a Resque worker, use `QUIT`.
+If you want to gracefully shutdown a ResqueAdmin worker, use `QUIT`.
 
 If you want to kill a stale or stuck child, use `USR1`. Processing
 will continue as normal unless the child was not found. In that case
-Resque assumes the parent process is in a bad state and shuts down.
+ResqueAdmin assumes the parent process is in a bad state and shuts down.
 
 If you want to kill a stale or stuck child and shutdown, use `TERM`
 
@@ -457,11 +457,11 @@ then `CONT` to start it again.
 
 When shutting down processes, Heroku sends every process a TERM signal at the
 same time. By default this causes an immediate shutdown of any running job
-leading to frequent `Resque::TermException` errors.  For short running jobs, a simple
+leading to frequent `ResqueAdmin::TermException` errors.  For short running jobs, a simple
 solution is to give a small amount of time for the job to finish
 before killing it.
 
-Resque doesn't handle this out of the box (for both cedar-14 and heroku-16), you need to
+ResqueAdmin doesn't handle this out of the box (for both cedar-14 and heroku-16), you need to
 install the [`resque-heroku-signals`](https://github.com/iloveitaly/resque-heroku-signals) 
 addon which adds the required signal handling to make the behavior described above work.
 Related issue: https://github.com/resque/resque/issues/1559
@@ -471,9 +471,9 @@ To accomplish this set the following environment variables:
 * `RESQUE_PRE_SHUTDOWN_TIMEOUT` - The time between the parent receiving a shutdown signal (TERM by default) and it sending that signal on to the child process. Designed to give the child process
 time to complete before being forced to die.
 
-* `TERM_CHILD` - Must be set for `RESQUE_PRE_SHUTDOWN_TIMEOUT` to be used. After the timeout, if the child is still running it will raise a `Resque::TermException` and exit.
+* `TERM_CHILD` - Must be set for `RESQUE_PRE_SHUTDOWN_TIMEOUT` to be used. After the timeout, if the child is still running it will raise a `ResqueAdmin::TermException` and exit.
 
-* `RESQUE_TERM_TIMEOUT` - By default you have a few seconds to handle `Resque::TermException` in your job. `RESQUE_TERM_TIMEOUT` and `RESQUE_PRE_SHUTDOWN_TIMEOUT` must be lower than the [heroku dyno timeout](https://devcenter.heroku.com/articles/limits#exit-timeout).
+* `RESQUE_TERM_TIMEOUT` - By default you have a few seconds to handle `ResqueAdmin::TermException` in your job. `RESQUE_TERM_TIMEOUT` and `RESQUE_PRE_SHUTDOWN_TIMEOUT` must be lower than the [heroku dyno timeout](https://devcenter.heroku.com/articles/limits#exit-timeout).
 
 ### Mysql::Error: MySQL server has gone away
 
@@ -529,14 +529,14 @@ end
 The Front End
 -------------
 
-Resque comes with a Sinatra-based front end for seeing what's up with
+ResqueAdmin comes with a Sinatra-based front end for seeing what's up with
 your queue.
 
 ![The Front End](https://camo.githubusercontent.com/64d150a243987ffbc33f588bd6d7722a0bb8d69a/687474703a2f2f7475746f7269616c732e6a756d7073746172746c61622e636f6d2f696d616765732f7265737175655f6f766572766965772e706e67)
 
 ### Standalone
 
-If you've installed Resque as a gem running the front end standalone is easy:
+If you've installed ResqueAdmin as a gem running the front end standalone is easy:
 
     $ resque-web
 
@@ -544,7 +544,7 @@ It's a thin layer around `rackup` so it's configurable as well:
 
     $ resque-web -p 8282
 
-If you have a Resque config file you want evaluated just pass it to
+If you have a ResqueAdmin config file you want evaluated just pass it to
 the script as the final argument:
 
     $ resque-web -p 8282 rails_root/config/initializers/resque.rb
@@ -559,7 +559,7 @@ or set the Redis connection string if you need to do something like select a dif
 
 ### Passenger
 
-Using Passenger? Resque ships with a `config.ru` you can use. See
+Using Passenger? ResqueAdmin ships with a `config.ru` you can use. See
 Phusion's guide:
 
 Apache: <https://www.phusionpassenger.com/library/deploy/apache/deploy/ruby/>
@@ -567,7 +567,7 @@ Nginx: <https://www.phusionpassenger.com/library/deploy/nginx/deploy/ruby/>
 
 ### Rack::URLMap
 
-If you want to load Resque on a subpath, possibly alongside other
+If you want to load ResqueAdmin on a subpath, possibly alongside other
 apps, it's easy to do with Rack's `URLMap`:
 
 ``` ruby
@@ -575,7 +575,7 @@ require 'resque_admin/server'
 
 run Rack::URLMap.new \
   "/"       => Your::App.new,
-  "/resque" => Resque::Server.new
+  "/resque" => ResqueAdmin::Server.new
 ```
 
 Check `examples/demo/config.ru` for a functional example (including
@@ -583,28 +583,28 @@ HTTP basic auth).
 
 ### Rails 3
 
-You can also mount Resque on a subpath in your existing Rails 3 app by adding `require 'resque_admin/server'` to the top of your routes file or in an initializer then adding this to `routes.rb`:
+You can also mount ResqueAdmin on a subpath in your existing Rails 3 app by adding `require 'resque_admin/server'` to the top of your routes file or in an initializer then adding this to `routes.rb`:
 
 ``` ruby
-mount Resque::Server.new, :at => "/resque"
+mount ResqueAdmin::Server.new, :at => "/resque"
 ```
 
 
-Resque vs DelayedJob
+ResqueAdmin vs DelayedJob
 --------------------
 
-How does Resque compare to DelayedJob, and why would you choose one
+How does ResqueAdmin compare to DelayedJob, and why would you choose one
 over the other?
 
-* Resque supports multiple queues
+* ResqueAdmin supports multiple queues
 * DelayedJob supports finer grained priorities
-* Resque workers are resilient to memory leaks / bloat
+* ResqueAdmin workers are resilient to memory leaks / bloat
 * DelayedJob workers are extremely simple and easy to modify
-* Resque requires Redis
+* ResqueAdmin requires Redis
 * DelayedJob requires ActiveRecord
-* Resque can only place JSONable Ruby objects on a queue as arguments
+* ResqueAdmin can only place JSONable Ruby objects on a queue as arguments
 * DelayedJob can place _any_ Ruby object on its queue as arguments
-* Resque includes a Sinatra app for monitoring what's going on
+* ResqueAdmin includes a Sinatra app for monitoring what's going on
 * DelayedJob can be queried from within your Rails app if you want to
   add an interface
 
@@ -612,7 +612,7 @@ If you're doing Rails development, you already have a database and
 ActiveRecord. DelayedJob is super easy to setup and works great.
 GitHub used it for many months to process almost 200 million jobs.
 
-Choose Resque if:
+Choose ResqueAdmin if:
 
 * You need multiple queues
 * You don't care / dislike numeric priorities
@@ -632,17 +632,17 @@ Choose DelayedJob if:
 * You want to easily throw anything on the queue
 * You don't want to setup Redis
 
-In no way is Resque a "better" DelayedJob, so make sure you pick the
+In no way is ResqueAdmin a "better" DelayedJob, so make sure you pick the
 tool that's best for your app.
 
-Resque Dependencies
+ResqueAdmin Dependencies
 -------------------
 
     $ gem install bundler
     $ bundle install
 
 
-Installing Resque
+Installing ResqueAdmin
 -----------------
 
 ### In a Rack app, as a gem
@@ -661,7 +661,7 @@ Now start your application:
 
     rackup config.ru
 
-That's it! You can now create Resque jobs from within your app.
+That's it! You can now create ResqueAdmin jobs from within your app.
 
 To start a worker, create a Rakefile in your app's root (or add this
 to an existing Rakefile):
@@ -701,7 +701,7 @@ Now start your application:
 
     $ ./script/server
 
-That's it! You can now create Resque jobs from within your app.
+That's it! You can now create ResqueAdmin jobs from within your app.
 
 To start a worker, add this to your Rakefile in `RAILS_ROOT`:
 
@@ -721,7 +721,7 @@ Don't forget you can define a `resque:setup` hook in
 
     $ ./script/plugin install git://github.com/resque/resque
 
-That's it! Resque will automatically be available when your Rails app
+That's it! ResqueAdmin will automatically be available when your Rails app
 loads.
 
 To start a worker:
@@ -749,7 +749,7 @@ Now start your application:
 
     $ rails server
 
-That's it! You can now create Resque jobs from within your app.
+That's it! You can now create ResqueAdmin jobs from within your app.
 
 To start a worker, add this to a file in `lib/tasks` (ex:
 `lib/tasks/resque.rake`):
@@ -769,16 +769,16 @@ Don't forget you can define a `resque:setup` hook in
 Configuration
 -------------
 
-You may want to change the Redis host and port Resque connects to, or
+You may want to change the Redis host and port ResqueAdmin connects to, or
 set various other options at startup.
 
-Resque has a `redis` setter which can be given a string or a Redis
-object. This means if you're already using Redis in your app, Resque
+ResqueAdmin has a `redis` setter which can be given a string or a Redis
+object. This means if you're already using Redis in your app, ResqueAdmin
 can re-use the existing connection.
 
-String: `Resque.redis = 'localhost:6379'`
+String: `ResqueAdmin.redis = 'localhost:6379'`
 
-Redis: `Resque.redis = $redis`
+Redis: `ResqueAdmin.redis = $redis`
 
 For our rails app we have a `config/initializers/resque.rb` file where
 we load `config/resque.yml` by hand and set the Redis information
@@ -799,7 +799,7 @@ rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
 rails_env = ENV['RAILS_ENV'] || 'development'
 
 resque_config = YAML.load_file(rails_root + '/config/resque.yml')
-Resque.redis = resque_config[rails_env]
+ResqueAdmin.redis = resque_config[rails_env]
 ```
 
 Easy peasy! Why not just use `RAILS_ROOT` and `RAILS_ENV`? Because
@@ -813,7 +813,7 @@ Also, you could disable jobs queueing by setting 'inline' attribute.
 For example, if you want to run all jobs in the same process for cucumber, try:
 
 ``` ruby
-Resque.inline = ENV['RAILS_ENV'] == "cucumber"
+ResqueAdmin.inline = ENV['RAILS_ENV'] == "cucumber"
 ```
 
 
@@ -823,26 +823,26 @@ Plugins and Hooks
 For a list of available plugins see
 <http://wiki.github.com/resque/resque/plugins>.
 
-If you'd like to write your own plugin, or want to customize Resque
-using hooks (such as `Resque.after_fork`), see
+If you'd like to write your own plugin, or want to customize ResqueAdmin
+using hooks (such as `ResqueAdmin.after_fork`), see
 [docs/HOOKS.md](http://github.com/resque/resque/blob/master/docs/HOOKS.md).
 
 
 Namespaces
 ----------
 
-If you're running multiple, separate instances of Resque you may want
+If you're running multiple, separate instances of ResqueAdmin you may want
 to namespace the keyspaces so they do not overlap. This is not unlike
 the approach taken by many memcached clients.
 
 This feature is provided by the [redis-namespace][rs] library, which
-Resque uses by default to separate the keys it manages from other keys
+ResqueAdmin uses by default to separate the keys it manages from other keys
 in your Redis server.
 
-Simply use the `Resque.redis.namespace` accessor:
+Simply use the `ResqueAdmin.redis.namespace` accessor:
 
 ``` ruby
-Resque.redis.namespace = "resque:GitHub"
+ResqueAdmin.redis.namespace = "resque:GitHub"
 ```
 
 We recommend sticking this in your initializer somewhere after Redis
@@ -852,7 +852,7 @@ is configured.
 Demo
 ----
 
-Resque ships with a demo Sinatra app for creating jobs that are later
+ResqueAdmin ships with a demo Sinatra app for creating jobs that are later
 processed in the background.
 
 Try it out by looking at the README, found at `examples/demo/README.markdown`.
@@ -863,7 +863,7 @@ Monitoring
 
 ### god
 
-If you're using god to monitor Resque, we have provided example
+If you're using god to monitor ResqueAdmin, we have provided example
 configs in `examples/god/`. One is for starting / stopping workers,
 the other is for killing workers that have been running too long.
 
@@ -883,7 +883,7 @@ Please add them to the [FAQ](https://github.com/resque/resque/wiki/FAQ) or open
 Development
 -----------
 
-Want to hack on Resque?
+Want to hack on ResqueAdmin?
 
 First clone the repo and run the tests:
 
@@ -917,7 +917,7 @@ Read [CONTRIBUTING.md](CONTRIBUTING.md) first.
 
 Once you've made your great commits:
 
-1. [Fork][1] Resque
+1. [Fork][1] ResqueAdmin
 2. Create a topic branch - `git checkout -b my_branch`
 3. Push to your branch - `git push origin my_branch`
 4. Create a [Pull Request](http://help.github.com/pull-requests/) from your branch

data/bin/resque

@@ -17,11 +17,11 @@ parser = OptionParser.new do |opts|
   opts.separator "Options:"
 
   opts.on("-r", "--redis [HOST:PORT]", "Redis connection string") do |host|
-    Resque.redis = host
+    ResqueAdmin.redis = host
   end
 
   opts.on("-N", "--namespace [NAMESPACE]", "Redis namespace") do |namespace|
-    Resque.redis.namespace = namespace
+    ResqueAdmin.redis.namespace = namespace
   end
 
   opts.on("-h", "--help", "Show this message") do
@@ -53,13 +53,13 @@ end
 def remove(worker)
   abort "** resque remove WORKER_ID" if worker.nil?
 
-  Resque.remove_worker(worker)
+  ResqueAdmin.remove_worker(worker)
   puts "** removed #{worker}"
 end
 
 def list
-  if Resque.workers.any?
-    Resque.workers.each do |worker|
+  if ResqueAdmin.workers.any?
+    ResqueAdmin.workers.each do |worker|
       puts "#{worker} (#{worker.state})"
     end
   else

data/bin/resque-web

@@ -10,7 +10,7 @@ end
 require 'resque_admin/server'
 
 
-Vegas::Runner.new(Resque::Server, 'resque-web', {
+Vegas::Runner.new(ResqueAdmin::Server, 'resque-web', {
   :before_run => lambda {|v|
     path = (ENV['RESQUECONFIG'] || v.args.first)
     load path.to_s.strip if path
@@ -18,14 +18,14 @@ Vegas::Runner.new(Resque::Server, 'resque-web', {
 }) do |runner, opts, app|
   opts.on('-N NAMESPACE', "--namespace NAMESPACE", "set the Redis namespace") {|namespace|
     runner.logger.info "Using Redis namespace '#{namespace}'"
-    Resque.redis.namespace = namespace
+    ResqueAdmin.redis.namespace = namespace
   }
   opts.on('-r redis-connection', "--redis redis-connection", "set the Redis connection string") {|redis_conf|
     runner.logger.info "Using Redis connection '#{redis_conf}'"
-    Resque.redis = redis_conf
+    ResqueAdmin.redis = redis_conf
   }
   opts.on('-a url-prefix', "--append url-prefix", "set reverse_proxy friendly prefix to links") {|url_prefix|
     runner.logger.info "Using URL Prefix '#{url_prefix}'"
-    Resque::Server.url_prefix = url_prefix
+    ResqueAdmin::Server.url_prefix = url_prefix
   }
 end

data/lib/resque_admin/data_store.rb

@@ -1,5 +1,5 @@
-module Resque
-  # An interface between Resque's persistence and the actual
+module ResqueAdmin
+  # An interface between ResqueAdmin's persistence and the actual
   # implementation.
   class DataStore
     extend Forwardable
@@ -53,7 +53,7 @@ module Resque
                                      :increment_stat,
                                      :stat
 
-    # Compatibility with any non-Resque classes that were using Resque.redis as a way to access Redis
+    # Compatibility with any non-ResqueAdmin classes that were using ResqueAdmin.redis as a way to access Redis
     def method_missing(sym,*args,&block)
       # TODO: deprecation warning?
       @redis.send(sym,*args,&block)
@@ -82,7 +82,7 @@ module Resque
       @redis.client.reconnect
     end
 
-    # Returns an array of all known Resque keys in Redis. Redis' KEYS operation
+    # Returns an array of all known ResqueAdmin keys in Redis. Redis' KEYS operation
     # is O(N) for the keyspace, so be careful - this can be slow for big databases.
     def all_resque_keys
       @redis.keys("*").map do |key|

data/lib/resque_admin/errors.rb

@@ -1,4 +1,4 @@
-module Resque
+module ResqueAdmin
   # Raised whenever we need a queue but none is provided.
   class NoQueueError < RuntimeError; end
 

data/lib/resque_admin/failure/airbrake.rb

@@ -4,19 +4,19 @@ rescue LoadError
   raise "Can't find 'airbrake' gem. Please add it to your Gemfile or install it."
 end
 
-module Resque
+module ResqueAdmin
   module Failure
     class Airbrake < Base
       def self.configure(&block)
-        Resque.logger.warn "This actually sets global Airbrake configuration, " \
+        ResqueAdmin.logger.warn "This actually sets global Airbrake configuration, " \
           "which is probably not what you want."
-        Resque::Failure.backend = self
+        ResqueAdmin::Failure.backend = self
         ::Airbrake.configure(&block)
       end
 
       def self.count(queue = nil, class_name = nil)
         # We can't get the total # of errors from Airbrake so we fake it
-        # by asking Resque how many errors it has seen.
+        # by asking ResqueAdmin how many errors it has seen.
         Stat[:failed]
       end