redom 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 by Yi Hu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+DJS Tutorial
+
+  DJS is a distributed object library for Server-WebBrowser communication. This tutorial shows how to create a web application using DJS.
+
+===============
+Getting started
+===============
+
+- Creating a DJS connection class
+
+  A DJS connection class is where you write the scripts to manipulate the browser-side objects from server. The DJS connection class must be subclass of 'DJS::DJSConnection'. An instance of DJS connection class will be created when the connection between browser and DJS server is established. There are four methods in 'DJS::DJSConnection' that can be overridden to tell DJS what to do.
+
+  on_open()       - Called when the connection is established.
+  on_error(err)   - Called when an browser-side error occurs.
+  on_message(msg) - Called when an message is received from browser.(not implemented)
+  on_close()      - Called when the connection is shutdown.(not implemented)
+
+  Here is an example:
+#
+  class MyConnection < DJS::Connection
+    def on_open
+      window.alert "Hello world!"
+    end
+    def on_error(error)
+      p error
+    end
+  end
+#
+
+- Starting DJS server
+
+  After a DJS connection class is defined, you can start DJS server using 'DJS::start(klass)' method. Your DJS connection class must be passed as the argument.
+#
+  DJS.start(MyConnection, {:host => 127.0.0.1, :port => 8080})
+#
+
+- Adding DJS library to HTML
+
+  Add DJS JavaScript library 'djs.js' in your HTML. And call 'djs.start(host)' to connect to a DJS server.
+#
+  <script type="text/javascript" src="djs.js"></script>
+  <script type="text/javascript">
+    window.onload = function() {
+      djs.start("ws://127.0.0.1:8080");
+    }
+  </script>
+#
+
+- Stopping DJS server
+
+  Use 'DJS.stop' to stop a DJS server.
+#
+  DJS.stop
+#
+
+========
+API Docs
+========
+
+* Module: DJS
+
+  - DJS.start(klass, opts = {})
+    
+    Start DJS server.
+
+    Parameters:
+      klass (Class) - A class that extends DJS::Connection
+      opts (Hash) - Options. Default values are as below:
+        :buff_size => 200 - Messages stored before synchronization with browser.
+
+  - DJS.stop
+
+    Stop DJS server.
+
+  - DJS.connections
+
+    Return all DJS connection instances that the DJS server is holding currently.
+
+    Returns:
+      (DJS::Connections) - An DJS::Connections instance that contains all DJS::Connection instances the DJS server is holding currently.
+
+    Examples:
+      DJS.connections.do_something
+  
+
+* Class: DJS::Connection
+
+  - sync
+
+    Synchronize with browser immediately.
+
+  - window
+
+    A reference for browser-side object 'window'.
+
+   Returns:
+     (DJS::ProxyObject) - A DJS::ProxyObject that references to browser-side object 'window'.
+
+   Examples:
+     window.alert "Hello world."
+
+* Class: DJS:ProxyObject
+
+  - sync, to_s, to_f, to_i, to_a, to_h, to_b
+
+    Synchronize with browser immediately and return the true value of the referenced object.
+
+    Returns:
+      (Object) - Primitive type if the referenced object is primitive, otherwise the DJS::ProxyObject itself.
+
+    Examples:
+      value = document.getElementById("text").value.sync
+
+=====
+Hints
+=====
+
+- Define a event handler as 'object.event_name = :event_handler_name'
+  Examples:
+    def button_click_handler(event)
+      button = event.srcElement
+    end
+    document.getElementById("button").onclick = :button_click_handler
+
+
+

data/bin/redom

