creeper 0.0.5 → 1.0.0

data/lib/creeper/celluloid_ext.rb

@@ -0,0 +1,42 @@
+module Celluloid
+  class Actor
+
+    def handle_crash(exception)
+      prefix = (@subject.respond_to?(:prefix) rescue nil) ? ("#{@subject.prefix} " rescue nil) : nil
+      Logger.crash("#{prefix}#{@subject.class} crashed!", exception)
+      shutdown ExitEvent.new(@proxy, exception)
+    rescue => ex
+      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
+    end
+
+  end
+end
+
+module Celluloid
+  class PoolManager
+
+    # ensure that the provisioned worker is alive to prevent PoolManager from dying
+    def execute(method, *args, &block)
+      worker = provision_worker
+      
+      begin
+        worker._send_ method, *args, &block
+      rescue Celluloid::DeadActorError, Celluloid::MailboxError
+        execute(method, *args, &block)
+      ensure
+        @idle << worker if worker && worker.alive?
+      end
+    end
+
+    def crash_handler(actor, reason)
+      return unless reason # don't restart workers that exit cleanly
+      index = @idle.rindex(actor) # replace the old actor if possible
+      if index
+        @idle[index] = @worker_class.new_link(*@args)
+      else
+        @idle << @worker_class.new_link(*@args)
+      end
+    end
+
+  end
+end

data/lib/creeper/creep.rb

@@ -1,30 +1,24 @@
 module Creeper
   module Creep
 
-    def clear!
-      Creeper.default_session.disconnect if Creeper.instance_variable_defined?(:@default_session) and Creeper.instance_variable_get(:@default_session)
-      Creeper.instance_variable_set(:@default_session, nil)
+    def enqueue(job, data = {}, options = {})
+      Creeper.enqueue(job, data, options)
     end
 
-    def default_session
-      return Creeper.instance_variable_get(:@default_session) if Creeper.instance_variable_defined?(:@default_session)
-      Creeper.instance_variable_set(:@default_session, Creeper::Session.new)
-    end
-
-    def enqueue(job, args = {}, opts = {})
-      default_session.enqueue(job, args, opts)
+    def job(name, &block)
+      Creeper.job(name, &block)
     end
 
-    def job(name, &block)
-      default_session.job(name, &block)
+    def before(name = nil, &block)
+      Creeper.before(name, &block)
     end
 
-    def before(&block)
-      default_session.before(&block)
+    def after(name = nil, &block)
+      Creeper.after(name, &block)
     end
 
-    def error(&block)
-      default_session.error(&block)
+    def error(name = nil, &block)
+      Creeper.error(name, &block)
     end
 
   end

data/lib/creeper/logger.rb

@@ -0,0 +1,37 @@
+module Creeper
+  module Logger
+    module_function
+
+    # Send a debug message
+    def debug(string)
+      Creeper.logger.debug(string) if Creeper.logger
+    end
+
+    # Send a info message
+    def info(string)
+      Creeper.logger.info(string) if Creeper.logger
+    end
+
+    # Send a warning message
+    def warn(string)
+      Creeper.logger.warn(string) if Creeper.logger
+    end
+
+    # Send an error message
+    def error(string)
+      Creeper.logger.error(string) if Creeper.logger
+    end
+
+    # Handle a crash
+    def crash(string, exception)
+      string << "\n" << format_exception(exception)
+      error string
+    end
+
+    # Format an exception message
+    def format_exception(exception)
+      str = "#{exception.class}: #{exception.to_s}\n"
+      str << exception.backtrace.join("\n")
+    end
+  end
+end

data/lib/creeper/version.rb

@@ -1,3 +1,3 @@
 module Creeper
-  VERSION = "0.0.5"
+  VERSION = "1.0.0"
 end

data/lib/creeper/worker.rb

@@ -1,173 +1,331 @@
+require 'creeper'
+
+require 'celluloid'
+require 'creeper/celluloid_ext'
+# require 'em-jack'
+
+Creeper.logger = Celluloid.logger
+
 module Creeper
