combi 0.1.0 → 0.2.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28565637d9bdb76e4bd9f256be6af0c89900ec25
-  data.tar.gz: 411ec39864499243853f42677ec76f3708c8c630
+  metadata.gz: ac4f813928579df4ccf43c961482b6291268d32f
+  data.tar.gz: b27cb7008850b414d42d45b1b8f7d177d59e32f9
 SHA512:
-  metadata.gz: 8a353643e81e81912a88a8b756cf29a12ba19982e6db5e09c34fd88d153041bf14434a6d609196c202336d99671f08f3bf49b9c1fde43b1f656c04b2b66b9fa2
-  data.tar.gz: 98151bf6b13683a2992a3e0078bfea21f136377fd33971bb5190893aaac1e3e63b1ff9940516ae2558959229eb36e2d668890630b728850424e1467cf0e27d1a
+  metadata.gz: e0e6d420d29afb6f115273e2c17d9ef24b2ddec8084e53df4b3e10c9ab58c221ae966e87b495ba93c22095b188bf78f3ae0247d4d071141801ede2f56a3de795
+  data.tar.gz: 8699fe145b26e9d58ae734fc8d1b9c44d911ce46df719d61036e01cf60db7d402986befd22723fe91689ba0c780cfa83e162cd7966512de8a3065cfe08d509ac

data/lib/combi/buses/bus.rb

@@ -1,17 +1,15 @@
 require "combi/service"
 require_relative 'correlation'
 require 'yajl'
-require 'yajl/json_gem' # for object.to_json, JSON.parse, etc...
 
 module Combi
   class Bus
-    attr_reader :services
-
     RPC_DEFAULT_TIMEOUT = 1
+    attr_reader :routes
 
     def initialize(options)
       @options = options
-      @services = []
+      @routes = {}
       post_initialize
     end
 
@@ -19,9 +17,14 @@ module Combi
     end
 
     def add_service(service_definition, options = {})
-      service = make_service_instance(service_definition)
-      service.setup(self, options[:context])
-      @services << service
+      service_instance = make_service_instance(service_definition)
+      service_instance.actions.each do |service_name|
+        self.add_routes_for(service_name, service_instance)
+      end
+      service_instance.fast_actions.each do |service_name|
+        self.add_routes_for(service_name, service_instance, fast: true)
+      end
+      service_instance.setup(self, options[:context])
     end
 
     def start!
@@ -74,23 +77,94 @@ module Combi
       service_class = Class.new do
         include Combi::Service
         include a_module
+
+        define_method :service_module do
+           a_module
+        end
+        protected :service_module
+
+        def remote_methods
+          @_REMOTE_METHODS ||= service_module.public_instance_methods(false) - [:actions]
+        end
+        def to_s
+          @_TO_S ||= "#{service_module.name || 'Annonymous'}"
+        end
+      end
+      service_class.new
+    end
+
+    def add_routes_for(service_name, service_instance, options = {})
+      service_instance.remote_methods.each do |method|
+        add_route_for(service_name, method, service_instance, options)
+      end
+    end
+
+    def add_route_for(service_name, action_name, service_instance, options = {})
+      path = [service_name, action_name].join('/')
+      puts "New route: #{path} :: #{service_instance}"
+      @routes[path] = {service_instance: service_instance, options: options}
+    end
+
+    # Funny name of a exception used to signal that the requested
+    # combination of service and method can not be found.
+    #
+    # Looked much funnier the first time... (@amuino)
+    class UnknownStop < RuntimeError
+    end
+
+    def resolve_route(service_name, kind)
+      path = [service_name, kind].join('/')
+      handler = @routes[path]
+      if handler
+        return service_instance = handler[:service_instance]
+      else
+        log "[WARNING] Service Path #{path} not found"
+        log "[WARNING] routes: #{@routes.keys.inspect}"
+        raise UnknownStop.new(path)
       end
-      service = service_class.new
     end
 
-    def invoke_service(service_instance, action, params)
+    def invoke_service(service_name, action, params)
+      t0 = Time.now
+      path = "#{service_name}/#{action}?#{params.inspect}"
+      service_instance = resolve_route(service_name.to_s, action)
       # convert keys to symbols in-place
       params.keys.each {|key| params[key.to_sym] = params.delete(key) }