@@ -0,0 +1,83 @@
+#! /usr/bin/env ruby
+
+require 'em-websocket'
+require 'optparse'
+require 'redom'
+
+options = {
+  :host => '0.0.0.0',
+  :port => 8080
+}
+
+parser = OptionParser.new { |opts|
+  opts.banner = "Usage: redom [options] app"
+
+  opts.separator ""
+  opts.separator "Server options:"
+
+  opts.on("-h", "--host HOST",             "bind to HOST address (default: #{options[:host]})") { |host| options[:host] = host }
+  opts.on("-p", "--port PORT",             "use PORT (default: #{options[:port]})") { |port| options[:port] = port.to_i }
+
+  opts.separator ""
+  opts.separator "Secure options:"
+
+  opts.on(      "--secure",                "accept secure wss:// connections") { options[:secure] = true }
+  opts.on(      "--private-key-file PATH", "path to private key") { |path|
+    if tls = options[:tls_options]
+      tls[:private_key_file] = path
+    else
+      options[:tls_options] = { :private_key_file => path }
+    end
+  }
+  opts.on(      "--cert-chain-file PATH",  "path to certificate") { |path|
+    if tls = options[:tls_options]
+      tls[:cert_chain_file] = path
+    else
+      options[:tls_options] = { :cert_chain_file => path }
+    end
+  }
+  opts.on(      "--secure-proxy",          "running behind an SSL/Terminator") { options[:secure_proxy] = true }
+  
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on(      "--worker NUM",            "number of worker thread (default: 5)") { |num| options[:worker] = num.to_i }
+  opts.on(      "--buff-size NUM",         "size of packed RPC message before sync") { |num| options[:buff_size] = num.to_i }
+  opts.on(      "--log FILE",              "path to log (default: STDOUT)") { |path| options[:log] = path }
+  opts.on(      "--log-level fatal|error|warn|info|debug", "log level (default: error)") { |lv| options[:log_level] = lv }
+  opts.on_tail( "--help",                  "show this message") { puts opts; exit }
+  opts.on_tail( "--version",               "show version") { puts Redom::VERSION; exit }
+}
+
+parser.parse ARGV
+
+
+if ARGV.length > 0
+#$LOAD_PATH << pwd unless $LOAD_PATH.include?(pwd)
+  require Dir.pwd + '/' + ARGV[-1]
+else
+  puts 'No Redom app file specified.'
+  exit
+end
+
+Redom.start options
+
+EventMachine.run do
+  EventMachine::WebSocket.start(options) do |ws|
+    ws.onopen {
+      Redom.on_open ws
+    }
+
+    ws.onmessage { |msg|
+      Redom.on_message ws, msg
+    }
+
+    ws.onclose {
+      Redom.on_close ws
+    }
+
+    ws.onerror { |error|
+       Redom.on_error ws, error
+    }
+  end
+end

data/lib/redom.rb

@@ -0,0 +1,94 @@
+require 'fiber'
+require 'json'
+require 'logger'
+require 'thread'
+
+$LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+%w[
+  utils connection dispatcher proxy task worker thread_pool runtime version
+].each { |file|
+  require "redom/#{file}"
+}
+
+module Redom
+  DEFAULT_OPTIONS = {
+    :log => STDOUT,
+    :log_level => 'error',
+    :worker => 5,
+    :buff_size => 200
+  }
+
+  REQ_HANDSHAKE          = 0
+  REQ_METHOD_INVOCATION  = 1
+  REQ_PROXY_RESULT       = 2
+
+  IDX_REQUEST_TYPE     = 0
+  # REQ_HANDSHAKE
+  IDX_CONNECTION_CLASS = 1
+  # REQ_METHOD_INVOCATION
+  IDX_METHOD_NAME      = 1
+  IDX_ARGUMENTS        = 2
+  # REQ_PROXY_RESULT
+  IDX_TASK_ID          = 1
+  IDX_PROXY_RESULT     = 2
+
+  TYPE_UNDEFINED = 0
+  TYPE_PROXY     = 1
+  TYPE_ARRAY     = 2
+  TYPE_ERROR     = 3
+  TYPE_METHOD    = 4
+
+  T_INFO_METHOD_NAME = 0
+  T_INFO_ARGUMENTS   = 1
+  T_INFO_BLOCK       = 2
+
+  P_INFO_OID  = 0
+  P_INFO_RCVR = 1
+  P_INFO_NAME = 2
+  P_INFO_ARGS = 3
+
+  class << self
+    # Start Redom dispatcher
+    # @param [Hash] opts Options
+    def start(opts = {})
+      opts = DEFAULT_OPTIONS.merge(opts)
+      logger = Logger.new(opts[:log])
+      logger.level = case opts[:log_level].downcase
+      when 'fatal'
+        Logger::FATAL
+      when 'error'
+        Logger::ERROR
+      when 'warn'
+        Logger::WARN
+      when 'info'
+        Logger::INFO
+      when 'debug'
+        Logger::DEBUG
+      else
+        Logger::FATAL
+      end
+      Utils.logger = logger
+      Utils.dispatcher = @@dispatcher = Dispatcher.new(opts)
+    end
+
+    def stop
+      @@dispatcher.stop
+    end
+
+    def on_open(ws)
+      @@dispatcher.on_open(ws)
+    end
+
+    def on_message(ws, msg)
+      @@dispatcher.on_message(ws, msg)
+    end
+
+    def on_close(ws)
+      @@dispatcher.on_close(ws)
+    end
+
+    def on_error(ws, err)
+      @@dispatcher.on_error(ws, err)
+    end
+  end
+end

