creeper 1.0.9 → 2.0.0

data/.gitignore

@@ -2,6 +2,7 @@
 *.rbc
 .bundle
 .config
+.DS_Store
 .yardoc
 Gemfile.lock
 InstalledFiles

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p194@creeper"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.15.0 (master)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -3,4 +3,20 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in creeper.gemspec
 gemspec
 
-gem 'celluloid', git: 'git://github.com/celluloid/celluloid.git'
+gem 'rails', '3.2.8'
+
+gem 'slim'
+gem 'sprockets'
+gem 'sass'
+
+group :test do
+  ## guard ##
+  gem 'coolline'
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-spork'
+
+  gem 'growl',             require: !!(RUBY_PLATFORM =~ /darwin/i) ? 'growl'     : false
+  gem 'libnotify',         require: !!(RUBY_PLATFORM =~ /linux/i)  ? 'libnotify' : false
+  gem 'terminal-notifier', require: !!(RUBY_PLATFORM =~ /darwin/i) ? 'growl'     : false
+end

data/Guardfile

@@ -0,0 +1,32 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'spork', cucumber: false, test_unit: false, rspec: true, bundler: false, wait: 15, rspec_env: { 'RAILS_ENV' => 'test' } do
+  watch('Gemfile')
+  watch('Gemfile.lock')
+  watch('spec/spec_helper.rb') { :rspec }
+  watch('test/test_helper.rb') { :test_unit }
+  watch(%r{features/support/}) { :cucumber }
+  watch(%r{^spec/support/(.+)\.rb$}) { :rspec }
+end
+
+guard 'rspec', version: 2, bundler: false, all_after_pass: !ENV['ALL'].nil?, all_on_start: !ENV['ALL'].nil?, cli: '--drb --colour --format nested' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+  
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end

data/Rakefile

@@ -1,2 +1,10 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+task default: :spec

data/bin/creeper

@@ -1,62 +1,14 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib') unless $LOAD_PATH.include?(File.dirname(__FILE__) + '/../lib')
-
-require 'creeper/launcher'
-require 'optparse'
-
-options = { runner_count: 1 }
-
-op = OptionParser.new("", 24, '  ') do |opts|
-  cmd = File.basename($0)
-  opts.banner = "Usage: #{cmd} [ruby options] [#{cmd} options]"
-
-  opts.separator "Ruby options:"
-
-  opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") do
-    $DEBUG = true
-  end
-
-  opts.separator "#{cmd} options:"
-
-  opts.on("-D", "--daemonize", "run daemonized in the background") do |d|
-    options[:daemonize] = !!d
-  end
-
-  opts.on("-j", "--job-file FILE", "Creeper-specific job file") do |f|
-    options[:job_file] = f
-  end
-
-  opts.on("-r", "--runner-count NUMBER", "Threads to run (default: #{options[:runner_count]})") do |r|
-    options[:runner_count] = (r.to_i rescue 1)
-  end
-
-  opts.separator "Common options:"
-
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts.to_s.gsub(/^.*DEPRECATED.*$/s, '')
-    exit
-  end
-
-  opts.on_tail("-v", "--version", "Show version") do
-    puts "#{cmd} v#{Creeper::VERSION}"
-    exit
-  end
-
-  opts.parse! ARGV
-
-end
-
-unless options[:job_file]
-  $stderr.puts "ERROR: job file required", ''
-  puts op.to_s.gsub(/^.*DEPRECATED.*$/s, '')
+require_relative '../lib/creeper/cli'
+
+begin
+  cli = Creeper::CLI.instance
+  cli.parse
+  cli.run
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
   exit 1
 end
-
-if $DEBUG
-  require 'pp'
-  pp(options)
-end
-
-Creeper::Launcher.launch!(options) if options[:daemonize]
-Creeper.new(options).start.join

