langrove-plugin-resque 0.0.9

data/README.md

@@ -0,0 +1,78 @@
+`Plugin::Resque`
+=================
+
+Intergates Resque support into LanGrove.</ br>
+
+
+`gem install langrove-plugin-resque`
+
+Implements 
+----------
+
+* `Adaptor::ResqueWorker`
+* `Handler::ResqueJob`
+* `Plugin::ResqueQue`
+
+
+Supports
+---------
+
+* `LanGrove::Adaptor`
+* `LanGrove::Behaviour::Deferrable`
+
+
+Examples
+--------
+
+### Configure to post jobs onto a queue.
+
+<pre>
+
+	...
+
+    :plugins:
+        :a_job_queue:
+        	:class: ResqueQue
+            :job: JobName
+            :queue: job_name
+
+	...
+
+    :server:
+        :behavior:
+            :deferrable:
+                :plugin: :a_job_queue
+                :at:
+                    :handler_after_receive: :defer_capsule
+                    #
+                    # will post the caspsule as payload
+                    # onto the specified resque queue 
+                    # after the Handler.receive( data )
+                    # method returns.
+                    #
+
+    ...
+
+</pre>
+
+### Configure to perform jobs on a queue.
+
+<pre>
+
+    ...
+
+    :adaptor:
+        :class: ResqueAdaptor
+        :queue: job_name
+
+    ...
+
+    :handler:
+        :class: JobName
+        #
+        # Should extend Handler::ResqueJob
+        #  
+
+    ...
+
+</pre>

data/lib/adaptor/resque_adaptor.rb

@@ -0,0 +1,95 @@
+module Resque
+  
+  class Worker
+  
+    #
+    # Alias the shutdown! as called on the INT and TERM 
+    # traps that Resque assigned, 
+    # 
+    # So that the surrounding Daemon can also receive the
+    # instruction to stop.
+    #
+    # 
+    alias_method :resque_shutdown!, :shutdown!
+    
+    def shutdown!
+      
+      #
+      # Call the original Worker shutdown!
+      # And further raise the instruction to stop.
+      #
+      
+      resque_shutdown!
+      
+      raise LanGrove::DaemonStopException.new
+      
+    end
+    
+  end
+  
+end
+
+module Adaptor
+  
+  class ResqueAdaptor < LanGrove::Adaptor::Base
+    
+    def initialize(  root, config, deamon_name )
+      
+      super
+      
+      @type = :resque_adaptor
+      
+      raise config_exception(
+
+        "#{self.class} requires :queue:"
+
+      ) if (
+
+        config.nil? or
+        
+        not config.has_key?( :queue ) or
+        not @queue = config[ :queue ] or
+        @queue == ''
+
+      )
+      
+    end
+    
+    def connector( params, &block )
+      
+      #
+      # This yields Resque::Job(s), 
+      # one at a time, 
+      # into the caller.
+      #
+ 
+      wait_for_job( @queue, &block )
+      
+    end
+    
+    private
+    
+    def wait_for_job( queue, &block )
+      
+      worker = Resque::Worker.new( queue )
+      
+      worker.work do |job_spec|
+        
+        new_job = job_spec.payload_class.new
+        
+        new_job.payload = job_spec.payload
+        
+        #
+        # Job is yielded up the assignment pipeline to
+        # get access to all the local infrastructure.
+        #
+        
+        yield new_job
+        
+      end
+
+    end
+    
+  end
+  
+end

data/lib/handler/resque_job.rb

@@ -0,0 +1,102 @@
+module Handler
+  
+  class ResqueJob < LanGrove::Handler::Base
+    
+    attr_accessor :payload
+    
+    def start_handler
+      
+      #
+      # Trigger the handler_start event
+      #
+      @root.trigger( self, :handler, :start )
+      
+      #
+      # The job payload header may define an :action
+      # to perform, 
+      # 
+      unless payload['args'][0]['action'].nil?
+        
+        unless self.respond_to?( payload['args'][0]['action'].to_sym )
+          
+          #
+          # local handler does not define that action
+          # bring the house down
+          #
+          raise LanGrove::DaemonConfigException( 
+          
+            "#{self.class}.#{payload[0]['action']}() not defined. Required by payload header: #{payload[0].inspect} "
+          
+          )
+          
+        end
+        
+        #
+        # Should the header :action return false,
+        #
+        unless self.send( payload['args'][0]['action'].to_sym )
+          
+          #
+          # Then the job will be skipped.
+          #
+          @logger.debug "#{self.class} job SKIPPED"
+          
+          return
+          
+        end
+        
+      end
+      
+      
+      #
+      # Call implementor overridable start
+      #
+      start
+      
+      do_work
+      
+      
+      #
+      # Job was sent up the same assignment pipeline as
+      # socket handler, 
+      # 
+      # It has therefore been assigned into the server's
+      # @client collection
+      # 
+      # It needs to be removed
+      #
+      I.notify( @logger, "need to disconnect from server here", [:vital] )
+      #
+      # 
+      # 
+      
+      stop
+      
+    end
+    
+
+    def stop_handler
+      
+      @root.trigger( self, :handler, :stop )
+      
+      stop
+      
+    end
+    
+    
+    def self.perform( *args )
+      
+      #
+      # Does not do the job, serves only to collect
+      # the payload and yield into the local runtime 
+      # via the ResqueAdaptor,
+      #
+      # Requeue jobs are marked as failed unless this 
+      # is present.
+      #
+      
+    end
+    
+  end
+  
+end