data/lib/redom/connection.rb

@@ -0,0 +1,96 @@
+module Redom
+  module Connection
+    include Utils
+
+    # Default event handlers
+    def on_open; end
+    def on_close; end
+    def on_error(err); end
+
+    # Proxy of browser objects
+    def window
+      Proxy.new(self, [:window], {:backtrace => caller[0]})
+    end
+    def document
+      Proxy.new(self, [:document], {:backtrace => caller[0]})
+    end
+
+    def method_missing(name, *args, &blck)
+      window.method_missing(name, *args, &blck)
+    end
+
+    def connections(filter = self.class)
+      _dispatcher.connections(filter)
+    end
+
+    # Initialization
+    def _init(ws, opts)
+      @ws = ws
+      @proxies = Hash.new
+      @buff_size = opts[:buff_size]
+      self
+    end
+
+    def _bulk(proxy)
+      fid = _fid
+      stack = @proxies[fid] || @proxies[fid] = Hash.new
+      stack[proxy._info[P_INFO_OID]] = proxy
+      if stack.size == @buff_size
+        sync
+      end
+    end
+
+    def sync(obj = nil)
+      obj = _fid if obj == self
+      if Connection === obj
+        _dispatcher.run_task(obj, :sync, [_fid], nil)
+        return
+      end
+
+      fid = obj ? obj : _fid
+      stack = @proxies[fid]
+      return if !stack || stack.empty?
+
+      msg = []
+      stack.each { |k, v|
+        msg << v._info
+      }
+
+      rsp = Fiber.yield(msg)
+
+      error = nil
+      while result = rsp.shift
+        proxy = stack[result[0]]
+        if Array === result[1]
+          case result[1][0]
+          when TYPE_UNDEFINED
+            # TODO
+          when TYPE_PROXY
+            proxy._origin proxy
+          when TYPE_ERROR
+            # TODO
+          end
+        else
+          proxy._origin result[1]
+        end
+      end
+
+      stack.clear
+
+      on_error(error) if error
+    end
+
+    def _cid
+      @ws.__id__
+    end
+
+    def _fid
+      "F#{Fiber.current.__id__}"
+    end
+
+    def _send(msg)
+      _logger.debug "Message sent. ID='#{@ws.__id__}'\n#{msg}"
+      @ws.send msg
+    end
+  end
+end

data/lib/redom/dispatcher.rb

