rabbit_rpc 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dfc96f46c3426bcc0d99bc1bb4e5915b21fbfe9b
+  data.tar.gz: a79352d3a4ddc718970493cc715d24e13c891ad0
+SHA512:
+  metadata.gz: 9cb7b84171dd10688b417d5d28fc1bc8899785949b51f17b5961668f48268f1b7e309b2b33bf721f72ae1cadbb7b5848ef0eb0582b55bd4707804da6db4a05b1
+  data.tar.gz: 5a2e9cc981bbaef8ee781b205941afd721f2f682527229903118218a7de345b7e434a8a1cb59e81f1248ced3529c4c4163c411e72561f21184ca96fbed7a2ccd

data/.gitignore

@@ -0,0 +1,19 @@
+.ruby-version
+.ruby-gemset
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in caerbannog.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sohaib Bhatti
+
+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,119 @@
+# RabbitRPC
+
+RabbitRPC helps in the rapid development of ruby services and their RPC
+invocation over RabbitMQ in a service-oriented architecture.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rabbit_rpc'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rabbit_rpc
+
+## Getting Started
+
+Rabbit-RPC can be broadly divided into two parts. EventMachine servers that
+consume messages over RabbitMQ and an RPC invocation interface used for
+producing messages.
+
+### Implementing Services(RabbitMQ Consumers)
+
+Services can easily be defined via Rabbit-RPC.
+
+```ruby
+class AuthorizationService
+  class << self
+
+    def auth(email, pass)
+      {
+        ok:    true,
+        email: email,
+        pass:  pass
+      }
+    end
+  end
+end
+```
+
+Once the services have been implemented and are loaded into loaded into
+the global namespace, the service can then establish a connection with
+RabbitMQ and start consuming messages.
+
+```ruby
+RabbitRPC::Connection.new(QUEUE_NAME, QUEUE_ADDRESS).listen!
+```
+
+Methods expected to send a response back to the RPC invocator,
+will encode the response message and produce them on a callback queue.
+
+Methods defined with the "one_way" prefix will not send a response back
+to the RPC invocator. 
+
+### RPC Invocation
+
+RPC invocations, whether they're for services to communicate with one
+another or for the user facing web server(Rails or Sinatra) to
+communicate with the various services can be defined on an individual
+basis. The reasoning behind this is that each service does not
+necessarily need access to all other services and their corresponding
+methods
+
+By default, Rabbit-RPC expects a rabbit_rpc.yml file to present in the config
+folder of the ruby app.This YAML file contains a definition of the names
+of the services(queue names), their corresponding RabbitMQ URLs and
+which method calls should exist.
+
+```yml
+UserService:
+  address: amqp://localhost:5672
+  methods:
+    User: create, read, delete
+    Authorization: auth
+
+EntertainmentService
+  address: amqp://localhost:5672
+  methods:
+    Movie: likes
+    Music: likes
+```
+
+Rabbit-RPC relies on some conventions for it to work. 
+ - The names of the services and their RabbitMQ queue names are the same.
+ - A service might be responsible for multiple functionaly. For the YAML
+   example above, the UserService is responsible for both the CRUD and
+   authentication of users. The service object is they key, and its
+   methods are provided by comma serperated values.
+ - Unless a method is defined with a "one_way" prefix, the RPC client
+   will wait for a a response in a synchronous fashion.
+
+```ruby
+  RabbitRPC::Config.initialize!
+  RabbitRPC::Client::UserService::Authorization.auth 'username', 'password'
+  => {"ok"=>true, "email"=>"username", "password"=>"password"}
+
+  RabbitRPC::Client::UserService::User.one_way_send_mail
+  => nil
+```
+
+## Example
+
+A sample implementation of a service and RPC invocation can be seen [here.](https://github.com/sohaibbhatti/rabbit_rpc_example)
+
+## Contributing
+
+As with all gems in their infancy. Rabbit-RPC is in a skeletal state. Some
+of the code especially related to the Synchronous connection can be
+optimized.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rabbit_rpc.rb

@@ -0,0 +1,17 @@
+require "rabbit_rpc/version"
+require "rabbit_rpc/logging"
+require "rabbit_rpc/message"
+require "rabbit_rpc/message_parser"
+require "rabbit_rpc/config"
+require "rabbit_rpc/client"
+require "rabbit_rpc/synchronous_connection"
+require "rabbit_rpc/request_handler"
+require "rabbit_rpc/connection"
+
+module RabbitRPC
+
+  def self.logger
+    RabbitRPC::Logging.logger
+  end
+
+end

data/lib/rabbit_rpc/client.rb

@@ -0,0 +1,5 @@
+module RabbitRPC
+  # RPC methods and services are created in the RabbitRPC::Client namespace
+  # Refer to the Config.initialize! method
+  module Client; end
+end

data/lib/rabbit_rpc/config.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+require 'active_support/inflector'
+
+module RabbitRPC
+  class InvalidFormatError < StandardError; end
+
+  class Config
+    @@service_address = {}
+
+    class << self
+
+      def client_rpc_path
+        @@rpc_path ||= File.join 'config', 'rabbit_rpc.yml'
+      end
+
+      def client_rpc_path=(path)
+        @@rpc_path = path
+      end
+
+      # Traverses through the RPC YAML file and creates RPC invocations
+      # under the RabbitRPC::Client namespace.
+      #
+      # UserService:
+      #   Authorization: auth
+      #   Friend: list, delete
+      #
+      # RabbitRPC::Client::UserService::Friends.list
+      # TODO: Abstract this logic into a seperate class
+      def initialize!
+        YAML.load_file(client_rpc_path).each do |service_name, class_definitions|
+          unless class_definitions.is_a?(Hash) && class_definitions.keys.sort == %w[address methods]
+            raise InvalidFormatError, "Error parsing the structure of the RPC YAML"
+          end
+
+          mdule        = Module.new
+          service_name = "#{service_name}".classify
+
+          ::RabbitRPC::Client.const_set service_name, mdule
+          class_definitions.each do |param, value|
+            if is_address?(param)
+              @@service_address ||= {}
+              @@service_address[service_name] = value
+            elsif is_method_declaration?(param)
+              populate_rpc(service_name, value)
+            end
+          end
+        end
+      end
+
+      private
+
+      def is_address?(key)
+        key == 'address'
+      end
+
+      def is_method_declaration?(key)
+        key == 'methods'
+      end
+
+      def populate_rpc(service_name, class_and_methods)
+        if @@service_address[service_name].nil?
+          raise InvalidFormatError, "The address declaration in the YAML file appears to be missing for #{service_name}"
+        end
+
+        class_and_methods.each do |klass_name, methods|
+          klass_name = klass_name.classify
+
+          klass = Class.new do
+            methods.gsub(/\s+/, "").split(',').each do |method_name|
+              define_singleton_method(method_name) do |*args|
+
+                RabbitRPC::SynchronousConnection.new(
+                  service_name,
+                  "#{service_name}.callback",
+                  @@service_address[service_name]).publish!(RabbitRPC::Message.new("#{klass_name}Service.#{method_name}", *args))
+              end
+            end
+          end
+
+          "RabbitRPC::Client::#{service_name}".constantize.const_set(klass_name, klass)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/rabbit_rpc/connection.rb

@@ -0,0 +1,80 @@
+require 'amqp'
+
+#TODO: RabbitMQ connection options
+module RabbitRPC
+  class Connection
+    PREFETCH_DEFAULT = 5
+
+    include Logging
+
+    attr_reader :queue_name, :uri, :opts, :prefetch
+
+    def initialize(queue_name, uri, prefetch, opts = {})
+      @queue_name = queue_name
+      @uri        = uri
+      @opts       = opts
+      @prefetch   = prefetch || PREFETCH_DEFAULT
+    end
+
+    def listen!
+      EventMachine.run do
+        close_connection_on_interrupt
+        subscribe_to_queue
+      end
+    end
+
+    private
+
+    def subscribe_to_queue
+      queue.subscribe do |metadata, payload|
+
+        EM.defer do
+          request_handler  = RequestHandler.new(payload)
+          response_message = request_handler.execute
+
+
+          unless request_handler.one_way
+
+            channel.default_exchange.publish(
+              response_message.to_msgpack,
+              routing_key:    metadata.reply_to,
+              correlation_id: metadata.message_id,
+              mandatory:      true
+            )
+          end
+
+        end
+      end
+    end
+
+    def connect!
+      connection_params = ::AMQP::Client.parse_connection_uri @uri
+      connection_params.merge! @opts
+      logger.info 'Connecting to RabbitMQ'
+      @connection ||= ::AMQP.connect connection_params
+    end
+
+    def channel
+      logger.info 'Establishng connection with channel'
+      @channel ||= ::AMQP::Channel.new connect!, prefetch: @prefetch
+    end
+
+    # Private - Establish connection with a RabbitMQ queue.
+    # TODO: Queue options need to be provided
+    def queue
+      logger.info 'Connecting to queue'
+      @queue ||= channel.queue @queue_name
+    end
+
+    def close_connection_on_interrupt
+      %w[INT TERM].each do |interrupt_type|
+        Signal.trap(interrupt_type) do
+          logger.info 'Exiting'
+          @connection.close do
+            EventMachine.stop { exit }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit_rpc/logging.rb

@@ -0,0 +1,32 @@
+require 'logger'
+
+module RabbitRPC
+
+  module Logging
+
+    def self.included(base)
+      base.send :include, Methods
+      base.extend Methods
+    end
+
+    module Methods
+      def logger
+        RabbitRPC::Logging.logger
+      end
+
+      # TODO: logger options
+      def log_exception(ex)
+        RabbitRPC::Logging.log_exception(ex)
+      end
+    end
+
+    def self.logger(target = $stdout)
+      @logger ||= Logger.new(target)
+    end
+
+    def self.log_exception(ex)
+      logger.error ('Message: ' + ex.message)
+      logger.error (['backtrace:'] + ex.backtrace).join("\n")
+    end
+  end
+end

data/lib/rabbit_rpc/message.rb

@@ -0,0 +1,43 @@
+require 'msgpack'
+
+module RabbitRPC
+  class Message
+
+    attr_reader :method_name, :args
+
+    def initialize(method_name, *args)
+      @method_name = method_name
+      @args        = args
+    end
+
+    # Squeezes and serializes the RPC method name and arguments
+    #
+    # Returns the packed and serialized string
+    def pack
+      serialize(method: @method_name, args: @args)
+    end
+
+    # Unpacks a serialized message to a hash containing the method and
+    # its args. This method needs to be modified if a serializer other
+    # than MessagePack is to be used.
+    #
+    # Returns a Hash
+    def self.unpack(message)
+      MessagePack.unpack message
+    end
+
+    def self.generate_id
+      SecureRandom.uuid
+    end
+
+    private
+
+    # Private: Serialize the message. Currently using message pack. The
+    # implementation can be changed in order to use some other serializer.
+    #
+    # Returns the serialized String
+    def serialize(message)
+      message.to_msgpack
+    end
+  end
+end

data/lib/rabbit_rpc/message_parser.rb

@@ -0,0 +1,36 @@
+module RabbitRPC
+  class MessageParserException; end
+
+  class MessageParser
+    attr_reader :service_name, :method_name
+
+    # methods with the following prefix will not wait
+    # for a response
+    ONE_WAY_PREFIX = 'one_way'
+
+    def initialize(message)
+      @message = message
+    end
+
+    # Public: Extracts the Service name and method name
+    #
+    # Examples
+    #
+    #  "UserService.create"
+    #  # => "UserService", "create"
+    #
+    # Returns nothing
+    def parse
+      method = @message.is_a?(RabbitRPC::Message) ? @message.method_name : @message['method']
+      @service_name, @method_name = method.split('.')
+    end
+
+    # Public: Identifies whether a wait for a response is expected
+    #
+    # Returns a Boolean
+    def one_way?
+      parse if @method_name.nil?
+      @method_name.start_with?(ONE_WAY_PREFIX)
+    end
+  end
+end

data/lib/rabbit_rpc/request_handler.rb

@@ -0,0 +1,37 @@
+module RabbitRPC
+  class RequestHandler
+    include Logging
+
+    attr_reader :one_way
+
+    def initialize(serialized_message)
+      @message = Message.unpack serialized_message
+    end
+
+    def execute
+      parser = MessageParser.new(@message)
+      parser.parse
+
+      @one_way = parser.one_way?
+
+      logger.info "Received message #{@message}"
+
+      Kernel.const_get(parser.service_name).send(parser.method_name, *@message['args'] )
+    rescue ArgumentError => e
+      log_exception(e)
+      { ok: false, message: e.message }
+    rescue Exception => e
+      log_exception(e)
+      exception_response
+    end
+
+    private
+
+    # We do not want to return the actual exceptions back
+    # TODO: Perhaps have this user defined?
+    def exception_response
+      { ok: false, message: 'Error processing request' }
+    end
+
+  end
+end

data/lib/rabbit_rpc/synchronous_connection.rb

@@ -0,0 +1,81 @@
+require 'bunny'
+require 'active_support/core_ext/object/try'
+
+#TODO: Implement callback queue timeout
+#TODO: RabbitMQ connection options
+module RabbitRPC
+  # Connects to RabbitMQ for blocking RPC calls.
+  # Wait for a response when querying other services
+  class SynchronousConnection
+    DEFAULT_HEARTBEAT = 30
+
+    include Logging
+
+    # RabbitMQ related info
+    attr_reader :queue_name, :callback_queue_name, :rabbit_mq_url, :heartbeat
+
+    # Message unique identifier and resposne
+    attr_reader :message_id, :response
+
+    def initialize(queue_name, callback_queue_name, rabbit_mq_url, heart_beat = nil)
+      @queue_name          = queue_name
+      @callback_queue_name = callback_queue_name
+      @rabbit_mq_url       = rabbit_mq_url
+      @heartbeat           = heart_beat || DEFAULT_HEARTBEAT
+
+      @message_id          = Message.generate_id
+    end
+
+    def publish!(unpacked_message)
+      connect!
+
+      send_request(unpacked_message.pack)
+
+      if wait_for_response?(unpacked_message)
+        callback_queue.subscribe(block: true, ack: true) do |delivery_info, properties, payload|
+          if message_id == properties.try(:[],:correlation_id)
+            @channel.acknowledge(delivery_info.delivery_tag, false)
+            @response = Message.unpack payload
+
+            logger.info "Received message #{@response}"
+            delivery_info.consumer.cancel
+          end
+        end
+
+        return @response
+      end
+
+      return response
+    end
+
+    private
+
+    def connect!
+      @connection = Bunny.new(@rabbit_mq_url, heartbeat: @heartbeat).start
+      @channel    = @connection.create_channel
+    end
+
+    def callback_queue
+      @channel.queue(@callback_queue_name, auto_delete: false)
+    end
+
+    def exchange
+      @exchange ||= @channel.default_exchange
+    end
+
+    def send_request(message)
+      exchange.publish(
+        message,
+        routing_key: @queue_name,
+        message_id:  @message_id,
+        reply_to:    @callback_queue_name,
+        auto_delete: false
+      )
+    end
+
+    def wait_for_response?(message)
+      !MessageParser.new(message).one_way?
+    end
+
+  end
+end

data/lib/rabbit_rpc/version.rb

@@ -0,0 +1,3 @@
+module RabbitRPC
+  VERSION = "0.0.2"
+end

data/rabbit_rpc.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rabbit_rpc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rabbit_rpc"
+  spec.version       = RabbitRPC::VERSION
+  spec.authors       = ["Sohaib Bhatti"]
+  spec.email         = ["sohaibbbhatti@gmail.com"]
+  spec.description   = %q{Framework for developing services and workers using RabbitMQ}
+  spec.summary       = %q{Ruby RabbitMQ framework}
+  spec.homepage      = "https://github.com/sohaibbhatti/rabbit_rpc"
+  spec.license       = "MIT"
+
+  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 "msgpack", "~> 0.5.8"
+  spec.add_dependency "active_support", "~> 3.0.0"
+  spec.add_dependency "bunny", "~> 0.10.8"
+  spec.add_dependency "amqp", "~> 1.0.4"
+
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "evented-spec"
+end

data/spec/config_spec.rb

@@ -0,0 +1,49 @@
+require 'rabbit_rpc'
+
+describe RabbitRPC::Config do
+  describe '.client_rpc_path' do
+    it 'assumes the file to be present in the config folder by default' do
+      RabbitRPC::Config.client_rpc_path.should == 'config/rabbit_rpc.yml'
+    end
+
+    it 'returns the configured value' do RabbitRPC::Config.client_rpc_path = 'foo/bar.yml'
+      RabbitRPC::Config.client_rpc_path.should == 'foo/bar.yml'
+    end
+  end
+
+  describe '.initialize!' do
+    context 'with a valid YAML file' do
+      before do
+        RabbitRPC::Config.client_rpc_path = 'spec/support/rpc.yaml'
+        RabbitRPC::Config.initialize!
+      end
+
+      it 'reads the client rpc file and initializes classes under the Client namespace' do
+        %w[create read delete].each do |meth|
+          RabbitRPC::Client::UserService::User.should respond_to meth
+        end
+
+        RabbitRPC::Client::UserService::Auth.should respond_to 'authorize'
+      end
+
+      it 'successfully encodes the messages with the proper arguments' do
+        # Do not wait for response
+        RabbitRPC::SynchronousConnection.any_instance.stub(:publish!).and_return(true)
+
+        RabbitRPC::Message.should_receive(:new).with('AuthService.authorize', 'omg', 'this', 'works'). \
+          and_call_original
+        RabbitRPC::Client::UserService::Auth.authorize 'omg', 'this', 'works'
+      end
+    end
+
+    it 'raises an exception if the address of the service is missing in the yml file' do
+      RabbitRPC::Config.client_rpc_path = 'spec/support/rpc_no_address.yaml'
+      expect { RabbitRPC::Config.initialize! }.to raise_error(RabbitRPC::InvalidFormatError)
+    end
+
+    it 'raises and exception if method definition is not decipherable' do
+      RabbitRPC::Config.client_rpc_path = 'spec/support/rpc_invalid_structure.yaml'
+      expect { RabbitRPC::Config.initialize! }.to raise_error(RabbitRPC::InvalidFormatError)
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,71 @@
+require 'rabbit_rpc'
+require 'evented-spec'
+
+describe RabbitRPC::Connection do
+  include EventedSpec::EMSpec
+  let(:connection) { RabbitRPC::Connection.new('UserService', 'amqp://localhost:5672', 5) }
+  let(:sync_connection) { RabbitRPC::SynchronousConnection.new('UserService', 'UserService.callback', 'amqp://localhost:5672') }
+  let(:exchange) { double 'exchange', publish: true }
+
+  it 'connects to the the specified rabbitMQ queue' do
+    em do
+      ::AMQP::Channel.any_instance.should_receive(:queue).with('UserService').and_call_original
+      connection.listen!
+      done(0.5)
+    end
+  end
+
+  it 'attempts to execute received messages' do
+    RabbitRPC::SynchronousConnection.new('UserService', 'UserService.callback', 'amqp://localhost:5672').publish!(RabbitRPC::Message.new('User.one_way_create'))
+
+    em do
+      RabbitRPC::RequestHandler.should_receive(:new).at_least(1).times.with(RabbitRPC::Message.new('User.one_way_create').pack).and_call_original
+      connection.listen!
+      done(0.5)
+    end
+  end
+
+  context 'when the client expects a response' do
+
+    it 'sends a response to the callback queue' do
+      RabbitRPC::Message.stub(:generate_id).and_return 'omg'
+      ::AMQP::Channel.any_instance.stub(:default_exchange).and_return exchange
+
+      send_message_expecting_response
+
+      em do
+        exchange.should_receive(:publish).with(anything(), routing_key: 'UserService.callback', correlation_id: 'omg', mandatory: true)
+        connection.listen!
+        done(0.5)
+      end
+    end
+  end
+
+  context 'when the client does not expect a response' do
+    it 'does not send a response to the callback queue' do
+      RabbitRPC::Message.stub(:generate_id).and_return 'omg'
+      ::AMQP::Channel.any_instance.stub(:default_exchange).and_return exchange
+
+      send_one_way_message
+
+      em do
+        exchange.should_not_receive(:publish).with(anything(), routing_key: 'UserService.callback', correlation_id: 'omg', mandatory: true)
+        connection.listen!
+        done(0.5)
+      end
+    end
+  end
+
+  # Disables the client blocking wait for receiving the message
+  # on the callback queue
+  def send_message_expecting_response
+    message = RabbitRPC::Message.new('User.create')
+    sync_connection.stub(:wait_for_response?).and_return(false)
+    sync_connection.publish! message
+  end
+
+  def send_one_way_message
+    message = RabbitRPC::Message.new('User.one_way_create')
+    sync_connection.publish! message
+  end
+end

data/spec/logging_spec.rb

@@ -0,0 +1,14 @@
+require 'rabbit_rpc'
+
+describe RabbitRPC::Logging do
+  let(:random_class) do
+    class RandomClass
+      include RabbitRPC::Logging
+    end
+  end
+
+  it 'grants the class and its objects the ability to log' do
+    random_class.logger.should be_instance_of Logger
+    random_class.new.logger.should be_instance_of Logger
+  end
+end

data/spec/message_parser_spec.rb

@@ -0,0 +1,50 @@
+require 'rabbit_rpc'
+
+describe RabbitRPC::MessageParser do
+  let(:message) { {'method' => 'UserService.create', 'args' => [1, 2, 3] } }
+  let(:one_way) { {'method' => 'AuthService.one_way_delete', 'args' => [1, 2, 3] } }
+
+  describe '#one_way?' do
+    it 'determines if the method begins with the one_way prefix' do
+      example_one = RabbitRPC::MessageParser.new(message)
+      example_one.parse
+      example_one.one_way?.should be_false
+
+      example_two = RabbitRPC::MessageParser.new(one_way)
+      example_two.parse
+      example_two.one_way?.should be_true
+    end
+
+    context 'parser has not executed' do
+      it 'determines if the method begins with the one_way prefix' do
+        RabbitRPC::MessageParser.new(message).one_way?.should be_false
+        RabbitRPC::MessageParser.new(one_way).one_way?.should be_true
+      end
+    end
+  end
+
+  describe '#parse' do
+    it 'correctly identifies the name of the Service' do
+      example_one = RabbitRPC::MessageParser.new(message)
+      example_one.parse
+      example_one.service_name.should == 'UserService'
+
+      example_two = RabbitRPC::MessageParser.new(one_way)
+      example_two.parse
+      example_two.service_name.should == 'AuthService'
+    end
+
+    it 'correctly identifies the name of the method' do
+      example_one = RabbitRPC::MessageParser.new(message)
+      example_one.parse
+      example_one.method_name.should == 'create'
+
+      example_two = RabbitRPC::MessageParser.new(one_way)
+      example_two.parse
+      example_two.method_name.should == 'one_way_delete'
+    end
+
+    # Test case for message class and hash
+    # Invalid format?
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,36 @@
+require 'rabbit_rpc'
+
+describe RabbitRPC::Message do
+
+  describe '#pack' do
+    it 'succesfully shifts the RPC method and its arguments to a single datastructure' do
+      message = RabbitRPC::Message.new 'hello', 'argument_one', { optional: 'arguments' }
+      message.should_receive(:serialize).with(method: 'hello', args: ['argument_one', { optional: 'arguments' }])
+      message.pack
+    end
+
+    it 'succesfully handles the case of no arguments present' do
+      message = RabbitRPC::Message.new 'hello'
+      message.should_receive(:serialize).with(method: 'hello', args: [])
+      message.pack
+    end
+  end
+
+  describe '.unpack' do
+    it 'successfully converts the serialized message into a readable datastructure' do
+      message = RabbitRPC::Message.new 'hello', 'argument_one', { optional: 'arguments' }
+      RabbitRPC::Message.unpack(message.pack).should == {
+        'method' => 'hello',
+        'args'  => ['argument_one', { 'optional' => 'arguments' }]
+      }
+    end
+  end
+
+  describe '.generate_id' do
+    it 'generates random values' do
+      RabbitRPC::Message.generate_id.should_not be_nil
+      RabbitRPC::Message.generate_id.should_not == RabbitRPC::Message.generate_id
+    end
+  end
+end
+

data/spec/request_handler_spec.rb

@@ -0,0 +1,45 @@
+require 'rabbit_rpc'
+
+describe RabbitRPC::RequestHandler do
+  let!(:sample_service) do
+    class UserService
+      def self.create
+        'woot'
+      end
+    end
+  end
+  let(:message)         { RabbitRPC::Message.new 'UserService.create' }
+  let(:one_way_message) { RabbitRPC::Message.new 'UserService.one_way_create' }
+  let(:invalid_message) { RabbitRPC::Message.new 'Usvice.create' }
+  let(:invalid_args_message) { RabbitRPC::Message.new 'UserService.create', 'args' }
+
+  describe '#execute' do
+    it 'succesfully executes the request method' do
+      RabbitRPC::RequestHandler.new(message.pack).execute.should == 'woot'
+    end
+
+    it 'identifies whether the method expects a response' do
+      handler = RabbitRPC::RequestHandler.new(message.pack)
+      handler.execute
+      handler.one_way.should be_false
+
+      handler = RabbitRPC::RequestHandler.new(one_way_message.pack)
+      handler.execute
+      handler.one_way.should be_true
+    end
+
+    it 'returns an exception message in the event of errors' do
+      RabbitRPC::RequestHandler.new(invalid_message.pack).execute.should == {
+        ok: false,
+        message: 'Error processing request'
+      }
+    end
+
+    it 'returns an error notifying an Argument error' do
+      RabbitRPC::RequestHandler.new(invalid_args_message.pack).execute.should == {
+        ok: false,
+        message: 'wrong number of arguments (1 for 0)'
+      }
+    end
+  end
+end

data/spec/support/rpc.yaml

@@ -0,0 +1,5 @@
+UserService:
+  address: amqp:://localhost:5672
+  methods:
+    User: create, read, delete
+    Auth: authorize

data/spec/support/rpc_invalid_structure.yaml

@@ -0,0 +1,2 @@
+Invalid: Format
+Foo: Bar

data/spec/support/rpc_no_address.yaml

@@ -0,0 +1,4 @@
+UserService:
+  methods:
+    User: create, read, delete
+    Auth: authorize

data/spec/synchronous_connection_spec.rb

@@ -0,0 +1,41 @@
+require 'rabbit_rpc'
+
+describe RabbitRPC::SynchronousConnection do
+  describe '#publish!' do
+    let(:connection)      { RabbitRPC::SynchronousConnection.new('foo', 'bar', 'amqp:://localhost:5672') }
+    let(:exchange)        { double 'exchange', publish: true }
+    let(:message)         { RabbitRPC::Message.new 'User.create', 'bar' }
+    let(:one_way_message) { RabbitRPC::Message.new 'User.one_way_create', 'bar' }
+    let(:queue)           { double 'queue', subscribe: true }
+
+    before do
+      connection.stub(:exchange).and_return exchange
+      connection.stub(:callback_queue).and_return queue
+    end
+
+    it 'sends a message to the relevant queue' do
+      exchange.should_receive(:publish).with(
+        message.pack,
+        routing_key: 'foo',
+        message_id:  anything(),
+        reply_to:    'bar',
+        auto_delete: false
+      )
+      connection.publish! message
+    end
+
+    context 'when a response is expected' do
+      it 'subscribes to the callback queue to listen for a response' do
+        queue.should_receive :subscribe
+        connection.publish!(message)
+      end
+    end
+
+    context 'when no response is expected' do
+      it 'terminates' do
+        queue.should_not_receive :subscribe
+        connection.publish!(one_way_message)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: rabbit_rpc
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Sohaib Bhatti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.8
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: evented-spec
+  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: Framework for developing services and workers using RabbitMQ
+email:
+- sohaibbbhatti@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rabbit_rpc.rb
+- lib/rabbit_rpc/client.rb
+- lib/rabbit_rpc/config.rb
+- lib/rabbit_rpc/connection.rb
+- lib/rabbit_rpc/logging.rb
+- lib/rabbit_rpc/message.rb
+- lib/rabbit_rpc/message_parser.rb
+- lib/rabbit_rpc/request_handler.rb
+- lib/rabbit_rpc/synchronous_connection.rb
+- lib/rabbit_rpc/version.rb
+- rabbit_rpc.gemspec
+- spec/config_spec.rb
+- spec/connection_spec.rb
+- spec/logging_spec.rb
+- spec/message_parser_spec.rb
+- spec/message_spec.rb
+- spec/request_handler_spec.rb
+- spec/support/rpc.yaml
+- spec/support/rpc_invalid_structure.yaml
+- spec/support/rpc_no_address.yaml
+- spec/synchronous_connection_spec.rb
+homepage: https://github.com/sohaibbhatti/rabbit_rpc
+licenses:
+- MIT
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby RabbitMQ framework
+test_files:
+- spec/config_spec.rb
+- spec/connection_spec.rb
+- spec/logging_spec.rb
+- spec/message_parser_spec.rb
+- spec/message_spec.rb
+- spec/request_handler_spec.rb
+- spec/support/rpc.yaml
+- spec/support/rpc_invalid_structure.yaml
+- spec/support/rpc_no_address.yaml
+- spec/synchronous_connection_spec.rb