-      service_instance.send(action, params)
-    rescue => e
+      deferrable = sync_to_async service_instance.send(action, params)
+      deferrable.callback &log_service_invocation(true, t0, path)
+      deferrable.errback &log_service_invocation(false, t0, path)
+      deferrable
+    rescue StandardError => e
       # TODO: report in a more effective way (I will not read server logs to find this)
       require 'yaml'
       puts " *** ERROR INVOKING SERVICE ***"
       puts "   - #{e.inspect}"
-      puts "   - #{service_instance.class.ancestors.join ' > '}"
+      puts "   - #{service_name} #{service_instance.class.ancestors.join ' > '}"
       puts "   - #{action}"
-      puts "   - #{params.to_yaml}"
-      raise e
+      puts "   - #{params.to_yaml.split("\n").join("\n\t")}"
+      # FIXME: strings because is what in_process tests expects
+      return sync_to_async error: { klass: e.class.name, message: e.message, backtrace: e.backtrace }
+    end
+
+    def sync_to_async(response)
+      return response if response.respond_to? :succeed # already a deferrable
+      deferrable = EM::DefaultDeferrable.new
+      if response.respond_to?(:keys) and response[:error]
+        deferrable.fail response[:error]
+      else
+        deferrable.succeed response
+      end
+      return deferrable
+    end
+
+    def log_service_invocation(success, t0, path)
+      Proc.new do |response|
+        result = success ? 'OK' : 'KO'
+        time = '%10.6fs' % (Time.now - t0)
+        base_msg = "#{result}\t#{time}\t#{path}"
+        base_msg += "\t#{response.inspect}" if success == false
+        puts base_msg
+      end
     end
 
   end

data/lib/combi/buses/http.rb

@@ -14,9 +14,9 @@ module Combi
       def on_message(request)
         path = request.path.split('/')
         message = {
-          "service" => path[1],
-          "kind" => path[2],
-          "payload" => JSON.parse(request.body)
+          service_name: path[1],
+          kind: path[2],
+          payload: Yajl::Parser.parse(request.body, symbolize_keys: true)
         }
         @bus.on_message(message)
       end
@@ -46,46 +46,21 @@ module Combi
       @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'] ||= {}
-          begin
-            response = invoke_service(service_instance, kind, message['payload'])
-          rescue RuntimeError => e
-            response = {error: {klass: e.class.name, message: e.message, backtrace: e.backtrace } }
-          end
-          {result: 'ok', response: response}
-        else
-          {result: 'error', response: {error: { klass: 'unknown action', message: kind } } }
-        end
-      else
-        {result: 'error', response: {error: 'unknown service'}}
-      end
-    end
-
-    def respond_to(service_instance, action, options = {})
-      handlers[action.to_s] = {service_instance: service_instance, options: options}
-    end
-
-    def handlers
-      @handlers ||= {}
+    def on_message(service_name:, kind:, payload: {})
+      invoke_service(service_name, kind, payload)
     end
 
     def request(name, kind, message, options = {})
       options[:timeout] ||= RPC_DEFAULT_TIMEOUT
 
       correlation_id = Combi::Correlation.generate
-      waiter = EventedWaiter.wait_for(correlation_id, @response_store, options[:timeout])
+      waiter = @response_store.wait_for(correlation_id, options[:timeout])
       url = "#{@options[:remote_api]}#{name}/#{kind}"
-      request_async = EventMachine::HttpRequest.new(url, connection_timeout: options[:timeout]).post(body: message.to_json)
+      message_json = Yajl::Encoder.encode(message)
+      request_async = EventMachine::HttpRequest.new(url, connection_timeout: options[:timeout]).post(body: message_json)
       request_async.callback do |r|
-        parsed = JSON.parse(r.response)
-        waiter.succeed(parsed['response'])
+        parsed = Yajl::Parser.parse(r.response, symbolize_keys: true)
+        waiter.succeed(parsed)
       end
       request_async.errback do |x|
         waiter.fail(Timeout::Error.new)

data/lib/combi/buses/in_process.rb

@@ -3,53 +3,24 @@ require 'combi/buses/bus'
 module Combi
   class InProcess < Bus
 
-    def request(handler_name, kind, message, options = {})
+    def request(service_name, kind, message, options = {})
       options[:timeout] ||= RPC_DEFAULT_TIMEOUT
-      handler = memory_handlers[handler_name.to_s]
       waiter = EventMachine::DefaultDeferrable.new
