cocaine-framework-ruby 0.11.2

data/lib/cocaine/server/health.rb

@@ -0,0 +1,76 @@
+require 'eventmachine'
+
+
+$log = Logger.new(STDERR)
+$log.level = Logger::DEBUG
+
+
+class Timer
+  def initialize(timeout)
+    @timeout = timeout
+  end
+end
+
+
+class DisownTimer < Timer
+  def initialize(timeout = 10.0)
+    super timeout
+  end
+
+  def start(&block)
+    @timer = EM::Timer.new @timeout do
+      block.call
+    end
+  end
+
+  def cancel
+    @timer.cancel if @timer
+  end
+end
+
+
+class HeartbeatTimer < Timer
+  def initialize(timeout = 30.0)
+    super timeout
+  end
+
+  def start(&block)
+    @timer = EM::PeriodicTimer.new @timeout do
+      block.call
+    end
+  end
+
+  def cancel
+    @timer.cancel if @timer
+  end
+end
+
+
+class Cocaine::HealthManager
+  def initialize(dispatcher, options={})
+    @dispatcher = dispatcher
+    options = {disown: 2.0, heartbeat: 10.0}.merge options
+    @disown = DisownTimer.new(options[:disown])
+    @heartbeat = HeartbeatTimer.new(options[:heartbeat])
+  end
+
+  def start
+    $log.debug 'health manager has been started'
+    @heartbeat.start { exhale }
+  end
+
+  def breath
+    $log.debug '[->] doing breath'
+    @disown.cancel
+  end
+
+  private
+  def exhale
+    $log.debug '[<-] doing exhale'
+    @disown.start {
+      $log.error 'worker has been disowned'
+      EM.next_tick { EM.stop }
+    }
+    @dispatcher.send_heartbeat 0
+  end
+end

data/lib/cocaine/server/http.rb

@@ -0,0 +1,63 @@
+require 'cgi'
+require 'net/http'
+
+require 'cocaine/namespace'
+
+$log = Logger.new(STDERR)
+$log.level = Logger::DEBUG
+
+module Cocaine::Http
+  class Request
+    attr_reader :method, :version, :query, :headers, :body
+
+    def initialize(rq)
+      @ch = rq.read
+    end
+
+    def read
+      ch = Cocaine::Channel.new
+      @ch.callback { |msg|
+        @method, url, @version, headers, @body = MessagePack::unpack msg
+        @headers = Hash[headers]
+        tmp_query = URI.parse(url).query
+        @query = tmp_query == nil ? {} : CGI.parse(tmp_query)
+        ch.trigger self
+      }.errback { |err|
+        ch.error err
+      }
+      ch
+    end
+  end
+
+  class Response
+    def initialize(response)
+      @response = response
+    end
+
+    def write_headers(code, headers)
+      @response.write [code, headers]
+    end
+
+    def body=(body)
+      @response.write body
+    end
+
+    def error(errno, reason)
+      @response.error errno, reason
+    end
+
+    def close
+      @response.close
+    end
+  end
+
+  def http(method_name)
+    old_method_name = "#{method_name}_old".to_sym
+    alias_method(old_method_name, method_name)
+    define_method(method_name) do |rq, rs|
+      request = Request.new rq
+      response = Response.new rs
+      send(old_method_name, request, response)
+    end
+  end
+end

data/lib/cocaine/server/request.rb

@@ -0,0 +1,9 @@
+class Cocaine::Request
+  def initialize(channel)
+    @ch = channel
+  end
+
+  def read
+    @ch
+  end
+end

data/lib/cocaine/server/response.rb

@@ -0,0 +1,31 @@
+require 'cocaine/error'
+
+
+class Cocaine::Response
+  def initialize(session, dispatcher)
+    @session = session
+    @dispatcher = dispatcher
+    @closed = false
+  end
+
+  def write(data)
+    check_closed
+    @dispatcher.send_chunk @session, data.to_msgpack
+  end
+
+  def error(errno, reason)
+    check_closed
+    @dispatcher.send_error @session, errno, reason
+  end
+
+  def close
+    check_closed
+    @closed = true
+    @dispatcher.send_choke @session
+  end
+
+  private
+  def check_closed
+    raise IllegalStateError.new 'Response is already closed' if @closed
+  end
+end

data/lib/cocaine/server/sandbox.rb