data/bin/creeperctl

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+class Creeperctl
+
+  attr_reader :stage, :pidfile, :timeout
+
+  def initialize(stage, pidfile, timeout)
+    @stage = stage
+    @pidfile = pidfile
+    @timeout = timeout
+
+    done 'No pidfile given' if !pidfile
+    done "Pidfile #{pidfile} does not exist" if !File.exist?(pidfile)
+    done 'Invalid pidfile content' if pid == 0
+
+    fetch_process
+
+    begin
+      send(stage)
+    rescue NoMethodError
+      done 'Invalid control command'
+    end
+  end
+
+  def fetch_process
+    Process.getpgid(pid)
+  rescue Errno::ESRCH
+    done "Process doesn't exist"
+  end
+
+  def done(msg)
+    puts msg
+    exit(0)
+  end
+
+  def pid
+    File.read(pidfile).to_i
+  end
+
+  def quiet
+    `kill -USR1 #{pid}`
+  end
+
+  def stop
+    `kill -TERM #{pid}`
+    timeout.times do
+      begin
+        Process.getpgid(pid)
+      rescue Errno::ESRCH
+        FileUtils.rm_f pidfile
+        done 'Creeper shut down gracefully.'
+      end
+      sleep 1
+    end
+    `kill -9 #{pid}`
+    FileUtils.rm_f pidfile
+    done 'Creeper shut down forcefully.'
+  end
+
+  def shutdown
+    quiet
+    stop
+  end
+
+end
+
+stage = ARGV[0]
+pidfile = ARGV[1]
+timeout = ARGV[2].to_i
+timeout = 10 if timeout == 0
+
+Creeperctl.new(stage, pidfile, timeout)

data/config.ru

@@ -0,0 +1,18 @@
+require 'creeper'
+
+Creeper.configure_client do |config|
+  config.redis = { :size => 1 }
+end
+
+#Creeper.redis {|conn| conn.flushdb }
+#10.times do |idx|
+  #Creeper::Client.push('class' => 'HardWorker', 'args' => ['foo', 0.1, idx])
+#end
+
+#Creeper.redis { |conn| conn.zadd('retry', Time.now.utc.to_f + 3000, MultiJson.encode({
+  #'class' => 'HardWorker', 'args' => ['foo', 0.1, Time.now.to_f],
+  #'queue' => 'default', 'error_message' => 'No such method', 'error_class' => 'NoMethodError',
+  #'failed_at' => Time.now.utc, 'retry_count' => 0 })) }
+
+require 'creeper/web'
+run Creeper::Web

data/creeper.gemspec

@@ -1,25 +1,35 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/creeper/version', __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'creeper/version'
 
 Gem::Specification.new do |gem|
+  gem.name          = "creeper"
+  gem.version       = Creeper::VERSION
   gem.authors       = ["Lyon Hill", "Andrew Bennett"]
   gem.email         = ["lyondhill@gmail.com", "potatosaladx@gmail.com"]
   gem.description   = %q{Creeper is an evented version of Stalker}
   gem.summary       = %q{A better solution for io bound jobs, same as stalker in functionality but more evented}
   gem.homepage      = "https://github.com/potatosalad/creeper"
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) } + ['creeperctl']
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "creeper"
   gem.require_paths = ["lib"]
-  gem.version       = Creeper::VERSION
+
+  gem.add_dependency 'redis', '~> 3'
+  gem.add_dependency 'redis-namespace'
+  gem.add_dependency 'beanstalk-client'
+  gem.add_dependency 'connection_pool', '~> 0.9.2'
+  gem.add_dependency 'celluloid',  '~> 0.11.1'
+  gem.add_dependency 'kgio'
+  gem.add_dependency 'multi_json', '~> 1'
 
   gem.add_development_dependency 'pry'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
-
-  gem.add_dependency 'beanstalk-client'
-  gem.add_dependency 'celluloid'
-  gem.add_dependency 'kgio'
+  gem.add_development_dependency 'sinatra'
+  gem.add_development_dependency 'slim'
+  gem.add_development_dependency 'actionmailer', '~> 3'
+  gem.add_development_dependency 'activerecord', '~> 3'
 end