-      if handler.nil?
-        waiter.fail('error' => 'unknown service')
-      else
-        service_instance = handler[:service_instance]
-        message = JSON.parse(message.to_json)
-        if service_instance.respond_to?(kind)
-          waiter.timeout(options[:timeout], 'error' => 'Timeout::Error')
-          begin
-            Timeout.timeout(options[:timeout]) do
-              response = invoke_service(service_instance, kind, message)
-              if response.respond_to? :succeed
-                response.callback do |service_response|
-                  log "responding with deferred response: #{service_response.inspect[0..500]}"
-                  waiter.succeed service_response
-                end
-                response.errback do |service_response|
-                  failure_response = { 'error' => service_response }
-                  log "responding with deferred failure: #{service_response.inspect[0..500]}"
-                  waiter.fail(failure_response)
-                end
-              else
-                waiter.succeed response
-              end
-            end
-          rescue Timeout::Error => e
-            waiter.fail 'error' => 'Timeout::Error'
-          rescue RuntimeError => e
-            waiter.fail 'error' => {'klass' => e.class.name, 'message' => e.message, 'backtrace' => e.backtrace}
+      begin
+        Timeout.timeout(options[:timeout]) do
+          message = Yajl::Parser.parse(Yajl::Encoder.encode(message), symbolize_keys: true)
+          response = invoke_service(service_name, kind, message)
+          response.callback do |service_response|
+            waiter.succeed service_response
+          end
+          response.errback do |service_response|
+            waiter.fail error: service_response
           end
-        else
-          waiter.fail('error' => { 'klass' => 'unknown action', 'message' => kind.to_s })
         end
+      rescue Timeout::Error => e
+        waiter.fail error: 'Timeout::Error'
       end
       waiter
     end
-
-    def respond_to(service_instance, action, options = {})
-      memory_handlers[action.to_s] = {service_instance: service_instance, options: options}
-    end
-
-    def memory_handlers
-      @memory_handlers ||= {}
-    end
-
   end
 end

data/lib/combi/buses/queue.rb

@@ -25,8 +25,13 @@ module Combi
       end
     end
 
-    def respond_to(service_instance, action, options = {})
-      log "registering #{action}"
+    def add_routes_for(service_name, service_instance, options = {})
+      create_queue_for_service(service_name, options)
+      super
+    end
+
+    def create_queue_for_service(service_name, options = {})
+      log "creating queue #{service_name}"
       queue_options = {}
       subscription_options = {}
       if options[:fast] == true
@@ -35,10 +40,10 @@ module Combi
         subscription_options[:ack] = true
       end
       queue_service.ready do
-        queue_service.queue(action.to_s, queue_options) do |queue|
-          log "subscribing to queue #{action.to_s} with options #{queue_options}"
+        queue_service.queue(service_name.to_s, queue_options) do |queue|
+          log "subscribing to queue #{service_name.to_s} with options #{queue_options}"
           queue.subscribe(subscription_options) do |delivery_info, payload|
-            respond service_instance, payload, delivery_info
+            respond service_name, payload, delivery_info
             queue_service.acknowledge delivery_info unless options[:fast] == true
           end
         end
@@ -51,7 +56,7 @@ module Combi
       options[:routing_key] = name.to_s
       correlation_id = Combi::Correlation.generate
       options[:correlation_id] = correlation_id
-      waiter = EventedWaiter.wait_for(correlation_id, @response_store, options[:timeout])
+      waiter = @response_store.wait_for(correlation_id, options[:timeout])
       queue_service.next_ready_only do
         log "Making request: #{name}.#{kind} #{message.inspect[0..500]}\t|| #{options.inspect[0..500]}"
         queue_service.call(kind, message, options)
@@ -59,36 +64,18 @@ module Combi
       waiter
     end
 
-    def respond(service_instance, request, delivery_info)
-      message = JSON.parse request
-      kind = message['kind']
-      payload = message['payload']
-      options = message['options']
-      if service_instance.respond_to?(kind)
-        log "generating response for #{service_instance.class}#{service_instance.actions.inspect}.#{kind} #{payload.inspect[0..500]}"
-        begin
-          response = invoke_service(service_instance, kind, payload)
-        rescue RuntimeError => e
-          response = {error: {klass: e.class.name, message: e.message, backtrace: e.backtrace } }
-        end
-      else
-        log "Service instance does not respond to #{kind}: #{service_instance.inspect}"
-        response = {error: { klass: 'unknown action', message: kind } }
+    def respond(service_name, request, delivery_info)
+      message = Yajl::Parser.parse request, symbolize_keys: true
+      kind = message[:kind]
+      payload = message[:payload]
+      options = message[:options]
+      response = invoke_service(service_name, kind, payload)
+      response.callback do |service_response|
+        queue_service.respond service_response, delivery_info
       end