@@ -0,0 +1,38 @@
+$log = Logger.new(STDERR)
+$log.level = Logger::DEBUG
+
+
+class Cocaine::Sandbox
+  module Errno
+    NO_SUCH_EVENT = 1
+  end
+
+  def initialize
+    @handlers = {}
+  end
+
+  def on(event, handler)
+    @handlers[event] = handler
+  end
+
+  def invoke(event, request, response)
+    if @handlers.has_key? event
+      invoke_handler event, request, response
+    else
+      write_error Errno::NO_SUCH_EVENT, "application has no event '#{event}'", response
+    end
+  end
+
+  private
+  def invoke_handler(event, request, response)
+    $log.debug "invoking '#{event}'"
+    handler = @handlers[event]
+    handler.execute(request, response)
+  end
+
+  private
+  def write_error(errno, reason, response)
+    response.error errno, reason
+    response.close
+  end
+end

data/lib/cocaine/server/worker.rb

@@ -0,0 +1,73 @@
+require 'optparse'
+
+require 'cocaine/asio/connection'
+require 'cocaine/server/dispatcher'
+require 'cocaine/server/sandbox'
+
+$log = Logger.new(STDERR)
+$log.level = Logger::DEBUG
+
+
+class Cocaine::Worker
+  def initialize(options={})
+    options = {
+        endpoint: '',
+        uuid: '',
+    }.merge(options)
+
+    @endpoint = options[:endpoint]
+    @uuid = options[:uuid]
+
+    @sandbox = Cocaine::Sandbox.new
+  end
+
+  def on(event, handler)
+    @sandbox.on event, handler
+  end
+
+  def run
+    EM.error_handler { |error|
+      short_reason = error.inspect
+      traceback = error.backtrace.join("\n")
+      $log.warn "error caught at the top of event loop:\n#{short_reason}\n#{traceback}"
+    }
+
+    EM.run do
+      $log.debug 'starting worker'
+      $log.debug "connecting to the #{@endpoint}"
+      EM.connect @endpoint, nil, Cocaine::Connection do |conn|
+        $log.debug "connection established with #{@endpoint}"
+        @dispatcher = Cocaine::WorkerDispatcher.new self, conn
+        @dispatcher.send_handshake 0, @uuid
+        @dispatcher.send_heartbeat 0
+      end
+    end
+  end
+
+  def invoke(event, request, response)
+    @sandbox.invoke(event, request, response)
+  end
+
+  def terminate(errno, reason)
+    $log.debug "terminating with: [#{errno}] #{reason}"
+    @dispatcher.send_terminate 0, errno, reason
+    EM.stop
+    exit(errno)
+  end
+end
+
+
+class Cocaine::WorkerFactory
+  def self.create
+    options = {}
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: <your_worker.rb> --app NAME --locator ADDRESS --uuid UUID --endpoint ENDPOINT'
+
+      opts.on('--app NAME', 'Worker name') { |a| options[:app] = a }
+      opts.on('--locator ADDRESS', 'Locator address') { |a| options[:locator] = a }
+      opts.on('--uuid UUID', 'Worker uuid') { |a| options[:uuid] = a }
+      opts.on('--endpoint ENDPOINT', 'Worker endpoint') { |a| options[:endpoint] = a }
+    end.parse!
+    return Cocaine::Worker.new options
+  end
+end

data/lib/cocaine/synchrony/channel.rb

@@ -0,0 +1,72 @@
+require 'fiber'
+require 'em-synchrony'
+
+require 'cocaine/namespace'
+
+class Cocaine::Synchrony::Channel
+  def initialize(channel)
+    @pending = []
+    register_fiber channel
+  end
+
+  def read
+    if @pending.empty?
+      future = Fiber.yield
+    else
+      future = @pending.pop
+    end
+    future.get
+  end
+
+  def each
+    loop do
+      begin
+        yield Fiber.yield.get
+      rescue ChokeEvent
+        return
+      end
+    end
+  end
+
+  def collect(count=0)
+    if count == 0
+      collect_until_choke
+    else
+      collect_until_count count
+    end
+  end
+
+  private
+  def register_fiber(channel)
+    fb = Fiber.current
+    channel.callback { |future|
+      if fb.alive?
+        fb.resume future
+      else
+        @pending.push future
+      end
+    }
+  end
+
+  private
+  def collect_until_count(count)
+    results = []
+    each do |chunk|
+      results.push chunk
+      count -= 1
+      if count == 0
+        break
+      end
+    end
+    results
+  end
+
+  private
+  def collect_until_choke
+    results = []
+    each do |chunk|
+      results.push chunk
+    end
+    results
+  end
+end