+
+  at_exit { shutdown_workers }
+
   class Worker
 
-    ## utilities ##
+    def self.work(jobs = nil, size = 2)
 
-    class NoJobsDefined < RuntimeError; end
-    class NoSuchJob < RuntimeError; end
-    class JobTimeout < RuntimeError; end
-    class BadURL < RuntimeError; end
+      options = {
+        size: size,
+        args: [jobs, size]
+      }
 
-    def logger
-      Creeper.logger
-    end
+      Creeper.worker_pool = Creeper::Worker.pool(options)
 
-    def log_exception(*args)
-      Creeper.log_exception(*args)
+      begin
+        trap(:INT)  { Creeper.shutdown = true }
+        trap(:TERM) { Creeper.shutdown = true }
+        trap(:QUIT) { Creeper.shutdown = true }
+        Creeper.worker_pool.start
+      end until Creeper.shutdown?
+
+      exit
     end
 
-    def error_logger
-      Creeper.error_logger
+    # def self.em_work(jobs = nil, size = 2)
+
+    #   options = {
+    #     size: size,
+    #     args: [jobs]
+    #   }
+
+    #   tubes = jobs_for(jobs)
+
+    #   Creeper.worker_pool = Creeper::Worker.pool(options)
+
+    #   sleep 1
+
+    #   EM.run do
+    #     trap(:INT)  { Creeper.shutdown = true; EM.stop }
+    #     trap(:TERM) { Creeper.shutdown = true; EM.stop }
+    #     trap(:QUIT) { Creeper.shutdown = true; EM.stop }
+
+    #     jack = EMJack::Connection.new(Creeper.beanstalk_url)
+
+    #     reserve_loop = ->(timeout) do
+    #       r = jack.reserve(timeout)
+    #       r.callback do |job|
+    #         Creeper.worker_pool.work! job
+    #         EM.next_tick { reserve_loop.call(timeout) }
+    #       end
+    #       r.errback do
+    #         EM.next_tick { reserve_loop.call(timeout) }
+    #       end
+    #     end
+
+    #     watch_tubes = ->(list) do
+    #       if list.empty?
+    #         reserve_loop.call(Creeper.reserve_timeout)
+    #       else
+    #         w = jack.watch(list.shift)
+    #         w.callback do
+    #           watch_tubes.call(list)
+    #         end
+    #       end
+    #     end
+
+    #     watch_tubes.call(tubes)
+
+    #   end
+
+    # end
+
+    def self.jobs_for(jobs = nil)
+      case jobs
+      when :all, nil
+        Creeper.all_jobs
+      else
+        Array(jobs)
+      end
     end
 
-    def log(msg)
-      logger.info(msg)
+    include Celluloid
+
+    attr_accessor :number
+    attr_reader :jobs, :pool_size
+
+    def initialize(jobs = nil, pool_size = 2)
+      @jobs      = self.class.jobs_for(jobs)
+      @pool_size = pool_size
+
+      Creeper.register_worker(self)
+      Logger.info "#{prefix} Working #{self.jobs.size} jobs: [ #{self.jobs.join(' ')} ]"
     end
 
-    def log_error(msg)
-      error_logger.error(msg)
+    def dump(job, name = nil, data = nil)
+      "#{name.inspect rescue nil} { data: #{(data.inspect rescue nil)}, job: #{(job.inspect rescue nil)} }"
     end
 
-    ##
+    def prefix
+      "[#{number_format % number} - #{'%x' % Thread.current.object_id}]"
+    end
 
-    attr_reader   :options, :session, :thread
-    attr_accessor :soft_quit, :working
+    def number_format
+      "%#{pool_size.to_s.length}d"
+    end
 
-    def initialize(options = {})#jobs = nil, parent_session = , session = nil)
-      @options = options
+    def time_in_milliseconds
+      ((stopped_at - started_at).to_f * 1000).to_i
     end
 
-    ### config ###
+    def started_at
+      Thread.current[:creeper_started_at]
+    end
 
