cf-message-bus 0.0.1

data/lib/cf_message_bus.rb

@@ -0,0 +1,4 @@
+require "cf_message_bus/version"
+
+module CfMessageBus
+end

data/lib/cf_message_bus/message_bus.rb

@@ -0,0 +1,121 @@
+require "eventmachine"
+require "eventmachine/schedule_sync"
+require "cf_message_bus/message_bus_factory"
+
+module CfMessageBus
+  class Error < StandardError; end
+
+  class MessageBus
+    def initialize(config)
+      @logger = config[:logger]
+      @internal_bus = MessageBusFactory.message_bus(config[:uri])
+      @subscriptions = {}
+      @internal_bus.on_reconnect { start_internal_bus_recovery }
+      @recovery_callback = lambda {}
+    end
+
+    def subscribe(subject, opts = {}, &block)
+      @subscriptions[subject] = [opts, block]
+
+      subscribe_on_reactor(subject, opts) do |parsed_data, inbox|
+        EM.defer do
+          run_handler(block, parsed_data, inbox, subject, 'subscription')
+        end
+      end
+    end
+
+    def publish(subject, message = nil, &callback)
+      EM.schedule do
+        internal_bus.publish(subject, encode(message), &callback)
+      end
+    end
+
+    def recover(&block)
+      @recovery_callback = block
+    end
+
+    def request(subject, data = nil, options = {}, &block)
+      internal_bus.request(subject, encode(data), options) do |payload, inbox|
+        process_message(payload, inbox) do |parsed_data, inbox|
+          run_handler(block, parsed_data, inbox, subject, 'response')
+        end
+      end
+    end
+
+    def synchronous_request(subject, data = nil, opts = {})
+      result_count = opts[:result_count] || 1
+      timeout = opts[:timeout] || -1
+
+      return [] if result_count <= 0
+
+      response = EM.schedule_sync do |promise|
+        results = []
+
+        sid = request(subject, encode(data), max: result_count) do |data|
+          results << data
+          promise.deliver(results) if results.size == result_count
+        end
+
+        if timeout >= 0
+          internal_bus.timeout(sid, timeout, expected: result_count) do
+            promise.deliver(results)
+          end
+        end
+      end
+
+      response
+    end
+
+    def unsubscribe(subscription_id)
+      internal_bus.unsubscribe(subscription_id)
+    end
+
+    private
+
+    attr_reader :internal_bus
+
+    def run_handler(block, parsed_data, inbox, subject, type)
+      begin
+        block.yield(parsed_data, inbox)
+      rescue => e
+        @logger.error "exception processing #{type} for: '#{subject}' '#{parsed_data.inspect}' \n#{e.inspect}\n #{e.backtrace.join("\n")}"
+      end
+    end
+
+    def start_internal_bus_recovery
+      EM.defer do
+        @logger.info("Reconnected to internal_bus.")
+
+        @recovery_callback.call
+
+        @subscriptions.each do |subject, options|
+          @logger.info("Resubscribing to #{subject}")
+          subscribe(subject, options[0], &options[1])
+        end
+      end
+    end
+
+    def subscribe_on_reactor(subject, opts = {}, &blk)
+      EM.schedule do
+        internal_bus.subscribe(subject, opts) do |msg, inbox|
+          process_message(msg, inbox, &blk)
+        end
+      end
+    end
+
+    def process_message(msg, inbox, &block)
+      payload = JSON.parse(msg, symbolize_keys: true)
+      block.yield(payload, inbox)
+    rescue => e
+      @logger.error "exception parsing json: '#{msg}' '#{e.inspect}'"
+      block.yield({error: "JSON Parse Error: failed to parse", exception: e, message: msg}, inbox)
+    end
+
+    def encode(message)
+      unless message.nil? || message.is_a?(String)
+        message = JSON.dump(message)
+      end
+      message
+    end
+  end
+end

data/lib/cf_message_bus/message_bus_factory.rb