data/lib/cocaine/synchrony/service.rb

@@ -0,0 +1,53 @@
+require 'cocaine/client/service'
+require 'cocaine/synchrony/channel'
+
+
+module Cocaine::Synchrony
+  def self.sync(df)
+    fb = Fiber.current
+    df.callback do |result|
+      if fb == Fiber.current
+        return result
+      else
+        fb.resume result
+      end
+    end
+
+    df.errback do |err|
+      if fb == Fiber.current
+        raise err
+      else
+        fb.resume err
+      end
+    end
+
+    result = Fiber.yield
+    if result.is_a? Exception
+      raise result
+    else
+      return result
+    end
+  end
+end
+
+
+class Cocaine::Synchrony::Service
+  def initialize(name, host='localhost', port=10053)
+    @service = Cocaine::Service.new name, host, port
+    connect
+    create_proxy_methods
+  end
+
+  def connect
+    Cocaine::Synchrony.sync @service.connect
+  end
+
+  private
+  def create_proxy_methods
+    @service.api.each do |id, name|
+      self.metaclass.send(:define_method, name) do |*args|
+        Cocaine::Synchrony::Channel.new @service.send name, *args
+      end
+    end
+  end
+end

data/lib/cocaine/testing/mock_server.rb

@@ -0,0 +1,123 @@
+require 'em-synchrony'
+require 'logger'
+
+require 'cocaine/synchrony/service'
+
+$log = Logger.new(STDOUT)
+$log.level = Logger::DEBUG
+
+
+class Hook
+  attr_reader :callbacks
+  def initialize
+    @callbacks = {
+        :connected => lambda {},
+        :message => {}
+    }
+  end
+
+  def connected(&block)
+    @callbacks[:connected] = block
+  end
+
+  def message(request, &block)
+    @callbacks[:message][request] = block
+  end
+end
+
+
+class CocaineRuntimeMock
+  module Server
+    def initialize(name, responses=nil, hook=nil, options={})
+      $log.debug "new connection for '#{name}'"
+      @name = name
+      @responses = responses || {}
+      @hook = hook || Hook.new
+      @options = options
+    end
+
+    def post_init
+      @hook.callbacks[:connected].call
+    end
+
+    def receive_data(data)
+      unpacker ||= MessagePack::Unpacker.new
+      unpacker.feed_each data do |chunk|
+        id, session, data = chunk
+        $log.debug "received message: [#{id}, #{session}, #{data}]"
+
+        if @hook.callbacks[:message].has_key? chunk
+          response = @hook.callbacks[:message][chunk].call
+          send_response session, response
+        elsif @responses.has_key? chunk
+          response = @responses[chunk]
+          send_response session, response
+        end
+      end
+    end
+
+    private
+    def send_response(session, response)
+      $log.debug "iterating over response: #{response}"
+      response.each do |chunk|
+        if chunk.is_a? Error
+          send_data chunk.pack session
+        else
+          send_data (Chunk.new chunk.to_msgpack).pack session
+        end
+      end
+      send_data Choke.new.pack session
+    end
+  end
+
+  def initialize(options = {})
+    options = {:host => 'localhost', :port => 10053}.merge(options)
+
+    @host = options[:host]
+    @port = options[:port]
+
+    @services = {}
+    @responses = {}
+    @hooks = {}
+
+    @servers = []
+
+    register 'locator', 0, endpoint: [@host, @port], version: 1, api: {}
+  end
+
+  def register(name, session, options={})
+    raise "service '#{name}' already registered" if @services.has_key? name
+
+    $log.debug "registering '#{name}' service"
+
+    options = {endpoint: ['localhost', 0], version: 1, api: {}}.merge options
+    @services[name] = options
+
+    on 'locator',
+       [0, session, [name]],
+       [[options[:endpoint], options[:version], options[:api]]]
+  end
+
+  def on(name, request, response)
+    @responses[name] ||= {}
+    @responses[name][request] = response
+  end
+
+  def when(name)
+    @hooks[name] ||= Hook.new
+  end
+
+  def run
+    @services.each do |name, options|
+      $log.debug "starting '#{name}' service at #{options[:endpoint]}"
+      sig = EM::start_server *options[:endpoint], Server, name, @responses[name], @hooks[name], options
+      @servers.push sig
+    end
+  end
+
+  def stop
+    @servers.each do |sig|
+      EM.stop_server sig
+    end
+  end
+end