beanstalker 0.4.17 → 0.5.0

data/VERSION

@@ -1 +1 @@
-0.4.17
+0.5.0

data/beanstalker.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{beanstalker}
-  s.version = "0.4.17"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gleb Pomykalov"]
-  s.date = %q{2011-02-09}
+  s.date = %q{2011-03-04}
   s.description = %q{Beanstalker is a tool for executing long tasks in background in our rails application.}
   s.email = %q{glebpom@gmail.com}
   s.extra_rdoc_files = [
@@ -30,7 +30,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = %q{http://github.com/glebpom/beanstalker}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.0}
+  s.rubygems_version = %q{1.5.2}
   s.summary = %q{Beanstalker provides deep integration with Beanstalk. Fork from http://github.com/kristjan/async_observer}
 
   if s.respond_to? :specification_version then

data/lib/beanstalker/mapper.rb

@@ -1,23 +1,52 @@
 module Beanstalker
   class Mapper
+    class Error < StandardError; end
+    class WithBlockNotPresent < Error; end
+    class NotAcceptable < Error; end
+    class KindUnknown < NotAcceptable; end
+    class TaskUnknown < NotAcceptable; end
+
     def initialize(*args)
       @mapping = {}
+      @current_kind = nil
       args.each do |filename|
         include_from_file(filename)
       end
     end
 
     def include_from_file(filename)
-      puts "Loading #{filename}"
       instance_eval(File.read(filename), filename)
     end
 
     def on(name, &block)
-      @mapping[name.to_sym] = block
+      $logger.info "We are processing #{@current_kind}/#{name} now"
+      if @current_kind.nil?
+        raise WithBlockNotPresent, "Wrap #on calls with #with block to setup :kind of task in beanstalker_mapper.rb"
+      end
+      @mapping[@current_kind] ||= {}
+      @mapping[@current_kind][name.to_sym] = block
+    end
+
+    def with(kind, &block)
+      @current_kind = kind.to_sym
+      block.call
+      @current_kind = nil
     end
 
-    def method_for(name)
-      @mapping[name.to_sym]
+    def can_handle_kind?(kind)
+      @mapping && !! @mapping[kind.to_sym]
+    end
+
+    def method_for(kind, name)
+      kind_mapping = @mapping[kind.to_sym]
+      if kind_mapping.nil?
+        raise KindUnknown, "No handler for kind = #{kind.to_sym.inspect}"
+      end
+      task_mapping = kind_mapping[name.to_sym]
+      if task_mapping.nil?
+        raise TaskUnknown, "No handler for task = #{name.to_sym.inspect}"
+      end
+      task_mapping
     end
   end
 end

data/lib/beanstalker/queue.rb

@@ -72,20 +72,22 @@ class << Beanstalker::Queue
 
     if interpolator
       code = packed = interpolator
-    else 
+    else
       code = gen(obj, sel, args)
       packed = pkg(code, worker_opts, obj, sel)
     end
-    
+
     RAILS_DEFAULT_LOGGER.info("put #{pri} #{code} to #{tube} with ttr #{ttr}")
     put!(packed, pri, delay, ttr, tube)
   end
 
   def pkg(code, opts, obj, sel)
-    opts.merge(:type => :rails, 
-               :code => code, 
-               :class => obj.is_a?(Class) ? obj.name : obj.class.to_s, 
-               :method => sel.to_s)
+    opts.merge(:kind => 'rails_beanstalker',
+               :data => {
+                 :code => code,
+                 :class => obj.is_a?(Class) ? obj.name : obj.class.to_s,
+                 :method => sel.to_s
+               })
   end
 
   # Be careful not to pass in a selector that's not valid ruby source.

data/lib/beanstalker/worker.rb

@@ -147,11 +147,18 @@ class Beanstalker::Worker
 
   def dispatch(job)
     ActiveRecord::Base.verify_active_connections!
+    $logger.info "Got job: #{job.ybody.inspect}"
     if rails_job?(job)
       run_ao_job(job)
     elsif mapped_job?(job)
       run_mapped_job(job)
+    else
+      $logger.error "Job #{job.inspect} cannot be processed... deleteing"
+      job.delete
     end
+  rescue Exception => e
+    $logger.error "Exception: #{e.inspect}... Bury job"
+    job.bury
   end
 
   def safe_dispatch(job)
@@ -182,24 +189,26 @@ class Beanstalker::Worker
 
   def handle_error(job, ex)
     custom_error_handler_ok = false
-    Daemonizer.logger.warn "Handling exception: #{ex.inspect}, job = #{job.id}"
-
-    if job[:class]
-      klass = Object.const_get(job[:class])
-      error_handler = class_error_handler(klass)
-      if error_handler.is_a?(Proc)
-        Daemonizer.logger.info "Running custom error handler for class #{job[:class]}, job = #{job.id}"
-        error_handler.call(job, ex)
-        job_reserved = begin
-          job.stats['state'] == 'reserved'
-        rescue Beanstalk::NotFoundError
-          false
-        end
-        if job_reserved
-          Daemonizer.logger.info "Custom error handler for class #{job[:class]} didn't release job. job = #{job.id}"
-        else
-          Daemonizer.logger.info "Custom error handler for class #{job[:class]} released job. job = #{job.id}"
-          custom_error_handler_ok = true
+    Daemonizer.logger.warn "Handling exception: #{ex.backtrace.join('\n')}, job = #{job.id}"
+
+    if rails_job?(job)
+      if job[:class]
+        klass = Object.const_get(job[:class])
+        error_handler = class_error_handler(klass)
+        if error_handler.is_a?(Proc)
+          Daemonizer.logger.info "Running custom error handler for class #{job[:class]}, job = #{job.id}"
+          error_handler.call(job, ex)
+          job_reserved = begin
+            job.stats['state'] == 'reserved'
+          rescue Beanstalk::NotFoundError
+            false
+          end
+          if job_reserved
+            Daemonizer.logger.info "Custom error handler for class #{job[:class]} didn't release job. job = #{job.id}"
+          else
+            Daemonizer.logger.info "Custom error handler for class #{job[:class]} released job. job = #{job.id}"
+            custom_error_handler_ok = true
+          end
         end
       end
     end
@@ -252,27 +261,36 @@ class Beanstalker::Worker
   end
 
   def run_mapped_job(job)
-    run_with_ruby_timeout_if_set(job[:name], job) do
+    job_body = job.ybody.stringify_keys
+    job_kind = job_body['kind']
+    job_data = job_body['data'].stringify_keys
+    job_method = job_data['method']
+
+    job_desc = "#{job_kind}/#{job_method}"
+
+    run_with_ruby_timeout_if_set(job_desc, job) do
       t1 = Time.now
-      if @map_job = map_job(job[:name])
-        @map_job.call(job[:params] || {})
-        logger.info "Finished. Job id=#{job.stats['id']}. Mapped from '#{job[:name]}'. Time taken: #{(Time.now - t1).to_f} sec"
+      @map_job = @mapper && @mapper.method_for(job_kind, job_method)
+      if @map_job
+        @map_job.call(job_data['body'] || {})
+        logger.info "Finished. Job id=#{job.stats['id']}. Mapped from '#{job_desc}'. Time taken: #{(Time.now - t1).to_f} sec"
       else
-        logger.error "Job id=#{job.stats['id']}. Mapping not found: '#{job[:name]}'. Releases #{job.stats['releases']}. Deleting"
+        logger.error "Job id=#{job.stats['id']}. Mapping not found: '#{job_desc}'. Releases #{job.stats['releases']}. Deleting"
       end
       job.delete
     end
   end
 
   def run_ao_job(job)
-    run_with_ruby_timeout_if_set(job[:code], job) do
+    job_data = job.ybody.stringify_keys['data']
+    code = job_data.stringify_keys['code']
+    run_with_ruby_timeout_if_set(code, job) do
       t1 = Time.now
       f = self.class.before_filter
       statistics = job.stats.dup
-      code = job[:code]
       can_run = f ? f.call(job) : true
       if can_run
-        run_code(job)
+        run_code(job.id, code)
         job.delete
         logger.info "Finished. Job id=#{statistics['id']}. Code '#{code}'. Time taken: #{(Time.now - t1).to_f} sec"
       else
@@ -281,20 +299,16 @@ class Beanstalker::Worker
     end
   end
 
-  def run_code(job)
-    eval(job.ybody[:code], @top_binding, "(beanstalk job #{job.id})", 1)
+  def run_code(job_id, code)
+    eval(code, @top_binding, "(beanstalk job #{job_id})", 1)
   end
 
   def rails_job?(job)
-    begin job.ybody[:type] == :rails rescue false end
+    job.ybody.stringify_keys['kind'].to_s == 'rails_beanstalker'
   end
 
   def mapped_job?(job)
-    begin job.ybody[:type] == :mapped rescue false end
-  end
-
-  def map_job(job)
-    @mapper && @mapper.method_for(job)
+    @mapper && @mapper.can_handle_kind?(job.ybody.stringify_keys['kind'])
   end
 
   def do_all_work

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: beanstalker
 version: !ruby/object:Gem::Version 
-  hash: 45
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
-  - 17
-  version: 0.4.17
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Gleb Pomykalov
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-09 00:00:00 +03:00
+date: 2011-03-04 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -114,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Beanstalker provides deep integration with Beanstalk. Fork from http://github.com/kristjan/async_observer