stapfen 1.5.0 → 2.0.0

data/CHANGES.md

@@ -0,0 +1,8 @@
+# Changes to Stapfen
+
+
+## 2.0.0
+
+* Add support for JMS-backed `Stapfen::Worker` classes
+* Deep copy the configuration passed into `Stomp::Client` to work-around [stomp #80](https://github.com/stompgem/stomp/issues/80)
+* Support per-instance log configuration [#3](https://github.com/lookout/stapfen/issues/3)

data/README.md

@@ -1,6 +1,12 @@
 # Stapfen
 
-Stapfen is a simple gem to make writing stand-alone STOMP workers easier.
+
+Stapfen is a simple gem to make writing workers that consume messages via
+[STOMP](http://stomp.github.io/) or
+[JMS](https://en.wikipedia.org/wiki/Java_Message_Service) easier.
+
+Stapfen allows you to write one worker class, and use either protocol
+depending on the environment and needs.
 
 
 ## Usage
@@ -10,37 +16,63 @@ Stapfen is a simple gem to make writing stand-alone STOMP workers easier.
 
 Consider the following `myworker.rb` file:
 
-    class MyWorker < Stapfen::Worker
-      configure do
-        {:hosts => [
-          {
-            :host => 'localhost',
-            :port => 61613,
-            :login => 'guest',
-            :passcode => 'guest',
-            :ssl => false
-          }
-        ]}
-      end
-
-      consume 'thequeue', :dead_letter_queue => '/queue/dlq',
-                          :max_redeliveries => 0 do |message|
-        data = expensive_computation(message.body)
-        persist(data)
-      end
-    end
-
-    MyWorker.run!
-
-
-The value returned from the `configure` block is expected to be a valid
+```ruby
+class MyWorker < Stapfen::Worker
+  use_stomp!
+
+  configure do
+    {
+      :hosts => [
+        {
+          :host => 'localhost',
+          :port => 61613,
+          :login => 'guest',
+          :passcode => 'guest',
+          :ssl => false
+        }
+      ]
+    }
+  end
+
+  # [Optional] Set up a logger for each worker instance
+  log do
+    Logger.new(STDOUT)
+  end
+
+  consume 'thequeue', :dead_letter_queue => '/queue/dlq',
+                      :max_redeliveries => 0 do |message|
+
+    data = expensive_computation(message.body)
+    # Save my data, or do something worker-specific with it
+    persist(data)
+
+    # Send another message
+    client.publish('/topic/computation-acks', "finished with #{message.message_id}")
+  end
+
+end
+
+MyWorker.run!
+```
+
+
+When using the STOMP protocol, the value returned from the `configure` block is expected to be a valid
 `Stomp::Client` [connection
 hash](https://github.com/stompgem/stomp#hash-login-example-usage-this-is-the-recommended-login-technique).
 
+In the case of the JMS protocol, the value returned from the `configure` block
+is expected to be a valid [configuration
+hash](https://github.com/reidmorrison/jruby-jms#consumer) for the
+[jruby-jms](https://github.com/reidmorrison/jruby-jms) gem.
+
+---
+
 It is also important to note that the `consume` block will be invoked inside an
 **instance** of `MyWorker` and will execute inside its own `Thread`, so take
 care when accessing other shared resources.
 
+### STOMP-specific support
+
 The consume block accepts the usual
 [Stomp::Client](https://github.com/stompgem/stomp) subscription headers, as well
 as :dead_letter_queue and :max\_redeliveries.  If either of the latter two is
@@ -48,6 +80,7 @@ present, the consumer will unreceive any messages for which the block returns
 false; after :max\_redeliveries, it will send the message to :dead_letter_queue.
 `consume` blocks without these headers will fail silently rather than unreceive.
 
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/stapfen/client/jms.rb

@@ -0,0 +1,91 @@
+require 'jms'
+require 'stapfen/destination'
+
+module Stapfen
+  module Client
+    class JMS
+      attr_reader :connection
+
+      def initialize(configuration)
+        super()
+        @config = configuration
+        @connection = nil
+      end
+
+      # Connect to the broker via JMS and start the JMS session
+      #
+      # @return [JMS::Connection]
+      def connect(*args)
+        @connection = ::JMS::Connection.new(@config)
+        @connection.start
+        return @connection
+      end
+
+      # Accessor method which will cache the session if we've already created
+      # it once
+      #
+      # @return [JMS::Session] Instantiated +JMS::Session+ for our
+      #   +connection+
+      def session
+        @session ||= connection.create_session
+      end
+
+      def publish(destination, body, headers={})
+        destination = Stapfen::Destination.from_string(destination)
+
+        session.producer(destination.jms_opts) do |p|
+          # Create the JMS typed Message
+          message = session.message(body)
+
+          message.delivery_mode = ::JMS::DeliveryMode::PERSISTENT if headers.delete(:persistent)
+
+          # Take the remainder of the headers and push them into the message
+          # properties.
+          headers.each_pair do |key, value|
+            message.setStringProperty(key.to_s, value.to_s)
+          end
+
+          p.send(message)
+        end
+      end
+
+      def subscribe(destination, headers={}, &block)
+        destination = Stapfen::Destination.from_string(destination)
+        connection.on_message(destination.jms_opts) do |m|
+          block.call(m)
+        end
+      end
+
+      # Close the JMS::Connection and the JMS::Session if it's been created
+      # for this client
+      #
+      # @return [Boolean] True/false depending on whether we actually closed
+      #   the connection
+      def close
+        return false unless @connection
+        @session.close if @session
+        @connection.close
+        @connection = nil
+        return true
+      end
+
+      # API compatibilty method, doesn't actually indicate that the connection
+      # is closed. Will only return true if no connection currently exists
+      #
+      # @return [Boolean]
+      def closed?
+        return connection.nil?
+      end
+
+      def runloop
+        loop do
+          sleep 1
+        end
+      end
+
+      def can_unreceive?
+        false
+      end
+    end
+  end
+end

data/lib/stapfen/client/stomp.rb

@@ -0,0 +1,35 @@
+require 'stomp'
+
+module Stapfen
+  module Client
+    class Stomp < ::Stomp::Client
+
+      def initialize(config)
+        # Perform a deep-copy of the configuration since +Stomp::Client+ will
+        # mutate/mess up the configuration +Hash+ passed in here, see:
+        #   <https://github.com/stompgem/stomp/issues/80>
+        super(Marshal.load(Marshal.dump(config)))
+      end
+
+      def connect(*args)
+        # No-op, since Stomp::Client will connect on instantiation
+      end
+
+      def can_unreceive?
+        true
+      end
+
+      def runloop
+        # Performing this join/runningloop to make sure that we don't
+        # experience potential deadlocks between signal handlers who might
+        # close the connection, and an infinite Client#join call
+        #
+        # Instead of using client#open? we use #running which will still be
+        # true even if the client is currently in an exponential reconnect loop
+        while self.running do
+          self.join(1)
+        end
+      end
+    end
+  end
+end

data/lib/stapfen/client.rb

@@ -0,0 +1,8 @@
+
+module Stapfen
+  module Client
+    #def publish(destination, body)
+    #  destination = Stapfen::Destination.from_string(destination)
+    #end
+  end
+end

data/lib/stapfen/destination.rb

@@ -20,6 +20,26 @@ module Stapfen
       end
     end
 
+    def as_jms
+      if queue?
+        return "queue://#{@name}"
+      end
+
+      if topic?
+        return "topic://#{@name}"
+      end
+    end
+
+    def jms_opts
+      if queue?
+        return {:queue_name => name}
+      end
+
+      if topic?
+        return {:topic_name => name}
+      end
+    end
+
     # Create a {Stapfen::Destination} from the given string
     #
     # @param [String] name

data/lib/stapfen/logger.rb

@@ -18,7 +18,7 @@ module Stapfen
 
       def proxy_log_method(method, arguments)
         if self.logger
-          self.logger.send(method, *arguments)
+          self.logger.call.send(method, *arguments)
           return true
         end
         return false
@@ -39,7 +39,7 @@ module Stapfen
 
     def proxy_log_method(method, arguments)
       if self.class.logger
-        self.class.logger.send(method, *arguments)
+        self.class.logger.call.send(method, *arguments)
         return true
       end
       return false

data/lib/stapfen/message.rb

@@ -1,15 +1,3 @@
-begin
-  require 'stomp'
-rescue LoadError
-  # Can't process Stomp
-end
-
-begin
-  require 'java'
-  require 'jms'
-rescue LoadError
-  # Can't process JMS
-end
 
 module Stapfen
   class Message

data/lib/stapfen/version.rb

@@ -1,3 +1,3 @@
 module Stapfen
-  VERSION = '1.5.0'
+  VERSION = '2.0.0'
 end

data/lib/stapfen/worker.rb

@@ -11,12 +11,8 @@ module Stapfen
     @@signals_handled = false
     @@workers = []
 
-    # Class instance variables!
-    @use_stomp = true
-
     class << self
       attr_accessor :configuration, :consumers, :logger, :destructor
-
     end
 
     # Instantiate a new +Worker+ instance and run it
@@ -56,7 +52,7 @@ module Stapfen
     end
 
     def self.stomp?
-      @use_stomp
+      @use_stomp.nil? || @use_stomp
     end
 
     # Force the worker to use JMS as the messaging protocol.
@@ -82,13 +78,13 @@ module Stapfen
     end
 
     def self.jms?
-      !(@use_stomp)
+      !(stomp?)
     end
 
     # Optional method, should be passed a block which will yield a {{Logger}}
     # instance for the Stapfen worker to use
-    def self.log
-      @logger = yield
+    def self.log(&block)
+      @logger = block
     end
 
     # Main message consumption block
@@ -158,55 +154,17 @@ module Stapfen
 
     def run
       if self.class.stomp?
-        run_stomp
+        require 'stapfen/client/stomp'
+        @client = Stapfen::Client::Stomp.new(self.class.configuration.call)
       elsif self.class.jms?
-        run_jms
-      end
-    end
-
-    def run_jms
-      JMS::Connection.start(self.class.configuration.call) do |connection|
-        @client = connection
-        debug("Running with #{@client} inside of Thread:#{Thread.current.inspect}")
-
-        self.class.consumers.each do |name, headers, block|
-          destination = Stapfen::Destination.from_string(name)
-          type = 'queue'
-          options = {}
-
-          if destination.queue?
-            options[:queue_name] = destination.name
-          end
-
-          if destination.topic?
-            type = 'topic'
-            options[:topic_name] = destination.name
-          end
-
-          method_name = "handle_#{type}_#{name}".to_sym
-          self.class.send(:define_method, method_name, &block)
-
-          connection.on_message(options) do |m|
-            message = Stapfen::Message.from_jms(m)
-            self.send(method_name, message)
-          end
-        end
-
-        begin
-          loop do
-            sleep 1
-          end
-          debug("Exiting the JMS runloop for #{self}")
-        rescue Interrupt
-          exit_cleanly
-        end
+        require 'stapfen/client/jms'
+        @client = Stapfen::Client::JMS.new(self.class.configuration.call)
       end
-    end
 
-    def run_stomp
-      @client = Stomp::Client.new(self.class.configuration.call)
       debug("Running with #{@client} inside of Thread:#{Thread.current.inspect}")
 
+      @client.connect
+
       self.class.consumers.each do |name, headers, block|
         unreceive_headers = {}
         [:max_redeliveries, :dead_letter_queue].each do |sym|
@@ -219,25 +177,28 @@ module Stapfen
         method_name = name.gsub(/[.|\-]/, '_').to_sym
         self.class.send(:define_method, method_name, &block)
 
-        client.subscribe(name, headers) do |message|
+        client.subscribe(name, headers) do |m|
+          message = nil
+          if self.class.stomp?
+            message = Stapfen::Message.from_stomp(m)
+          end
+
+          if self.class.jms?
+            message = Stapfen::Message.from_jms(m)
+          end
+
           success = self.send(method_name, message)
 
-          if !success && !unreceive_headers.empty?
-            client.unreceive(message, unreceive_headers)
+          unless success
+            if client.can_unreceive? && !unreceive_headers.empty?
+              client.unreceive(m, unreceive_headers)
+            end
           end
         end
       end
 
       begin
-        # Performing this join/runningloop to make sure that we don't
-        # experience potential deadlocks between signal handlers who might
-        # close the connection, and an infinite Client#join call
-        #
-        # Instead of using client#open? we use #running which will still be
-        # true even if the client is currently in an exponential reconnect loop
-        while client.running do
-          client.join(1)
-        end
+        client.runloop
         warn("Exiting the runloop for #{self}")
       rescue Interrupt
         exit_cleanly
@@ -251,8 +212,10 @@ module Stapfen
       self.class.destructor.call if self.class.destructor
 
       # Only close the client if we have one sitting around
-      if client && !client.closed?
-        client.close
+      if client
+        unless client.closed?
+          client.close
+        end
       end
     end
   end

data/lib/stapfen.rb

@@ -1,4 +1,19 @@
+begin
+  require 'stomp'
+rescue LoadError
+  # Can't process Stomp
+end
+
+begin
+  require 'java'
+  require 'jms'
+rescue LoadError
+  # Can't process JMS
+end
+
+
 require 'stapfen/version'
+require 'stapfen/client'
 require 'stapfen/worker'
 
 module Stapfen

data/spec/client/jms_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM == 'java'
+  require 'stapfen/client/jms'
+
+  describe Stapfen::Client::JMS, :java => true do
+    let(:config) { {} }
+    subject(:client) { described_class.new(config) }
+
+    it { should respond_to :connect }
+
+    describe '#can_unreceive?' do
+      subject { client.can_unreceive? }
+
+      it { should_not be_true }
+    end
+
+    describe '#connect' do
+      subject(:connection) { client.connect }
+      let(:jms_conn) { double('JMS::Connection') }
+
+      before :each do
+        ::JMS::Connection.should_receive(:new).and_return(jms_conn)
+      end
+
+      it 'should start the connection' do
+        jms_conn.should_receive(:start)
+        expect(connection).to eql(jms_conn)
+      end
+    end
+
+    describe '#session' do
+      let(:session) { double('JMS::Session') }
+      let(:connection) { double('JMS::Connection') }
+
+      before :each do
+        client.stub(:connection => connection)
+      end
+
+      context 'without a session already' do
+        it 'should create a new session' do
+          connection.should_receive(:create_session).and_return(session)
+          expect(client.session).to eql(session)
+        end
+      end
+
+      context 'with an existing session' do
+        it 'should return that existing session' do
+          connection.should_receive(:create_session).once.and_return(session)
+          3.times do
+            expect(client.session).to eql(session)
+          end
+        end
+      end
+    end
+
+    describe '#publish' do
+    end
+
+    describe '#closed?' do
+      subject(:result) { client.closed? }
+
+      context 'if a connection exists' do
+        before :each do
+          client.stub(:connection).and_return(double('JMS::Connection'))
+        end
+
+        it { should be_false }
+      end
+
+      context 'without a connection' do
+        it { should be_true }
+      end
+    end
+
+    describe '#close' do
+      subject(:result) { client.close }
+      let(:connection) { double('JMS::Connection') }
+
+      before :each do
+        client.instance_variable_set(:@connection, connection)
+      end
+
+      context 'without an existing session' do
+        it 'should close the client' do
+          connection.should_receive(:close)
+          expect(result).to be_true
+        end
+      end
+
+      context 'with an existing session' do
+        let(:session) { double('JMS::Session') }
+
+        before :each do
+          client.instance_variable_set(:@session, session)
+        end
+
+        it 'should close the client and session' do
+          session.should_receive(:close)
+          connection.should_receive(:close)
+          expect(result).to be_true
+        end
+      end
+    end
+  end
+end

data/spec/client/stomp_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'stapfen/client/stomp'
+
+describe Stapfen::Client::Stomp do
+end

data/spec/client_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'stapfen/client'
+
+describe Stapfen::Client do
+end

data/spec/destination_spec.rb

@@ -5,6 +5,19 @@ describe Stapfen::Destination do
   it { should respond_to :name }
   it { should respond_to :type }
 
+  describe '#as_jms' do
+    let(:name) { 'rspec/dlq' }
+    subject(:destination) do
+      d = described_class.new
+      d.type = :queue
+      d.name = name
+      d.as_jms
+    end
+
+    it { should be_instance_of String }
+    it { should eql "queue://#{name}" }
+  end
+
   describe '#as_stomp' do
     let(:name) { 'rspec/dlq' }
 

data/spec/logger_spec.rb

@@ -29,7 +29,7 @@ describe Stapfen::Logger do
       let(:plogger) { double('RSpec Logger') }
 
       before :each do
-        logger.class.stub(:logger).and_return(plogger)
+        logger.class.stub(:logger).and_return(lambda { plogger })
       end
 
       it 'should pass info messages along' do

data/spec/worker_spec.rb

@@ -38,6 +38,22 @@ describe Stapfen::Worker do
       end
     end
 
+    describe '#log' do
+      it "should store the block it's passed" do
+        logger = double('Mock Logger')
+
+        worker.log do
+          logger
+        end
+
+        expect(worker.logger).to be_instance_of Proc
+      end
+
+      after :each do
+        worker.logger = nil
+      end
+    end
+
     describe '#configure' do
       it 'should error when not passed a block' do
         expect {
@@ -52,11 +68,10 @@ describe Stapfen::Worker do
           config
         end
 
-        worker.configuration.call.should == config
+        expect(worker.configuration.call).to eql(config)
       end
     end
 
-
     describe '#exit_cleanly' do
       subject(:result) { worker.exit_cleanly }
 
@@ -120,14 +135,28 @@ describe Stapfen::Worker do
       end
 
       context 'unreceive behavior' do
-        let(:client) { double('Stomp::Client', :running => false) }
+        let(:client) do
+          c = double('Mock Stapfen::Client')
+          c.stub(:connect)
+          c.stub(:can_unreceive? => true)
+          c.stub(:runloop)
+          c
+        end
+
         let(:name) { '/queue/some_queue' }
+        let(:message) do
+          m = Stomp::Message.new(nil)
+          m.stub(:body => 'rspec msg')
+          m
+        end
+
+
         before :each do
-          Stomp::Client.stub(:new).and_return(client)
+          Stapfen::Client::Stomp.stub(:new).and_return(client)
 
           # Get a subscription?  Call the message handler block.
           client.stub(:subscribe) do |name, headers, &block|
-            block.call('msg')
+            block.call(message)
           end
         end
 
@@ -164,7 +193,7 @@ describe Stapfen::Worker do
               worker.new.run
             end
             it 'should pass :unreceive_headers through to the unreceive call' do
-              client.should_receive(:unreceive).with('msg', unrec_headers).once
+              client.should_receive(:unreceive).with(message, unrec_headers).once
 
               worker.consume(name, raw_headers) {|msg| false }
               worker.new.run

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stapfen
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-27 00:00:00.000000000 Z
+date: 2013-10-03 00:00:00.000000000 Z
 dependencies: []
 description: A simple gem for writing good basic STOMP workers
 email:
@@ -19,6 +19,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGES.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -26,11 +27,17 @@ files:
 - Rakefile
 - examples/simple.rb
 - lib/stapfen.rb
+- lib/stapfen/client.rb
+- lib/stapfen/client/jms.rb
+- lib/stapfen/client/stomp.rb
 - lib/stapfen/destination.rb
 - lib/stapfen/logger.rb
 - lib/stapfen/message.rb
 - lib/stapfen/version.rb
 - lib/stapfen/worker.rb
+- spec/client/jms_spec.rb
+- spec/client/stomp_spec.rb
+- spec/client_spec.rb
 - spec/destination_spec.rb
 - spec/logger_spec.rb
 - spec/message_spec.rb
@@ -51,7 +58,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1455385429346077259
+      hash: 497669016429276389
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -60,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1455385429346077259
+      hash: 497669016429276389
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -68,6 +75,9 @@ signing_key:
 specification_version: 3
 summary: A simple gem for writing good basic STOMP workers
 test_files:
+- spec/client/jms_spec.rb
+- spec/client/stomp_spec.rb
+- spec/client_spec.rb
 - spec/destination_spec.rb
 - spec/logger_spec.rb
 - spec/message_spec.rb