creeper 0.0.2 → 0.0.3

data/creeper.gemspec

@@ -15,9 +15,12 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Creeper::VERSION
 
-  gem.add_dependency "beanstalk-client"
+  gem.add_development_dependency 'pry'
   gem.add_development_dependency 'rspec'
-  gem.add_dependency 'pry'
+  # gem.add_development_dependency 'stalker'
+
+  gem.add_dependency 'beanstalk-client'
+  gem.add_dependency 'kgio'
 
 end
 

data/lib/creeper.rb

@@ -1,161 +1,306 @@
 require 'beanstalk-client'
-require "creeper/version"
-require "creeper/worker"
+
 require 'json'
 require 'uri'
 require 'timeout'
 
-STDOUT.sync = true
+require 'fcntl'
+require 'etc'
+require 'stringio'
+require 'kgio'
+
+require 'logger'
+
+require 'creeper/version'
+require 'creeper/session'
+require 'creeper/worker'
+
+$stdout.sync = $stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
 
 module Creeper
+
+  # These hashes map Threads to Workers
+  RUNNERS = {}
+  GRAVEYARD = {}
+
+  SELF_PIPE = []
+
+  # signal queue used for self-piping
+  SIG_QUEUE = []
+
+  # list of signals we care about and trap in Creeper
+  QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :TTIN, :TTOU ]
+
+  START_CTX = {
+    :argv => ARGV.map { |arg| arg.dup },
+    0 => $0.dup,
+  }
+  START_CTX[:cwd] = begin
+    a = File.stat(pwd = ENV['PWD'])
+    b = File.stat(Dir.pwd)
+    a.ino == b.ino && a.dev == b.dev ? pwd : Dir.pwd
+  rescue
+    Dir.pwd
+  end
+
+  attr_accessor :logger, :error_logger
+  attr_accessor :jobs, :patience, :runner_count, :soft_quit, :timeout
+
   extend self
 
-  def connect(url)
-    @@url = url
-    beanstalk
+  ## utilities ##
+
+  def logger
+    @logger ||= Logger.new($stdout)
   end
 
-  def enqueue(job, args={}, opts={})
-    pri   = opts[:pri]   || 65536
-    delay = [0, opts[:delay].to_i].max  
-    ttr   = opts[:ttr]   || 120
-    beanstalk.use job
-    beanstalk.put [ job, args ].to_json, pri, delay, ttr
-  rescue Beanstalk::NotConnected => e
-    failed_connection(e)
+  def log_exception(prefix, exc, logger = error_logger)
+    message = exc.message
+    message = message.dump if /[[:cntrl:]]/ =~ message
+    logger.error "#{prefix}: #{message} (#{exc.class})"
+    exc.backtrace.each { |line| logger.error(line) }
   end
 
-  def job(j, &block)
-    @@handlers ||= {}
-    @@handlers[j] = block
+  def error_logger
+    @error_logger ||= Logger.new($stderr)
   end
 
-  def before(&block)
-    @@before_handlers ||= []
-    @@before_handlers << block
+  ##
+
+  ## main process ##
+
+  ### config ###
+
+  def patience
+    @patience ||= 60
   end
 
-  def error(&blk)
-    @@error_handler = blk
+  def runner_count
+    @runner_count ||= 1
   end
 
-  def running
-    @@running ||= []
+  def runner_count=(value)
+    (@runner_count = value).tap do
+      reset_proc_name
+    end
   end
 
-  def soft_quit?
-    @@soft_quit ||= false
+  def soft_quit
+    @soft_quit ||= false
   end
+  alias :soft_quit? :soft_quit
 
   def soft_quit=(soft_quit)
-    @@soft_quit = soft_quit
+    (@soft_quit = soft_quit).tap do
+      awaken_creeper if soft_quit?
+    end
+  end
+
+  def timeout
+    @timeout ||= 30
+  end
+
+  ###
+
+  def work(jobs = nil, runner_count = 1)
+    self.jobs, self.runner_count = jobs, runner_count
+
+    default_session.beanstalk # check if we can connect to beanstalk
+
+    start.join
   end
 
