pione 0.2.2 → 0.3.0

data/lib/pione/package/scenario-handler.rb

@@ -0,0 +1,95 @@
+module Pione
+  module Package
+    # ScenarioHandler handles scenario related operations.
+    class ScenarioHandler
+      include SimpleIdentity
+
+      attr_reader :location
+      attr_reader :info
+
+      # @param location [BasicLocation]
+      #   scenario location
+      # @param info [Hash]
+      #   scenario information table
+      def initialize(location, info)
+        @location = location
+        @info = info
+      end
+
+      # Write an information file for the scenario.
+      def write_info_file
+        (@location + "pione-scenario.json").write(JSON.pretty_generate(@info))
+        Log::SystemLog.info("write %s" % (@location + "pione-scenario.json").address)
+      end
+
+      # Return input location of the scenario. If the scenario doesn't have
+      # input location, return nil.
+      #
+      # @return [BasicLocation]
+      #   the input location
+      def input
+        input_location = @location + "input"
+        return input_location.exist? ? input_location : nil
+      end
+
+      # Return list of input data location.
+      #
+      # @return [BasicLocation]
+      #   input file locations
+      def inputs
+        info.inputs.map {|path| @location + path}
+      end
+
+      # Return the output location.
+      #
+      # @return [BasicLocation]
+      #   the output location
+      def output
+        @location + "output"
+      end
+
+      # Return output file locations.
+      #
+      # @return [BasicLocation]
+      #   output file locations
+      def outputs
+        @info.outputs.map {|path| @location + path}
+      end
+
+      # Validate reheasal results.
+      def validate(result_location)
+        return [] unless output.exist?
+
+        errors = []
+        output.entries.each do |entry|
+          name = entry.basename
+          result = result_location + name
+          if result.exist?
+            if entry.read != result.read
+              errors << RehearsalResult.new(:different, name)
+            end
+          else
+            errors << RehearsalResult.new(:not_exist, name)
+          end
+        end
+        return errors
+      end
+    end
+
+    # RehearsalResult represents error result of rehearsal test.
+    class RehearsalResult < StructX
+      member :key
+      member :name
+
+      # Create an error message.
+      def to_s
+        case key
+        when :different
+          "%s is different from expected result." % name
+        when :not_exist
+          "%s doesn't exist." % name
+        end
+      end
+    end
+  end
+end

data/lib/pione/package/scenario-info.rb

@@ -0,0 +1,34 @@
+module Pione
+  module Package
+    class ScenarioInfo < StructX
+      member :name
+      member :param_set
+      member :inputs, default: lambda {Array.new}
+      member :outputs, default: lambda {Array.new}
+
+      # Read the scenario information JSON source. The source is a string or
+      # location of the file.
+      def self.read(src)
+        data = JSON.load(src.is_a?(Location::DataLocation) ? src.read : src)
+        new(name: data["ScenarioName"], param_set: data["ParamSet"], inputs: data["Inputs"], outputs: data["Outputs"])
+      end
+
+      # Return file paths of the scenario.
+      def filepaths
+        list = []
+        list += inputs
+        list += outputs
+        return list
+      end
+
+      def to_json(*args)
+        data = Hash.new
+        data["ScenarioName"] = name
+        data["ParamSet"] = param_set
+        data["Inputs"] = inputs
+        data["Outputs"] = outputs
+        data.to_json(*args)
+      end
+    end
+  end
+end

data/lib/pione/package/scenario-reader.rb

@@ -0,0 +1,29 @@
+module Pione
+  module Package
+    # ScenarioReader is a reader for scenario location.
+    class ScenarioReader
+      class << self
+        def read(location)
+          new(location).read
+        end
+      end
+
+      def initialize(location)
+        @location = location
+        @document_location = @location + "Scenario.pione"
+        @info_location = @location + "pione-scenario.json"
+      end
+
+      def read
+        if @document_location.mtime > @info_location.mtime
+          # update the information file and make handler by it
+          new_info = ScenarioScanner.scan(@location)
+          return ScenarioHandler.new(@locaiton, new_info).tap {|handler| handler.write_info_file}
+        else
+          # make handler by informaiton file
+          ScenarioHandler.new(@location, ScenarioInfo.read(@info_location))
+        end
+      end
+    end
+  end
+end

