cocaine-framework-ruby 0.11.2

data/lib/cocaine/client/dispatcher.rb

@@ -0,0 +1,46 @@
+require 'cocaine/asio/channel/combiner'
+require 'cocaine/asio/channel/manager'
+require 'cocaine/client/error'
+require 'cocaine/dispatcher'
+
+$log = Logger.new(STDERR)
+$log.level = Logger::DEBUG
+
+
+class Cocaine::ClientDispatcher < Cocaine::Dispatcher
+  def initialize(conn)
+    super conn
+    @channels = Cocaine::ChannelManager.new
+  end
+
+  def invoke(method_id, *data)
+    session, channel = @channels.create
+    message = MessagePack::pack([method_id, session, data])
+    @conn.send_data message
+    Cocaine::ChannelCombiner.new channel
+  end
+
+  protected
+  def process(session, message)
+    channel = @channels[session]
+    case message.id
+      when RPC::CHUNK
+        channel.trigger unpack message.data
+      when RPC::ERROR
+        channel.error Cocaine::ServiceError.new "[#{message.errno}] #{message.reason}"
+      when RPC::CHOKE
+        channel.error ChokeEvent.new
+        channel.close
+      else
+        raise "unexpected message id: #{message.id}"
+    end
+  end
+
+  private
+  def unpack(data)
+    if data.kind_of?(Array)
+      data = data.join(',')
+    end
+    MessagePack.unpack(data)
+  end
+end

data/lib/cocaine/client/error.rb

@@ -0,0 +1,7 @@
+module Cocaine
+  class ConnectionError < Exception
+  end
+
+  class ServiceError < Exception
+  end
+end

data/lib/cocaine/client/service.rb

@@ -0,0 +1,130 @@
+require 'rubygems'
+require 'logger'
+
+require 'msgpack'
+require 'eventmachine'
+
+require 'cocaine/asio/channel'
+require 'cocaine/asio/connection'
+require 'cocaine/client/dispatcher'
+require 'cocaine/client/error'
+require 'cocaine/protocol'
+
+
+class Object
+  def metaclass
+    class << self
+      self
+    end
+  end
+end
+
+
+$log = Logger.new(STDERR)
+$log.level = Logger::DEBUG
+
+
+class Cocaine::AbstractService
+  attr_reader :api
+
+  def initialize(name)
+    @name = name
+    @api = {}
+  end
+
+  def invoke(method_id, *args)
+    $log.debug "invoking '#{@name}' method #{method_id} with #{args}"
+    @dispatcher.invoke method_id, *args
+  end
+
+  private
+  def connect_to_endpoint(*endpoint)
+    df = EM::DefaultDeferrable.new
+    $log.debug "connecting to the service '#{@name}' at #{endpoint} ..."
+    EM.connect *endpoint, Cocaine::Connection do |conn|
+      conn.hooks.on :connected do
+        conn.hooks.clear
+        $log.debug "connection established with service '#{@name}' at #{endpoint}"
+        @dispatcher = Cocaine::ClientDispatcher.new conn
+        df.succeed
+      end
+
+      conn.hooks.on :disconnected do
+        conn.hooks.clear
+        $log.debug "failed to connect to the '#{@name}' service at #{endpoint}"
+        df.fail Cocaine::ConnectionError.new
+      end
+    end
+    df
+  end
+end
+
+
+class Cocaine::Locator < Cocaine::AbstractService
+  @default_host = 'localhost'
+  @default_port = 10053
+  class << self
+    attr_accessor :default_host, :default_port
+  end
+
+  def initialize(host=self.class.default_host, port=self.class.default_port)
+    @name = 'locator'
+    @host = host
+    @port = port
+  end
+
+  def resolve(name)
+    df = EventMachine::DefaultDeferrable.new
+    connect_df = connect_to_endpoint @host, @port
+    connect_df.callback { do_resolve name, df }
+    connect_df.errback { |err| df.fail err }
+    df
+  end
+
+  private
+  def do_resolve(name, df)
+    $log.debug "resolving service '#{name}'"
+    channel = invoke 0, name
+    channel.callback do |future|
+      begin
+        df.succeed future.get
+      rescue Exception => err
+        df.fail err
+      end
+    end
+  end
+end
+
+
+class Cocaine::Service < Cocaine::AbstractService
+  def initialize(name, host='localhost', port=10053)
+    super name
+    @settings = {:host => host, :port => port}
+  end
+
+  def connect
+    df = EventMachine::DefaultDeferrable.new
+    locator = Cocaine::Locator.new @settings[:host], @settings[:port]
+    d = locator.resolve @name
+    d.callback { |result| on_connect result, df }
+    d.errback { |err| df.fail err }
+    df
+  end
+
+  private
+  def on_connect(result, df)
+    $log.debug "service '#{@name}' resolved: #{result}"
+
+    @endpoint, @version, @api = result
+    @api.each do |id, name|
+      self.metaclass.send(:define_method, name) do |*args|
+        invoke id, *args
+      end
+    end
+
+    #todo: No ipv6 support yet
+    connect_df = connect_to_endpoint *@endpoint
+    connect_df.callback { df.succeed }
+    connect_df.errback { |err| df.fail err }
+  end
+end