-  def work(jobs=nil, thread_count=1)
-    thread_count.times do
-      w = Creeper::Worker.new()
-      t =  Thread.new do
-        w.work(jobs)
+  def start
+    init_self_pipe!
+    QUEUE_SIGS.each do |sig|
+      trap(sig) do
+        logger.debug "creeper received #{sig}" if $DEBUG
+        SIG_QUEUE << sig
+        awaken_creeper
       end
-      running << {thread: t, worker: w}
     end
 
-    while not soft_quit?
-      running.each_with_index do |runner, index|
-        if not runner[:thread].alive?
-          w = Creeper::Worker.new()
-          t =  Thread.new do
-            w.work(jobs)
-          end
-          running[index] << {thread: t, worker: w}
+    logger.info "creeper starting"
+
+    self
+  end
+
+  def join
+    respawn = true
+    last_check = Time.now
+
+    reset_proc_name
+    logger.info "creeper process ready"
+    begin
+      reap_all_runners
+      case SIG_QUEUE.shift
+      when nil
+        # break if soft_quit?
+        # avoid murdering runners after our master process (or the
+        # machine) comes out of suspend/hibernation
+        if (last_check + timeout) >= (last_check = Time.now)
+          sleep_time = timeout - 1
+        else
+          sleep_time = timeout/2.0 + 1
+          logger.debug("creeper waiting #{sleep_time}s after suspend/hibernation") if $DEBUG
         end
+        maintain_runner_count if respawn
+        logger.debug("creeper sleeping for #{sleep_time}s") if $DEBUG
+        creeper_sleep(sleep_time)
+      when :QUIT # graceful shutdown
+        break
+      when :TERM, :INT # immediate shutdown
+        stop(false)
+        break
+      when :WINCH
+        self.runner_count = 0
+        logger.debug "WINCH: setting runner_count to #{runner_count}" if $DEBUG
+      when :TTIN
+        self.runner_count += 1
+        logger.debug "TTIN: setting runner_count to #{runner_count}" if $DEBUG
+      when :TTOU
+        self.runner_count -= 1 if runner_count > 0
+        logger.debug "TTOU: setting runner_count to #{runner_count}" if $DEBUG
       end
-      sleep 1
-    end
-    running.each do |runner|
-      if runner[:worker].job_in_progress?
-        log "Murder [scheduling]"
-        runner[:worker].soft_quit = true  
-      else
-        log "Murder [now]"
-        runner[:thread].kill
-      end
+    rescue => e
+      Creeper.log_exception("creeper loop error", e)
+    end while true
+    stop # gracefully shutdown all captains on our way out
+    logger.info "creeper complete"
+  end
+
+  def stop(graceful = true)
+    limit = Time.now + patience
+    kill_all_runners
+    until (RUNNERS.empty? && GRAVEYARD.empty?) || (n = Time.now) > limit
+      reap_graveyard(graceful)
+      sleep(0.1)
     end
-    running.each do |runner|
-      runner[:thread].join
+    if n and n > limit
+      logger.debug "creeper patience exceeded by #{n - limit} seconds (limit #{patience} seconds)" if $DEBUG
     end
-    log "SEPPUKU!!"
+    reap_graveyard(false)
+    logger.debug graceful ? "creeper gracefully stopped" : "creeper hard stopped" if $DEBUG
   end
 
-  def failed_connection(e)
-    log_error exception_message(e)
-    log_error "*** Failed connection to #{beanstalk_url}"
-    log_error "*** Check that beanstalkd is running (or set a different BEANSTALK_URL)"
-    exit 1
-  end
+  private
 
-  def log(msg)
-    puts msg
+  # wait for a signal hander to wake us up and then consume the pipe
+  def creeper_sleep(sec)
+    IO.select([ SELF_PIPE[0] ], nil, nil, sec) or return
+    SELF_PIPE[0].kgio_tryread(11)
   end
 
-  def log_error(msg)
-    STDERR.puts msg
+  def awaken_creeper
+    SELF_PIPE[1].kgio_trywrite('.') # wakeup creeper process from select
   end
 
-  def beanstalk
-    @@beanstalk ||= Beanstalk::Pool.new(beanstalk_addresses)
+  def init_self_pipe!
+    SELF_PIPE.each { |io| io.close rescue nil }
+    SELF_PIPE.replace(Kgio::Pipe.new)
+    SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
   end
 