data/lib/pione/package/scenario-scanner.rb

@@ -0,0 +1,96 @@
+module Pione
+  module Package
+    # ScenarioScanner scans scenario location.
+    class ScenarioScanner
+      class << self
+        def scenario?(location)
+          not(/^\./.match(location.basename)) and (location + "Scenario.pione").exist?
+        end
+
+        def scan(location)
+          new(location).scan
+        end
+      end
+
+      # Create a scanner with the location. The location should be local scheme.
+      def initialize(location)
+        unless location.local?
+          raise Location::NotLocal.new(location)
+        end
+        @location = location
+      end
+
+      # Scan the scenario directory and return scenario informations. If the
+      # location is not scenario directory, return false.
+      def scan
+        unless self.class.scenario?(@location)
+          return false
+        else
+          name, param_set = scan_annotations
+          inputs = scan_data_dir("input")
+          outputs = scan_data_dir("output")
+          ScenarioInfo.new(name: name, param_set: param_set, inputs: inputs, outputs: outputs)
+        end
+      rescue Parslet::ParseFailed => e
+        raise InvalidScenario.new("invalid scenario document because of parser failed: %s" % e.message)
+      end
+
+      # Scan annotations from scenario file and return scenario name and
+      # parameter set.
+      def scan_annotations
+        # setup fake language environment
+        env = Lang::Environment.new.setup_new_package("ScenarioScanner")
+
+        # parse the scenario document
+        Document.load(env, @location + "Scenario.pione", nil, nil, nil, @location + "Scenario.pione")
+
+        # get name and parameter set from fake package's annotations
+        annotations = env.package_get(Lang::PackageExpr.new(package_id: env.current_package_id)).annotations
+        name = find_name(annotations)
+        param_set = find_param_set(annotations)
+
+        return name, param_set
+      end
+
+      # Scan data files.
+      def scan_data_dir(name)
+        if (@location + name).exist?
+          (@location + name).file_entries.each_with_object([]) do |entry, target|
+            unless /^\./.match(entry.basename)
+              target << File.join(name, entry.basename)
+            end
+          end
+        else
+          return []
+        end
+      end
+
+      # Find "ScenarioName" annotaion.
+      def find_name(annotations)
+        names = annotations.select {|annotation| annotation.annotation_type == "ScenarioName"}
+        case names.size
+        when 0
+          raise InvalidScenario.new("No scenario name in %s" % (@location + "Scenario.pione"))
+        when 1
+          names.first.value
+        else
+          name_list = names.map {|name| name.value}.join(", ")
+          raise InvalidScenario.new("Multiple scenario names found: %s" % name_list)
+        end
+      end
+
+      # Find "ParamSet" annotaion.
+      def find_param_set(annotations)
+        param_sets = annotations.select {|annotation| annotation.annotation_type == "ParamSet"}
+        case param_sets.size
+        when 0
+          return nil
+        when 1
+          param_sets.first.value
+        else
+          raise InvalidScenario.new("Multiple parameter set found in %s" % @location.address)
+        end
+      end
+    end
+  end
+end

data/lib/pione/patch.rb

@@ -7,4 +7,3 @@ require 'pione/patch/array-patch'
 require 'pione/patch/drb-patch'
 require 'pione/patch/rinda-patch'
 require 'pione/patch/uri-patch'
-require 'pione/patch/monitor-patch'

data/lib/pione/patch/drb-patch.rb