data/lib/langrove-plugin-resque.rb

@@ -0,0 +1,4 @@
+require 'langrove' unless defined?( LanGrove )
+require 'adaptor/resque_adaptor'
+require 'plugin/resque_que'
+require 'handler/resque_job'

data/lib/plugin/resque_que.rb

@@ -0,0 +1,130 @@
+
+#
+# brew install redis
+# - For the queue db
+#  
+# bundler installed resque 
+# (per the Gemfile)
+# 
+# resque-web 
+# - Starts a queue stats interface at http://localhost:5678/
+# 
+
+module Plugin
+  
+  class ResqueQue < LanGrove::Plugin::Deferrer
+    
+    def validate_config
+      
+      super
+      
+      config_exception(
+      
+        "#{self.class} requires :queue: defined" 
+      
+      ) if @config[:queue].nil? or @config[:queue] == '' 
+      
+      queue = @config[:queue]
+      
+      
+      #
+      # Dynamically define job class
+      #
+      # - Resque wants a class with @queue
+      #   defined
+      # - Make one to give
+      #
+      
+      @job_class = Object.const_set( @job, 
+      
+        Class.new do
+          
+          self.instance_variable_set(
+          
+            :@queue, queue
+          
+          )
+          
+       end
+        
+      )
+      
+    end
+
+    
+    def defer_key( handler )
+      
+      #
+      # Enqueue job with the handler.key
+      #
+      
+      return enqueue(
+      
+        queue_header( :get_capsule, handler ),
+        
+        handler.key
+        
+      )
+      
+    end
+    
+    def defer_capsule( handler )
+      
+      #
+      # Enqueue job with the handler.capsule
+      #
+      
+      return enqueue(
+      
+        queue_header( :load_capsule, handler ), 
+        
+        handler.capsule
+        
+      )
+      
+    end
+    
+    private
+    
+    def enqueue( header, payload )
+      
+      begin 
+        
+        Resque.enqueue( 
+      
+          @job_class,
+          
+          header,
+      
+          payload
+        
+        )
+        
+        @logger.debug(
+        
+"#{self.class}.enqueue():#{type} job:#{@job_class} parameter:#{payload.inspect}"
+
+        )
+        
+        return true
+        
+      rescue Exception => e
+          
+        error = 
+        
+"#{self.class} failed to enqueue: #{header},#{payload} as #{type}, Exception #{e}"
+
+        @logger.error( error )
+        
+        #
+        # The daemon needs to fall over.
+        #
+        raise e
+         
+      end
+      
+    end
+
+  end
+  
+end

data/spec/adaptor/resque_adaptor_spec.rb