-      if response.respond_to? :succeed
-        log "response is deferred"
-        response.callback do |service_response|
-          log "responding with deferred answer: #{service_response.inspect[0..500]}"
-          queue_service.respond(service_response.to_json, delivery_info)
-        end
-        response.errback do |service_response|
-          failure_response = { error: service_response }
-          log "responding with deferred failure: #{service_response.inspect[0..500]}"
-          queue_service.respond(failure_response.to_json, delivery_info)
-        end
-      else
-        log "responding with inmediate answer: #{response.inspect[0..500]}"
-        queue_service.respond(response.to_json, delivery_info)
+      response.errback do |service_response|
+        failure_response = { error: service_response }
+        queue_service.respond failure_response, delivery_info
       end
     end
 

data/lib/combi/buses/web_socket.rb

@@ -23,8 +23,8 @@ module Combi
       end
 
       def on_message(ws, session, raw_message)
-        @bus.log "ON MESSAGE #{raw_message[0..500]}"
-        message = JSON.parse(raw_message)
+        @bus.log "WS SERVER ON MESSAGE #{raw_message[0..500]}"
+        message = Yajl::Parser.parse raw_message, symbolize_keys: true
         @bus.on_message(ws, message, session)
       end
 
@@ -73,7 +73,7 @@ module Combi
 
         ws.on :message do |event|
           @bus.log "ON MESSAGE: #{event.data[0..500]}"
-          message = JSON.parse(event.data)
+          message = Yajl::Parser.parse event.data, symbolize_keys: true
           @bus.on_message(ws, message)
         end
 
@@ -96,11 +96,10 @@ module Combi
 
     end
 
-    attr_reader :handlers, :ready
+    attr_reader :ready
 
     def initialize(options)
       super
-      @handlers = {}
     end
 
     def post_initialize
@@ -161,80 +160,52 @@ module Combi
     end
 
     def on_message(ws, message, session = nil)
-      if message['correlation_id'] && message.has_key?('result')
+      if message[:correlation_id] && message.has_key?(:result)
         @response_store.handle_rpc_response(message)
-        log "Stored message with correlation_id #{message['correlation_id']} - #{message.inspect[0..500]}"
+        log "Handled response with correlation_id #{message[:correlation_id]} - #{message.inspect[0..500]}"
         return
       end
-      service_name = message['service']
-      kind = message['kind']
-      payload = message['payload'] || {}
-      payload['session'] = session
+      service_name = message[:service]
+      kind = message[:kind]
+      payload = message[:payload] || {}
+      payload[:session] = session
       begin
-        response = lookup_and_invoke_service(service_name, kind, payload)
+        response = invoke_service(service_name, kind, payload)
       rescue RuntimeError => e
         response = {error: {klass: e.class.name, message: e.message, backtrace: e.backtrace } }
       end
 
-      msg = {result: 'ok', correlation_id: message['correlation_id']}
+      msg = {result: 'ok', correlation_id: message[:correlation_id]}
 
-      if response.respond_to? :succeed
-        log "response is deferred"
-        response.callback do |service_response|
-          log "responding with deferred answer: #{service_response.inspect[0..500]}"
-          msg[:response] = service_response.to_json
-          ws.send(msg.to_json)
-        end
-        response.errback do |service_response|
-          log "responding with deferred error: #{service_response.inspect[0..500]}"
-          error_response = { error: service_response }
-          msg[:response] = error_response.to_json
-          ws.send(msg.to_json)
-        end
-      else
-        log "responding with inmediate answer: #{response.inspect[0..500]}"
-        msg[:response] = response.to_json
-        ws.send(msg.to_json)
+      response.callback do |service_response|
+        msg[:response] = service_response
+        serialized = Yajl::Encoder.encode msg
+        ws.send serialized
       end