@@ -0,0 +1,114 @@
+module Redom
+  class Dispatcher
+    include Utils
+
+    def initialize(opts)
+      if find_all_connection_classes.size == 0
+        _logger.warn 'No Redom::Connection class defined.'
+      end
+
+      @opts = opts
+      @conns = Hash.new
+      @tasks = Hash.new
+      @pool = ThreadPool.new(@opts)
+      @pool.start
+    end
+
+    def stop
+      @pool.stop
+    end
+
+    def run_task(conn, name, args, blck)
+      task = Task.new(conn, @pool.worker, [name, args, blck])
+      @tasks[task._id] = task
+      task.run
+    end
+
+    def on_open(ws)
+      _logger.debug "Connection established. ID='#{ws.__id__}'"
+    end
+
+    def on_message(ws, msg)
+      _logger.debug "Message received. ID='#{ws.__id__}'\n#{msg}"
+      req = JSON.parse(msg)
+      case req[IDX_REQUEST_TYPE]
+      when REQ_HANDSHAKE
+        if cls = @conn_cls[req[IDX_CONNECTION_CLASS]]
+          conn = cls.new._init(ws, @opts)
+          @conns[ws.__id__] = conn
+          task = Task.new(conn, @pool.worker, [:on_open, []])
+          @tasks[task._id] = task
+          task.run
+        else
+          _logger.error "Undefined Redom::Connection class '#{req[IDX_CONNECTION_CLASS]}'."
+        end
+      when REQ_METHOD_INVOCATION
+        if conn = @conns[ws.__id__]
+          req[IDX_ARGUMENTS].map! { |arg|
+            if Array === arg
+              case arg[0]
+              when TYPE_PROXY
+                  arg = Proxy.new(conn, [arg[1]])
+              when TYPE_ARRAY
+                  arg = arg[1]
+              end
+            end
+            arg
+          }
+          task = Task.new(conn, @pool.worker, req[IDX_METHOD_NAME..-1])
+          @tasks[task._id] = task
+          task.run
+        else
+          _logger.error "Connection missing. ID='#{ws.__id__}'"
+        end
+      when REQ_PROXY_RESULT
+        if task = @tasks[req[IDX_TASK_ID]]
+          task.run req[IDX_PROXY_RESULT]
+        else
+          _logger.error "Task missing. ID='#{req[IDX_TASK_ID]}'"
+        end
+      else
+        _logger.error "Undefined request type '#{req[IDX_REQUEST_TYPE]}'."
+      end
+    end
+
+    def on_close(ws)
+      _logger.debug "Connection closed. ID='#{ws.__id__}'"
+      if conn = @conns[ws.__id__]
+        task = Task.new(conn, @pool.worker, [:on_close, []])
+        @tasks[task._id] = task
+        task.run
+        @conns.delete ws.__id__
+      end
+    end
+
+    def on_error(ws, err)
+      _logger.debug "Error occured. ID='#{ws.__id__}'"
+    end
+
+    def delete_task(task_id)
+      @tasks.delete task_id
+    end
+
+    def connections(filter = nil)
+      if filter
+        @conns.values.select { |conn|
+          filter === conn
+        }
+      else
+        @conns.values
+      end
+    end
+
+    private
+
+    def find_all_connection_classes
+      @conn_cls = Hash.new
+      ObjectSpace.each_object(Class).select { |cls|
+        cls < Connection
+      }.each { |cls|
+        @conn_cls[cls.name] = cls
+      }
+    end
+  end
+end

data/lib/redom/proxy.rb

@@ -0,0 +1,67 @@
+module Redom
+  class Proxy
+    def initialize(conn, info, extra = {})
+      @conn = conn
+      @info = info
+      @info[P_INFO_OID] = __id__ unless @info[P_INFO_OID]
+
+      @solved = false
+      @origin = nil
+    end
+    attr_reader :origin
+
+    def method_missing(name, *args, &blck)
+      return @origin.send(name, *args, &block) if @solved && !@origin.is_a?(Proxy)
+
+      if blck
+        @conn.sync
+        return @origin.send(name, *args, &block)
+      end
+
+      proxy = Proxy.new(@conn, [nil, _info[P_INFO_OID], name, _arg(args)], {:backtrace => caller[0]})
+      @conn._bulk proxy
+      proxy
+    end
+
+    def sync
+      unless @solved
+        @conn.sync
+      end
+      @origin
+    end
+
+    def _info
+      @info
+    end
+
+    def _origin(org)
+      @solved = true
+      @origin = org
+    end
+
+    private
+
+    def _arg(arg)
+      case arg
+      when Proxy
+        [TYPE_PROXY, arg._info[P_INFO_OID]]
+      when Array
+        arg.map! { |item|
+          _arg(item)
+        }
+        [TYPE_ARRAY, arg]
+      when Hash
+        arg.each { |k, v|
+          arg[k] = _arg(v)
+        }
+        arg
+      when Method
+        [TYPE_METHOD, arg.name]
+      when Symbol
+        [TYPE_METHOD, arg.to_s]
+      else
+        arg
+      end
+    end
+  end
+end

