cocaine-framework 0.12.0.pre.rc4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2b30cb410a7cdae36692be845443f20e70f6fb1
+  data.tar.gz: 8e2f6823087e7161aeeb049387d561eb8e1742a3
+SHA512:
+  metadata.gz: a43592c3b4d2abf4077730fa553d8736046403f2e4ff3e78a52286cffacad5e732bec030a475db361c8c0b9f688c1630812d74b1fbf3141910307a2e2c07432e
+  data.tar.gz: 64fb788a2a46339f7e551e21c5e2eaaab1b582a6783ef36b3536e234de0e70fc1abf28a5a384508ddea1f253c4bdc022a4ea95e7530002ba0096974a026f1a44

data/lib/cocaine/cocaine.rb

@@ -0,0 +1,472 @@
+require 'logger'
+require 'msgpack'
+require 'optparse'
+require 'uri'
+
+require 'celluloid'
+require 'celluloid/io'
+
+module Cocaine
+  # For dynamic method creation. [Detail].
+  class Meta
+    def metaclass
+      class << self
+        self
+      end
+    end
+  end
+
+  METHOD_ID = 0
+  TX_TREE_ID = 1
+  RX_TREE_ID = 2
+
+  module Default
+    module Locator
+      $host = '::'
+      $port = 10053
+      API = {
+          0 => [
+              'resolve',
+              {},
+              {
+                  0 => ['write', nil, {}],
+                  1 => ['error', {}, {}],
+                  2 => ['close', {}, {}]
+              }
+          ]
+      }
+      ERROR_CODE = 1
+    end
+  end
+
+  module RPC
+    HANDSHAKE, HEARTBEAT, TERMINATE, INVOKE, CHUNK, ERROR, CHOKE = (0..6).to_a
+
+    RXTREE = {
+        CHUNK => ['write', nil, {}],
+        ERROR => ['error', {}, {}],
+        CHOKE => ['close', {}, {}]
+    }
+    TXTREE = RXTREE
+  end
+
+  # [Detail]
+  # Base class for shared read channel state.
+  class Mailbox
+    def initialize(queue)
+      @queue = queue
+    end
+  end
+
+  # [API]
+  # Read-only part for shared reader state.
+  class RxMailbox < Mailbox
+    def recv(timeout=30.0)
+      @queue.receive timeout
+    end
+  end
+
+  # [Detail]
+  # Write-only part for shared reader state.
+  class TxMailbox < Mailbox
+    def initialize(queue, tree)
+      super queue
+
+      @tree = Hash.new
+      tree.each do |id, (method, txtree, rxtree)|
+        @tree[id] = txtree
+      end
+    end
+
+    def push(id, payload)
+      txtree = @tree[id]
+      if txtree && txtree.empty?
+        # Todo: Close.
+        LOG.debug "Closing RX channel #{self}"
+      end
+
+      @queue << [id, payload]
+    end
+  end
+
+  # [Detail]
+  # Shared reader state, that acts like channel. Need for channel splitting between the library and a user.
+  class RxChannel
+    attr_reader :tx, :rx
+
+    def initialize(tree)
+      queue = Celluloid::Mailbox.new
+      @tx = TxMailbox.new queue, tree
+      @rx = RxMailbox.new queue
+    end
+  end
+
+  # [API]
+  # Writer channel. Patches itself with current state, providing methods described in tx tree.
+  class TxChannel < Meta
+    def initialize(tree, session, socket)
+      @session = session
+      @socket = socket
+      @tree = nil
+      rebind tree
+    end
+
+    private
+    def push(id, *args)
+      LOG.debug "<- [#{@session}, #{id}, #{args}]"
+      @socket.write MessagePack.pack [@session, id, args]
+      rebind @tree[id][Cocaine::TX_TREE_ID]
+    end
+
+    def rebind(new)
+      if new.nil?
+        LOG.debug 'Found recursive leaf - doing nothing with tx channel'
+        return
+      end
+
+      old = @tree || Hash.new
+      old.each do |id, (method, txtree, rxtree)|
+        LOG.debug "Removed '#{method}' method for tx channel"
+        self.metaclass.send(:define_method, method) do |*|
+          raise Exception.new "Method '#{method}' is removed"
+        end
+      end
+
+      new ||= Hash.new
+      new.each do |id, (method, txtree, rxtree)|
+        LOG.debug "Defined '#{method}' method for tx channel"
+        self.metaclass.send(:define_method, method) do |*args|
+          push id, *args
+        end
+      end
+
+      @tree = new
+    end
+  end
+
+  # [Detail]
+  # Service actor, which can define itself via its dispatch tree.
+  class DefinedService < Meta
+    include Celluloid::IO
+
+    def initialize(name, endpoints, dispatch)
+      @name = name
+      @dispatch = dispatch
+
+      @counter = 1
+      @sessions = Hash.new
+
+      LOG.debug "Initializing '#{name}' service - with possible endpoints: #{endpoints}"
+      endpoints.each do |host, port|
+        LOG.debug "Trying to connect to '#{name}' at '[#{host}]:#{port}'"
+        begin
+          @endpoint = [host, port]
+          @socket = TCPSocket.new(host, port)
+          break
+        rescue IOError => err
+          LOG.warn "Failed: #{err}"
+        end
+      end
+
+      dispatch.each do |id, (method, txtree, rxtree)|
+        LOG.debug "Defined '#{method}' method for service #{self}"
+        self.metaclass.send(:define_method, method) do |*args|
+          LOG.debug "Invoking #{@name}.#{method}(#{args})"
+          return invoke(id, *args)
+        end
+      end
+
+      async.run
+    end
+
+    private
+    def run
+      LOG.debug "Service '#{@name}' is running"
+      unpacker = MessagePack::Unpacker.new
+      loop do
+        data = @socket.readpartial(4096)
+        unpacker.feed_each(data) do |decoded|
+          async.received *decoded
+        end
+      end
+    end
+
+    def received(session, id, payload)
+      LOG.debug "-> [#{session}, #{id}, #{payload}]"
+      tx, rx = @sessions[session]
+      if rx
+        rx.push id, payload
+      else
+        LOG.warn "Received message to closed session: [#{session}, #{id}, #{payload}]"
+      end
+    end
+
+    def invoke(id, *args)
+      method, txtree, rxtree = @dispatch[id]
+      LOG.debug "Invoking #{@name}[#{id}=#{method}] with #{args}"
+
+      txchan = TxChannel.new txtree, @counter, @socket
+      rxchan = RxChannel.new rxtree
+      @sessions[@counter] = [txchan, rxchan.tx]
+
+      LOG.debug "<- [#{@counter}, #{id}, #{args}]"
+      message = MessagePack.pack([@counter, id, args])
+      @counter += 1
+
+      @socket.write message
+      return txchan, rxchan.rx
+    end
+  end
+
+  # [API]
+  class Locator < DefinedService
+    def initialize(host=nil, port=nil)
+      super :locator, [[host || Default::Locator::host, port || Default::Locator::port]], Default::Locator::API
+    end
+  end
+
+  class ServiceError < IOError
+  end
+
+  # [API]
+  # Service class. All you need is name and (optionally) locator endpoint.
+  class Service < DefinedService
+    def initialize(name, host=nil, port=nil)
+      locator = Locator.new host, port
+      tx, rx = locator.resolve name
+      id, payload = rx.recv
+      if id == Default::Locator::ERROR_CODE
+        raise ServiceError.new payload
+      end
+
+      endpoints, version, dispatch = payload
+      super name, endpoints, dispatch
+    end
+  end
+
+  # [Detail]
+  # Special worker actor for RAII.
+  class WorkerActor
+    include Celluloid
+
+    def initialize(block)
+      @block = block
+    end
+
+    def execute(tx, rx)
+      @block.call tx, rx
+      yield
+    end
+  end
+
+  # [API]
+  # Worker class.
+  class Worker
+    include Celluloid
+    include Celluloid::IO
+
+    execute_block_on_receiver :on
+    finalizer :finalize
+
+    def initialize(app, uuid, endpoint)
+      @app = app
+      @uuid = uuid
+      @endpoint = endpoint
+      @actors = Hash.new
+      @sessions = Hash.new
+    end
+
+    def on(event, &block)
+      @actors[event.to_s] = WorkerActor.new block
+    end
+
+    def run
+      LOG.debug "Starting worker '#{@app}' with uuid '#{@uuid}' at '#{@endpoint}'"
+      @socket = UNIXSocket.open(@endpoint)
+      async.handshake
+      async.health
+      async.serve
+    end
+
+    private
+    def handshake
+      LOG.debug '<- Handshake'
+      @socket.write MessagePack::pack([1, RPC::HANDSHAKE, [@uuid]])
+    end
+
+    def health
+      heartbeat = MessagePack::pack([1, RPC::HEARTBEAT, []])
+      loop do
+        LOG.debug '<- Heartbeat'
+        @socket.write heartbeat
+        sleep 5.0
+      end
+    end
+
+    def serve
+      unpacker = MessagePack::Unpacker.new
+      loop do
+        data = @socket.readpartial 4096
+        unpacker.feed_each data do |decoded|
+          async.received *decoded
+        end
+      end
+    end
+
+    def received(session, id, payload)
+      LOG.debug "-> Message(#{session}, #{id}, #{payload})"
+      case id
+        when RPC::HANDSHAKE
+        when RPC::HEARTBEAT
+        when RPC::TERMINATE
+          terminate *payload
+        when RPC::INVOKE
+          invoke session, *payload
+        when RPC::CHUNK, RPC::ERROR
+          push session, id, *payload
+        when RPC::CHOKE
+          LOG.debug "Closing #{session} session"
+          @sessions.delete session
+        else
+          LOG.warn "Received unknown message: [#{session}, #{id}, #{payload}]"
+      end
+    end
+
+    def invoke(session, event)
+      actor = @actors[event]
+      txchan = TxChannel.new RPC::TXTREE, session, @socket
+      rxchan = RxChannel.new RPC::RXTREE
+
+      if actor
+        @sessions[session] = [txchan, rxchan.tx]
+        actor.execute txchan, rxchan.rx do
+          LOG.debug '<- Choke'
+          txchan.close
+        end
+      else
+        LOG.warn "Event '#{event}' is not registered"
+        txchan.error -1, "event '#{event}' is not registered"
+      end
+    end
+
+    def push(session, id, *payload)
+      tx, rx = @sessions[session]
+      if rx
+        rx.push id, *payload
+      else
+        raise Exception.new "received push event on unknown #{session} session"
+      end
+    end
+
+    def terminate(errno, reason)
+      LOG.warn "Terminating [#{errno}]: #{reason}"
+      exit errno
+    end
+
+    def finalize
+      if @socket
+        @socket.close
+      end
+    end
+  end
+
+  # [API].
+  class WorkerFactory
+    def self.create
+      options = {}
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: <worker.rb> --app NAME --locator ADDRESS --uuid UUID --endpoint ENDPOINT'
+
+        opts.on('--app NAME', 'Worker name') do |app|
+          options[:app] = app
+        end
+
+        opts.on('--locator ADDRESS', 'Locator address') do |endpoint|
+          options[:locator] = endpoint
+        end
+
+        opts.on('--uuid UUID', 'Worker uuid') do |uuid|
+          options[:uuid] = uuid
+        end
+
+        opts.on('--endpoint ENDPOINT', 'Worker endpoint') do |endpoint|
+          options[:endpoint] = endpoint
+        end
+      end.parse!
+
+      Cocaine::LOG.debug "Options: #{options}"
+      Default::Locator::host, sep, Default::Locator::port = options[:locator].rpartition(':')
+      Default::Locator::port = Default::Locator::port.to_i
+
+      Cocaine::LOG.debug "Setting default Locator endpoint to: #{Default::Locator::host}:#{Default::Locator::port}"
+      return Worker.new(options[:app], options[:uuid], options[:endpoint])
+    end
+  end
+
+  class Rack
+    def self.on(event)
+      worker = Cocaine::WorkerFactory.create
+
+      worker.on :http do |res, req|
+        id, payload = req.recv
+        Cocaine::LOG.debug "After receive: '#{{:id => id, :payload => payload}}'"
+
+        case id
+          when Cocaine::RPC::CHUNK
+            method, url, version, headers, body = MessagePack::unpack payload
+            Cocaine::LOG.debug "After unpack: '#{id}, #{[method, url, version, headers, body]}'"
+
+            env = Hash[*headers.flatten]
+            parsed_url = URI.parse("http://#{env['Host']}#{url}")
+            default_host = parsed_url.hostname  || 'localhost'
+            default_port = parsed_url.port      || '80'
+
+            # noinspection RubyStringKeysInHashInspection
+            env.update(
+                {
+                    'GATEWAY_INTERFACE' => 'CGI/1.1',
+                    'PATH_INFO'         => parsed_url.path  || '',
+                    'QUERY_STRING'      => parsed_url.query || '',
+                    'REMOTE_ADDR'       => '::1',
+                    'REMOTE_HOST'       => 'localhost',
+                    'REQUEST_METHOD'    => method,
+                    'REQUEST_URI'       => url,
+                    'SCRIPT_NAME'       => '',
+                    'SERVER_NAME'       => default_host,
+                    'SERVER_PORT'       => default_port.to_s,
+                    'SERVER_PROTOCOL'   => "HTTP/#{version}",
+                    'rack.version'      => [1, 5],
+                    'rack.input'        =>  body,
+                    'rack.errors'       => $stderr,
+                    'rack.multithread'  => true,
+                    'rack.multiprocess' => false,
+                    'rack.run_once'     => false,
+                    'rack.url_scheme'   => 'http',
+                    'HTTP_VERSION'      => "HTTP/#{version}",
+                    'REQUEST_PATH'      => parsed_url.path,
+                }
+            )
+
+            Cocaine::LOG.debug "ENV: #{env}"
+
+            now                        = Time.now
+            code, headers, body        = yield env
+            headers['X-Response-Took'] = Time.now - now
+            res.write MessagePack.pack [code, headers.to_a]
+            body.each do |item|
+              res.write(item)
+            end
+
+            body.close if body.respond_to?(:close)
+          when Cocaine::RPC::ERROR
+          when Cocaine::RPC::CHOKE
+          else
+            # Type code here.
+        end
+      end
+
+      worker.run
+      sleep
+    end
+  end
+end

data/lib/cocaine/version.rb

@@ -0,0 +1,3 @@
+module Cocaine
+  VERSION = '0.12.0-rc4'
+end

data/lib/cocaine.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'logger'
+
+module Cocaine
+  LOG = Logger.new STDERR
+  LOG.level = ENV['WORKER_LOG_LEVEL'] || Logger::DEBUG
+end
+
+require 'cocaine/version'
+require 'cocaine/cocaine'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: cocaine-framework
+version: !ruby/object:Gem::Version
+  version: 0.12.0.pre.rc4
+platform: ruby
+authors:
+- Evgeny Safronov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: celluloid-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+description: |-
+  Cocaine Framework is a framework for simplifying development both server-side and client-side
+  applications.
+email:
+- division494@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cocaine.rb
+- lib/cocaine/cocaine.rb
+- lib/cocaine/version.rb
+homepage: https://github.com/cocaine/cocaine-framework-ruby
+licenses:
+- Ruby
+- LGPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby/Cocaine library
+test_files: []