combi 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f32c087a7be58753b98c2453f2b30051eaf5abf5
+  data.tar.gz: 0204a9e540356da36488b94166bc7b479f49f29c
+SHA512:
+  metadata.gz: a7b26b16b375706f08da91f6e3fbdb3fa71423e2e3c9f1081a3f03ff65d1a1c1d9aa8ec1497311089f80fc2c57f61a1e72b741d8d59f0101b7755f5018276a13
+  data.tar.gz: 3e1e5784274ab360b7b165901244da15bdb7df3dfc2d3530e6bead4308c6c42250fe38e170f4710d6c1ccf0090177db2aa83d27f9dbbfce392b6f5c9fc18c193

data/.gitignore

@@ -0,0 +1,12 @@
+.rspec
+.rvmrc
+/.bundle
+/log/*
+/tmp/*
+/coverage/
+/spec/tmp/*
+.project
+.DS_Store
+Gemfile.lock
+
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 1uptalent
+
+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,100 @@
+combi: A mini bus for micro services
+====================================
+
+![A Volkswagen Combi](http://upload.wikimedia.org/wikipedia/commons/thumb/a/af/Volkswagen-rapunzel.jpg/640px-Volkswagen-rapunzel.jpg)
+
+###Implemented buses
+
+- In Process: for testing or fast running implementations
+- Web Sockets: for remote (may be behind proxy) clients
+- Queue: for inter server communications (based on AMQP)
+- HTTP: for consumer only services (not session, stateless). Probably will work in any TCP capable network
+
+## Disclaimer
+
+This is a work in progress. Expect serious refactors, breaking changes.
+
+## How to use
+
+###Server
+
+Define a new service:
+```
+module Service
+  module Salutation
+
+    def actions
+      [:salute]
+    end
+
+    def say_hello(params)
+      "hello #{params['name']}"
+    end
+
+  end
+end
+```
+Launch the server (web sockets):
+```
+require 'combi'
+require 'combi/reactor'
+require 'em-websocket'
+
+Combi::Reactor.start
+bus = Combi::ServiceBus.for(:web_socket)
+bus.start!
+bus.add_service(Service::Salutation)
+
+ws_handler = Class.new do
+  def new_session(arg); end
+end.new
+
+port = 9292
+EM::next_tick do
+  EM::WebSocket.start(host: '0.0.0.0', port: port) do |ws|
+    bus.manage_ws_event(ws, ws_handler)
+  end
+end
+Combi::Reactor.join_thread
+```
+
+###Client
+Launch the client (web sockets):
+```
+require 'combi'
+require 'combi/reactor'
+Combi::Reactor.start
+
+ws_handler = Class.new do
+  def on_open; end
+end.new
+
+port = 9292
+bus = Combi::ServiceBus.for(:web_socket, remote_api: "ws://localhost:#{port}/", handler: ws_handler)
+bus.start!
+
+request = bus.request(:salute, :say_hello, {name: 'world'}) # :salute is the name of action declared in service
+request.callback do |response|
+  puts "Server says: #{response}"
+end
+
+Combi::Reactor.join_thread
+```
+
+## Testing
+
+`rspec`, the integration suite, test services requesting other services through other buses (compisition).
+
+For AMQP buses, a RabbitMQ server is required. We provide a setup/teardown based in docker.
+
+OSX users, you will need docker and boot2docker installed.
+Linux users, you will need docker installed, and make some adjustments to spec/support/rabbitmq_server.rb (the ssh tunnel is not needed)
+
+##Contributors
+
+[Abel Muino](https://twitter.com/amuino)
+[German DZ](https://twitter.com/GermanDZ)
+
+## License
+
+MIT License.

data/combi.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'combi/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'combi'
+  s.version     = Combi::VERSION
+  s.summary     = 'Mini Bus for microservices'
+  s.description = 'Provides implementation for in process, amqp or web socket service bus'
+  s.authors     = ['German Del Zotto', 'Abel Muiño']
+  s.email       = ['germ@ndz.com.ar', 'amuino@1uptalent.com']
+  s.files       = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  s.homepage    = 'https://github.com/1uptalent/combi'
+  s.license     = 'MIT'
+  s.add_dependency 'yajl-ruby', '~> 1.2.0'
+  s.add_development_dependency 'rspec-given', '~> 3.5.4'
+  s.add_development_dependency 'amqp', '~> 1.3.0'
+  s.add_development_dependency 'faye-websocket', '~> 0.7.2'
+  s.add_development_dependency 'em-websocket', '~> 0.5.1'
+  s.add_development_dependency 'thin', '~> 1.6.2'
+  s.add_development_dependency 'em-synchrony', '~> 1.0.3'
+  s.add_development_dependency 'em-http-request', '~> 1.1.2'
+  s.add_development_dependency 'evented-spec', '~> 0.9.0'
+end

data/lib/combi.rb

@@ -0,0 +1,2 @@
+require 'combi/version'
+require 'combi/service_bus'

data/lib/combi/buses/bus.rb

@@ -0,0 +1,82 @@
+require "combi/service"
+require 'yajl'
+require 'yajl/json_gem' # for object.to_json, JSON.parse, etc...
+
+module Combi
+  class Bus
+    attr_reader :services
+
+    RPC_DEFAULT_TIMEOUT = 1
+    RPC_MAX_POLLS = 10
+
+    def initialize(options)
+      @options = options
+      @services = []
+      post_initialize
+    end
+
+    def post_initialize
+    end
+
+    def add_service(service_definition, options = {})
+      service = make_service_instance(service_definition)
+      service.setup(self, options[:context])
+      @services << service
+    end
+
+    def start!
+    end
+
+    def stop!
+    end
+
+    def restart!
+      stop!
+      start!
+    end
+
+    def enable(services)
+      services.each do |service|
+        case service
+        when :queue
+          require 'queue_service'
+          EventMachine.run do
+            Combi::QueueService.start ConfigProvider.for(:amqp)
+          end
+        when :redis
+          require 'redis'
+          $redis = Redis.new ConfigProvider.for(:redis)
+        when :active_record
+          require 'active_record'
+          ActiveRecord::Base.establish_connection ConfigProvider.for(:database)
+        when :bus
+          $service_bus = Combi::ServiceBus.for(:queue)
+        end
+      end
+    end
+
+    def log(message)
+      return unless @debug_mode ||= ENV['DEBUG'] == 'true'
+      puts "#{object_id} #{self.class.name} #{message}"
+    end
+
+    protected
+
+    def make_service_instance(service_definition)
+      if Combi::Service === service_definition
+        service = service_definition
+      else
+        service = create_service_from_module(service_definition)
+      end
+    end
+
+    def create_service_from_module(a_module)
+      service_class = Class.new do
+        include Combi::Service
+        include a_module
+      end
+      service = service_class.new
+    end
+
+  end
+end

data/lib/combi/buses/http.rb

@@ -0,0 +1,88 @@
+require 'combi/buses/bus'
+require 'combi/response_store'
+require 'em-http-request'
+
+module Combi
+  class Http < Bus
+
+    class Server
+
+      def initialize(bus)
+        @bus = bus
+      end
+
+      def on_message(request)
+        path = request.path.split('/')
+        message = {
+          "service" => path[1],
+          "kind" => path[2],
+          "payload" => JSON.parse(request.body)
+        }
+        @bus.on_message(message)
+      end
+
+    end
+
+    class Client
+
+      def initialize(remote_api, handler, bus)
+        @handler = handler
+        @remote_api = remote_api
+        @bus = bus
+      end
+
+    end
+
+    def post_initialize
+      @response_store = Combi::ResponseStore.new
+      if @options[:remote_api]
+        @machine = Client.new(@options[:remote_api], @options[:handler], self)
+      else
+        @machine = Server.new(self)
+      end
+    end
+
+    def manage_request(env)
+      @machine.on_message Rack::Request.new(env)
+    end
+
+    def on_message(message)
+      service_name = message['service']
+      handler = handlers[service_name.to_s]
+      if handler
+        service_instance = handler[:service_instance]
+        kind = message['kind']
+        if service_instance.respond_to? kind
+          message['payload'] ||= {}
+          response = service_instance.send(kind, message['payload'])
+          {result: 'ok', response: response}
+        end
+      end
+    end
+
+    def respond_to(service_instance, handler, options = {})
+      handlers[handler.to_s] = {service_instance: service_instance, options: options}
+    end
+
+    def handlers
+      @handlers ||= {}
+    end
+
+    def request(name, kind, message, options = {})
+      options[:timeout] ||= RPC_DEFAULT_TIMEOUT
+
+      correlation_id = rand(10_000_000).to_s
+      waiter = EventedWaiter.wait_for(correlation_id, @response_store, options[:timeout])
+      url = "#{@options[:remote_api]}#{name}/#{kind}"
+      request_async = EventMachine::HttpRequest.new(url, connection_timeout: options[:timeout]).post(body: message.to_json)
+      request_async.callback do |r|
+        waiter.succeed(JSON.parse(r.response)['response'])
+      end
+      request_async.errback do |x|
+        waiter.fail(RuntimeError.new(Timeout::Error))
+      end
+      waiter
+    end
+
+  end
+end

data/lib/combi/buses/in_process.rb

@@ -0,0 +1,45 @@
+require 'combi/buses/bus'
+
+module Combi
+  class InProcess < Bus
+
+    def request(handler_name, kind, message, options = {})
+      options[:timeout] ||= RPC_DEFAULT_TIMEOUT
+      handler = memory_handlers[handler_name.to_s]
+      return if handler.nil?
+      service_instance = handler[:service_instance]
+      message = JSON.parse(message.to_json)
+      return unless service_instance.respond_to?(kind)
+      waiter = EventMachine::DefaultDeferrable.new
+      waiter.timeout(options[:timeout], RuntimeError.new(Timeout::Error))
+      begin
+        Timeout.timeout(options[:timeout]) do
+          response = service_instance.send(kind, message)
+          if response.respond_to? :succeed
+            response.callback do |service_response|
+              waiter.succeed service_response
+            end
+          else
+            waiter.succeed response
+          end
+        end
+      rescue Timeout::Error => e
+        log "ERROR"
+        waiter.fail RuntimeError.new(Timeout::Error)
+      rescue e
+        log "other ERROR"
+        log e.inspect
+      end
+      waiter
+    end
+
+    def respond_to(service_instance, handler, options = {})
+      memory_handlers[handler.to_s] = {service_instance: service_instance, options: options}
+    end
+
+    def memory_handlers
+      @memory_handlers ||= {}
+    end
+
+  end
+end

data/lib/combi/buses/queue.rb

@@ -0,0 +1,86 @@
+require 'combi/buses/bus'
+require 'combi/response_store'
+require 'combi/queue_service'
+
+module Combi
+  class Queue < Bus
+    attr_reader :queue_service
+
+    def initialize(options)
+      super
+      @response_store = Combi::ResponseStore.new
+      @queue_service = Combi::QueueService.new(options[:amqp_config], rpc: :enabled)
+      queue_service.rpc_callback = lambda do |message|
+        @response_store.handle_rpc_response(message)
+      end
+    end
+
+    def start!
+      queue_service.start
+    end
+
+    def stop!
+      queue_service.ready do
+        @queue_service.disconnect
+      end
+    end
+
+    def respond_to(service_instance, handler, options = {})
+      log "registering #{handler}"
+      queue_options = {}
+      subscription_options = {}
+      if options[:fast] == true
+        queue_options[:auto_delete] = false
+      else
+        subscription_options[:ack] = true
+      end
+      queue_service.ready do
+        queue_service.queue(handler.to_s, queue_options) do |queue|
+          log "subscribing to queue #{handler.to_s} with options #{queue_options}"
+          queue.subscribe(subscription_options) do |delivery_info, payload|
+            respond service_instance, payload, delivery_info
+            queue_service.acknowledge delivery_info unless options[:fast] == true
+          end
+        end
+      end
+    end
+
+    def request(name, kind, message, options = {})
+      options[:timeout] ||= RPC_DEFAULT_TIMEOUT
+      options[:routing_key] = name.to_s
+      correlation_id = rand(10_000_000).to_s
+      options[:correlation_id] = correlation_id
+      waiter = EventedWaiter.wait_for(correlation_id, @response_store, options[:timeout])
+      queue_service.ready do
+        log "Making request: #{name}.#{kind} #{message.inspect}\t|| #{options.inspect}"
+        queue_service.call(kind, message, options)
+      end
+      waiter
+    end
+
+    def respond(service_instance, request, delivery_info)
+      message = JSON.parse request
+      kind = message['kind']
+      payload = message['payload']
+      options = message['options']
+      unless service_instance.respond_to?(kind)
+        log "Service instance does not respond to #{kind}: #{service_instance.inspect}"
+        return
+      end
+      log "generating response for #{service_instance.class}#{service_instance.actions.inspect}.#{kind} #{payload.inspect}"
+      response = service_instance.send(kind, payload)
+
+      if response.respond_to? :succeed
+        log "response is deferred"
+        response.callback do |service_response|
+          log "responding with deferred answer: #{service_response.inspect}"
+          queue_service.respond(service_response, delivery_info)
+        end
+      else
+        log "responding with inmediate answer: #{response.inspect}"
+        queue_service.respond(response, delivery_info) unless response.nil?
+      end
+    end
+
+  end
+end