data/lib/redom/runtime.rb

@@ -0,0 +1,252 @@
+module Redom
+  class << self
+    def runtime
+<<EOS
+(function() {
+  var
+  TYPE_UNDEFINED = 0,
+  TYPE_PROXY     = 1,
+  TYPE_ARRAY     = 2,
+  TYPE_ERROR     = 3,
+  TYPE_METHOD    = 4
+
+  REQ_HANDSHAKE         = 0,
+  REQ_METHOD_INVOCATION = 1,
+  REQ_PROXY_RESULT      = 2,
+
+  P_INFO_OID  = 0,
+  P_INFO_RCVR = 1,
+  P_INFO_NAME = 2,
+  P_INFO_ARGS = 3;
+
+  var Redom = function(server) {
+    var ws = new WebSocket(server);
+      conn = "Connection",
+      refs = {
+        seq: 0,
+        hash: {},
+        put: function() {
+          var key;
+          if (arguments.length == 2) {
+            key = arguments[0];
+            this.hash[key] = arguments[1];
+          } else if (arguments.length == 1) {
+            key = "R" + (++this.seq);
+            this.hash[key] = arguments[0];
+          } else {
+            console.log("ERROR: wrong number of arguments!");
+          }
+          return key;
+        },
+        get: function(key) {
+          return this.hash[key];
+        }
+      },
+      tasks = [];
+
+    // Initialize refs
+    refs.put("window", window);
+    refs.put("document", document);
+    refs.put("history", history);
+    refs.put("navigator", navigator);
+    refs.put("location", location);
+
+    // Initialize WebSocket event handlers
+    function open(connectionClassName) {
+      ws.onopen = function() {
+        conn = connectionClassName;
+        ws.send(serialize([REQ_HANDSHAKE, conn]));
+        console.log("WebSocket opened.");
+      };
+      ws.onclose = function() {
+        console.log("WebSocket closed.");
+      };
+      ws.onerror = function(error) {
+        console.log(error);
+      };
+      ws.onmessage = function(event) {
+        var data = unserialize(event.data);
+        var tid = data[0];
+        var proxies = data[1];
+        var queue = tasks[tid];
+        if (!queue) {
+          queue = [];
+          tasks[tid] = queue;
+        }
+        for (var i = 0; i < proxies.length; i++) {
+          queue.push(proxies[i]);
+        }
+        try {
+          process(tid);
+        } catch (e) {
+          console.log(e);
+        }
+      };
+    };
+
+    // Close this WebSocket connection
+    function close() {
+      ws.close();
+    }
+
+    // Serialize JavaScript object into message
+    function serialize(data) {
+      return JSON.stringify(data);
+    };
+    // Unserialize message into JavaScript object
+    function unserialize(msg) {
+      return JSON.parse(msg);
+    };
+
+    // Restore arguments
+    function restore(args) {
+      if (args instanceof Array) {
+        switch(args[0]) {
+        case TYPE_ARRAY:
+          for (var i = 0; i < args[1].length; i++) {
+            args[1][i] = restore(args[1][i]);
+          }
+          return args[1];
+          break;
+        case TYPE_PROXY:
+          return refs.get(args[1]);
+          break;
+        case TYPE_METHOD:
+          return (function(name) {
+            if (window[name] && typeof(window[name]) == 'function') {
+              return function() {
+                window[name];
+              };
+            } else {
+              return function() {
+                var type, args = [];
+                for (var i = 0; i < arguments.length; i++) {
+                  switch(type = typeOf(arguments[i])) {
+                    case null:
+                      args.push(arguments[i]);
+                      break;
+                    case TYPE_PROXY:
+                    case TYPE_ARRAY:
+                      args.push([type, refs.put(arguments[i])]);
+                      break;
+                  }
+                }
+                ws.send(serialize([REQ_METHOD_INVOCATION, name, args]));
+              }
+            }
+          })(args[1]);
+          break;
+        }
+      } else {
+        return args;
+      }
+    };
+
+    // Evaluation proxies from server
+    function process(tid) {
+      var proxy, oid, name, args, result, type,
+        rsps = [],
+        queue = tasks[tid];
+      while (proxy = queue.shift()) {
+        oid = proxy[P_INFO_OID];
+        rcvr = refs.get(proxy[P_INFO_RCVR]);
+        name = proxy[P_INFO_NAME];
+        args = restore(proxy[P_INFO_ARGS]);
+
+        if (rcvr) {
+          result = execute(rcvr, name, args);
+          if (result == undefined) {
+            rsps.push([oid, [TYPE_UNDEFINED]]);
+            ws.send(serialize([REQ_PROXY_RESULT, tid, rsps]));
+            return;
+          } else {
+            refs.put(oid, result);
+            switch (type = typeOf(result)) {
+              case null:
+                rsps.push([oid, result]);
+                break;
+              case TYPE_PROXY:
+              case TYPE_ARRAY:
+                rsps.push([oid, [type]]);
+                break;
+            };
+          }
+        } else {
+          rsps.push([oid, TYPE_ERROR, "no such object. ID='" + proxy[P_INFO_RCVR] + "'."]);
+          ws.send(serialize([REQ_PROXY_RESULT, tid, rsps]));
+          return;
+        }
+      }
+      ws.send(serialize([REQ_PROXY_RESULT, tid, rsps]));
+    };
+
+    // Type of object
+    function typeOf(obj) {
+      switch(typeof obj) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "undefined":
+          return null;
+        case "object":
+          if (obj == null) {
+            return null;
+          } else if (obj instanceof Array) {
+            return TYPE_ARRAY;
+          } else {
+            return TYPE_PROXY;
+          }
+        case "function":
+          return TYPE_METHOD;
+      }
+      return TYPE_UNDEFINED;
+    }
+
+    // Method invocation
+    function execute(rcvr, name, args) {
+      var result;
+      if (name.match(/^(.+)=$/)) {
+        name = RegExp.$1;
+        if (name == "[]") {
+          result = rcvr[args[0]] = args[1];
+        } else {
+          result = rcvr[name] = args[0];
+        }
+      } else {
+        if (name == "[]") {
+          result = rcvr[args[0]];
+        } else {
+          result = rcvr[name];
+          if (typeof result == "function") {
+            result = result.apply(rcvr, args);
+          }
+        }
+      }
+      return result;
+    };
+
+    return {
+      getServer: function() {
+        return server;
+      },
+
+      getConnection: function() {
+        return conn;
+      },
+
+      open: function(connectionClassName) {
+        open(connectionClassName);
+      },
+
+      close: function() {
+        close();
+      }
+    };
+  };
+
+  window.Redom = Redom;
+})();
+EOS
+    end
+  end
+end

