blinkbox-common_messaging 0.5.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    N2MwMWMwOWQzM2ZkMTMzN2FlNzRhMTBkZjA0MWQ0Y2JjMWFmYmY3Mw==
+  data.tar.gz: !binary |-
+    MGJkMjdlZWRlYzgwNThmYmMwYjYzOGM0MjI2MGRkNzZhMDJiZTIzNw==
+SHA512:
+  metadata.gz: !binary |-
+    ZDEwMTY2MThmZjdlZDBmMWY1YWQ5ODdjMjQyYjk3ZDdhOTVmYjlmODgzMTJh
+    OThiZWU3ZjEyMjJkZWQ1YjBjYjkzOGVmNGNhOGNlMjQxYjRiMjM1MTA3ZDdh
+    Nzc4ZTk3NzgxN2E2OWU2YTQ5ZDJhYzMyYmIxZjNiYTdkZTEzZjE=
+  data.tar.gz: !binary |-
+    ZGNmZTQ0YTJiN2IxZGVkMjEzY2MwMDE2ZjU4YzFlNGNmMzFjNjQ3MmNhODlk
+    NDVlZWQ2MjY2ZDhjZTYwMThjNzM2ZGQzZDg5OTU3NDhhZDU4OGQ0Mjc5NWY1
+    YjIxNTdlOGM0MmJhYzQ1MzhkYWNmOTM1OWY5ZWJiODQ3OTNmOGY=

data/CHANGELOG.md