@@ -1,241 +1,300 @@
-# @api private
-module DRb
-  def waiter_table
-    @waiter_table ||= Pione::Util::WaiterTable.new
-  end
-  module_function :waiter_table
-
-  class DRbConnError
-    attr_reader :args
-
-    def initialize(*args)
-      super
-      @args = args
+module Pione
+  module DRbPatch
+    #
+    # special protocol
+    #
+
+    # Return waiter table for the aim that clients enable to wait to receive the
+    # reply.
+    def self.waiter_table
+      @waiter_table ||= Pione::Util::WaiterTable.new
     end
-  end
 
-  class DRbObject
-    # Creates fake connection for relay.
-    def __connect
-      DRbConn.open(@uri) {}
+    # ReplyReaderError is raised when reply reader happens something error. See
+    # +ReplyReader+ class.
+    class ReplyReaderError < RuntimeError
+      attr_reader :inner_exception
+
+      def initialize(exception)
+        @inner_exception = exception
+      end
     end
-  end
 
-  class DRbMessage
-    alias :orig_initialize :initialize
+    class ReplyReader
+      def initialize
+        @watcher_lock = Mutex.new
+        @watchers = Set.new
+      end
 
-    def initialize(*args)
-      @send_request_lock = Mutex.new
-      @recv_request_lock = Mutex.new
-      @send_reply_lock = Mutex.new
-      @recv_reply_lock = Mutex.new
-      orig_initialize(*args)
-    end
+      def start(protocol)
+        @thread ||= Thread.new do
+          begin
+            # loop for receiving reply and waiting the result
+            while true
+              # receive a replay
+              req_id, succ, result = protocol.recv_reply
+              # register it to waiter table
+              DRbPatch.waiter_table.push(req_id, [succ, result])
+            end
+          rescue => e
+            @watcher_lock.synchronize do
+              # pass the exception to watchers
+              @watchers.each do |watcher|
+                Log::Debug.communication("connection error happened in receiving reply.")
+                Log::Debug.communication(e)
+                watcher.raise(ReplyReaderError.new(e)) if watcher.alive?
+              end
 
-    def send_request(stream, ref, msg_id, arg, b)
-      req_id = Util::UUID.generate_int
-      if Global.show_communication
-        puts "send_request[%s] %s#%s(%s) on PID %s" % [req_id, ref.__drburi, msg_id, arg, Process.pid]
-      end
-      data = [
-        dump(req_id),
-        dump(ref.__drbref),
-        dump(msg_id.id2name),
-        dump(arg.length),
-        arg.map{|e|dump(e)}.join(''),
-        dump(b)
-      ].join('')
-      @send_request_lock.synchronize {stream.write(data)}
-      return req_id
-    rescue => e
-      if Global.show_communication
-        ErrorReport.print(e)
-      end
-      raise(DRbConnError, $!.message, $!.backtrace)
-    end
+              # remove dead watchers
+              @watchers.delete_if {|watcher| not(watcher.alive?)}
+            end
+          end
+        end
+      end
 
-    def recv_request(stream)
-      if Global.show_communication
-        puts "start recv_request on PID %s" % Process.pid
-      end
-      @recv_request_lock.synchronize do
-        req_id = load(stream)
-        ref = load(stream)
-        msg_id = load(stream)
-        argc = load(stream)
-        # puts "req_id %s, ref %s, msg_id %s, argc %s" % [req_id, ref, msg_id, argc]
-        ro = DRb.to_obj(ref)
-        raise(DRbConnError, "too many arguments") if @argc_limit < argc
-        argv = Array.new(argc, nil)
-        argc.times do |n|
-          argv[n] = load(stream)
+      # Makes reader thread for receiving unordered replies.
+      def add_watcher(watcher)
+        @watcher_lock.synchronize do
+          @watchers << watcher
         end
-        block = load(stream)
-        if Global.show_communication
-          # puts "end recv_request[%s] %s#%s(%s) on %s" % [req_id, ref ? ref.__drburi : "", msg_id, argv, Process.pid]
+      end
+
+      # Remove the request reader thread watcher.
+      def remove_watcher(watcher)
+        @watcher_lock.synchronize do
+          @watchers.delete_if {|th| th == watcher}
         end
-        return req_id, ro, msg_id, argv, block
       end
     end
 