-    def session
-      @session ||= Creeper::Session.new(options[:parent_session] || Creeper.default_session)
+    def started_at=(started_at)
+      Thread.current[:creeper_started_at] = started_at
     end
 
-    def soft_quit
-      @soft_quit ||= false
+    def stopped_at
+      Thread.current[:creeper_stopped_at]
     end
-    alias :soft_quit? :soft_quit
 
-    def working
-      @working ||= false
+    def stopped_at=(stopped_at)
+      Thread.current[:creeper_stopped_at] = stopped_at
     end
-    alias :working? :working
 
-    ###
+    ## beanstalk ##
 
     def beanstalk
-      session.beanstalk
+      Creeper.beanstalk
     end
 
-    def clear!
-      @soft_quit = false
-      @working = false
-      @session = nil
+    def ignore(tube)
+      beanstalk.ignore(tube)
+    rescue Beanstalk::NotConnected => e
+      disconnected(self, :ignore, tube) || raise
     end
 
-    def prepare
-      raise NoJobsDefined if session.handlers.empty?
+    def list_tubes_watched(cached = false)
+      beanstalk.list_tubes_watched
+    rescue Beanstalk::NotConnected => e
+      disconnected(self, :list_tubes_watched, cached) || raise
+    end
 
-      jobs   = session.all_jobs if options[:jobs] == :all
-      jobs ||= options[:jobs] ? [*options[:jobs]] : session.all_jobs
-      jobs   = session.all_jobs if jobs.empty?
+    def reserve(timeout = nil)
+      beanstalk.reserve(timeout)
+    rescue Beanstalk::NotConnected => e
+      disconnected(self, :reserve, timeout) || raise
+    end
 
-      jobs.each do |job|
-        raise(NoSuchJob, job) unless session.handlers.has_key?(job)
+    def watch(tube)
+      beanstalk.watch(tube)
+    rescue Beanstalk::NotConnected => e
+      disconnected(self, :watch, tube) || raise
+    end
+
+    ##
+
+    ## work ##
+
+    def start(short_circuit = false)
+      return false if short_circuit
+      exit         if stopped?
+      return true  if working?
+      prepare      if not prepared?
+
+      begin
+        job = reserve Creeper.reserve_timeout
+      rescue Beanstalk::TimedOut
+        Logger.debug "#{prefix} Back to the unemployment line" if $DEBUG
+        return false
       end
 
-      logger.info "Working #{jobs.size} jobs: [ #{jobs.join(' ')} ]"
+      exit if stopped?
 
-      jobs.each { |job| beanstalk.watch(job) }
+      Thread.current[:creeper_working] = true
 
-      beanstalk.list_tubes_watched.each do |server, tubes|
-        tubes.each { |tube| beanstalk.ignore(tube) unless jobs.include?(tube) }
+      Logger.debug "#{prefix} Got #{job.inspect}" if $DEBUG
+
+      work! job # asynchronously go to work
+    rescue SystemExit => e
+      job.release rescue nil
+      Creeper.unregister_worker(self)
+    rescue => e
+      job.release rescue nil
+      Creeper.unregister_worker(self, "start loop error")
+      raise
+    end
+
+    def finalize
+      Creeper.finalizers.each do |finalizer|
+        begin
+          case finalizer.arity
+          when 1
+            finalizer.call(self)
+          else
+            finalizer.call
+          end
+        rescue => e
+          Logger.crash "#{prefix} finalizer error", e
+        end
       end
-    rescue Beanstalk::NotConnected => e
-      log_exception("worker[#{@thread.inspect}] failed beanstalk connection", e)
+
+    ensure
+      Creeper.disconnect
     end
 
-    def work
-      prepare
-      loop { work_one_job }
+    def stop
+      Thread.current[:creeper_stopped] = true
     end
 
-    def work_one_job
-      stop if soft_quit?
+    def work(job)
+
+      exit if stopped?
 