@@ -0,0 +1,152 @@
+require 'langrove-plugin-resque'
+
+describe Adaptor::ResqueAdaptor do
+  
+  before :all do
+    
+    class FakeJob < Handler::ResqueJob
+      
+    end
+
+    ROOT = LanGrove::FakeRoot.new
+    
+  end
+  
+  
+  before :each do
+    
+    @queue_name = :queue_name
+    
+    @config = { 
+      
+      :queue => @queue_name 
+      
+    }
+    
+    @connect_spec = {
+      
+      :handler => {
+      
+        :class => Handler::ResqueJob,
+      
+        :config => {}
+        
+      }
+      
+    }
+    
+  end
+  
+  subject {
+    
+    Adaptor::ResqueAdaptor.new( 
+    
+      ROOT, @config , nil
+  
+    )
+    
+  }
+  
+  it 'raises on missing queue name' do
+    
+    expect {
+    
+      Adaptor::ResqueAdaptor.new(
+    
+        ROOT, { :queue => '' }, nil
+    
+      )
+      
+    }.to raise_error(
+    
+      LanGrove::DaemonConfigException,
+      
+      "Adaptor::ResqueAdaptor requires :queue:"
+    
+    )
+    
+  end
+  
+  context 'uses requeue to' do
+    
+    before :each do
+      
+      @parameters = {
+        
+        :handler => {
+          
+          :class => 'FakeJob'
+          
+        }
+        
+      }
+      
+      #
+      # Mock the resque infrastructure
+      #
+      
+      @worker = mock( 'Resque::Worker' )
+      
+      @job = mock( 'Job' )
+      
+      @payload = {}
+      
+      Resque::Worker.should_receive(
+      
+        :new
+      
+      ).and_return(
+      
+        @worker
+      
+      )
+      
+      @worker.should_receive( 
+      
+        :work
+      
+      ).and_yield(
+      
+        @job
+        
+      )
+      
+      @job.should_receive(
+      
+        :payload_class
+      
+      ).and_return(
+      
+        FakeJob
+      
+      )
+      
+      @job.should_receive(
+      
+        :payload
+        
+      ).and_return(
+      
+        @payload
+        
+      )
+      
+    end
+  
+    it 'yields jobs' do
+      
+      job = nil
+      
+      subject.connector( @parameters ) do |new_job|
+        
+        job = new_job
+        
+      end
+      
+      job.should be_a( FakeJob )
+      
+    end
+  
+  end
+  
+end

data/spec/handler/resque_job_spec.rb

@@ -0,0 +1,32 @@
+require 'langrove-plugin-resque'
+
+describe Handler::ResqueJob do
+  
+  before :each do
+    
+    @queue_name = :queue_name
+    
+    @job_parameter = {
+      
+      :the => 'originally',
+      :enqueued => 'payload'
+      
+    }
+    
+  end
+  
+  subject {
+    
+    worker = Handler::ResqueJob.new
+    
+    worker.instance_variable_set( 
+      
+      :@root, ROOT
+    
+    )
+    
+    worker
+    
+  }
+  
+end

data/spec/plugin/resque_que_spec.rb

@@ -0,0 +1,118 @@
+require 'langrove-plugin-resque'
+
+describe 'Plugin::ResqueQue' do
+  
+  before :each do
+
+    ROOT = LanGrove::FakeRoot.new
+
+    RESQUE_DEFERRER = {
+
+      :class => 'ResqueQue',
+      :job => 'ResqueWorker',
+      :queue => :resque_queue
+      
+    }
+    
+    @capsule = { :stamp => 'STAMP', :data => '' }
+    
+  end
+  
+  subject {
+    
+    LanGrove::ClassLoader.create( { 
+
+      :module => 'Plugin',
+      :class  => 'ResqueQue'
+
+    } ).new( ROOT, RESQUE_DEFERRER, nil )
+    
+  }
+  
+  it 'can enqueue the capsule key' do
+    
+    subject.validate_config
+    
+    handler = mock( 'handler' )
+    
+    handler.should_receive(
+    
+      :key
+    
+    ).and_return(
+    
+      'THE_KEY'
+      
+    )
+    
+    handler.should_receive(
+    
+      :capsule
+    
+    ).and_return(
+    
+      @capsule
+      
+    )
+    
+    Resque.should_receive( 
+      
+      :enqueue
+    
+    ).with(  
+    
+      Object.const_get(  
+      
+        RESQUE_DEFERRER[:job]
+      
+      ),
+      
+      anything(),
+      
+      "THE_KEY"
+    
+    )
+    
+    subject.defer_key( handler )
+    
+  end
+  
+  it 'can enqueue the capsule data' do
+    
+    subject.validate_config
+    
+    handler = mock( 'handler' )
+    
+    handler.should_receive(
+    
+      :capsule
+    
+    ).twice.and_return(
+    
+      @capsule
+      
+    )
+    
+    Resque.should_receive( 
+      
+      :enqueue
+    
+    ).with(  
+    
+      Object.const_get(  
+      
+        RESQUE_DEFERRER[:job]
+      
+      ),
+      
+      anything(),
+      
+      @capsule
+    
+    )
+    
+    subject.defer_capsule( handler )
+    
+  end
+  
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: langrove-plugin-resque
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+  prerelease: 
+platform: ruby
+authors:
+- Richard
+- ''
+- ''
+- ''
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: langrove
+  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: resque
+  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'
+description: ''
+email: ops@clue.co.za
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/adaptor/resque_adaptor.rb
+- lib/handler/resque_job.rb
+- lib/plugin/resque_que.rb
+- spec/adaptor/resque_adaptor_spec.rb
+- spec/handler/resque_job_spec.rb
+- spec/plugin/resque_que_spec.rb
+- lib/langrove-plugin-resque.rb
+- README.md
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Intergates Resque support into LanGrove
+test_files: []