-  def beanstalk_url
-    return @@url if defined?(@@url) and @@url
-    ENV['BEANSTALK_URL'] || 'beanstalk://localhost/'
+  def kill_all_runners
+    RUNNERS.each do |thread, worker|
+      GRAVEYARD[thread] = RUNNERS.delete(thread)
+    end
   end
 
-  class BadURL < RuntimeError; end
+  def maintain_runner_count
+    current_runner_count = RUNNERS.size - runner_count
 
-  def beanstalk_addresses
-    uris = beanstalk_url.split(/[\s,]+/)
-    uris.map {|uri| beanstalk_host_and_port(uri)}
+    spawn_missing_runners if current_runner_count < 0
+    murder_extra_runners  if current_runner_count > 0
+    reap_all_runners
+    reap_graveyard
   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 murder_extra_runners
+    until RUNNERS.size == runner_count
+      thread, worker = RUNNERS.shift
+      if worker.working?
+        logger.debug "creeper [murder] => soft quit" if $DEBUG
+        worker.soft_quit = true
+        GRAVEYARD[thread] = worker
+      else
+        logger.debug "creeper [murder] => hard quit" if $DEBUG
+        worker.session.disconnect
+        thread.kill
+        thread.join
+      end
+    end
   end
 
-  def exception_message(e)
-    msg = [ "Exception #{e.class} -> #{e.message}" ]
+  def reap_all_runners
+    RUNNERS.each do |thread, worker|
+      GRAVEYARD[thread] = worker if not thread.alive?
+    end
+  end
 
-    base = File.expand_path(Dir.pwd) + '/'
-    e.backtrace.each do |t|
-      msg << "   #{File.expand_path(t).gsub(/#{base}/, '')}"
+  def reap_graveyard(graceful = true)
+    GRAVEYARD.each do |thread, worker|
+      if graceful and worker.working?
+        logger.debug "creeper [graveyard] => soft quit" if $DEBUG
+        worker.soft_quit = true
+      else
+        logger.debug "creeper [graveyard] => hard quit" if $DEBUG
+        thread.kill rescue nil
+        thread.join
+        GRAVEYARD.delete(thread)
+      end
     end
+  end
 
-    msg.join("\n")
+  def spawn_missing_runners
+    until RUNNERS.size == runner_count
+      worker = Creeper::Worker.new(jobs: jobs)
+      thread = worker.start
+      RUNNERS[thread] = worker
+    end
   end
 
-  def all_jobs
-    @@handlers.keys
+  def reset_proc_name
+    proc_name "creeper(#{$$}) [#{runner_count}]"
   end
 
-  def job_handlers
-    @@handlers ||= {}
+  def proc_name(tag)
+    $0 = ([
+      File.basename(Creeper::START_CTX[0]),
+      tag
+    ]).concat(Creeper::START_CTX[:argv]).join(' ')
   end
 
-  def before_handlers
-    @@before_handlers ||= []
+  ##
+
+  public
+
+  def clear!
+    @default_session.disconnect if @default_session
+    @default_session = nil
   end
 
-  def error_handler
-    @@error_handler ||= nil
+  def default_session
+    @default_session ||= Creeper::Session.new
   end
 
-  def clear!
-    @@soft_quit = false
-    @@running = []
-    @@handlers = nil
-    @@before_handlers = nil
-    @@error_handler = nil
+  def enqueue(job, args = {}, opts = {})
+    default_session.enqueue(job, args, opts)
+  end
+
+  def job(name, &block)
+    default_session.job(name, &block)
+  end
+
+  def before(&block)
+    default_session.before(&block)
   end
+
+  def error(&block)
+    default_session.error(&block)
+  end
+
 end

data/lib/creeper/session.rb