-    end
-
-    def lookup_and_invoke_service(service_name, kind, payload)
-      handler = handlers[service_name.to_s]
-      if handler
-        service_instance = handler[:service_instance]
-        if service_instance.respond_to? kind
-          response = invoke_service(service_instance, kind, payload)
-        else
-          log "[WARNING] Service #{service_name}(#{service_instance.class.name}) does not respond to message #{kind}"
-          response = {error: { klass: 'unknown action', message: kind } }
-        end
-      else
-        log "[WARNING] Service #{service_name} not found"
-        log "[WARNING] handlers: #{handlers.keys.inspect}"
-        response = {error: 'unknown service'}
+      response.errback do |service_response|
+        msg[:response] = {error: service_response}
+        serialized = Yajl::Encoder.encode msg
+        ws.send serialized
       end
     end
 
-    def respond_to(service_instance, action, options = {})
-      log "registering #{action}"
-      handlers[action.to_s] = {service_instance: service_instance, options: options}
-      log "handlers: #{handlers.keys.inspect}"
-    end
-
     def request(name, kind, message, options = {})
       options[:timeout] ||= RPC_DEFAULT_TIMEOUT
+      correlation_id = Combi::Correlation.generate
       msg = {
         service: name,
         kind: kind,
-        payload: message
+        payload: message,
+        correlation_id: correlation_id
       }
-      correlation_id = Combi::Correlation.generate
-      msg[:correlation_id] = correlation_id
-      waiter = EventedWaiter.wait_for(correlation_id, @response_store, options[:timeout])
+      waiter = @response_store.wait_for(correlation_id, options[:timeout])
       @ready.callback do |r|
         web_socket = @machine.ws || options[:ws]
-        log "sending request #{msg.inspect}"
-        web_socket.send msg.to_json unless web_socket.nil?
+        unless web_socket.nil?
+          serialized = Yajl::Encoder.encode msg
+          log "sending request #{serialized}"
+          web_socket.send serialized
+        end
       end
       waiter
     end

data/lib/combi/queue_service.rb

@@ -47,7 +47,7 @@ module Combi
     end
 
     def connect(config, &after_connect)
-      puts "[INFO] trying to connect to queue"
+      puts "[INFO] trying to connect to queue server"
       @amqp_conn = AMQP.connect(config) do |connection, open_ok|
         @channel = AMQP::Channel.new @amqp_conn
         @channel.auto_recovery = true
@@ -94,8 +94,8 @@ module Combi
     end
 
     def respond(response, delivery_info)
-      response = response.call if response.respond_to? :call
-      publish response, routing_key: delivery_info.reply_to, correlation_id: delivery_info.correlation_id
+      serialized = Yajl::Encoder.encode response
+      publish serialized, routing_key: delivery_info.reply_to, correlation_id: delivery_info.correlation_id
     end
 
     def create_rpc_queue
@@ -103,9 +103,10 @@ module Combi
       @rpc_queue = queue('', exclusive: true, auto_delete: true) do |rpc_queue|
         log "\tRPC QUEUE: #{@rpc_queue.name}"
         rpc_queue.subscribe do |metadata, response|
+          parsed_response = Yajl::Parser.parse response, symbolize_keys: true
           message = {
-            'correlation_id' => metadata.correlation_id,
-            'response' => response
+            correlation_id: metadata.correlation_id,
+            response: parsed_response
           }
           rpc_callback.call(message) unless rpc_callback.nil?
         end
@@ -119,12 +120,8 @@ module Combi
       options[:expiration] = ((options[:timeout] || RPC_DEFAULT_TIMEOUT) * 1000).to_i
       options[:routing_key] ||= 'rcalls_queue'
       options[:reply_to] ||= @rpc_queue.name
-      request = {
-        kind: kind,
-        payload: message,
-        options: {}
-      }
-      publish(request.to_json, options)
+      request = Yajl::Encoder.encode kind: kind, payload: message, options: {}
+      publish request, options
     end
 
   end

data/lib/combi/response_store.rb

@@ -6,49 +6,36 @@ module Combi
       @waiters = {}
     end
 
-    def add_waiter(key, waiter)
-      @waiters[key] = waiter
-      waiter.callback { |r| finish key }
-      waiter.errback  { |r| finish key }
+    # Returns an EM::Deferrable
+    def wait_for(correlation_id, timeout)
+      waiter = EM::DefaultDeferrable.new
+      add_waiter correlation_id, waiter
+      waiter.timeout timeout, error: 'Timeout::Error'
     end
 
     def handle_rpc_response(response)
