=begin = distributed Ruby --- dRuby 1.3.1 Copyright (c) 1999-2000 Masatoshi SEKI You can redistribute it and/or modify it under the same term as Ruby. $Id: drb.rb,v 1.30 2001/01/18 14:49:35 mas Exp $ DRb --- dRuby module. DRbUndumped --- Mixin class. DRbProtocol --- Mixin class. DRbObject --- dRuby remote object. DRbConn --- DRbIdConv --- id <--> obj converter. DRbServer --- dRuby message handler. DRbUnknown --- unknown class object. =end require 'socket' require 'thread' require 'mutex_m' module DRb class DRbIdConv def to_obj(ref) ObjectSpace._id2ref(ref) end def to_id(obj) obj.nil? ? nil : obj.id end end module DRbUndumped def _dump(dummy) raise TypeError, 'can\'t dump' end end class DRbServerNotFound < RuntimeError; end class DRbUnknownError < RuntimeError def initialize(unknown) @unknown = unknown super(unknown.name) end attr_reader :unknown end class DRbUnknown def initialize(err, buf) @name = if /uninitialized constant (.+)/ =~ err then $1 else nil end @buf = buf end attr_reader :name, :buf def self._load(s) begin Marshal::load(s) rescue NameError DRbUnknown.new($!, s) end end def _dump(lv) @buf end def reload self.class._load(@buf) end def exception DRbUnknownError.new(self) end end module DRbProtocol def parse_uri(uri) if uri =~ /^druby:\/\/(.*?):(\d+)(.*)$/ host = $1 port = $2.to_i option = $3 [host, port, option] else raise RuntimeError, 'can\'t parse uri: ' + uri end end def dump(obj, soc) obj = DRbObject.new(obj) if obj.kind_of? DRbUndumped begin str = Marshal::dump(obj) rescue ro = DRbObject.new(obj) str = Marshal::dump(ro) end soc.write([str.size].pack('N') + str) if soc return str end def load(soc) sz = soc.read(4) # sizeof (N) raise TypeError, 'invalid header' if sz.nil? || sz.size < 4 sz = sz.unpack('N')[0] raise TypeError, 'too large packet' if load_limit < sz str = soc.read(sz) raise TypeError, 'premature marshal format(can\'t read)' if str.nil? || str.size < sz begin Marshal::load(str) rescue NameError DRbUnknown.new($!, str) end end def send_request(soc, ref, msg_id, args, block) dump(ref, soc) dump(msg_id.id2name, soc) dump(args.length, soc) #dump(args, soc) args.each do |e| dump(e, soc) end dump(block, soc) # soc.shutdown(1) soc.flush end def recv_request(soc) ro = load(soc) msg = load(soc).intern argc = load(soc) raise ArgumentError, 'too many arguments' if argc_limit < argc #argv = load(soc) argv = [] argc.times do argv.push load(soc) end # puts "recv_request/// not array: #{argv.type} #{$0}" unless argv.type == Array block = load(soc) [ro, msg, argv, block] end def send_reply(soc, succ, result) dump(succ, soc) dump(result, soc) # soc.shutdown(1) soc.flush end def recv_reply(soc) succ = load(soc) result = load(soc) [succ, result] end def ro_to_obj(ro) (ro && ro.__drbref) ? DRb.to_obj(ro.__drbref) : DRb.front end end class DRbConn extend Mutex_m @table = {} def self.new( remote_uri ) tab = nil synchronize { tab = (@table[Thread.current] ||= {}) } tab[remote_uri] ||= DRbPersistentConnection.new(remote_uri) end end class DRbPersistentConnection include DRbProtocol include Mutex_m def initialize(remote_uri) @load_limit = DRb.current_server.load_limit @host, @port, @opt = parse_uri(remote_uri) untaint_remote @socket = TCPSocket.new(@host, @port) #print '.'; $stdout.flush end attr_reader :load_limit def send_message(ref, msg_id, args, block) send_request @socket, ref, msg_id, args, block recv_reply @socket end private def untaint_remote @host.untaint @port.untaint @opt.untaint end end class DRbObject def initialize(obj, uri=nil) @uri = uri || DRb.uri @ref = obj ? DRb.to_id(obj) : nil end def __drbref @ref end undef to_s undef to_a def method_missing(msg_id, *args, &block) if @uri == DRb.uri obj = @ref ? DRb.to_obj(@ref) : DRb.front return obj.__send__(msg_id, *args, &block) end ok, result = DRbConn.new(@uri).send_message(self, msg_id, args, block) ok or raise result result end end class DRbServer include DRbProtocol @@acl = nil @@idconv = DRbIdConv.new @@secondary_server = nil @@argc_limit = 256 @@load_limit = 256 * 1024 def self.default_argc_limit(argc) @@argc_limit = argc end def self.default_load_limit(sz) @@load_limit = sz end def self.default_acl(acl) @@acl = acl end def self.default_id_conv(idconv) @@idconv = idconv end def initialize(uri=nil, front=nil, acl=nil, idconv=nil) host, port, opt = parse_uri( uri || 'druby://:0' ) @server = TCPServer.open(port) host = Socket.gethostname if host.empty? port = @server.addr[1] if @server @uri = "druby://#{host}:#{port}" @front = front @acl = acl || @@acl @idconv = idconv || @@idconv @argc_limit = @@argc_limit @load_limit = @@load_limit @grp = ThreadGroup.new @thread = run Thread.exclusive do DRb.primary_server ||= self end end attr_reader :uri, :thread, :front attr_accessor :argc_limit, :load_limit def alive? @thread.alive? end def stop_service @thread.kill end def to_obj(ref) @idconv.to_obj(ref) end def to_id(obj) @idconv.to_id(obj) end private def run Thread.start { begin while true accept_request end ensure @server.close if @server kill_sub_thread end } end def kill_sub_thread list = @grp.list while list.size > 0 list.each do |th| th.kill end list @grp.list end end def accept_request Thread.start( @server.accept ) {|sock| begin allow? sock or raise 'Forbidden' @grp.add Thread.current Thread.current['DRb'] = { 'socket' => sock , 'server' => self } while true do process_request sock end ensure sock.close if sock end } end def process_request( sock ) begin ro, mid, argv, block = recv_request(sock) insecure_method? mid and raise NameError, "insecure method '#{msg}'" # puts "procreq/// not array: #{argv.type} #{$0}" unless argv.type == Array result = exec_request( ro_to_obj(ro), mid, argv, block ) succ = true rescue StandardError, ScriptError => err if $DEBUG then p err err.backtrace.each {|i| puts i } end result = err succ = false end send_reply sock, succ, result end def exec_request( obj, msg_id, argv, block ) unless block then # puts "execreq/// not array: #{argv.type} #{$0}" unless argv.type == Array obj.__send__ msg_id, *argv else catch_retry = nil obj.__send__(msg_id, *argv) {|x| catch_retry = false begin block_value = block.call(x) rescue LocalJumpError => err if err.message =~ /^retry/ # retry from proc-closure catch_retry = true elsif err.message =~ /^break/ # break from proc-closure break else raise err end end retry if catch_retry block_value } end end def allow?( s ) @acl ? @acl.allow_socket?(s) : true end INSECURE = { :instance_eval => true } def insecure_method?( id ) INSECURE.key? id end end module_function @primary_server = nil def start_service(uri=nil, front=nil, acl=nil) @primary_server = DRbServer.new(uri, front, acl) end attr_accessor :primary_server module_function :primary_server module_function :primary_server= def current_server drb = Thread.current['DRb'] ((drb and drb['server']) ? drb['server'] : @primary_server) or raise DRbServerNotFound end def stop_service @primary_server.stop_service if @primary_server @primary_server = nil end def uri current_server.uri end def front current_server.front end def to_obj(ref) current_server.to_obj(ref) end def to_id(obj) current_server.to_id(obj) end def thread @primary_server ? @primary_server.thread : nil end def install_id_conv(idconv) DRbServer.default_id_conv(idconv) end def install_acl(acl) DRbServer.default_acl(acl) end end DRbObject = DRb::DRbObject DRbUndumped = DRb::DRbUndumped