@@ -0,0 +1,142 @@
+module Creeper
+  class Session
+
+    attr_accessor :beanstalk, :beanstalk_url
+    attr_accessor :before_handlers, :error_handler, :handlers
+
+    def initialize(parent_session = nil)
+      if parent_session
+        @beanstalk_url   = parent_session.beanstalk_url
+        @before_handlers = parent_session.before_handlers
+        @error_handler   = parent_session.error_handler
+        @handlers        = parent_session.handlers
+      end
+
+      @before_handlers ||= []
+      @handlers        ||= {}
+    end
+
+    def clear!
+      handlers.clear
+      before_handlers.clear
+      self.error_handler = nil
+    end
+
+    ## class methods ##
+
+    def self.beanstalk_addresses(beanstalk_url)
+      uris = beanstalk_url.split(/[\s,]+/)
+      uris.map do |uri|
+        beanstalk_host_and_port(uri)
+      end
+    end
+
+    def self.beanstalk_host_and_port(uri_string)
+      uri = URI.parse(uri_string)
+      raise(BadURL, uri_string) if uri.scheme != 'beanstalk'
+      "#{uri.host}:#{uri.port || 11300}"
+    end
+
+    def self.beanstalk_url
+      ENV['BEANSTALK_URL'] || 'beanstalk://localhost/'
+    end
+
+    ##
+
+    ## beanstalk ##
+
+    class BadURL < RuntimeError; end
+
+    def connect
+      Beanstalk::Pool.new(beanstalk_addresses)
+    end
+
+    def disconnect
+      beanstalk.close.tap do
+        @beanstalk = nil
+      end
+    end
+
+    def reconnect
+      disconnect rescue nil
+      beanstalk
+    end
+
+    def beanstalk
+      @beanstalk ||= connect
+    end
+
+    def beanstalk_url
+      @beanstalk_url ||= singleton_class.beanstalk_url
+    end
+
+    def beanstalk_addresses
+      singleton_class.beanstalk_addresses(beanstalk_url)
+    end
+
+    ##
+
+    ## handlers ##
+
+    def job(name, &block)
+      handlers[name] = block
+    end
+
+    def before(&block)
+      before_handlers << block
+    end
+
+    def error(&block)
+      self.error_handler = block
+    end
+
+    def all_jobs
+      handlers.keys
+    end
+
+    ##
+
+    ## queue ##
+
+    def enqueue(job, args = {}, opts = {})
+      pri   = opts[:pri]   || 65536
+      delay = [0, opts[:delay].to_i].max  
+      ttr   = opts[:ttr]   || 120
+      beanstalk.use job
+      beanstalk.put [ job, args ].to_json, pri, delay, ttr
+    rescue Beanstalk::NotConnected => e
+      failed_connection(e)
+    end
+
+    ##
+
+    protected
+
+    def failed_connection(e)
+      log_error exception_message(e)
+      log_error "*** Failed connection to #{beanstalk_url}"
+      log_error "*** Check that beanstalkd is running (or set a different BEANSTALK_URL)"
+    end
+    
+
+    def log(msg)
+      Creeper.logger.info(msg)
+    end
+
+    def log_error(msg)
+      Creeper.error_logger.error(msg)
+    end
+
+    def exception_message(e)
+      msg = [ "Exception #{e.class} -> #{e.message}" ]
+
+      base = File.expand_path(Dir.pwd) + '/'
+      e.backtrace.each do |t|
+        msg << "   #{File.expand_path(t).gsub(/#{base}/, '')}"
+      end
+
+      msg.join("\n")
+    end
+
+  end
+end

data/lib/creeper/version.rb

@@ -1,3 +1,3 @@
 module Creeper
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/creeper/worker.rb

@@ -1,168 +1,173 @@
-require 'beanstalk-client'
-require 'json'
-require 'uri'
-require 'timeout'
-
-class Creeper::Worker
-  def initialize
-    @handlers = Creeper.job_handlers
-    @before_handlers = Creeper.before_handlers
-    @error_handler = Creeper.error_handler
-  end
+module Creeper
+  class Worker
 
-  class NoJobsDefined < RuntimeError; end
-  class NoSuchJob < RuntimeError; end
-  class JobTimeout < RuntimeError; end
-  class BadURL < RuntimeError; end
+    ## utilities ##
 
-  def soft_quit?
-    @soft_quit ||= false
-  end
+    class NoJobsDefined < RuntimeError; end
+    class NoSuchJob < RuntimeError; end
+    class JobTimeout < RuntimeError; end
+    class BadURL < RuntimeError; end
 