-      correlation_id = response['correlation_id']
+      correlation_id = response[:correlation_id]
       waiter = @waiters[correlation_id]
       return unless waiter
-      response = JSON.parse response['response']
-      if response.respond_to?(:keys) and response['error']
-        waiter.fail(response)
+      response = response[:response] #Yajl::Parser.parse response[:response], sybolize_keys: true
+      if response.respond_to?(:keys) and response[:error]
+        waiter.fail response
       else
-        waiter.succeed(response)
+        waiter.succeed response
       end
     end
 
-    def finish(key)
-      @waiters.delete key
-    end
-  end
+    protected
 
-  class EventedWaiter
-    include EM::Deferrable
-    def self.log(message)
-      return unless @debug_mode ||= ENV['DEBUG'] == 'true'
-      puts "#{Time.now.to_f} #{self.name} #{message}"
-    end
-
-    def self.wait_for(key, response_store, timeout)
-      t1 = Time.now
-      log "started waiting for #{key}"
-      waiter = new(key, response_store, timeout)
-      response_store.add_waiter(key, waiter)
-      waiter.callback {|r| log "success waiting for #{key}: #{Time.now.to_f - t1.to_f}s" }
-      waiter.errback {|r| log "failed waiting for #{key}: #{Time.now.to_f - t1.to_f}s, #{r.inspect[0..500]}" }
+    def add_waiter(correlation_id, waiter)
+      @waiters[correlation_id] = waiter
+      waiter.callback { |r| remove_waiter correlation_id }
+      waiter.errback  { |r| remove_waiter correlation_id }
       waiter
     end
 
-    def initialize(key, response_store, timeout)
-      self.timeout(timeout, 'error' => 'Timeout::Error')
+    def remove_waiter(correlation_id)
+      @waiters.delete correlation_id
     end
-
   end
 end

data/lib/combi/service.rb

@@ -6,7 +6,6 @@ module Combi
       context[:service_bus] = service_bus
       setup_context(context)
       setup_services
-      register_actions
     end
 
     def setup_context(context)
@@ -21,15 +20,6 @@ module Combi
     def setup_services
     end
 
-    def register_actions
-      actions.each do |handler|
-        service_bus.respond_to(self, handler)
-      end
-      fast_actions.each do |handler|
-        service_bus.respond_to(self, handler, fast: true)
-      end
-    end
-
     def no_response
       nil
     end
@@ -46,6 +36,10 @@ module Combi
       []
     end
 
+    def remote_methods
+      @_REMOTE_METHODS ||= public_methods(false) - Combi::Service.public_instance_methods
+    end
+
     def service_bus
       @service_bus
     end
@@ -55,5 +49,9 @@ module Combi
       yield block if block_given?
     end
 
+    def to_s
+      @_TO_S ||= "#{self.class.name}"
+    end
+
   end
 end

data/lib/combi/version.rb

@@ -1,3 +1,3 @@
 module Combi
-  VERSION = '0.1.0'
+  VERSION = '0.2.0.pre'
 end

data/spec/integration/multi_bus_spec.rb

@@ -36,7 +36,7 @@ describe "in a multi bus environment" do
               defer.fail('unknown error')
             end
           else
-            if service_result.respond_to?(:keys) && service_result['error']
+            if service_result.respond_to?(:keys) && service_result[:error]
               defer.fail('other service failed')
             else
               defer.succeed(service_result*2)
@@ -173,7 +173,7 @@ describe "in a multi bus environment" do
               prepare
               EM.synchrony do
                 service_result = EM::Synchrony.sync main_bus_consumer.request(:say_hello_if_you_can, :do_it, params, options)
-                service_result['error']['message'].should eq "I can't talk"
+                service_result[:error][:message].should eq "I can't talk"
                 done
                 finalize
               end
@@ -191,7 +191,7 @@ describe "in a multi bus environment" do
               EM.synchrony do
                 params.merge!('service_name' => 'say_hello_if_you_can')
                 service_result = EM::Synchrony.sync main_bus_consumer.request(:repeat_with_me, :do_it, params, options)
-                service_result['error'].should eq 'other service failed'
+                service_result[:error].should eq 'other service failed'
                 done
                 finalize
               end

data/spec/lib/combi/buses/bus_spec.rb

@@ -1,22 +1,40 @@
 require 'spec_helper'