@@ -0,0 +1,72 @@
+# Change log
+
+## Open Source release (2015-01-28 14:11:21)
+
+Today we have decided to publish parts of our codebase on Github under the [MIT licence](LICENCE). The licence is very permissive, but we will always appreciate hearing if and where our work is used!
+
+## 0.5.2 ([#9](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/9) 2014-12-22 15:03:21)
+
+Ensure Bunny logging to Graylog
+
+### Improvement
+
+- Ensure the logger is set for bunny at the low level. [Bunny Docs](http://rubybunny.info/articles/connecting.html)
+
+## 0.5.1 ([#8](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/8) 2014-11-25 17:44:39)
+
+Only stringify if it can be stringified
+
+### Bug fix
+
+- Mapping Updates are arrays, not objects, which fail when sent into the initialiser.
+
+## 0.5.0 ([#7](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/7) 2014-11-10 13:05:42)
+
+Temporary queues
+
+### New feature
+
+- Added support for temporary and exclusive queues. Needed for `common_mapping`.
+
+## 0.4.1 ([#5](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/5) 2014-11-06 16:31:05)
+
+Refactor
+
+### Improvements
+
+- Just shift code between two files. No code alterations whatsoever.
+
+## 0.4.0 ([#4](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/4) 2014-10-24 10:11:02)
+
+Validation of messages
+
+### New feature
+
+- Payloads can be validated or not, allowing 'catch all' queues.
+
+## 0.3.0 ([#3](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/3) 2014-10-09 10:46:10)
+
+Prefetch
+
+### New feature
+
+- Add prefetch capability
+
+## 0.2.0 ([#2](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/2) 2014-10-03 13:30:51)
+
+Remote uris
+
+### New feature
+
+- Any message sent with this library that contains a hash with the key `"type" => "remote"` will have its deep key placed into the `remote_uris` header for Marvin 2.0's resource fetcher to process.
+- Consolidated `VERSION` retrieval.
+
+## 0.1.0 ([#1](https://git.mobcastdev.com/Platform/common_messaging.rb/pull/1) 2014-09-01 08:37:37)
+
+Basic needs of the messaging library
+
+### New Features
+
+- Allows blinkbox Books specific message message publishing and subscription
+- Automatically validates incoming and outbound message structure against the json schema.
+

data/README.md

@@ -0,0 +1 @@
+# Blinkbox::CommonMessaging

data/VERSION

@@ -0,0 +1 @@
+0.5.2

data/lib/blinkbox/common_messaging.rb

@@ -0,0 +1,239 @@
+require "blinkbox/common_messaging/version"
+require "bunny"
+require "uri"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/string/inflections"
+require "ruby_units"
+require "forwardable"
+require "json-schema"
+require "securerandom"
+require "logger"
+require "blinkbox/common_messaging/header_detectors"
+require "blinkbox/common_messaging/queue"
+require "blinkbox/common_messaging/exchange"
+
+module Blinkbox
+  # A group of methods and classes which enable the delivery of messages through the
+  # blinkbox Books ecosystem via AMQP.
+  #
+  # `CommonMessaging.configure!` should be used to set up connection details first, then 
+  # every subsequent call to `CommonMessaging::Queue.new` will create a `Bunny::Queue` object
+  # using the connection details that were present at the time.
+  module CommonMessaging
+    # The default RabbitMQ connection details, in the format that Bunny needs them.
+    DEFAULT_CONFIG = {
+      bunny: {
+        host: "localhost",
+        port: 5672,
+        user: "guest",
+        pass: "guest",
+        vhost: "/",
+        log_level: Logger::WARN,
+        automatically_recover: true,
+        threaded: true,
+        continuation_timeout: 4000
+      },
+      retry_interval: {
+        initial: Unit("5 seconds"),
+        max: Unit("5 seconds")
+      },
+      logger: Logger.new(nil)
+    }
+
+    # This method only stores connection details for calls to `CommonMessaging::Queue.new`.
+    # Any queues already created will not be affected by subsequent calls to this method.
+    #
+    # This method converts the given options from the blinkbox Books common config format
+    # to the format required for Bunny so that calls like the following are possible:
+    #
+    # @example Using with CommonConfig
+    #   require "blinkbox/common_config"
+    #   require "blinkbox/common_messaging"
+    #   
+    #   config = Blinkbox::CommonConfig.new
+    #   Blinkbox::CommonMessaging.configure!(config.tree(:rabbitmq))
+    #
+    # @param [Hash] config The configuration options needed for an MQ connection.
+    # @option config [String] :url The URL to the RabbitMQ server, eg. amqp://user:pass@host.name:1234/virtual_host
+    # @option config [Unit] :initialRetryInterval The interval at which re-connection attempts should be made when a RabbitMQ failure first occurs.
+    # @option config [Unit] :maxRetryInterval The maximum interval at which RabbitMQ reconnection attempts should back off to.
+    # @param [#debug, #info, #warn, #error, #fatal] logger The logger instance which should be used by Bunny
+    def self.configure!(config, logger = nil)
+      @@config = DEFAULT_CONFIG
+
+      unless config[:url].nil?
+        uri = URI.parse(config[:url])
+        @@config.deep_merge!(
+          bunny: {
+            host: uri.host,
+            port: uri.port,
+            user: uri.user,
+            pass: uri.password,
+            vhost: uri.path
+          }
+        )
+      end
+
+      %i{initialRetryInterval maxRetryInterval}.each do |unit_key|
+        if config[unit_key]
+          config[unit_key] = Unit(config[unit_key]) unless config[unit_key].is_a?(Unit)
+
+          @@config.deep_merge!(
+            retry_interval: {
+              unit_key.to_s.sub('RetryInterval', '').to_sym => config[unit_key]
+            }
+          )
+        end
+      end
+
+      self.logger = logger unless logger.nil?
+    end
+
+    # Returns the current config being used (as used by Bunny)
+    #
+    # @return [Hash]
+    def self.config
+      @@config rescue DEFAULT_CONFIG
+    end
+
+    # Sets the logger delivered to Bunny when new connections are made
+    #
+    # @param [] logger The object to which log messages should be sent.
+    def self.logger=(logger)
+      %i{debug info warn error fatal level= level}.each do |m|
+        raise ArgumentError, "The logger did not respond to '#{m}'" unless logger.respond_to?(m)
+      end
+      @@config[:logger] = logger
+      @@config[:bunny][:logger] = logger
+    end
+
+    # Returns (and starts if necessary) the connection to the RabbitMQ server as specified by the current
+    # config. Will keep only one connection per configuration at any time and will return or create a new connection
+    # as necessary. Channels are created with publisher confirmations.
+    #
+    # Application code should not need to use this method.
+    #
+    # @return [Bunny::Session]
+    def self.connection
+      @@connections ||= {}
+      @@connections[config] ||= Bunny.new(config[:bunny])
+      @@connections[config].start
+      @@connections[config]
+    end
+
+    # Blocks until all the open connections have been closed, calling the block with any message_ids which haven't been delivered
+    #
+    # @param [Boolean] block_until_confirms Force the method to block until all messages have been acked or nacked.
+    # @yield [message_id] Calls the given block for any message that was undeliverable (if block_until_confirms was `true`)
+    # @yieldparam [String] message_id The message_id of the message which could not be delivered
+    def self.close_connections(block_until_confirms: true)
+      @@connections.each do |k, c|
+        if block_until_confirms && !c.wait_for_confirms
+          c.nacked_set.each do |message_id|
+            yield message_id if block_given?
+          end
+        end
+        c.close
+      end
+    end
+
+    module JsonSchemaPowered
+      extend Forwardable
+      def_delegators :@data, :responds_to?, :to_json, :[]
+
+      def method_missing(m, *args, &block)
+        @data.send(m, *args, &block)
+      end
+
+      def to_hash
+        @data
+      end
+
+      def to_s
+        @data.to_json
+      end
+
+      def ==(other)
+        self.to_hash == other.to_hash
+      rescue
+        # Any errors would be because the other isn't a hash, so the answer must be false
+        false
+      end
+
+      def inspect
+        classification_string = @data["classification"].map do |cl| 
+          "#{cl["realm"]}:#{cl["id"]}"
+        end.join(", ")
+        "<#{self.class.name.split("::").last}: #{classification_string}>"
+      rescue
+        to_s
+      end
+    end
+
+    class UndeliverableMessageError < RuntimeError; end
+
+    # Generates ruby classes representing blinkbox Books messages from the schema files at the
+    # given path.
+    #
+    # @example Initialising CommonMessaging for sending
+    #   Blinkbox::CommonMessaging.init_from_schema_at("ingestion.book.metatdata.v2.schema.json")
+    #   msg = Blinkbox::CommonMessaging::IngestionBookMetadataV2.new(title: "A title")
+    #   exchange.publish(msg)
+    #
+    # @example Using the root path
+    #   Blinkbox::CommonMessaging.init_from_schema_at("./schema/ingestion/book/metatdata/v2.schema.json")
+    #   # => [Blinkbox::CommonMessaging::SchemaIngestionBookMetadataV2]
+    #
+    #   Blinkbox::CommonMessaging.init_from_schema_at("./schema/ingestion/book/metatdata/v2.schema.json", "./schema")
+    #   # => [Blinkbox::CommonMessaging::IngestionBookMetadataV2]
+    # 
+    # @param [String] path The path to a (or a folder of) json-schema file(s) in the blinkbox Books format.
+    # @param [String] root The root path from which namespaces will be calculated. 
+    # @return Array of class names generated
+    def self.init_from_schema_at(path, root = path)
+      fail "The path #{path} does not exist" unless File.exist?(path)
+      return Dir[File.join(path, "**/*.schema.json")].map { |file| init_from_schema_at(file, root) }.flatten if File.directory?(path)
+
+      root = File.dirname(root) if root =~ /\.schema\.json$/
+      schema_name = path.sub(%r{^(?:\./)?#{root}/?(.+)\.schema\.json$}, "\\1").tr("/",".")
+      class_name = class_name_from_schema_name(schema_name)
+
+      # We will re-declare these classes if required, rather than raise an error.
+      remove_const(class_name) if constants.include?(class_name.to_sym)
+
+      const_set(class_name, Class.new {
+        include JsonSchemaPowered
+
+        def initialize(data = {})
+          @data = data
+          @data = @data.stringify_keys if data.respond_to?(:stringify_keys)
+          JSON::Validator.validate!(self.class.const_get("SCHEMA_FILE"), @data, insert_defaults: true)
+        end
+
+        def content_type
+          self.class.const_get("CONTENT_TYPE")
+        end
+      })
+
+      klass = const_get(class_name)
+      klass.const_set('CONTENT_TYPE', "application/vnd.blinkbox.books.#{schema_name}+json")
+      klass.const_set('SCHEMA_FILE', path)
+      klass
+    end
+
+    def self.class_from_content_type(content_type)
+      fail "No content type was given" if content_type.nil? || content_type.empty?
+      begin
+        schema_name = content_type.sub(%r{^application/vnd\.blinkbox\.books\.(.+)\+json$}, '\1')
+        const_get(class_name_from_schema_name(schema_name))
+      rescue
+        raise "The schema for the #{content_type} content type has not been loaded"
+      end
+    end
+
+    def self.class_name_from_schema_name(schema_name)
+      schema_name.tr("./", "_").camelcase
+    end
+  end
+end

data/lib/blinkbox/common_messaging/exchange.rb

@@ -0,0 +1,84 @@
+module Blinkbox
+  module CommonMessaging
+    class Exchange
+      extend Forwardable
+      def_delegators :@exchange, :on_return
+
+      # A wrapped class for Bunny::Exchange. Wrapped so we can take care of message validation and header 
+      # conventions in the blinkbox Books format.
+      #
+      # @param [String] exchange_name The name of the Exchange to connect to.
+      # @param [String] facility The name of the app or service (we've adopted the GELF naming term across ruby)
+      # @param [String] facility_version The version of the app or service which sent the message.
+      # @raise [Bunny::NotFound] If the exchange does not exist.
+      def initialize(exchange_name, facility: File.basename($0, '.rb'), facility_version: "0.0.0-unknown")
+        @app_id = "#{facility}:v#{facility_version}"
+        connection = CommonMessaging.connection
+        channel = connection.create_channel
+        channel.confirm_select
+        @exchange = channel.headers(
+          exchange_name,
+          durable: true,
+          auto_delete: false,
+          passive: true
+        )
+      end
+
+      # Publishes a message to the exchange with blinkbox Books default message headers and properties.
+      #
+      # Worth noting that because of a quirk of the RabbitMQ Headers Exchange you cannot route on properties
+      # so, in order to facilitate routing on content-type, that key is written to the headers by default as
+      # well as to the properties.
+      #
+      # @param [Blinkbox::CommonMessaging::JsonSchemaPowered, String] data The information which will be sent as the payload of the message. An instance of any class generated by Blinkbox::CommonMessaging.init_from_schema_at while :validate is true, or a String if false.
+      # @param [Hash] headers A hash of string keys and string values which will be sent as headers with the message. Used for matching.
+      # @param [Array<String>] message_id_chain Optional. The message_id_chain of the message which was received in order to prompt this one.
+      # @param [Boolean] confirm Will block this method until the MQ server has confirmed the message has been persisted and routed.
+      # @param [Boolean] validate if false will relax the constraint that the inbound data must be a JsonSchemaPowered object.
+      # @return [String] The correlation_id of the message which was delivered.
+      def publish(data, headers: {}, message_id_chain: [], confirm: true, validate: true)
+        raise ArgumentError, "All published messages must be validated. Please see Blinkbox::CommonMessaging.init_from_schema_at for details." if validate && !data.class.included_modules.include?(JsonSchemaPowered)
+        raise ArgumentError, "message_id_chain must be an array of strings" unless message_id_chain.is_a?(Array)
+
+        message_id = generate_message_id
+        new_message_id_chain = message_id_chain.dup << message_id
+        correlation_id = new_message_id_chain.first
+
+        headers = headers.merge!("message_id_chain" => new_message_id_chain)
+        options = {}
+
+        if data.respond_to?(:content_type)
+          hd = Blinkbox::CommonMessaging::HeaderDetectors.new(data)
+          headers = hd.modified_headers(headers)
+          # We have to do both of these because of RabbitMQ's weird header exchange protocol
+          headers["content-type"] = data.content_type 
+          options[:content_type] = data.content_type
+          data = data.to_json
+        end
+
+        options.merge!(
+          persistent: true,
+          correlation_id: correlation_id,
+          message_id: message_id,
+          app_id: @app_id,
+          timestamp: Time.now.to_i,
+          headers: headers
+        )
+        @exchange.publish(data, options)
+
+        if confirm && !@exchange.channel.wait_for_confirms
+          message_id = @exchange.channel.nacked_set.first
+          raise UndeliverableMessageError, "Message #{message_id} was returned as undeliverable by RabbitMQ."
+        end
+
+        message_id
+      end
+
+      private
+
+      def generate_message_id
+        SecureRandom.hex(8) # 8 generates a 16 byte string
+      end
+    end
+  end
+end

data/lib/blinkbox/common_messaging/header_detectors.rb

@@ -0,0 +1,20 @@
+class Blinkbox::CommonMessaging::HeaderDetectors
+  @@header_detectors = []
+
+  def initialize(obj)
+    @obj = obj
+  end
+
+  def modified_headers(original_headers = {})
+    @@header_detectors.each do |m|
+      original_headers = send(m, original_headers)
+    end
+    original_headers
+  end
+
+  def self.register(method_name)
+    @@header_detectors << method_name
+  end
+end
+
+Dir.glob(File.join(__dir__, "header_detectors/*.rb")) { |hd| require hd }

data/lib/blinkbox/common_messaging/header_detectors/detect_remote_uris.rb

@@ -0,0 +1,41 @@
+class Blinkbox::CommonMessaging::HeaderDetectors
+  def detect_remote_uris(original_headers)
+    hash = @obj.to_hash.extend(ExtraHashMethods)
+    deep_keys = hash.deep_key_select do |h|
+      h["type"] == "remote"
+    end
+    if !deep_keys.empty?
+      original_headers.merge!(
+        "has_remote_uris" => true,
+        "remote_uris" => deep_keys
+      )
+    end
+    original_headers
+  end
+
+  register :detect_remote_uris
+end
+
+module ExtraHashMethods
+  def deep_key_select(parent_key: "", &block)
+    keys = []
+    keys.push parent_key if block.call(self)
+    self.each do |k, v|
+      case v
+      when Hash
+        v.extend(ExtraHashMethods).deep_key_select(parent_key: k, &block).each do |hit|
+          keys.push [parent_key, hit].join(".").sub(/^\./,"")
+        end
+      when Array
+        v.each_with_index do |item, i|
+          if item.is_a? Hash
+            item.extend(ExtraHashMethods).deep_key_select(parent_key: "#{k}[#{i}]", &block).each do |hit|
+              keys.push [parent_key, hit].join(".").sub(/^\./,"")
+            end
+          end
+        end
+      end
+    end
+    keys
+  end
+end

data/lib/blinkbox/common_messaging/queue.rb

@@ -0,0 +1,149 @@
+require "securerandom"
+
+module Blinkbox
+  module CommonMessaging
+    # A proxy class for generating queues and binding them to exchanges using Bunny. In the
+    # format expected from blinkbox Books services.
+    class Queue
+      extend Forwardable
+      def_delegators :@queue, :status
+
+      # Create a queue object for subscribing to messages with.
+      #
+      # NB. There is no way to know what bindings have already been made for a queue, so all code
+      # subscribing to a queue should cope with receiving messages it's not expecting.
+      #
+      # @param [String] queue_name The name of the queue which should be used and (if necessary) created.
+      # @param [String] exchange The name of the Exchange to bind to. The default value should be avoided for production uses.
+      # @param [String, nil] dlx The name of the Dead Letter Exchange to send nacked messages to.
+      # @param [Array,Hash] bindings An array of hashes, each on detailing the parameters for a new binding.
+      # @param [Integer] prefetch The number of messages to collect at a time when subscribing.
+      # @raise [Bunny::NotFound] If the exchange does not exist.
+      # @return [Bunny::Queue] A blinkbox managed Bunny Queue object
+      def initialize(queue_name, exchange: "amq.headers", dlx: "#{exchange}.DLX", bindings: [], prefetch: 10, exclusive: false, temporary: false)
+        raise ArgumentError, "Prefetch must be a positive integer" unless prefetch.is_a?(Integer) && prefetch > 0
+        connection = CommonMessaging.connection
+        @logger = CommonMessaging.config[:logger]
+        # We create one channel per queue because it means that any issues are isolated
+        # and we can start a new channel and resume efforts in a segregated manner.
+        @channel = connection.create_channel
+        @channel.prefetch(prefetch)
+        args = {}
+        args["x-dead-letter-exchange"] = dlx unless dlx.nil?
+        @queue = @channel.queue(
+          queue_name,
+          durable: !temporary,
+          auto_delete: temporary,
+          exclusive: exclusive,
+          arguments: args
+        )
+        @exchange = @channel.headers(
+          exchange,
+          durable: true,
+          auto_delete: false,
+          passive: true
+        )
+        Kernel.warn "No bindings were given, the queue is unlikely to receive any messages" if bindings.empty?
+        bindings.each do |binding|
+          @queue.bind(@exchange, arguments: binding)
+        end
+      end
+
+      # Defines a new block for handling exceptions which occur when processing an incoming message. Cases where this might occur include:
+      #
+      # * A message which doesn't have a recognised content-type (ie. one which has been 'init'ed)
+      # * An invalid JSON message
+      # * A valid JSON message which doesn't pass schema validation
+      #
+      # @example Sending excepted messages to a log, then nack them
+      #   log = Logger.new(STDOUT)
+      #   queue = Blinkbox::CommonMessaging::Queue.new("My.Queue")
+      #   queue.on_exception do |e, delivery_info, metadata, payload|
+      #     log.error e
+      #     channel.reject(delivery_info[:delivery_tag], false)
+      #   end
+      #
+      # @yield [exception, channel, delivery)info, metadata, payload] Yields for each exception which occurs.
+      # @yieldparam [Exception] exception The exception which was raised.
+      # @yieldparam [Bunny::Connection] exception The channel this exchnage is using (useful for nacking).
+      # @yieldparam [Hash] delivery_info The RabbitMQ delivery info for the message (useful for nacking).
+      # @yieldparam [Hash] metadata The metadata delivered from the RabbitMQ server (parameters and headers).
+      # @yieldparam [String] payload The message that was received
+      def on_exception(&block)
+        raise ArgumentError, "Please specify a block to call when an exception is raised" unless block_given?
+        @on_exception = block
+      end
+
+      # Emits the metadata and objectified payload for every message which appears on the queue. Any message with a content-type
+      # not 'init'ed will be rejected (without retry) automatically.
+      #
+      # * Returning `true` or `:ack` from the block will acknowledge and remove the message from the queue
+      # * Returning `false` or `:reject` from the block will send the message to the DLQ
+      # * Returning `:retry` will put the message back on the queue to be tried again later.
+      #
+      # @example Subscribing to messages
+      #   queue = Blinkbox::CommonMessaging::Queue.new("catch-all", exchange_name: "Marvin", [{}])
+      #   queue.subscribe(block:true) do |metadata, obj|
+      #     puts "Messge received."
+      #     puts "Headers: #{metadata[:headers].to_json}"
+      #     puts "Body: #{obj.to_json}"
+      #   end
+      #
+      # @param [Boolean] :block Should this method block while being executed (true, default) or spawn a new thread? (false)
+      # @param [Array<Blinkbox::CommonMessaging::JsonSchemaPowered>, nil] :accept List of schema types to accept (any not on the list will be rejected). `nil` will accept all message types and not validate incoming messages.
+      # @yield [metadata, payload_object] A block to execute for each message which is received on this queue.
+      # @yieldparam metadata [Hash] The properties and headers (in [:headers]) delivered with the message.
+      # @yieldparam payload_object [Blinkbox::CommonMessaging::JsonSchemaPowered] An object representing the validated JSON payload.
+      # @yieldreturn [Boolean, :ack, :reject, :retry]
+      def subscribe(block: true, accept: nil)
+        raise ArgumentError, "Please give a block to run when a message is received" unless block_given?
+        @queue.subscribe(
+          block: block,
+          manual_ack: true
+        ) do |delivery_info, metadata, payload|
+          begin
+            if accept.nil?
+              object = payload
+            else
+              klass = Blinkbox::CommonMessaging.class_from_content_type(metadata[:headers]['content-type'])
+              if accept.include?(klass)
+                object = klass.new(JSON.parse(payload)) 
+              else
+                response = :reject 
+              end
+            end
+            response ||= yield(metadata, object)
+            case response
+            when :ack, true
+              @channel.ack(delivery_info[:delivery_tag])
+            when :reject, false
+              @channel.reject(delivery_info[:delivery_tag], false)
+            when :retry
+              @channel.reject(delivery_info[:delivery_tag], true)
+            else
+              fail "Unknown response from subscribe block: #{response}"
+            end
+          rescue Exception => e
+            (@on_exception || method(:default_on_exception)).call(e, @channel, delivery_info, metadata, payload)
+          end
+        end
+      end
+
+      # Purges all messages from this queue. Destroys data!
+      #
+      # @return [true] Returns true if the purge occurred correctly (or a RabbitMQ error if it couldn't)
+      def purge!
+        @queue.purge
+        true
+      end
+
+      private
+
+      # The default handler for exceptions which occur when processing a message.
+      def default_on_exception(exception, channel, delivery_info, metadata, payload)
+        @logger.error exception
+        channel.reject(delivery_info[:delivery_tag], false)
+      end
+    end
+  end
+end

data/lib/blinkbox/common_messaging/version.rb

@@ -0,0 +1,9 @@
+module Blinkbox
+  module CommonMessaging
+    VERSION = begin
+      File.read(File.join(File.dirname(__FILE__), "../../../VERSION"))
+    rescue Errno::ENOENT
+      "0.0.0-unknown"
+    end
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: blinkbox-common_messaging
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- JP Hastings-Spital
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-units
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple helper for messaging around blinkbox Books
+email:
+- jphastings@blinkbox.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- README.md
+- VERSION
+- lib/blinkbox/common_messaging.rb
+- lib/blinkbox/common_messaging/exchange.rb
+- lib/blinkbox/common_messaging/header_detectors.rb
+- lib/blinkbox/common_messaging/header_detectors/detect_remote_uris.rb
+- lib/blinkbox/common_messaging/queue.rb
+- lib/blinkbox/common_messaging/version.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simple helper for messaging around blinkbox Books
+test_files: []