data/lib/creeper.rb

@@ -1,443 +1,138 @@
-require 'beanstalk-client'
-require 'json'
-require 'logger'
-require 'thread'
-require 'timeout'
-require 'uri'
-
 require 'creeper/version'
+require 'creeper/logging'
+require 'creeper/client'
+require 'creeper/worker'
+require 'creeper/beanstalk_connection'
+require 'creeper/redis_connection'
+require 'creeper/util'
 
-module Creeper
-
-  class BadURL < RuntimeError; end
-
-  HANDLERS = {
-    named:        {},
-    before_each:  [],
-    before_named: {},
-    after_each:   [],
-    after_named:  {},
-    error_each:   [],
-    error_named:  {},
-    finalizers:   []
-  }
-
-  WORKERS = {}
-
-  ## default configuration ##
-
-  @patience_soft   = 60
-  @patience_hard   = 30
-  @pool_size       = 2
-  @retry_count     = 3
-  @reserve_timeout = 1
-
-  @lock = Mutex.new
-
-  ##
-
-  class << self
-
-    ## configuration ##
-
-    attr_reader   :lock
-    attr_accessor :patience_soft, :patience_hard, :pool_size, :reserve_timeout, :retry_count
-
-    def beanstalk_url
-      lock.synchronize do
-        @beanstalk_url ||= ENV['BEANSTALK_URL'] || 'beanstalk://127.0.0.1/'
-      end
-    end
-
-    def beanstalk_url=(beanstalk_url)
-      lock.synchronize do
-        @beanstalk_url = beanstalk_url
-      end
-    end
-
-    def err_logger
-      lock.synchronize do
-        @err_logger ||= ::Logger.new($stderr)
-      end
-    end
-
-    def err_logger=(err_logger)
-      lock.synchronize do
-        @err_logger = err_logger
-      end
-    end
-
-    def out_logger
-      lock.synchronize do
-        @out_logger ||= ::Logger.new($stdout)
-      end
-    end
-
-    def out_logger=(out_logger)
-      lock.synchronize do
-        @out_logger = out_logger
-      end
-    end
-
-    def worker_pool
-      lock.synchronize do
-        @worker_pool
-      end
-    end
-
-    def worker_pool=(worker_pool)
-      lock.synchronize do
-        @worker_pool = worker_pool
-      end
-    end
+require 'creeper/legacy'
 
-    def shutdown?
-      lock.synchronize do
-        !!@shutdown
-      end
-    end
+require 'creeper/extensions/action_mailer'
+require 'creeper/extensions/active_record'
+require 'creeper/rails' if defined?(::Rails::Engine)
 
-    def shutdown=(shutdown)
-      lock.synchronize do
-        @shutdown = shutdown
-      end
-    end
+require 'multi_json'
 