-  def soft_quit=(soft_quit)
-    # exit if !job_in_progress? && soft_quit
-    @soft_quit = soft_quit
-  end
+    def logger
+      Creeper.logger
+    end
 
-  def job_in_progress?
-    @in_progress ||= false
-  end
+    def log_exception(*args)
+      Creeper.log_exception(*args)
+    end
 
-  def prep(jobs=nil)
-    raise NoJobsDefined unless defined?(@handlers)
-    @error_handler = nil unless defined?(@error_handler)
+    def error_logger
+      Creeper.error_logger
+    end
 
-    jobs ||= all_jobs
+    def log(msg)
+      logger.info(msg)
+    end
 
-    jobs.each do |job|
-      raise(NoSuchJob, job) unless @handlers[job]
+    def log_error(msg)
+      error_logger.error(msg)
     end
 
-    log "Working #{jobs.size} jobs: [ #{jobs.join(' ')} ]"
+    ##
 
-    jobs.each { |job| beanstalk.watch(job) }
+    attr_reader   :options, :session, :thread
+    attr_accessor :soft_quit, :working
 
-    beanstalk.list_tubes_watched.each do |server, tubes|
-      tubes.each { |tube| beanstalk.ignore(tube) unless jobs.include?(tube) }
+    def initialize(options = {})#jobs = nil, parent_session = , session = nil)
+      @options = options
     end
-  rescue Beanstalk::NotConnected => e
-    failed_connection(e)
-  end
 
-  def work(jobs=nil)
-    prep(jobs)
-    loop { work_one_job }
-  end
+    ### config ###
 
-  def work_one_job
-    Thread.current.kill if soft_quit?
-    job = beanstalk.reserve
-    name, args = JSON.parse job.body
-    log_job_begin(name, args)
-    handler = @handlers[name]
-    raise(NoSuchJob, name) unless handler
-
-    begin
-      if defined? @before_handlers and @before_handlers.respond_to? :each
-        @before_handlers.each do |block|
-          block.call(name)
-        end
-      end
-      handler.call(args)
-    end
-
-    job.delete
-    log_job_end(name)
-  rescue Beanstalk::NotConnected => e
-    failed_connection(e)
-  rescue SystemExit
-    raise
-  rescue => e
-    log_error exception_message(e)
-    job.bury rescue nil
-    log_job_end(name, 'failed') if @job_begun
-    if error_handler
-      if error_handler.arity == 1
-        error_handler.call(e)
-      else
-        error_handler.call(e, name, args)
-      end
+    def session
+      @session ||= Creeper::Session.new(options[:parent_session] || Creeper.default_session)
     end
-  end
 
-  def failed_connection(e)
-    log_error exception_message(e)
-    log_error "*** Failed connection to #{beanstalk_url}"
-    log_error "*** Check that beanstalkd is running (or set a different BEANSTALK_URL)"
-    exit 1
-  end
+    def soft_quit
+      @soft_quit ||= false
+    end
+    alias :soft_quit? :soft_quit
 
-  def log_job_begin(name, args)
-    @in_progress = true
-    args_flat = unless args.empty?
-      '(' + args.inject([]) do |accum, (key,value)|
-        accum << "#{key}=#{value}"
-      end.join(' ') + ')'
-    else
-      ''
+    def working
+      @working ||= false
     end
+    alias :working? :working
 
-    log [ "Working", name, args_flat ].join(' ')
-    @job_begun = Time.now
-  end
+    ###
 
-  def log_job_end(name, failed=false)
-    @in_progress = false
-    ellapsed = Time.now - @job_begun
-    ms = (ellapsed.to_f * 1000).to_i
-    log "Finished #{name} in #{ms}ms #{failed ? ' (failed)' : ''}"
-  end
+    def beanstalk
+      session.beanstalk
+    end
 
-  def log(msg)
-    puts msg
-  end
+    def clear!
+      @soft_quit = false
+      @working = false
+      @session = nil
+    end
 
-  def log_error(msg)
-    STDERR.puts msg
-  end
+    def prepare
+      raise NoJobsDefined if session.handlers.empty?
 