-    def send_reply(req_id, stream, succ, result)
-      if Global.show_communication
-        puts "start send_reply[%s] %s on PID %s" % [req_id, result, Process.pid]
-        unless succ
-          p result
-          result.backtrace.each do |line|
-            puts line
-          end
-          p result.args
-        end
+    # +PioneTCPSocket+ is a reply reader thread extension for standard
+    # +DRbTCPSocket+.
+    class PioneTCPSocket < DRb::DRbTCPSocket
+      def initialize(uri, soc, config={})
+        super
+        @reply_reader = ReplyReader.new
       end
-      @send_reply_lock.synchronize do
-        stream.write(dump(req_id) + dump(succ) + dump(result, !succ))
+
+      # Send the request from client to server.
+      def send_request(ref, msg_id, arg, b)
+        # set watcher
+        @reply_reader.add_watcher(Thread.current)
+
+        # send the request
+        req_id = @msg.send_request(stream, ref, msg_id, arg, b)
+
+        # start reply reader
+        @reply_reader.start(self)
+
+        # wait the reply by using watier table
+        succ, result = Pione::DRbPatch.waiter_table.take(req_id, msg_id, arg)
+
+        # remove watcher
+        @reply_reader.remove_watcher(Thread.current)
+
+        return succ, result
       end
-      if Global.show_communication
-        puts "end send_reply[%s] %s on PID %s" % [req_id, result, Process.pid]
+
+      # Send the reply with request id. Note: this overrides original +send_rely+.
+      def send_reply(req_id, succ, result)
+        @msg.send_reply(req_id, stream, succ, result)
       end
-    rescue
-      raise(DRbConnError, $!.message, $!.backtrace)
-    end
 
-    def recv_reply(stream)
-      if Global.show_communication
-        puts "start recv_reply on PID %s" % Process.pid
+      # Return true if connection socket exists.
+      def alive?
+        return (@socket and not(@socket.closed?))
       end
-      @recv_reply_lock.synchronize do
-        req_id = load(stream)
-        succ = load(stream)
-        result = load(stream)
-        if Global.show_communication
-          puts "end recv_reply[%s] on PID %s" % [req_id, Process.pid]
+    end
+
+    # +PioneDRbMessage+ is a special protocol for +PioneTCPSocket+.
+    class PioneDRbMessage < DRb::DRbMessage
+      def initialize(*args)
+        @send_request_lock = Mutex.new
+        @recv_request_lock = Mutex.new
+        @send_reply_lock = Mutex.new
+        @recv_reply_lock = Mutex.new
+        super
+      end
+
+      # Send a request to the stream. This is different from original at the
+      # point that patched version has request id.
+      def send_request(stream, ref, msg_id, arg, b)
+        # generate a new request id
+        req_id = Util::UUID.generate_int
+
+        # show debug message
+        Log::Debug.communication do
+          "client sends a request %s#%s (fd: %s, req_id: %s)" % [ref.__drburi, msg_id, stream.to_i, req_id]
         end
-        return req_id, succ, result
+
+        # make a dumped request sequece(request id, ref, msg_id, argc, argv, b)
+        data = [
+          req_id, ref.__drbref, msg_id.id2name, arg.length, *arg, b
+        ].map{|elt| dump(elt)}.join('')
+
+        @send_request_lock.synchronize {stream.write(data)}
+
+        return req_id
+      rescue => e
+        Log::Debug.communication "following error happened while we send request"
+        Log::Debug.communication e
+        raise DRb::DRbConnError.new, $!.message, $!.backtrace
       end
-    end
-  end
 
-  class ReplyReaderThreadError < RuntimeError
-    attr_reader :inner_exception
+      # Receive request from the stream. See +ClientReuqest+.
+      def recv_request(stream)
+        Log::Debug.communication "server tries to receive a request... (fd: %s)" % stream.to_i
 