data/lib/redom/task.rb

@@ -0,0 +1,52 @@
+module Redom
+  class Task
+    include Utils
+
+    def initialize(conn, worker, info)
+      @conn = conn
+      @worker = worker
+      @info = info
+      @results = []
+    end
+
+    def run(proxy_result = nil)
+      @results << proxy_result if proxy_result
+      @worker.do_task self
+    end
+
+    def resume
+      if !@results.empty?
+        result = @fiber.resume(@results.shift)
+      else
+        mthd = @conn.method(@info[T_INFO_METHOD_NAME])
+        args = @info[T_INFO_ARGUMENTS]
+        blck = @info[T_INFO_BLOCK]
+        @fiber = Fiber.new do
+          if mthd
+            if blck
+              mthd.call(*args, &blck)
+            else
+              mthd.call(*args)
+            end
+          else
+            _logger.error "Method '#{@info[T_INFO_METHOD_NAME]}' is not defined in class '#{@conn.class}'."
+            @conn.method(:on_error).call("No such method '#{@info[T_INFO_METHOD_NAME]}'.")
+          end
+          @conn.sync
+          nil
+        end
+        result = @fiber.resume
+      end
+
+      if result
+        @conn._send [_id, result].to_json
+      else
+        _dispatcher.delete_task _id
+      end
+    end
+
+    def _id
+      "T#{__id__}"
+    end
+  end
+end

