freddy 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2db3000f993c822db69070b9f68a96af43fee7fc
+  data.tar.gz: dfb430e314b3626e5c65b06f4932fcfd691fffa6
+SHA512:
+  metadata.gz: 0654512ddf983cb2aef3bda80f46c01ec302cd728fc53e519f67971ac25f7c1ba3cc2170bd5778bfda6d3460acb1aa365851c21b37c3331a481c855621b7ac8c
+  data.tar.gz: ca4e0785cf2f79ce58158a42d6cfda05d81d4c201e0753182d870c5976303eca45a84bf73e016082df020d214115499304b75be3290f2d7abe0bb7ad36c44772

data/.gitignore

@@ -0,0 +1 @@
+.bundle/

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 @@
+ruby-2.1

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.1.0
+services:
+  - rabbitmq
+before_script:
+  - bundle
+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/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    freddy (0.3.0)
+      bunny (= 1.6.3)
+      hamster (~> 1.0.1.pre.rc3)
+      symbolizer
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    amq-protocol (1.9.2)
+    atomic (1.1.16)
+    bunny (1.6.3)
+      amq-protocol (>= 1.9.2)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    hamster (1.0.1.pre.rc3)
+      atomic (~> 1.1)
+    method_source (0.8.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    slop (3.6.0)
+    symbolizer (0.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  freddy!
+  pry
+  rake
+  rspec

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,163 @@
+# 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::ErrorResponse` as:
+```ruby
+begin
+  response = freddy.deliver_with_response 'Q', {}
+  # ...
+rescue Freddy::ErrorResponse => e
+  e.response # => { error: '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
+```
+
+  * join the current thread to the responder thread
+```ruby
+responder_handler.join
+```
+
+  * 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.
+
+This is especially devious when using `deliver_with_response` in a responder because `deliver_with_response` creates a new anonymous responder which will not receive the response if the parent responder uses a sleep call.
+
+To resolve this problem *freddy* uses 4 responder threads by default (configurable by `responder_thread_count`). Note that this means that ordered message processing is not guaranteed by default. 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,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "freddy"
+  spec.version       = '0.3.0'
+  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", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "bunny", "1.6.3"
+  spec.add_dependency "symbolizer"
+  spec.add_dependency "hamster", "~> 1.0.1.pre.rc3"
+end

data/lib/freddy.rb

@@ -0,0 +1,86 @@
+require 'bunny'
+require 'json'
+require 'symbolizer'
+
+require_relative 'freddy/consumer'
+require_relative 'freddy/producer'
+require_relative 'freddy/request'
+
+class Freddy
+  class ErrorResponse < StandardError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super('Use #response to get the error response')
+    end
+  end
+
+  FREDDY_TOPIC_EXCHANGE_NAME = 'freddy-topic'.freeze
+
+  def self.format_backtrace(backtrace)
+    backtrace.map{ |x|
+      x.match(/^(.+?):(\d+)(|:in `(.+)')$/);
+      [$1,$2,$4]
+    }.join "\n"
+  end
+
+  def self.format_exception(exception)
+    "#{exception.exception}\n#{format_backtrace(exception.backtrace)}"
+  end
+
+  def self.notify(name, message, parameters={})
+    if defined? Airbrake
+      Airbrake.notify_or_ignore({
+        error_class: name,
+        error_message: message,
+        cgi_data: ENV.to_hash,
+        parameters: parameters
+      })
+    end
+  end
+
+  def self.notify_exception(exception, parameters={})
+    if defined? Airbrake
+      Airbrake.notify_or_ignore(exception, cgi_data: ENV.to_hash, parameters: parameters)
+    end
+  end
+
+  def self.build(logger = Logger.new(STDOUT), bunny_config)
+    bunny = Bunny.new(bunny_config)
+    bunny.start
+
+    channel = bunny.create_channel(nil, bunny_config[:responder_thread_count] || 4)
+    new(channel, logger)
+  end
+
+  attr_reader :channel, :consumer, :producer, :request
+
+  def initialize(channel, logger)
+    @channel  = channel
+    @consumer = Consumer.new channel, logger
+    @producer = Producer.new channel, logger
+    @request  = Request.new channel, logger
+  end
+
+  def respond_to(destination, &callback)
+    @request.respond_to destination, &callback
+  end
+
+  def tap_into(pattern, &callback)
+    @consumer.tap_into pattern, &callback
+  end
+
+  def deliver(destination, payload, timeout: 0)
+    opts = {}
+    opts[:expiration] = (timeout * 1000).to_i if timeout > 0
+
+    @producer.produce destination, payload, opts
+  end
+
+  def deliver_with_response(destination, payload, timeout: 3, delete_on_timeout: true)
+    @request.sync_request destination, payload, {
+      timeout: timeout, delete_on_timeout: delete_on_timeout
+    }
+  end
+end

data/lib/freddy/consumer.rb

@@ -0,0 +1,64 @@
+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)
+      @channel, @logger = channel, logger
+      @topic_exchange = @channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
+    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)
+      consumer = queue.subscribe options do |delivery_info, properties, payload|
+        parsed_payload = parse_payload(payload)
+        log_receive_event(queue.name, parsed_payload)
+        block.call parsed_payload, Delivery.new(delivery_info, properties)
+      end
+      @logger.debug "Consuming messages on #{queue.name}"
+      ResponderHandler.new consumer, @channel
+    end
+
+    def tap_into(pattern, &block)
+      queue = @channel.queue("", exclusive: true).bind(@topic_exchange, routing_key: pattern)
+      consumer = queue.subscribe do |delivery_info, properties, payload|
+        block.call parse_payload(payload), delivery_info.routing_key
+      end
+      @logger.debug "Tapping into messages that match #{pattern}"
+      ResponderHandler.new consumer, @channel
+    end
+
+    private
+
+    def parse_payload(payload)
+      if payload == 'null'
+        {}
+      else
+        Symbolizer.symbolize(JSON(payload))
+      end
+    end
+
+    def create_queue(destination)
+      @channel.queue(destination)
+    end
+
+    def log_receive_event(queue_name, payload)
+      if defined?(Logasm) && @logger.is_a?(Logasm)
+        @logger.info "Received message", queue: queue_name
+        @logger.debug "Received message", queue: queue_name, payload: payload
+      else
+        @logger.debug "Received message on #{queue_name} with payload #{payload}"
+      end
+    end
+  end
+end