combi 0.0.3

data/lib/combi/buses/web_socket.rb

@@ -0,0 +1,227 @@
+require 'combi/buses/bus'
+require 'combi/response_store'
+
+module Combi
+  class WebSocket < Bus
+
+    class Server
+
+      def initialize(bus)
+        @bus = bus
+        @bus.ready.succeed
+      end
+
+      def start!
+      end
+
+      def stop!
+      end
+
+      def on_open(ws, handler)
+        @bus.log "ON OPEN #{handler.inspect}"
+        handler.new_session(ws)
+      end
+
+      def on_message(ws, session, raw_message)
+        @bus.log "ON MESSAGE #{raw_message}"
+        message = JSON.parse(raw_message)
+        @bus.on_message(ws, message, session)
+      end
+
+      def on_close(session)
+        session && session.close
+      end
+
+      def ws
+        @ws
+      end
+
+    end
+
+    class Client
+      require 'faye/websocket'
+
+      def initialize(remote_api, handler, bus)
+        @handler = handler
+        @remote_api = remote_api
+        @bus = bus
+      end
+
+      def start!
+        open_websocket
+      end
+
+      def stop!
+        @ws && @ws.close
+        @bus.log "stop requested"
+      end
+
+      def restart!
+        stop!
+        start!
+      end
+
+      def open_websocket
+        @bus.log  @remote_api
+        @ws = ws = Faye::WebSocket::Client.new(@remote_api)
+        ws.on :open do |event|
+          @bus.log "OPEN"
+          @bus.log "HANDLER #{@handler.inspect}"
+          @handler.on_open
+          @bus.ready.succeed
+        end
+
+        ws.on :message do |event|
+          @bus.log "ON MESSAGE: #{event.data}"
+          message = JSON.parse(event.data)
+          @bus.on_message(ws, message)
+        end
+
+        ws.on :close do |event|
+          @bus.log  "close #{event.code}: #{event.reason}"
+          @ws = ws = nil
+        end
+
+        ws.on :error do |event|
+          @bus.log  "received error: #{event.inspect}"
+          stop!
+        end
+      end
+
+      def ws
+        @bus.log "ws present: #{@ws != nil}"
+        @ws
+      end
+
+    end
+
+    attr_reader :handlers, :ready
+
+    def initialize(options)
+      super
+      @handlers = {}
+    end
+
+    def post_initialize
+      @ready = EventMachine::DefaultDeferrable.new
+      @response_store = Combi::ResponseStore.new
+      if @options[:remote_api]
+        require 'eventmachine'
+        @machine = Client.new(@options[:remote_api], @options[:handler], self)
+      else
+        @machine = Server.new(self)
+      end
+    end
+
+    def start!
+      @machine.start!
+    end
+
+    def stop!
+      @machine.stop!
+    end
+
+    def manage_request(env, handler)
+      require 'faye/websocket'
+
+      return unless Faye::WebSocket.websocket?(env)
+      @ws = ws = Faye::WebSocket.new(env)
+      session = nil
+
+      ws.on :message do |event|
+        @machine.on_message(ws, session, event.data)
+      end
+
+      ws.on :open do |event|
+        session = @machine.on_open(ws, handler)
+      end
+
+      ws.on :close do |event|
+        @machine.on_close(session)
+      end
+      # Return async Rack response
+      ws.rack_response
+    end
+
+    def manage_ws_event(ws, handler)
+      session = nil
+
+      ws.onmessage do |raw_message|
+        @machine.on_message(ws, session, raw_message)
+      end
+
+      ws.onopen do |handshake|
+        session = @machine.on_open(ws, handler)
+      end
+
+      ws.onclose do
+        @machine.on_close(session)
+      end
+    end
+
+    def on_message(ws, message, session = nil)
+      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}"
+        return
+      end
+      service_name = message['service']
+      kind = message['kind']
+      payload = message['payload'] || {}
+      payload['session'] = session
+      response = invoke_service(service_name, kind, payload)
+
+      msg = {result: 'ok', correlation_id: message['correlation_id']}
+
+      if response.respond_to? :succeed
+        response.callback do |service_response|
+          msg[:response] = service_response
+          ws.send(msg.to_json)
+        end
+      else
+        msg[:response] = response
+        ws.send(msg.to_json)
+      end
+    end
+
+    def 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 = service_instance.send(kind, payload)
+        else
+          log "[WARNING] Service #{service_name}(#{service_instance.class.name}) does not respond to message #{kind}"
+        end
+      else
+        log "[WARNING] Service #{service_name} not found"
+        log "[WARNING] handlers: #{handlers.keys.inspect}"
+      end
+    end
+
+    def respond_to(service_instance, handler, options = {})
+      log "registering #{handler}"
+      handlers[handler.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
+      msg = {
+        service: name,
+        kind: kind,
+        payload: message
+      }
+      correlation_id = rand(10_000_000).to_s
+      msg[:correlation_id] = correlation_id
+      waiter = EventedWaiter.wait_for(correlation_id, @response_store, options[:timeout])
+      @ready.callback do |r|
+        web_socket = @machine.ws || options[:ws]
+        log "sending request #{msg.inspect}"
+        web_socket.send msg.to_json
+      end
+      waiter
+    end
+
+  end
+end

data/lib/combi/helpers.rb

@@ -0,0 +1,18 @@
+require 'timeout'
+
+module Combi
+
+  def self.wait_for(defer, options = {}, &block)
+    options[:timeout] ||= 2
+    poll_time = options[:timeout] / 10
+    resolved = false
+    defer.callback { |response|
+      resolved = true
+      block.call response
+    }
+    Timeout::timeout(options[:timeout]) do
+      sleep poll_time while !resolved
+    end
+  end
+
+end

data/lib/combi/queue_service.rb

@@ -0,0 +1,102 @@
+require 'amqp'
+require 'amqp/utilities/event_loop_helper'
+
+module Combi
+  class QueueService
+
+    RPC_DEFAULT_TIMEOUT = 1
+    RPC_WAIT_PERIOD = 0.01
+
+    attr_accessor :rpc_callback
+
+    def initialize(config, options)
+      @config = config
+      @options = options
+      @rpc_queue = nil
+      @ready_defer = EventMachine::DefaultDeferrable.new
+    end
+
+    def ready(&block)
+      @ready_defer.callback &block
+    end
+
+    def log(message)
+      return unless @debug_mode ||= ENV['DEBUG'] == 'true'
+      puts "#{object_id} #{self.class.name} #{message}"
+    end
+
+    def start
+      connect @config do
+        if @options[:rpc] == :enabled
+          create_rpc_queue
+        else
+          puts "ready"
+          @ready_defer.succeed
+        end
+      end
+    end
+
+    def connect(config, &after_connect)
+      @amqp_conn = AMQP.connect(config) do |connection, open_ok|
+        @channel = AMQP::Channel.new @amqp_conn
+        @channel.auto_recovery = true
+        @exchange = @channel.direct ''
+        after_connect.call
+      end
+    end
+
+    def disconnect
+      @amqp_conn.close do
+        puts "disconnected from RABBIT"
+      end
+    end
+
+    def publish(*args, &block)
+      args[0] = args[0].to_json unless args[0].is_a? String
+      @exchange.publish *args, &block
+    end
+
+    def queue(name, options = {}, &block)
+      @channel.queue(name, options, &block)
+    end
+
+    def acknowledge(delivery_info)
+      @channel.acknowledge(delivery_info.delivery_tag, false)
+    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
+    end
+
+    def create_rpc_queue
+      @rpc_queue.unsubscribe unless @rpc_queue.nil?
+      @rpc_queue = queue('', exclusive: true, auto_delete: true) do |rpc_queue|
+        log "\tRPC QUEUE: #{@rpc_queue.name}"
+        rpc_queue.subscribe do |metadata, response|
+          message = {
+            'correlation_id' => metadata.correlation_id,
+            'response' => response
+          }
+          rpc_callback.call(message) unless rpc_callback.nil?
+        end
+        @ready_defer.succeed
+      end
+    end
+
+    def call(kind, message, options = {})
+      log "sending request #{kind} #{message.inspect} with options #{options.inspect}"
+      raise "RPC is not enabled or reply_to is not included" if (@rpc_queue.nil? || @rpc_queue.name.nil?) && options[:reply_to].nil?
+      options[:timeout] ||= RPC_DEFAULT_TIMEOUT
+      options[:routing_key] ||= 'rcalls_queue'
+      options[:reply_to] ||= @rpc_queue.name
+      request = {
+        kind: kind,
+        payload: message,
+        options: {}
+      }
+      publish(request, options)
+    end
+
+  end
+end

data/lib/combi/reactor.rb

@@ -0,0 +1,46 @@
+require 'eventmachine'
+
+module Combi
+  class Reactor
+    def self.start(&block)
+      EM::error_handler do |error|
+        STDERR << "ERROR IN EM\n"
+        STDERR << "\t#{error.inspect}"
+        STDERR << "\t#{error.backtrace.join("\t\n")}" << "\n"
+      end
+      log "-EM.start- the reactor is running: #{EM::reactor_running?}"
+      raise "EM did not shut down" if EM::reactor_running?
+      @@reactor_thread = Thread.new do
+        log "------- starting EM reactor"
+        EM::run do
+          log "------- reactor started"
+          Signal.trap("INT")  { EM::stop_event_loop }
+          Signal.trap("TERM") { EM::stop_event_loop }
+          block.call unless block.nil?
+        end
+        log "------- reactor stopped"
+      end
+      30.times do
+        sleep 0.1 unless EM::reactor_running?
+      end
+    end
+
+    def self.stop
+      log "-EM.stop- the reactor is running: #{EM::reactor_running?}"
+      EM::stop_event_loop if EM::reactor_running?
+      50.times do
+        sleep 0.3 if EM::reactor_running?
+      end
+    end
+
+    def self.join_thread
+      @@reactor_thread.join if @@reactor_thread
+    end
+
+    def self.log(message)
+      return unless @debug_mode ||= ENV['DEBUG'] == 'true'
+      puts "#{object_id} #{self.class.name} #{message}"
+    end
+
+  end
+end

data/lib/combi/response_store.rb

@@ -0,0 +1,36 @@
+require 'eventmachine'
+
+module Combi
+  class ResponseStore
+    def initialize()
+      @waiters = {}
+    end
+
+    def add_waiter(key, waiter)
+      @waiters[key] = waiter
+    end
+
+    def handle_rpc_response(response)
+      correlation_id = response['correlation_id']
+      waiter = @waiters[correlation_id]
+      response = response['response']
+      waiter.succeed(response)
+      @waiters.delete correlation_id
+    end
+  end
+
+  class EventedWaiter
+    include EM::Deferrable
+
+    def self.wait_for(key, response_store, timeout)
+      waiter = new(key, response_store, timeout, Combi::Bus::RPC_MAX_POLLS)
+      response_store.add_waiter(key, waiter)
+      waiter
+    end
+
+    def initialize(key, response_store, timeout, max_polls)
+      self.timeout(timeout, RuntimeError.new(Timeout::Error))
+    end
+
+  end
+end

data/lib/combi/service.rb

@@ -0,0 +1,59 @@
+module Combi
+  module Service
+
+    def setup(service_bus, context)
+      context ||= {}
+      context[:service_bus] = service_bus
+      setup_context(context)
+      setup_services
+      register_actions
+    end
+
+    def setup_context(context)
+      @context = context
+      @context.keys.each do |context_var|
+        define_singleton_method context_var do
+          @context[context_var]
+        end
+      end
+    end
+
+    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
+
+    def async_response(&block)
+      lambda &block
+    end
+
+    def actions
+      []
+    end
+
+    def fast_actions
+      []
+    end
+
+    def service_bus
+      @service_bus
+    end
+
+    def enable(*services, &block)
+      service_bus.enable(services)
+      yield block if block_given?
+    end
+
+  end
+end