data/lib/cocaine/decoder.rb

@@ -0,0 +1,11 @@
+require 'cocaine/namespace'
+
+
+class Cocaine::Decoder
+  def feed(data, &block)
+    @decoder ||= MessagePack::Unpacker.new
+    @decoder.feed_each(data) do |decoded|
+      block.call decoded
+    end
+  end
+end

data/lib/cocaine/dispatcher.rb

@@ -0,0 +1,19 @@
+require 'logger'
+
+$log = Logger.new(STDERR)
+$log.level = Logger::DEBUG
+
+
+class Cocaine::Dispatcher
+  def initialize(conn)
+    @conn = conn
+    @conn.hooks.on :message do |session, message|
+      process session, message
+    end
+  end
+
+  protected
+  def process(session, message)
+    raise NotImplementedError
+  end
+end

data/lib/cocaine/error.rb

@@ -0,0 +1,2 @@
+class IllegalStateError < StandardError
+end

data/lib/cocaine/future.rb

@@ -0,0 +1,26 @@
+class Cocaine::Future
+  def set_value(value)
+    @value = value
+  end
+
+  def set_error(error)
+    @error = error
+  end
+
+  def get
+    raise @error if @error
+    @value
+  end
+
+  def self.value(value)
+    f = Cocaine::Future.new
+    f.set_value value
+    f
+  end
+
+  def self.error(error)
+    f = Cocaine::Future.new
+    f.set_error error
+    f
+  end
+end

data/lib/cocaine/namespace.rb

@@ -0,0 +1,4 @@
+module Cocaine
+  module Synchrony
+  end
+end

data/lib/cocaine/protocol.rb

