freddy-jruby 0.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2f29ab8dfbedae9cbd544b20c86c7adf72d4859e
+  data.tar.gz: dd7c545605d297356f2fdb27b3fef5fda8735474
+SHA512:
+  metadata.gz: 4674e17c54e5dee1b926bf6354987d5a7e2df079a39754d4ed9a332ec705e8046e5fe69112af09d95b0b1be0fa94288c70a12b45eb4f0d5a7c994df9b5024a1b
+  data.tar.gz: 20784cb06674e8c0135315dfa9566a0933258e3b8cd7f74a722f68e4d7ff9126cec68d3154211c875af128baa39b8a96a5fd56c95461390ac3a5192ee7f94313

data/.gitignore

@@ -0,0 +1,5 @@
+.bundle/
+Gemfile.lock
+pkg
+.tags
+.tags1

data/.npmignore

@@ -0,0 +1,8 @@
+.git*
+.rspec
+.ruby*
+Gemfile*
+*.gemspec
+spec/
+*.rb
+lib/messaging

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+sm-messaging

data/.ruby-version

@@ -0,0 +1 @@
+2.2

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - jruby-9.0.0.0
+services:
+  - rabbitmq
+before_script:
+  - gem install bundler
+  - bundle install
+script: bundle exec rspec

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+group :test, :development do
+  gem 'rspec'
+  gem 'pry'
+end
+
+gemspec