@@ -0,0 +1,9 @@
+require 'nats/client'
+
+module CfMessageBus
+  class MessageBusFactory
+    def self.message_bus(uri)
+      ::NATS.connect(uri: uri, max_reconnect_attempts: Float::INFINITY)
+    end
+  end
+end

data/lib/cf_message_bus/mock_message_bus.rb

@@ -0,0 +1,78 @@
+module CfMessageBus
+  class MockMessageBus
+    def initialize(config = {})
+      @logger = config[:logger]
+      @subscriptions = Hash.new { |hash, key| hash[key] = [] }
+      @requests = {}
+      @published_messages = []
+    end
+
+    def subscribe(subject, opts = {}, &blk)
+      @subscriptions[subject] << blk
+      subject
+    end
+
+    def publish(subject, message = nil, &callback)
+      @subscriptions[subject].each do |subscription|
+        subscription.call(symbolize_keys(message))
+      end
+
+      @published_messages.push({subject: subject, message: message, callback: callback})
+
+      callback.call if callback
+    end
+
+    def request(subject, data=nil, options={}, &blk)
+      @requests[subject] = blk
+      publish(subject, data)
+      subject
+    end
+
+    def synchronous_request(subject, data=nil, options={})
+    end
+
+    def unsubscribe(subscription_id)
+      @subscriptions.delete(subscription_id)
+      @requests.delete(subscription_id)
+    end
+
+    def recover(&block)
+      @recovery = block
+    end
+
+    def respond_to_request(request_subject, data)
+      block = @requests.fetch(request_subject) { lambda { |data| nil } }
+      block.call(symbolize_keys(data))
+    end
+
+    def do_recovery
+      @recovery.call if @recovery
+    end
+
+    def published_messages
+      @published_messages
+    end
+
+    def clear_published_messages
+      @published_messages.clear
+    end
+
+    def has_published?(subject)
+      @published_messages.find { |message| message[:subject] == subject }
+    end
+
+    def has_published_with_message?(subject, message)
+      @published_messages.find { |publication| publication[:subject] == subject && publication[:message] == message }
+    end
+
+    private
+
+    def symbolize_keys(hash)
+      return hash unless hash.is_a?(Hash)
+      hash.inject({}) do |memo, (key, value)|
+        memo[key.to_sym] = symbolize_keys(value)
+        memo
+      end
+    end
+  end
+end

data/lib/cf_message_bus/version.rb

@@ -0,0 +1,3 @@
+module CfMessageBus
+  VERSION = "0.0.1"
+end

data/lib/eventmachine/schedule_sync.rb

@@ -0,0 +1,27 @@
+require "vcap/concurrency"
+
+module EventMachine
+  # Runs a block on the reactor thread and blocks the current thread
+  # while waiting for the result.  If the block raises an exception,
+  # it will be re-thrown in the calling thread.
+  #
+  # @param [Block]  blk  The block to be executed on the reactor thread.
+  #
+  # @return [Object]  The result of calling blk.
+  def self.schedule_sync(&blk)
+    promise = VCAP::Concurrency::Promise.new
+    EM.schedule do
+      begin
+        if blk.arity > 0
+          blk.call(promise)
+        else
+          promise.deliver(blk.call)
+        end
+      rescue Exception => e
+        promise.fail(e)
+      end
+    end
+
+    promise.resolve
+  end
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: cf-message-bus
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- CloudFoundry Core Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: nats
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.26
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.26
+- !ruby/object:Gem::Dependency
+  name: vcap-concurrency
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcap-concurrency
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Abstraction layer around NATS messaging bus
+email:
+- cfpi-dev@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cf_message_bus/message_bus.rb
+- lib/cf_message_bus/message_bus_factory.rb
+- lib/cf_message_bus/mock_message_bus.rb
+- lib/cf_message_bus/version.rb
+- lib/cf_message_bus.rb
+- lib/eventmachine/schedule_sync.rb
+homepage: 
+licenses:
+- Apache
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Cloud Foundry message bus
+test_files: []