@@ -0,0 +1,155 @@
+require 'msgpack'
+
+require 'cocaine/namespace'
+
+module RPC
+  HANDSHAKE = 0
+  HEARTBEAT = 1
+  TERMINATE = 2
+  INVOKE = 3
+  CHUNK = 4
+  ERROR = 5
+  CHOKE = 6
+end
+
+
+class Protocol
+  attr_reader :id
+
+  def pack(session)
+    [@id, session, content].to_msgpack
+  end
+
+  def to_s
+    "#{self.class.name}(#{content})"
+  end
+
+  protected
+  def initialize(id)
+    @id = id
+  end
+
+  protected
+  def content
+    []
+  end
+end
+
+
+class Handshake < Protocol
+  def initialize(uuid)
+    super RPC::HANDSHAKE
+    @uuid = uuid
+  end
+
+  protected
+  def content
+    [@uuid]
+  end
+end
+
+
+class Heartbeat < Protocol
+  def initialize
+    super RPC::HEARTBEAT
+  end
+end
+
+
+class Terminate < Protocol
+  attr_reader :errno
+  attr_reader :reason
+
+  def initialize(errno, reason)
+    super RPC::TERMINATE
+    @errno = errno
+    @reason = reason
+  end
+
+  protected
+  def content
+    [@errno, @reason]
+  end
+end
+
+
+class Invoke < Protocol
+  attr_reader :event
+
+  def initialize(event)
+    super RPC::INVOKE
+    @event = event
+  end
+
+  protected
+  def content
+    [@event]
+  end
+end
+
+
+class Chunk < Protocol
+  attr_reader :data
+
+  def initialize(data)
+    super RPC::CHUNK
+    @data = data
+  end
+
+  protected
+  def content
+    [@data]
+  end
+end
+
+
+class Error < Protocol
+  attr_reader :errno
+  attr_reader :reason
+
+  def initialize(errno, reason)
+    super RPC::ERROR
+    @errno = errno
+    @reason = reason
+  end
+
+  protected
+  def content
+    [@errno, @reason]
+  end
+end
+
+
+class Choke < Protocol
+  def initialize
+    super RPC::CHOKE
+  end
+end
+
+
+class Cocaine::ProtocolFactory
+  def self.create(id, data)
+    case id
+      when RPC::HANDSHAKE
+        Handshake.new *data
+      when RPC::HEARTBEAT
+        Heartbeat.new *data
+      when RPC::TERMINATE
+        Terminate.new *data
+      when RPC::INVOKE
+        Invoke.new *data
+      when RPC::CHUNK
+        Chunk.new *data
+      when RPC::ERROR
+        Error.new *data
+      when RPC::CHOKE
+        Choke.new *data
+      else
+        raise "unexpected message id: #{id}"
+    end
+  end
+end
+
+
+class ChokeEvent < Exception
+end

data/lib/cocaine/server/dispatcher.rb

@@ -0,0 +1,72 @@
+require 'cocaine/asio/channel'
+require 'cocaine/protocol'
+require 'cocaine/server/health'
+require 'cocaine/server/request'
+require 'cocaine/server/response'
+
+
+class Cocaine::WorkerDispatcher < Cocaine::Dispatcher
+  def initialize(worker, conn)
+    super conn
+    @worker = worker
+    @health = Cocaine::HealthManager.new self
+    @health.start
+    @channels = {}
+  end
+
+  def send_handshake(session, uuid)
+    send Handshake.new(uuid), session
+  end
+
+  def send_heartbeat(session)
+    send Heartbeat.new, session
+  end
+
+  def send_terminate(session, errno, reason)
+    send Terminate.new(errno, reason), session
+  end
+
+  def send_chunk(session, data)
+    send Chunk.new(data), session
+  end
+
+  def send_error(session, errno, reason)
+    send Error.new(errno, reason), session
+  end
+
+  def send_choke(session)
+    send Choke.new, session
+  end
+
+  protected
+  def process(session, message)
+    case message.id
+      when RPC::HEARTBEAT
+        @health.breath()
+      when RPC::TERMINATE
+        @worker.terminate message.errno, message.reason
+      when RPC::INVOKE
+        channel = Cocaine::Channel.new
+        request = Cocaine::Request.new channel
+        response = Cocaine::Response.new session, self
+        @channels[session] = channel
+        @worker.invoke(message.event, request, response)
+      when RPC::CHUNK
+        df = @channels[session]
+        df.trigger message.data
+      when RPC::ERROR
+        df = @channels[session]
+        df.error message.reason
+      when RPC::CHOKE
+        df = @channels.delete(session)
+        df.close
+      else
+        raise "unexpected message id: #{id}"
+    end
+  end
+
+  private
+  def send(message, session)
+    @conn.send_data message.pack(session)
+  end
+end