-    def initialize(exception)
-      @inner_exception = exception
-    end
-  end
+        @recv_request_lock.synchronize do
+          # read requst id, object id, method name, and arguments size
+          req_id = load(stream)
+          ref = load(stream)
+          msg_id = load(stream)
+          argc = load(stream)
 
-  class DRbTCPSocket
-    # Makes reader thread for receiving unordered replies.
-    def reader_thread(watcher)
-      @watcher_mutex ||= Mutex.new
-      @watchers ||= Set.new
-      @watchers << watcher
-      @thread ||= Thread.new do
-        begin
-          # loop for receiving reply and waiting the result
-          while true
-            req_id, succ, result = recv_reply
-            DRb.waiter_table.push(req_id, [succ, result])
+          Log::Debug.communication do
+            "server received a request (fd: %s, req_id: %s, ref: %s, msg_id: %s)" % [stream.to_i, req_id, ref.to_s, msg_id]
           end
-        rescue => e
-          @watcher_mutex.synchronize do
-            @watchers.each do |watcher|
-              if watcher.alive?
-                watcher.raise(ReplyReaderThreadError.new(e))
-              end
-            end
-            @watchers.delete_if {|watcher| not(watcher.alive?)}
+
+          # check arguement size
+          raise DRb::DRbConnError.new("too many arguments") if @argc_limit < argc
+
+          ro = nil
+          available = true
+
+          # refer to object
+          begin
+            ro = DRb.to_obj(ref)
+          rescue RangeError => e
+            Log::Debug.system("bad object id \"%s\" is referred (msg_id: %s)" % [ref, msg_id])
+            available = false
           end
+
+          # build arguments
+          argv = Array.new(argc, nil)
+          argc.times {|n| argv[n] = load(stream)}
+
+          # read block
+          block = load(stream)
+
+          return req_id, ro, msg_id, argv, block, available
         end
       end
-    end
 
-    def remove_reader_thread_watcher(watcher)
-      @watcher_mutex ||= Mutex.new
-      @watcher_mutex.synchronize do
-        @watchers.delete_if {|th| th == watcher}
-      end
-    end
+      # Send the reply.
+      def send_reply(req_id, stream, succ, result)
+        Log::Debug.communication {
+          "server sends a reply (fd: %s, req_id: %s, result: %s)" % [stream.to_i, req_id, result]
+        }
 
-    # req_id
-    def send_reply(req_id, succ, result)
-      @msg.send_reply(req_id, stream, succ, result)
-    end
+        # build a reply data
+        data = dump(req_id) + dump(succ) + dump(result, !succ)
 
-    def alive?
-      return @socket ? true : false
-    end
-  end
+        @send_reply_lock.synchronize {stream.write(data)}
+      rescue
+        raise DRb::DRbConnError, $!.message, $!.backtrace
+      end
 
-  class DRbConn
-    @table = {}
-    @retry = {}
+      # Receive a reply(request id, succ, and result) from the stream.
+      def recv_reply(stream)
+        Log::Debug.communication do
+          "client tries to receive a reply... (fd: %s)" % stream.to_i
+        end
 
-    def self.table
-      @table
-    end
+        @recv_reply_lock.synchronize do
+          req_id = load(stream)
+          succ = load(stream)
+          result = load(stream)
+
+          Log::Debug.communication(
+            "client received a reply (fd: %s, req_id: %s)" % [stream.to_i, req_id]
+          )
 
-    def self.clear_table
-      @table.values do |val|
-        val.close rescue nil
+          return req_id, succ, result
+        end
       end
-      @table.clear
     end
 
-    # @api private
-    def self.open(remote_uri)
-      conn = nil
+    # +PioneDRbConn+ provides connections to +DRb::DRbObject+. This class is
+    # different from original +DRbConn+ at the point of connection reuse.
+    class PioneDRbConn < DRb::DRbConn
+      @cache = {} # connection table
+      @retry = {} # retrial counter
+      @mutex = Mutex.new # same as original's
 