-  def beanstalk
-    @beanstalk ||= Beanstalk::Pool.new(beanstalk_addresses)
-  end
+      jobs = options[:jobs] || session.all_jobs
 
-  def beanstalk_url
-    Creeper.beanstalk_url
-  end
+      jobs.each do |job|
+        raise(NoSuchJob, job) unless session.handlers.has_key?(job)
+      end
 
-  def beanstalk_addresses
-    uris = beanstalk_url.split(/[\s,]+/)
-    uris.map {|uri| beanstalk_host_and_port(uri)}
-  end
+      logger.info "Working #{jobs.size} jobs: [ #{jobs.join(' ')} ]"
 
-  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}"
-  end
+      jobs.each { |job| beanstalk.watch(job) }
 
-  def exception_message(e)
-    msg = [ "Exception #{e.class} -> #{e.message}" ]
+      beanstalk.list_tubes_watched.each do |server, tubes|
+        tubes.each { |tube| beanstalk.ignore(tube) unless jobs.include?(tube) }
+      end
+    rescue Beanstalk::NotConnected => e
+      failed_connection(e)
+    end
 
-    base = File.expand_path(Dir.pwd) + '/'
-    e.backtrace.each do |t|
-      msg << "   #{File.expand_path(t).gsub(/#{base}/, '')}"
+    def work
+      prepare
+      loop { work_one_job }
     end
 
-    msg.join("\n")
-  end
+    def work_one_job
+      stop if soft_quit?
 
-  def all_jobs
-    @handlers.keys
-  end
+      job = beanstalk.reserve
+      name, args = JSON.parse job.body
+      log_job_begin(name, args)
+      handler = session.handlers[name]
+      raise(NoSuchJob, name) unless handler
 
-  def error_handler
-    @error_handler
-  end
+      begin
+        session.before_handlers.each do |block|
+          block.call(name)
+        end
+        handler.call(args)
+      end
 
-end
+      job.delete
+      log_job_end(name)
+    rescue Beanstalk::NotConnected => e
+      failed_connection(e)
+    rescue SystemExit
+      puts "FART"
+      raise
+    rescue => e
+      log_error exception_message(e)
+      job.bury rescue nil
+      log_job_end(name, 'failed') if @job_begun
+      if session.error_handler
+        if session.error_handler.arity == 1
+          session.error_handler.call(e)
+        else
+          session.error_handler.call(e, name, args)
+        end
+      end
+    end
 
+    def start
+      @thread = Thread.new do
+        work
+      end
+    end
+
+    def stop
+      logger.info "worker dying: #{Thread.current.inspect}"
+      session.disconnect
+      @thread.kill
+    end
+
+    protected
+
+    def failed_connection(e)
+      session.send(:failed_connection, e)
+    end
+
+    def exception_message(e)
+      session.send(:exception_message, e)
+    end
+
+    def log_job_begin(name, args)
+      @working = true
+      args_flat = unless args.empty?
+        '(' + args.inject([]) do |accum, (key,value)|
+          accum << "#{key}=#{value}"
+        end.join(' ') + ')'
+      else
+        ''
+      end
+
+      log [ "Working", name, args_flat ].join(' ')
+      @job_begun = Time.now
+    end
+
+    def log_job_end(name, failed=false)
+      @working = false
+      ellapsed = Time.now - @job_begun
+      ms = (ellapsed.to_f * 1000).to_i
+      log "Finished #{name} in #{ms}ms #{failed ? ' (failed)' : ''}"
+    end
+
+  end
+end

data/spec/lib/creeper/session_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Creeper::Session do
+
+  it "parses BEANSTALK_URL" do
+    ENV['BEANSTALK_URL'] = "beanstalk://localhost:12300"
+    Creeper::Session.new.beanstalk_addresses.should == ["localhost:12300"]
+    ENV['BEANSTALK_URL'] = "beanstalk://localhost:12300/, beanstalk://localhost:12301/"
+    Creeper::Session.new.beanstalk_addresses.should == ["localhost:12300","localhost:12301"]
+    ENV['BEANSTALK_URL'] = "beanstalk://localhost:12300   beanstalk://localhost:12301"
+    Creeper::Session.new.beanstalk_addresses.should == ["localhost:12300","localhost:12301"]
+    ENV['BEANSTALK_URL'] = nil
+  end
+  
+end