data/LICENCE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013-2015 SaleMove Inc.
+
+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,170 @@
+# Messaging API supporting acknowledgements and request-response
+
+[![Build Status](https://travis-ci.org/salemove/node-freddy.svg?branch=master)](https://travis-ci.org/salemove/node-freddy)
+[![Code Climate](https://codeclimate.com/github/salemove/freddy/badges/gpa.svg)](https://codeclimate.com/github/salemove/freddy)
+
+## Setup
+
+* Inject the appropriate logger and set up connection parameters:
+
+```ruby
+logger = Logger.new(STDOUT)
+freddy = Freddy.build(logger, host: 'localhost', port: 5672, user: 'guest', pass: 'guest')
+```
+
+## Delivering messages
+
+### Simple delivery
+
+#### Send and forget
+Sends a `message` to the given `destination`. If there is no consumer then the
+message stays in the queue until somebody consumes it.
+```ruby
+  freddy.deliver(destination, message)
+```
+
+#### Expiring messages
+Sends a `message` to the given `destination`. If nobody consumes the message in
+`timeout` seconds then the message is discarded. This is useful for showing
+notifications that must happen in a certain timeframe but where we don't really
+care if it reached the destination or not.
+```ruby
+freddy.deliver(destination, message, timeout: 5)
+```
+
+### Request delivery
+#### Expiring messages
+Sends a `message` to the given `destination`. Has a default timeout of 3 and
+discards the message from the queue if a response hasn't been returned in that
+time.
+```ruby
+response = freddy.deliver_with_response(destination, message)
+```
+
+#### Persistant messages
+Sends a `message` to the given `destination`. Keeps the message in the queue if
+a timeout occurs.
+```ruby
+response = freddy.deliver_with_response(destination, message, timeout: 4, delete_on_timeout: false)
+```
+
+#### Errors
+`deliver_with_response` raises an error if an error is returned. This can be handled by rescuing from `Freddy::InvalidRequestError` and `Freddy::TimeoutError` as:
+```ruby
+begin
+  response = freddy.deliver_with_response 'Q', {}
+  # ...
+rescue Freddy::InvalidRequestError => e
+  e.response # => { error: 'InvalidRequestError', message: 'Some error message' }
+rescue Freddy::TimeoutError => e
+  e.response # => { error: 'RequestTimeout', message: 'Timed out waiting for response' }
+```
+
+## Responding to messages
+```ruby
+freddy.respond_to destination do |message, msg_handler|
+  # ...
+end
+```
+
+The callback is called with 2 arguments
+  * the parsed message (note that in the message all keys are symbolized)
+  * the `MessageHandler` (described further down)
+
+## The MessageHandler
+
+When responding to messages the MessageHandler is given as the second argument.
+
+The following operations are supported:
+
+  * responding with a successful response
+```ruby
+msg_handler.success(response = nil)
+```
+
+  * responding with an error response
+```ruby
+msg_handler.error(error: "Couldn't process message")
+```
+
+## Tapping into messages
+When it's necessary to receive messages but not consume them, consider tapping.
+
+```ruby
+freddy.tap_into pattern do |message, destination|
+```
+
+* `destination` refers to the destination that the message was sent to
+* Note that it is not possible to respond to the message while tapping.
+* When tapping the following wildcards are supported in the `pattern` :
+  * `#` matching 0 or more words
+  * `*` matching exactly one word
+
+Examples:
+
+```ruby
+freddy.tap_into "i.#.free"
+```
+
+receives messages that are delivered to `"i.want.to.break.free"`
+
+```ruby
+freddy.tap_into "somebody.*.love"
+```
+
+receives messages that are delivered to `somebody.to.love` but doesn't receive messages delivered to `someboy.not.to.love`
+
+## The ResponderHandler
+
+When responding to a message or tapping the ResponderHandler is returned.
+```ruby
+responder_handler = freddy.respond_to ....
+```
+
+The following operations are supported:
+
+  * stop responding
+```ruby
+responder_handler.cancel
+```
+
+  * delete the destination
+```ruby
+responder_handler.destroy_destination
+```
+
+    * Primary use case is in tests to not leave dangling destinations. It deletes the destination even if there are responders for the same destination in other parts of the system. Use with caution in production code.
+
+
+## Notes about concurrency
+
+The underlying bunny implementation uses 1 responder thread by default. This means that if there is a time-consuming process or a sleep call in a responder then other responders will not receive messages concurrently.
+To resolve this problem *freddy* uses a thread pool for running concurrent responders.
+The thread pool is shared between *tap_into* and *respond_to* callbacks and the default size is 4.
+The thread pool size can be configured by passing the configuration option *max_concurrency*.
+
+
+Note that while it is possible to use *deliver_with_response* inside a *respond_to* block,
+it is not possible to use another *respond_to* block inside a different *respond_to* block.
+
+
+Note also that other configuration options for freddy users
+such as pool sizes for DB connections need to match or exceed *max_concurrency*
+to avoid running out of resources.
+
+Read more from <http://rubybunny.info/articles/concurrency.html>.
+
+## Credits
+
+**freddy** was originally written by [Urmas Talimaa] as part of SaleMove development team.
+
+![SaleMove Inc. 2012][SaleMove Logo]
+
+**freddy** is maintained and funded by [SaleMove, Inc].
+
+The names and logos for **SaleMove** are trademarks of SaleMove, Inc.
+
+[Urmas Talimaa]: https://github.com/urmastalimaa?source=c "Urmas"
+[SaleMove, Inc]: http://salemove.com/ "SaleMove Website"
+[SaleMove Logo]: http://app.salemove.com/assets/logo.png "SaleMove Inc. 2012"
+[Apache License]: http://choosealicense.com/licenses/apache/ "Apache License"

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+task ci: :spec
+task default: :spec

data/freddy.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  if RUBY_PLATFORM == 'java'
+    spec.name          = "freddy-jruby"
+  else
+    spec.name          = "freddy"
+  end
+  spec.version       = '0.4.3'
+  spec.authors       = ["Urmas Talimaa"]
+  spec.email         = ["urmas.talimaa@gmail.com"]
+  spec.description   = %q{Messaging API}
+  spec.summary       = %q{API for inter-application messaging supporting acknowledgements and request-response}
+  spec.license       = "Private"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+
+  if RUBY_PLATFORM == 'java'
+    spec.add_dependency 'march_hare', '~> 2.12.0'
+  else
+    spec.add_dependency "bunny", "2.2.0"
+  end
+
+  spec.add_dependency "symbolizer"
+  spec.add_dependency "hamster", "~> 1.0.1.pre.rc3"
+  spec.add_dependency "thread", "~> 0.2"
+end

data/lib/freddy/adaptive_queue.rb

@@ -0,0 +1,34 @@
+class Freddy
+  class AdaptiveQueue
+    def initialize(queue)
+      @queue = queue
+    end
+
+    def subscribe(&block)
+      if hare?
+        @queue.subscribe do |meta, payload|
+          block.call(payload, Delivery.new(meta, meta.routing_key))
+        end
+      else
+        @queue.subscribe do |info, properties, payload|
+          block.call(payload, Delivery.new(properties, info.routing_key))
+        end
+      end
+    end
+
+    def bind(*args)
+      @queue.bind(*args)
+      self
+    end
+
+    def name
+      @queue.name
+    end
+
+    private
+
+    def hare?
+      RUBY_PLATFORM == 'java'
+    end
+  end
+end

data/lib/freddy/consumer.rb

@@ -0,0 +1,77 @@
+require_relative 'responder_handler'
+require_relative 'message_handler'
+require_relative 'request'
+require_relative 'delivery'
+
+class Freddy
+  class Consumer
+
+    class EmptyConsumer < Exception
+    end
+
+    def initialize(channel, logger, consume_thread_pool)
+      @channel, @logger = channel, logger
+      @topic_exchange = @channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
+      @consume_thread_pool = consume_thread_pool
+      @dedicated_thread_pool = Thread.pool(1) # used only internally
+    end
+
+    def consume(destination, options = {}, &block)
+      raise EmptyConsumer unless block
+      consume_from_queue create_queue(destination), options, &block
+    end
+
+    def consume_from_queue(queue, options = {}, &block)
+      consume_using_pool(queue, options, @consume_thread_pool, &block)
+    end
+
+    def dedicated_consume(queue, &block)
+      consume_using_pool(queue, {}, @dedicated_thread_pool, &block)
+    end
+
+    def tap_into(pattern, &block)
+      queue = create_queue('', exclusive: true).bind(@topic_exchange, routing_key: pattern)
+      consumer = queue.subscribe do |payload, delivery|
+        @consume_thread_pool.process do
+          block.call parse_payload(payload), delivery.routing_key
+        end
+      end
+      @logger.debug "Tapping into messages that match #{pattern}"
+      ResponderHandler.new consumer, @channel
+    end
+
+    private
+
+    def consume_using_pool(queue, options, pool, &block)
+      consumer = queue.subscribe do |payload, delivery|
+        pool.process do
+          parsed_payload = parse_payload(payload)
+          log_receive_event(queue.name, parsed_payload, delivery.correlation_id)
+          block.call parsed_payload, delivery
+        end
+      end
+      @logger.debug "Consuming messages on #{queue.name}"
+      ResponderHandler.new consumer, @channel
+    end
+
+    def parse_payload(payload)
+      if payload == 'null'
+        {}
+      else
+        Symbolizer.symbolize(JSON(payload))
+      end
+    end
+
+    def create_queue(destination, options={})
+      AdaptiveQueue.new(@channel.queue(destination, options))
+    end
+
+    def log_receive_event(queue_name, payload, correlation_id)
+      if defined?(Logasm) && @logger.is_a?(Logasm)
+        @logger.debug "Received message", queue: queue_name, payload: payload, correlation_id: correlation_id
+      else
+        @logger.debug "Received message on #{queue_name} with payload #{payload} with correlation_id #{correlation_id}"
+      end
+    end
+  end
+end

data/lib/freddy/delivery.rb

@@ -0,0 +1,14 @@
+class Freddy
+  class Delivery
+    attr_reader :metadata, :routing_key
+
+    def initialize(metadata, routing_key)
+      @metadata = metadata
+      @routing_key = routing_key
+    end
+
+    def correlation_id
+      @metadata.correlation_id
+    end
+  end
+end

data/lib/freddy/message_handler.rb

@@ -0,0 +1,19 @@
+class Freddy
+  class MessageHandler
+    attr_reader :destination, :correlation_id
+
+    def initialize(adapter, delivery)
+      @adapter = adapter
+      @metadata = delivery.metadata
+      @correlation_id = @metadata.correlation_id
+    end
+
+    def success(response = nil)
+      @adapter.success(@metadata.reply_to, response)
+    end
+
+    def error(error = {error: "Couldn't process message"})
+      @adapter.error(@metadata.reply_to, error)
+    end
+  end
+end