-      @mutex.synchronize do
-        cache = @table[remote_uri]
-        if not(cache.nil?) and cache.alive?
-          conn = cache
-        else
-          if Global.show_communication
-            puts "new connection to %s on %s" % [remote_uri, Process.pid] if remote_uri
+      class << self
+        attr_reader :cache
+
+        # Clear connection cache table.
+        def clear_cache
+          @cache.values {|connection| connection.close rescue nil}
+          @cache.clear
+        end
+
+        # Open a remote URI. This method reuse connection if the URI is cached.
+        def open(remote_uri)
+          conn = nil
+
+          @mutex.synchronize do
+            cache = @cache[remote_uri]
+
+            # get connection
+            if not(cache.nil?) and cache.alive?
+              conn = cache # use cached connection
+            else
+              conn = self.new(remote_uri) # create a new connection
+              Log::Debug.communication "client created a new connection to %s" % remote_uri.inspect
+            end
+            @cache[remote_uri] = conn
+          end
+
+          succ, result = yield(conn)
+          @retry[remote_uri] = 0
+          return succ, result
+        rescue DRb::DRbConnError, ReplyReaderError, Errno::ECONNREFUSED => e
+          Log::Debug.communication "client failed to open a connection to %s." % remote_uri
+          @mutex.synchronize do
+            if @cache[remote_uri]
+              @cache[remote_uri].close
+              @cache.delete(remote_uri)
+            end
+            @retry[remote_uri] ||= 0
+            @retry[remote_uri] += 1
+          end
+          if @retry[remote_uri] < 6
+            sleep 0.1
+            retry
+          else
+            raise
           end
-          conn = self.new(remote_uri) unless conn
         end
-        @table[remote_uri] = conn
       end
 
-      succ, result = yield(conn)
-      @retry[remote_uri] = 0
-      return succ, result
-    rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
-      @table.delete(remote_uri)
-      @retry[remote_uri] ||= 0
-      @retry[remote_uri] += 1
-      if @retry[remote_uri] < 5
-        retry
-      else
-        raise
+      # Close the client-to-server socket.
+      def close
+        Log::Debug.communication("client closed the socket")
+        unless @closed
+          @closed = true
+          self.class.cache.delete(@uri)
+          super
+        end
       end
-    end
 
-    alias :orig_close :close
-
-    def close
-      if Global.show_communication
-        puts "socket closed on %s" % Process.pid
-      end
-      unless @closed
-        @closed = true
-        self.class.table.delete(remote_uri)
-        orig_close
+      # Send the message from client to server.
+      def send_message(ref, msg_id, arg, block)
+        @protocol.send_request(ref, msg_id, arg, block)
       end
     end
 
-    # Sends a request and takes the result from waiter table.
-    def send_message(ref, msg_id, arg, block)
-      req_id = @protocol.send_request(ref, msg_id, arg, block)
-      @protocol.reader_thread(Thread.current)
-      succ, result = DRb.waiter_table.take(req_id, msg_id, arg)
-      @protocol.remove_reader_thread_watcher(Thread.current)
-      return succ, result
+    #
+    # special server
+    #
+
+    # BadRequestError is raised when the object id requested by client is
+    # unknonw in server.
+    class BadRequestError < StandardError
     end
-  end
 
-  class DRbServer
     # ClientRequest represents client's requests.
     class ClientRequest
       def self.receive(client)
@@ -247,17 +306,23 @@ module DRb
       attr_reader :msg_id
       attr_reader :argv
       attr_reader :block
+      attr_reader :available
 
-      def initialize(req_id, obj, msg_id, argv, block)
+      def initialize(req_id, obj, msg_id, argv, block, available)
         @req_id = req_id
         @obj = obj
         @msg_id = msg_id.intern
         @argv = argv
         @block = block
+        @available = available
       end
 
       def eval
-        @block ? eval_with_block : eval_without_block
+        if @available
+          @block ? eval_with_block : eval_without_block
+        else
+          raise BadRequestError
+        end
       end
 
       private
@@ -307,28 +372,31 @@ module DRb
       end
     end
 