-    ##
-
-    ## connection ##
-
-    def beanstalk
-      Thread.current[:beanstalk_pool_connection] ||= connect
-    end
-
-    def beanstalk_addresses
-      uris = beanstalk_url.split(/[\s,]+/)
-      uris.map do |uri|
-        beanstalk_host_and_port(uri)
-      end
-    end
-
-    def connect(addresses = nil)
-      Beanstalk::Pool.new(addresses || beanstalk_addresses)
-    end
-
-    def disconnect
-      Thread.current[:beanstalk_pool_connection].close rescue nil
-      Thread.current[:beanstalk_pool_connection] = nil
-    end
-
-    ##
-
-    ## daemon ##
-
-    def work(jobs = nil, size = nil)
-      require 'creeper/worker'
-
-      Creeper.pool_size = size || Creeper.pool_size
-
-      Creeper::Worker.work(jobs, Creeper.pool_size)
-    end
-
-    ##
-
-    ## handlers ##
-
-    def all_jobs
-      lock.synchronize do
-        HANDLERS[:named].keys
-      end
-    end
-
-    def job(name, &block)
-      lock.synchronize do
-        HANDLERS[:named][name] = block
-        HANDLERS[:before_named][name] ||= []
-        HANDLERS[:after_named][name]  ||= []
-        HANDLERS[:error_named][name]  ||= []
-        HANDLERS[:named][name]
-      end
-    end
-
-    def drop(name)
-      lock.synchronize do
-        HANDLERS[:named].delete(name)
-        HANDLERS[:before_named].delete(name)
-        HANDLERS[:after_named].delete(name)
-        HANDLERS[:error_named].delete(name)
-        true
-      end
-    end
-
-    def handler_for(name)
-      lock.synchronize do
-        HANDLERS[:named][name]
-      end
-    end
-
-    def before(name = nil, &block)
-      if name and name != :each
-        lock.synchronize do
-          HANDLERS[:before_named][name] << block
-        end
-      else
-        lock.synchronize do
-          HANDLERS[:before_each] << block
-        end
-      end
-    end
-
-    def before_handlers_for(name)
-      lock.synchronize do
-        HANDLERS[:before_each] + HANDLERS[:before_named][name]
-      end
-    end
-
-    def after(name = nil, &block)
-      if name and name != :each
-        lock.synchronize do
-          HANDLERS[:after_named][name] << block
-        end
-      else
-        lock.synchronize do
-          HANDLERS[:after_each] << block
-        end
-      end
-    end
-
-    def after_handlers_for(name)
-      lock.synchronize do
-        HANDLERS[:after_each] + HANDLERS[:after_named][name]
-      end
-    end
-
-    def error(name = nil, &block)
-      if name and name != :each
-        lock.synchronize do
-          HANDLERS[:error_named][name] << block
-        end
-      else
-        lock.synchronize do
-          HANDLERS[:error_each] << block
-        end
-      end
-    end
-
-    def error_handlers_for(name)
-      lock.synchronize do
-        HANDLERS[:error_each] + HANDLERS[:error_named][name]
-      end
-    end
-
-    def finalizer(&block)
-      lock.synchronize do
-        HANDLERS[:finalizers] << block
-      end
-    end
-
-    def finalizers
-      lock.synchronize do
-        HANDLERS[:finalizers]
-      end
-    end
-
-    ##
-
-    ## queue ##
-
-    def enqueue(job, data = {}, options = {})
-      # OutLogger.debug "#{Thread.current[:actor].inspect} Enqueueing #{job.inspect}, #{data.inspect}"#\n#{Celluloid::Actor.all.pretty_inspect}"
-      OutLogger.debug "[#{Thread.current[:actor] ? Thread.current[:actor].subject.number : nil}] Enqueueing #{job.inspect}, #{data.inspect}" if $DEBUG
-      enqueue!(job, data, options)
-    rescue Beanstalk::NotConnected => e
-      disconnected(self, :enqueue, job, data, options)
-    end
-
-    def enqueue!(job, data = {}, options = {})
-      priority    = options[:priority] || options[:pri] || 65536
-      delay       = [ 0, options[:delay].to_i ].max
-      time_to_run = options[:time_to_run] || options[:ttr] || 120
-
-      beanstalk.use job
-      beanstalk.put JSON.dump([ job, data ]), priority, delay, time_to_run
-    end
-
-    ##
-
-    ## workers ##
-
-    def error_work(worker, data, name, job)
-      (worker.stopped_at = Time.now).tap do |stopped_at|
-        error_message = "#{worker.prefix} Error after #{worker.time_in_milliseconds}ms #{worker.dump(job, name, data)}"
-        OutLogger.error error_message
-      end
-    end
+module Creeper
 
-    def register_worker(worker)
-      lock.synchronize do
-        number = ((0..(WORKERS.keys.max || 0)+1).to_a - WORKERS.keys).first
-        WORKERS[number] = worker.tap do
-          worker.number = number
-        end
-      end
-    end
+  extend Creeper::Legacy::ClassMethods
 