data/lib/redom/thread_pool.rb

@@ -0,0 +1,27 @@
+module Redom
+  class ThreadPool
+    def initialize(opts)
+      @workers = Array.new
+      @idx = 0
+      opts[:worker].times {
+        @workers << Worker.new
+      }
+    end
+
+    def start
+      @workers.each { |worker|
+        worker.start
+      }
+    end
+
+    def stop
+      @workers.each { |worker|
+        worker.stop
+      }
+    end
+
+    def worker
+      @workers[(@idx += 1) == @workers.size ? @idx = 0 : @idx]
+    end
+  end
+end

data/lib/redom/utils.rb

@@ -0,0 +1,21 @@
+module Redom
+  module Utils
+    @@logger = nil
+
+    def self.logger=(logger)
+      @@logger = logger
+    end
+    
+    def self.dispatcher=(dispatcher)
+      @@dispatcher = dispatcher
+    end
+
+    def _logger
+      @@logger
+    end
+    
+    def _dispatcher
+      @@dispatcher
+    end
+  end
+end

data/lib/redom/version.rb

@@ -0,0 +1,3 @@
+module Redom
+  VERSION = '0.0.1'
+end

data/lib/redom/worker.rb

@@ -0,0 +1,34 @@
+module Redom
+  class Worker
+    include Utils
+
+    def initialize
+      @queue = Queue.new
+    end
+    
+    def start
+      @thread = Thread.start do
+        while task = @queue.pop
+          begin
+            task.resume
+          rescue
+            _logger.error "Task failed. ID='#{task.__id__}'\n"
+            _logger.error $!.message
+            $!.backtrace.each { |item|
+              _logger.error item
+            }
+          end
+        end
+      end
+    end
+
+    def stop
+      @thread.kill
+      @queue.clear
+    end
+
+    def do_task(task)
+      @queue.push task
+    end
+  end
+end

data/redom.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/redom/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'redom'
+  s.version       = Redom::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.summary       = 'A distributed object based server-centric web framework'
+  s.description   = 'A distributed object based server-centric web framework.'
+  s.author        = ['Yi Hu', 'Sasada Koichi']
+  s.email         = 'future.azure@gmail.com'
+  s.homepage      = 'https://github.com/future-azure/redom'
+
+  s.require_paths = ['lib']
+  s.files         = ['README.md', 'LICENSE', 'redom.gemspec']
+  s.files        += ['lib/redom.rb'] + Dir['lib/redom/**/*.rb']
+  s.files        += Dir['bin/redom']
+  s.executables   = ['redom']
+
+  s.add_dependency 'em-websocket', '>= 0.3.5'
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: redom
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Yi Hu
+- Sasada Koichi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-10 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: &70124221424660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70124221424660
+description: A distributed object based server-centric web framework.
+email: future.azure@gmail.com
+executables:
+- redom
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- redom.gemspec
+- lib/redom.rb
+- lib/redom/connection.rb
+- lib/redom/dispatcher.rb
+- lib/redom/proxy.rb
+- lib/redom/runtime.rb
+- lib/redom/task.rb
+- lib/redom/thread_pool.rb
+- lib/redom/utils.rb
+- lib/redom/version.rb
+- lib/redom/worker.rb
+- bin/redom
+homepage: https://github.com/future-azure/redom
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A distributed object based server-centric web framework
+test_files: []