data/spec/lib/creeper/worker_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Creeper::Worker do
+
+  context 'a worker' do
+
+    subject { Creeper::Worker.new }
+
+    after(:each) do
+      subject.clear!
+      Creeper.clear!
+    end
+
+    it 'should have a session different from the Creeper.default_session' do
+      subject.session.should_not == Creeper.default_session
+      subject.session.beanstalk.should_not == Creeper.default_session.beanstalk
+    end
+
+  end
+  
+end

data/spec/{creeper_spec.rb → lib/creeper_spec.rb}

@@ -13,7 +13,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     val.should == $result
   end
@@ -25,7 +25,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     $handled.should_not == nil
     'my.job'.should == $job_name
@@ -40,7 +40,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     exception.should == $handled
   end
@@ -52,7 +52,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     false.should == $handled
   end
@@ -64,7 +64,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     $handled.should == "didn't time out"
   end
@@ -76,7 +76,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     true.should == $handled
   end
@@ -88,7 +88,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     'my.job'.should == $jobname
   end
@@ -100,7 +100,7 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     true.should == $handled
   end
@@ -113,21 +113,12 @@ describe Creeper do
     w = Creeper::Worker.new
     w.stub(:exception_message)
     w.stub(:log)
-    w.prep
+    w.prepare
     w.work_one_job
     $handled.should_not == nil
     'my.job'.should ==  $job_name
     {'foo' => 123}.should == $job_args
   end
-  
-  it "parse BEANSTALK_URL" do
-    ENV['BEANSTALK_URL'] = "beanstalk://localhost:12300"
-    Creeper.beanstalk_addresses.should == ["localhost:12300"]
-    ENV['BEANSTALK_URL'] = "beanstalk://localhost:12300/, beanstalk://localhost:12301/"
-    Creeper.beanstalk_addresses.should == ["localhost:12300","localhost:12301"]
-    ENV['BEANSTALK_URL'] = "beanstalk://localhost:12300   beanstalk://localhost:12301"
-    Creeper.beanstalk_addresses.should == ["localhost:12300","localhost:12301"]
-  end
 
   def with_an_error_handler
     Creeper.error do |e, job_name, args|
@@ -136,6 +127,5 @@ describe Creeper do
       $job_args = args
     end
   end
-
   
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ $:.push File.expand_path("../lib", __FILE__)
 require 'creeper'
 require 'pry'
 
+Creeper.logger = Creeper.error_logger = Logger.new(nil)
 
 RSpec.configure do |config|
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: creeper
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,17 +9,17 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-09 00:00:00.000000000 Z
+date: 2012-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: beanstalk-client
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
@@ -44,7 +44,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: beanstalk-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kgio
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -74,11 +90,13 @@ files:
 - Rakefile
 - creeper.gemspec
 - lib/creeper.rb
+- lib/creeper/session.rb
 - lib/creeper/version.rb
 - lib/creeper/worker.rb
-- spec/creeper_spec.rb
+- spec/lib/creeper/session_spec.rb
+- spec/lib/creeper/worker_spec.rb
+- spec/lib/creeper_spec.rb
 - spec/spec_helper.rb
-- spec/worker_spec.rb
 homepage: https://github.com/lyondhill/creeper
 licenses: []
 post_install_message: 
@@ -105,7 +123,8 @@ specification_version: 3
 summary: A better solution for io bound jobs, same as stalker in functionality but
   more threadie.
 test_files:
-- spec/creeper_spec.rb
+- spec/lib/creeper/session_spec.rb
+- spec/lib/creeper/worker_spec.rb
+- spec/lib/creeper_spec.rb
 - spec/spec_helper.rb
-- spec/worker_spec.rb
 has_rdoc: 

data/spec/worker_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Creeper::Worker do
-  # before :each do
-  #   @base = Monitor::Base.new  
-  # end
-
-  # after :each do
-  #   @base = nil
-  # end
-  
-  it "shoud not create a vz object" do
-    2.should == 2
-  end
-  
-end