-    def shutdown_workers
-      begin
-        soft_shutdown_workers(Creeper.patience_soft)
-      rescue Timeout::Error
-        begin
-          hard_shutdown_workers(Creeper.patience_hard)
-        rescue Timeout::Error
-          kill_shutdown_workers
-        end
-      end
-    end
+  DEFAULTS = {
+    :queues => [],
+    :concurrency => 25,
+    :require => '.',
+    :environment => nil,
+    :timeout => 8,
+    :enable_rails_extensions => true,
+  }
 
-    def start_work(worker, data, name, job)
-      (worker.started_at = Time.now).tap do |started_at|
-        OutLogger.info "#{worker.prefix} Working #{worker.dump(job, name, data)}"
-      end
-    end
+  def self.options
+    @options ||= DEFAULTS.dup
+  end
 
-    def stop_work(worker, data, name, job)
-      (worker.stopped_at = Time.now).tap do |stopped_at|
-        OutLogger.info "#{worker.prefix} Finished in #{worker.time_in_milliseconds}ms #{worker.dump(job, name, data)}"
-      end
-    end
+  def self.options=(opts)
+    @options = opts
+  end
 
-    def unregister_worker(worker, reason = nil)
-      reason ||= 'Stopping'
-      OutLogger.info "#{worker.prefix} #{reason}"
-      lock.synchronize do
-        WORKERS.delete(worker.number)
-      end
-    end
+  ##
+  # Configuration for Creeper server, use like:
+  #
+  #   Creeper.configure_server do |config|
+  #     config.redis = { :namespace => 'myapp', :size => 25, :url => 'redis://myhost:8877/mydb' }
+  #     config.server_middleware do |chain|
+  #       chain.add MyServerHook
+  #     end
+  #   end
+  def self.configure_server
+    yield self if server?
+  end
 
-    ##
+  ##
+  # Configuration for Creeper client, use like:
+  #
+  #   Creeper.configure_client do |config|
+  #     config.redis = { :namespace => 'myapp', :size => 1, :url => 'redis://myhost:8877/mydb' }
+  #   end
+  def self.configure_client
+    yield self unless server?
+  end
 
-    protected
+  def self.server?
+    defined?(Creeper::CLI)
+  end
 
-    def beanstalk_host_and_port(uri_string)
-      uri = URI.parse(uri_string)
-      raise(BadURL, uri_string) if uri.scheme != 'beanstalk'
-      "#{uri.host}:#{uri.port || 11300}"
+  def self.beanstalk(&block)
+    if block_given?
+      yield beanstalk
+    else
+      @beanstalk ||= Creeper::BeanstalkConnection.create
     end
+  end
 
-    def disconnected(target, method, *args, &block)
-      Thread.current[:beanstalk_connection_retries] ||= 0
-
-      if Thread.current[:beanstalk_connection_retries] >= retry_count
-        OutLogger.error "Unable to connect to beanstalk after #{Thread.current[:beanstalk_connection_retries]} attempts"
-        Thread.current[:beanstalk_connection_retries] = 0
-        return false
-      end
-
-      disconnect
-
-      Thread.current[:beanstalk_connection_retries] += 1
-
-      sleep Thread.current[:beanstalk_connection_retries] * 2
-
-      target.send(method, *args, &block)
+  def self.beanstalk=(hash)
+    if @beanstalk
+      @beanstalk.close rescue nil
     end
