stapfen 2.2.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ca4badd6b7c0c0e44a1a101242b2fd87eb2a30d
+  data.tar.gz: 87865dda53e78a451e17acfa310a44471a546852
+SHA512:
+  metadata.gz: 6e659e0357574a33fe5b806106c00bbae8ef2cf1d5f3dc4148af817b2fa72860e700f64d9a0271e116bba5648ca9e3251f934f767aac102743dda02990eba77d
+  data.tar.gz: f95e44cd65ddf1ab1625161934f03781c14276779dd1389d168c1b28f004aff76d4dc8af2589b6addecca69b25957b7dff7be2e047758e33461fc3fa4dc9094e

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc
+activemq-all-5.8.0.jar

data/CHANGES.md

@@ -0,0 +1,16 @@
+# Changes to Stapfen
+
+## 2.0.2
+
+* Fix for unreceive handling
+
+## 2.0.1
+
+* More verbose exit handlers
+* Invoke `java.lang.System.exit` on the JVM when exiting
+
+## 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/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stapfen.gemspec
+gemspec
+
+gem 'jruby-jms', :platform => :jruby
+gem 'stomp', '>= 1.2.14'
+
+group :development do
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec-its'
+  gem 'pry'
+  gem 'debugger', :platform => :mri
+  gem 'debugger-pry', :platform => :mri
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 R. Tyler Croy
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+# Stapfen
+
+
+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.
+
+
+**[RDoc here](http://rdoc.info/github/lookout/stapfen/master/frames)**
+
+## Usage
+
+(Examples can be found in the `examples/` directory)
+
+
+Consider the following `myworker.rb` file:
+
+```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.
+
+### Fallback and dead-letter-queue support
+
+The consume block accepts the usual subscriptions headers, as well as two
+additional headers `:dead_letter_queue` and `:max_redeliveries`.  If either of
+the latter two is 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:
+
+    gem 'stapfen'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stapfen
+
+## Running Specs
+
+Download this from jar from Maven Central
+  * [activemq-all-5.8.0.jar](http://search.maven.org/#artifactdetails%7Corg.apache.activemq%7Cactivemq-all%7C5.8.0%7Cjar)
+  * Put it in gem root
+  * ```rake spec```
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = '--color --fail-fast'
+end
+
+task :test => :spec
+
+task :default => [:spec, :build]

data/examples/simple.rb

@@ -0,0 +1,44 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+require 'stapfen'
+require ENV['activemq_jar'] if ENV['USE_JMS']
+
+
+class Worker < Stapfen::Worker
+
+  configure do
+    {:hosts => [
+      {
+        :host => 'localhost',
+        :port => 61613,
+        :login => 'guest',
+        :passcode => 'guest',
+        :ssl => false
+      }
+    ],
+    :factory => 'org.apache.activemq.ActiveMQConnectionFactory'}
+  end
+
+  use_jms! if ENV['USE_JMS']
+
+  if ENV['USE_JMS']
+    consume '/queue/jms.queue.test',
+            :max_redeliveries => 3,
+            :dead_letter_queue => '/queue/jms.queue.test/dlq' do |message|
+      puts "received: #{message}"
+
+      # False here forces an unreceive
+      return false
+    end
+  else # use stomp
+    consume '/queue/test',
+            :max_redeliveries => 3,
+            :dead_letter_queue => '/queue/test/dlq' do |message|
+      puts "received: #{message}"
+
+      # False here forces an unreceive
+      return false
+    end
+  end
+end
+
+Worker.run!

data/lib/stapfen.rb

@@ -0,0 +1,25 @@
+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
+  class ConfigurationError < StandardError
+  end
+  class ConsumeError < StandardError
+  end
+  class InvalidMessageError < StandardError
+  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/client/jms.rb

@@ -0,0 +1,118 @@
+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?
+        true
+      end
+
+      # JMS doesn't implement unreceive in quite the way Stomp does, so we'll
+      # implement it here.
+      #
+      # Given a message and a set of unreceive headers, this will deliver the
+      # message back to its originating queue a limited number of times, then
+      # failover to the dead letter queue.
+      #
+      # @param [Stapfen::Message] message The message to unreceive.
+      # @param [Hash] unreceive_headers
+      # @option unreceive_headers [Integer] :max_redeliveries The number of times
+      #   to attempt redelivery.
+      # @option unreceive_headers [String] :dead_letter_queue After giving up on
+      #   redelivering, send the message here.
+      def unreceive(message, unreceive_headers)
+        return if unreceive_headers[:max_redeliveries].nil? && unreceive_headers[:max_redeliveries].nil?
+
+        destination = message.destination.to_s.sub('queue://','/queue/').sub('topic://','/topic')
+        retry_count = message.getStringProperty('retry_count').to_i || 0
+        retry_count +=1
+
+        if unreceive_headers[:max_redeliveries] && (retry_count <= unreceive_headers[:max_redeliveries])
+          self.publish(destination, message.data, {'retry_count' => retry_count.to_s})
+        elsif unreceive_headers[:dead_letter_queue] # Done retrying, send to DLQ
+          self.publish(unreceive_headers[:dead_letter_queue], message.data, {:original_destination => destination})
+        end
+      end
+    end
+  end
+end

data/lib/stapfen/client/kafka.rb

@@ -0,0 +1,76 @@
+begin
+  require 'hermann'
+  require 'hermann/consumer'
+rescue LoadError => e
+  if RUBY_PLATFORM == 'java'
+    raise
+  end
+end
+
+require 'stapfen/destination'
+
+module Stapfen
+  module Client
+    class Kafka
+      attr_reader :connection, :producer
+
+      # Initialize a Kafka client object
+      #
+      # @params [Hash] configuration object
+      # @option configuration [String] :topic The kafka topic
+      # @option configuration [String] :groupId The kafka groupId
+      # @option configuration [String] :zookeepers List of zookeepers
+      #
+      # @raises [ConfigurationError] if required configs are not present
+      def initialize(configuration)
+        super()
+        @config     = configuration
+        @topic      = @config[:topic]
+        @groupId    = @config[:groupId]
+        @zookeepers = @config[:zookeepers]
+        raise ConfigurationError unless @topic && @groupId && @zookeepers
+        @connection = Hermann::Consumer.new(@topic, @groupId, @zookeepers)
+      end
+
+      # This method is not implemenented
+      def connect(*args)
+        # No-op
+      end
+
+      # Cannot unreceive
+      def can_unreceive?
+        false
+      end
+
+      # Closes the consumer threads created by kafka.
+      #
+      # @return [Boolean] True/false depending on whether we actually closed
+      #   the connection
+      def close
+        return false unless @connection
+        @connection.shutdown
+        @connection = nil
+        return true
+      end
+
+      # Subscribes to a destination (i.e. kafka topic) and consumes messages
+      #
+      # @params [Destination] source of messages to consume
+      #
+      # @params [Hash] Not used
+      #
+      # @params [block] block to yield consumed messages
+      def subscribe(destination, headers={}, &block)
+        destination = Stapfen::Destination.from_string(destination)
+        connection.consume(destination.as_kafka, &block)
+      end
+
+      def runloop
+        loop do
+          sleep 1
+        end
+      end
+
+    end
+  end
+end