-      job = beanstalk.reserve
-      name, args = JSON.parse job.body
-      log_job_begin(name, args)
-      handler = session.handlers[name]
-      raise(NoSuchJob, name) unless handler
+      name, data = JSON.parse(job.body)
+
+      Creeper.start_work(self, data, name, job)
 
       begin
-        session.before_handlers.each do |block|
-          block.call(name)
+        Creeper.before_handlers_for(name).each do |handler|
+          process(handler, data, name, job)
+        end
+
+        Creeper.handler_for(name).tap do |handler|
+          process(handler, data, name, job)
+        end
+
+        Creeper.after_handlers_for(name).each do |handler|
+          process(handler, data, name, job)
         end
-        handler.call(args)
       end
 
       job.delete
-      log_job_end(name, args)
+
+      Creeper.stop_work(self, data, name, job)
+
+      # start! unless stopped? or EM.reactor_running?
+      start! unless stopped? # continue processing, even when end of links is reached
+
     rescue Beanstalk::NotConnected => e
-      log_exception("worker[#{@thread.inspect}] failed beanstalk connection", e)
+      disconnected(self, :work, job) || begin
+        job.release rescue nil
+        Creeper.unregister_worker(self)
+        raise
+      end
     rescue SystemExit => e
-      log_exception("worker[#{@thread.inspect}] exit", e)
-      raise
+      job.release rescue nil
+      Creeper.unregister_worker(self)
     rescue => e
-      log_exception("worker[#{@thread.inspect}] loop error", e)
+
       job.bury rescue nil
-      args ||= []
-      log_job_end(name, args, '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)
+
+      Creeper.error_work(self, data, name, job)
+
+      begin
+        Creeper.error_handlers_for(name).each do |handler|
+          process(handler, data, name, job)
         end
       end
+
+      Creeper.unregister_worker(self, "work loop error, burying #{dump(job, name, data)}")
+
+      raise
+    ensure
+      Thread.current[:creeper_started_at] = nil
+      Thread.current[:creeper_stopped_at] = nil
+      Thread.current[:creeper_working] = false
     end
 
-    def start
-      @thread = Thread.new do
-        work
+    def process(handler, data, name, job)
+      case handler.arity
+      when 3
+        handler.call(data, name, job)
+      when 2
+        handler.call(data, name)
+      when 1
+        handler.call(data)
+      else
+        handler.call
       end
     end
 
-    def stop
-      logger.info "worker dying: (current=#{Thread.current.inspect}#{@thread.inspect}"
-      session.disconnect
-      sleep 1
-      @thread.kill
-    end
+    ##
 
-    protected
+    ## flags ##
 
-    def log_job_begin(name, args)
-      @working = true
-      args_flat = flatten_args(args)
+    def prepared?
+      Thread.current[:creeper_prepared] == true
+    end
 
-      log [ "Working", name, args_flat ].join(' ')
-      @job_begun = Time.now
+    def stopped?
+      Thread.current[:creeper_stopped] == true || Creeper.shutdown?
     end
 
-    def log_job_end(name, args, failed=false)
-      @working = false
-      ellapsed = Time.now - @job_begun
-      ms = (ellapsed.to_f * 1000).to_i
-      args_flat = flatten_args(args)
-      log [ "Finished #{name} in #{ms}ms #{failed ? ' (failed)' : ''}", args_flat ].join(' ')
+    def working?
+      Thread.current[:creeper_working] == true
     end
 
-    def flatten_args(args)
-      unless args.empty?
-        '(' + args.inject([]) do |accum, (key,value)|
-          accum << "#{key}=#{value}"
-        end.join(' ') + ')'
-      else
-        ''
+    ##
+
+    protected
+
+    def disconnected(target, method, *args, &block)
+      Creeper.send(:disconnected, target, method, *args, &block)
+    end
+
+    def prepare
+      jobs.each do |job|
+        watch(job)
       end
+
+      list_tubes_watched.each do |server, tubes|
+        tubes.each do |tube|
+          ignore(tube) unless jobs.include?(tube)
+        end
+      end
+
+      Thread.current[:creeper_prepared] = true
     end
 
   end