+require 'combi/buses/bus'
 
 describe 'Combi::Bus' do
   context 'registers services' do
-    Given(:subject) { Combi::Bus.new({}) }
+    Given(:bus) { Combi::Bus.new({}) }
 
     context 'via instances' do
-      Given(:service_class) { Class.new{include Combi::Service} }
+      Given(:service_class) do
+        Class.new do
+          include Combi::Service
+          def actions; ['class']; end
+          def remote; end
+        end
+      end
       Given(:service_definition) { service_class.new }
-      When { subject.add_service service_definition }
-      Then { subject.services == [service_definition] }
+      Given(:path) { 'class/remote' }
+      When { bus.add_service service_definition }
+      Then { bus.routes.keys.length == 1 }
+      And  { bus.routes[path][:service_instance] == service_definition }
     end
 
     context 'via modules' do
-      Given(:service_definition) { Module.new }
-      When { subject.add_service service_definition }
-      Then { subject.services.length == 1 }
-       And { Combi::Service === subject.services[0] }
-       And { service_definition === subject.services[0] }
+      Given(:service_definition) do
+        Module.new do
+          def actions; ['module']; end
+          def remote; end
+        end
+      end
+      Given(:path) { 'module/remote' }
+      When { bus.add_service service_definition
+        puts bus.routes.inspect
+        puts bus.routes[path].inspect
+        puts bus.routes.keys.inspect
+      }
+      Then { bus.routes.keys.length == 1 }
+      And  { bus.routes[path][:service_instance].is_a? service_definition }
     end
   end
 end

data/spec/lib/combi/buses/web_socket_spec.rb

@@ -94,8 +94,8 @@ describe 'Combi::WebSocket' do
             provider.stop!
             service_result = EM::Synchrony.sync consumer.request(:null, :do_it, {}, { timeout: 0.3 })
             service_result.should be_a Hash
-            service_result.should have_key 'error'
-            service_result['error'].should eq 'Timeout::Error'
+            service_result.should have_key :error
+            service_result[:error].should eq 'Timeout::Error'
             done(0.3) #timeout response must came before this timeout
           end
           provider.stop!

data/spec/lib/combi/service_spec.rb

@@ -9,19 +9,15 @@ describe 'Combi::Service' do
     Given!("setup methods are stubbed") do
       subject.stub(:setup_context).and_call_original
       subject.stub(:setup_services).and_call_original
-      subject.stub(:register_actions).and_call_original
     end
     Given(:the_bus) { double "the bus" }
     When { subject.setup the_bus, context }
     context 'sets up the context' do
-      Then { subject.should have_received :setup_context }
+      Then { subject.should have_received(:setup_context).with context }
     end
     context 'allows the service to setup itself' do
       Then { subject.should have_received :setup_services }
     end
-    context 'registers the advertised actions' do
-      Then { subject.should have_received :register_actions }
-    end
     context 'always includes the service_bus in the context' do
       Then { subject.service_bus == the_bus }
     end

data/spec/shared_examples/standard_bus.rb

@@ -69,8 +69,8 @@ shared_examples_for "standard_bus" do
         EM.synchrony do
           service_result = EM::Synchrony.sync consumer.request(:sleep, :do_it, params, { timeout: time_base/2.0 })
           service_result.should be_a Hash
-          service_result.should have_key 'error'
-          service_result['error'].should eq 'Timeout::Error'
+          service_result.should have_key :error
+          service_result[:error].should eq 'Timeout::Error'
           done(time_base) #timeout response must came before this timeout
         end
         finalize
@@ -114,8 +114,15 @@ shared_examples_for "standard_bus" do
     end
 
     context 'for maps' do
-      Given(:data) { {'a' => 1, 'b' => 'dos'} }
-      Then { result_container[:result].should eq data}
+      context 'with string keys' do
+        Given(:data) { {'a' => 1, 'b' => 'dos'} }
+        Then { result_container[:result].keys.should eq data.keys.map(&:to_sym)}
+        And  { result_container[:result].values.should eq data.values }
+      end
+      context 'with symbol keys' do
+        Given(:data) { {a: 1, b: 'dos'} }
+        Then { result_container[:result].should eq data}
+      end
     end
 
     context 'for objects returns their json version' do
@@ -131,7 +138,7 @@ shared_examples_for "standard_bus" do
         end
       end
       Given(:data) { custom_class.new(custom_json).to_json}
