class Pione::DRbPatch::PioneDRbMessage

PioneDRbMessage is a special protocol for PioneTCPSocket.

Public Class Methods

new(*args) click to toggle source
Calls superclass method
# File lib/pione/patch/drb-patch.rb, line 111
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

Public Instance Methods

recv_reply(stream) click to toggle source

Receive a reply(request id, succ, and result) from the stream.

# File lib/pione/patch/drb-patch.rb, line 199
def recv_reply(stream)
  Log::Debug.communication do
    "client tries to receive a reply... (fd: %s)" % stream.to_i
  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]
    )

    return req_id, succ, result
  end
end
recv_request(stream) click to toggle source

Receive request from the stream. See ClientReuqest.

# File lib/pione/patch/drb-patch.rb, line 145
def recv_request(stream)
  Log::Debug.communication "server tries to receive a request... (fd: %s)" % stream.to_i

  @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)

    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

    # 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
send_reply(req_id, stream, succ, result) click to toggle source

Send the reply.

# File lib/pione/patch/drb-patch.rb, line 185
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]
  }

  # build a reply data
  data = dump(req_id) + dump(succ) + dump(result, !succ)

  @send_reply_lock.synchronize {stream.write(data)}
rescue
  raise DRb::DRbConnError, $!.message, $!.backtrace
end
send_request(stream, ref, msg_id, arg, b) click to toggle source

Send a request to the stream. This is different from original at the point that patched version has request id.

# File lib/pione/patch/drb-patch.rb, line 121
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

  # 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