-    class Invoker
-      extend Forwardable
-
-      attr_accessor :thread
-      def_delegators :@request, :req_id, :obj, :msg_id, :argv, :block
-
-      def initialize(drb_server, client, request)
-        @drb_server = drb_server
+    class RequestInvoker
+      def initialize(server, client, request)
+        @server = server
         @client = client
         @request = request
         check_insecure_method
       end
 
-      # @api private
-      def inspect
-        "#<Invoker %s#%s(%s)>" % [@request.obj, @request.msg_id, @request.argv]
+      def invoke
+        # evaluate request
+        succ, result = execute_request
+
+        # send_reply with req_id
+        begin
+          @client.send_reply(@request.req_id, succ, result)
+        rescue => e
+          Log::Debug.system("it happened communication failure in sending reply(req_id: %s): %s" % [@request.req_id, e.message])
+        end
       end
-      alias :to_s :inspect
+
+      private
 
       # perform without setup_message
-      def invoke
-        result = safe_invoke
+      def execute_request
+        result = eval_request
         if @request.msg_id == :to_ary && result.class == Array
           result = DRbArray.new(result)
         end
@@ -337,131 +405,142 @@ module DRb
         return false, e
       end
 
-      private
-
       def check_insecure_method
-        @drb_server.check_insecure_method(@request.obj, @request.msg_id)
+        @server.check_insecure_method(@request.obj, @request.msg_id)
       end
 
-      def safe_invoke
-        if $SAFE < @drb_server.safe_level
-          info = Thread.current['DRb']
-          Thread.new do
-            Thread.current['DRb'] = info
-            $SAFE = @drb_server.safe_level
-            @request.eval
-          end.value
-        else
-          @request.eval
-        end
+      def eval_request
+        $SAFE < @server.safe_level ? safe_eval_request : unsafe_eval_request
       end
-    end
 
-    class RequestLooper
-      def self.start(server, client)
-        self.new(server).start(client)
+      # Execute the request within sandbox.
+      def safe_eval_request
+        info = Thread.current['DRb']
+        Thread.new do
+          # import DRb info to the sandbox
+          Thread.current['DRb'] = info
+
+          # make sandbox
+          $SAFE = @drb_server.safe_level
+
+          # invoke request
+          unsafe_request_invoke
+        end.value
       end
 
+      # Execute the request.
+      def unsafe_eval_request
+        @request.eval
+      end
+    end
+
+    # RequestLooper is a receiver of client request. This is different from
+    # standard DRb's +main_loop+ at the point that this method doesn't need to
+    # wait finishing evaluation of request and reply.
+    class RequestLooper
       def initialize(server)
         @server = server
       end
 
       def start(client)
-        Thread.current['DRb'] = {'client' => client, 'server' => @server}
-        @server.add_exported_uri(client.uri)
-
-        loop {handle_request(client)}
+        loop {handle_client_request(client)}
       end
 
       private
 
-      def handle_request(client)
+      def handle_client_request(client)
+        # take request from client
         request = ClientRequest.receive(client)
-        invoker = Invoker.new(@server, client, request)
-        Thread.start(invoker) do |iv|
-          Thread.current['DRb'] = {'client' => client, 'server' => @server}
-          call_invoker(client, iv)
-        end
-      rescue DRbConnError => e
+
+        # run invoker
+        invoker = RequestInvoker.new(@server, client, request)
+        @server.invoker_threads.add(Thread.new{invoker.invoke})
+      rescue DRb::DRbConnError => e
+        Log::Debug.communication("server was disconnected from client because of connection error")
         client.close
-        if Global.show_communication
-          puts "closed socket on server side"
-          ErrorReport.print(e)
-        end
         raise StopIteration
       end
+    end
 
-      def call_invoker(client, invoker)
-        # perform invoker with retaining the information
-        invoker.thread = Thread.current
-        @server.invokers_mutex.synchronize {@server.invokers << invoker}
-        succ, result = invoker.invoke
-        @server.invokers_mutex.synchronize {@server.invokers.delete(invoker)}
-        invoker.thread = nil
+    class PioneDRbServer < DRb::DRbServer
+      attr_reader :invoker_threads
 