-      Then { result_container[:result].should eq JSON.parse(custom_json.to_json)}
+      Then { result_container[:result].should eq custom_json}
     end
   end
 
@@ -143,10 +150,10 @@ shared_examples_for "standard_bus" do
         prepare
         EM.synchrony do
           service_result = EM::Synchrony.sync consumer.request(:shout_error, :do_it, {message: error_message}, { timeout: 0.1 })
-          service_result['error'].should be_a Hash
-          service_result['error']['message'].should eq error_message
-          service_result['error']['backtrace'].should_not be_nil
-          service_result['error']['backtrace'].should be_an Array
+          service_result[:error].should be_a Hash
+          service_result[:error][:message].should eq error_message
+          service_result[:error][:backtrace].should_not be_nil
+          service_result[:error][:backtrace].should be_an Array
           done
           finalize
         end
@@ -155,7 +162,7 @@ shared_examples_for "standard_bus" do
   end
 
   context 'return an error when requesting an unknown service' do
-    Given(:error_message) { 'unknown service' }
+    Given(:error_message) { Combi::Bus::UnknownStop.name }
     When(:service) { provider.add_service broken_service }
     Then do
       em do
@@ -163,10 +170,11 @@ shared_examples_for "standard_bus" do
         EM.synchrony do
           begin
             service_result = EM::Synchrony.sync consumer.request(:some_not_service, :do_it, {}, { timeout: 0.1 })
-            if consumer.class == Combi::Queue
-              service_result['error'].should eq "Timeout::Error"
+            if defined?(Combi::Queue) and consumer.class == Combi::Queue
+              service_result[:error].should eq "Timeout::Error"
             else
-              service_result['error'].should eq error_message
+              service_result[:error][:klass].should eq error_message
+              service_result[:error][:message].should eq 'some_not_service/do_it'
             end
             done
             finalize
@@ -177,7 +185,7 @@ shared_examples_for "standard_bus" do
   end
 
   context 'return an error when requesting an unknown action for the service' do
-    Given(:error_message) { 'unknown action' }
+    Given(:error_message) { Combi::Bus::UnknownStop.name }
     When(:service) { provider.add_service echo_service }
     Then do
       em do
@@ -185,8 +193,8 @@ shared_examples_for "standard_bus" do
         EM.synchrony do
           begin
             service_result = EM::Synchrony.sync consumer.request(:echo_this, :do_other, {}, { timeout: 0.1 })
-            service_result['error']['klass'].should eq error_message
-            service_result['error']['message'].should eq 'do_other'
+            service_result[:error][:klass].should eq error_message
+            service_result[:error][:message].should eq 'echo_this/do_other'
             done
             finalize
           end

data/spec/support/web_server.rb

@@ -8,15 +8,17 @@ class DeferrableBody
   def initialize(defer)
     @defer = defer
     @defer.callback do |service_response|
+      json_response = Yajl::Encoder.encode service_response
       EM::next_tick do
-        self.call [{result: 'ok', response: service_response}.to_json]
+        self.call [json_response]
         self.succeed
       end
     end
     @defer.errback do |service_response|
       error_response = { error: service_response }
+      json_response = Yajl::Encoder.encode error_response
       EM::next_tick do
-        self.call [{result: 'ok', response: error_response}.to_json]
+        self.call [json_response]
         self.fail
       end
     end
@@ -38,16 +40,8 @@ def start_web_server(http_bus, port, webserver = 'thin')
   require webserver
   app = lambda do |env|
     response_message = http_bus.manage_request(env)
-    if response_message[:response].respond_to? :succeed
-      env['async.callback'].call [200, {}, DeferrableBody.new(response_message[:response])]
-      AsyncResponse
-    else
-      response_rack = Rack::Response.new
-      response_rack.status = response_message.nil? ? 201 : 200
-      response_rack.body = [response_message.to_json]
-      response_rack.finish
-      response_rack
-    end
+    env['async.callback'].call [200, {}, DeferrableBody.new(response_message)]
+    AsyncResponse
   end
   Thin::Logging.silent = true if webserver == 'thin'
   rack_handler = Rack::Handler.get(webserver)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: combi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0.pre
 platform: ruby
 authors:
 - German Del Zotto
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-26 00:00:00.000000000 Z
+date: 2014-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
@@ -191,9 +191,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.3.0