-
-    def soft_shutdown_workers(timeout)
-      Timeout.timeout(timeout) do
-        actors = Celluloid::Actor.all
-        OutLogger.info "Gracefully stopping #{actors.size} actors..." if actors.size > 0
-
-        # Attempt to shut down the supervision tree, if available
-        Celluloid::Supervisor.root.terminate if Celluloid::Supervisor.root
-
-        # Actors cannot self-terminate, you must do it for them
-        starts = working_actors.map do |actor|
-          begin
-            if actor.alive?
-              actor.stop! # fire and forget for those already working
-              actor.future(:start, true) # ensures that the mailbox is cleared out
-            end
-          rescue Celluloid::DeadActorError, Celluloid::MailboxError
-          end
-        end.compact
-
-        starts.each do |start|
-          begin
-            start.value
-          rescue Celluloid::DeadActorError, Celluloid::MailboxError
-          end
-        end
-
-        OutLogger.info "Graceful stop completed cleanly"
-      end
+    if hash.is_a?(Hash)
+      @beanstalk = BeanstalkConnection.create(hash)
+    elsif hash.is_a?(Beanstalk::Pool)
+      @beanstalk = hash
+    else
+      raise ArgumentError, "beanstalk= requires a Hash or Beanstalk::Pool"
     end
+  end
 
-    def hard_shutdown_workers(timeout)
-      Timeout.timeout(timeout) do
-        actors = Celluloid::Actor.all
-        OutLogger.info "Terminating #{actors.size} actors..." if actors.size > 0
-
-        # Attempt to shut down the supervision tree, if available
-        Celluloid::Supervisor.root.terminate if Celluloid::Supervisor.root
-
-        pool_managers.each do |pool_manager|
-          begin
-            pool_manager.terminate
-          rescue Celluloid::DeadActorError, Celluloid::MailboxError
-          end
-        end
-
-        # Actors cannot self-terminate, you must do it for them
-        working_actors.each do |actor|
-          begin
-            actor.terminate
-          rescue Celluloid::DeadActorError, Celluloid::MailboxError
-          end
-        end
+  def self.redis(&block)
+    @redis ||= Creeper::RedisConnection.create
+    raise ArgumentError, "requires a block" if !block
+    @redis.with(&block)
+  end
 
-        OutLogger.info "Termination completed cleanly"
-      end
+  def self.redis=(hash)
+    if hash.is_a?(Hash)
+      @redis = RedisConnection.create(hash)
+    elsif hash.is_a?(ConnectionPool)
+      @redis = hash
+    else
+      raise ArgumentError, "redis= requires a Hash or ConnectionPool"
     end
+  end
 
-    def kill_shutdown_workers
-      actors = Celluloid::Actor.all
-      OutLogger.info "Killing #{actors.size} actors..." if actors.size > 0
+  def self.client_middleware
+    @client_chain ||= Client.default_middleware
+    yield @client_chain if block_given?
+    @client_chain
+  end
 
-      # Attempt to shut down the supervision tree, if available
-      Celluloid::Supervisor.root.kill if Celluloid::Supervisor.root
+  def self.server_middleware
+    @server_chain ||= Processor.default_middleware
+    yield @server_chain if block_given?
+    @server_chain
+  end
 
-      # Actors cannot self-terminate, you must do it for them
-      Celluloid::Actor.all.each do |actor|
-        begin
-          actor.kill
-          actor.join
-        rescue Celluloid::DeadActorError, Celluloid::MailboxError
-        end
-      end
+  def self.server?
+    defined?(Creeper::CLI)
+  end
 
-      OutLogger.info "Killing completed cleanly"
-    end
+  def self.load_json(string)
+    MultiJson.decode(string)
+  end
 
-    def pool_managers
-      Celluloid::Actor.all.tap do |actors|
-        actors.keep_if do |actor|
-          actor.is_a?(Celluloid::PoolManager) rescue false
-        end
-      end
-    end
+  def self.dump_json(object)
+    MultiJson.encode(object)
+  end
 
-    def working_actors
-      Celluloid::Actor.all.tap do |actors|
-        actors.delete_if do |actor|
-          actor.is_a?(Celluloid::PoolManager) rescue false
-        end
-      end
-    end
+  def self.logger
+    Creeper::Logging.logger
+  end
 
+  def self.logger=(log)
+    Creeper::Logging.logger = log
   end
 
-end
+  def self.poll_interval=(interval)
+    self.options[:poll_interval] = interval
+  end
 
-require 'creeper/creep'
-require 'creeper/err_logger'
-require 'creeper/out_logger'
+end