-        # error report
-        if !succ && Global.show_communication
-          result.backtrace.each {|x| puts x}
-        end
+      def initialize(uri=nil, front=nil, config_or_acl=nil)
+        # current performing invokers
+        @invoker_threads = ThreadGroup.new
 
-        # send_reply with req_id
-        client.send_reply(invoker.req_id, succ, result) rescue nil
+        super
       end
-    end
 
-    def main_loop
-      if @protocol.uri =~ /^receiver:/
-        RequestLooper.start(self, @protocol)
-        # stop transceiver
-        @thread.kill.join
-      else
-        Thread.start(@protocol.accept) do |client|
-          # relay socket doesn't need request receiver loop because its aim is
-          # to get connection only
-          unless @protocol.kind_of?(RelaySocket)
-            RequestLooper.start(self, client)
+      def main_loop
+        if @protocol.uri =~ /^receiver:/
+          RequestLooper.start(self, @protocol)
+          @thread.kill.join # stop transceiver
+        else
+          Thread.start(@protocol.accept) do |client|
+            # relay socket doesn't need request receiver loop because its aim is
+            # to get connection only
+            unless @protocol.kind_of?(Pione::Relay::RelaySocket)
+              # set DRb info to current thread
+              Thread.current['DRb'] = {'client' => client, 'server' => self}
+
+              # add exported uri
+              DRb.mutex.synchronize do
+                client_uri = client.uri
+                @exported_uri << client_uri unless @exported_uri.include?(client_uri)
+              end
+
+              # start request loop
+              RequestLooper.new(self).start(client)
+            end
           end
         end
-      end
-    end
 
-    attr_reader :invokers
-    attr_reader :invokers_mutex
+        def stop_service
+          # stop invokers
+          @invoker_threads.list.each {|thread| thread.kill.join}
 
-    def initialize(uri=nil, front=nil, config_or_acl=nil)
-      if Hash === config_or_acl
-        config = config_or_acl.dup
-      else
-        acl = config_or_acl || @@acl
-        config = {
-          :tcp_acl => acl
-        }
+          # stop main loop etc.
+          super
+        end
       end
+    end
+  end
+end
 
-      @config = self.class.make_config(config)
-
-      @protocol = DRbProtocol.open_server(uri, @config)
-      @uri = @protocol.uri
-      @exported_uri = [@uri]
-
-      @front = front
-      @idconv = @config[:idconv]
-      @safe_level = @config[:safe_level]
-
-      @grp = ThreadGroup.new
-      @thread = run
-
-      # current performing invokers
-      @invokers = []
-      @invokers_mutex = Mutex.new
+# @api private
+module DRb
+  class DRbConnError
+    attr_reader :args
 
-      DRb.regist_server(self)
+    def initialize(*args)
+      super
+      @args = args
     end
+  end
 
-    def add_exported_uri(uri)
-      DRb.mutex.synchronize do
-        @exported_uri << uri unless @exported_uri.include?(uri)
-      end
+  class DRbObject
+    # Creates fake connection for relay.
+    def __connect
+      DRbConn.open(@uri) {}
     end
   end
+
+  # change default protocol
+  module DRbProtocol
+    @protocol.delete(DRbTCPSocket)
+    add_protocol(Pione::DRbPatch::PioneTCPSocket)
+  end
+
+  # replace some classes
+  __verbose__ = $VERBOSE
+  $VERBOSE = nil
+  # patch DRbConn for special protocol
+  const_set :DRbConn, Pione::DRbPatch::PioneDRbConn
+  # patch DRbMessage for special protocol
+  const_set :DRbMessage, Pione::DRbPatch::PioneDRbMessage
+  # patch for threaded request invocations
+  const_set :DRbServer, Pione::DRbPatch::PioneDRbServer
+  $VERBOSE = __verbose__
 end
+