DRb::DRbServer

Parent:Object

表示drb服务器实例的类。

在任何传入的dRuby调用可以被接受之前，DRbServer必须在本地进程中运行，或者任何本地对象都可以作为远程进程的dRuby引用传递，即使这些本地对象从未实际上被远程调用。如果您只是通过传递编组参数传出传出的dRuby调用，则不需要在本地进程中启动DRbServer。

除非使用多个服务器，否则通常通过调用DRb＃start_service启动本地DRbServer。

常量

INSECURE_METHOD

不安全方法列表。

这些方法不能通过dRuby调用。

属性

configR

这个DRbServer的配置

frontR

DRbServer的前端对象。

该对象接收远程方法调用，这些调用是在服务器的URI上使用对象标识进行的。

safe_levelR

此服务器的安全级别。这是一个对应于$ SAFE的数字。

默认的#safe_level是0

threadR

这个DRbServer的主线程。

这是侦听并接受客户端连接的线程，并不处理每个客户端的请求 - 响应会话。

uriR

这个DRbServer的URI。

公共类方法

default_acl（acl）显示源

将默认访问控制列表设置为acl。默认的ACL是nil。

# File lib/drb/drb.rb, line 1304
def self.default_acl(acl)
  @@acl = acl
end

default_argc_limit（argc）显示源文件

设置：argc_limit选项的默认值。

见new()。初始默认值是256。

# File lib/drb/drb.rb, line 1290
def self.default_argc_limit(argc)
  @@argc_limit = argc
end

default_id_conv（idconv）显示源

设置：id_conv选项的默认值。

见new（）。初始默认值是一个DRbIdConv实例。

# File lib/drb/drb.rb, line 1311
def self.default_id_conv(idconv)
  @@idconv = idconv
end

default_load_limit（sz）显示来源

设置：load_limit选项的默认值。

见new（）。初始默认值是25 MB。

# File lib/drb/drb.rb, line 1297
def self.default_load_limit(sz)
  @@load_limit = sz
end

default_safe_level（level）显示源文件

将默认安全级别设置为level。默认安全级别为0

请参阅新的了解更多信息。

# File lib/drb/drb.rb, line 1318
def self.default_safe_level(level)
  @@safe_level = level
end

new（uri = nil，front = nil，config_or_acl = nil）显示源文件

创建一个新的DRbServer实例。

uri是绑定到的URI。这通常是'druby：// <主机名>：<端口>'的形式，其中<主机名>是本地计算机的主机名。如果为零，则系统的默认主机名将被绑定到系统选择的端口上; 这些值可以从uri属性中检索。'druby：'指定默认的dRuby传输协议：可以指定另一个协议，例如'drbunix：'。

front是服务器的前端对象，即远程方法在服务器上调用的对象将被传递。如果为零，那么服务器将不接受远程方法调用。

如果config_or_acl是散列，则它是用于此服务器的配置。以下选项被认可：

:idconv

一个id到对象的转换对象。这默认为类DRb :: DRbIdConv的一个实例。

:verbose

如果为true，则服务器中对象上的所有不成功的远程调用都将记录到$ stdout。默认为false。

:tcp_acl

此服务器的访问控制列表。请参阅主dRuby发行版中的ACL类。

:load_limit

服务器接受的最大消息大小（以字节为单位）。默认为25 MB（26214400）。

:argc_limit

服务器接受远程方法的最大参数数量。默认为256。

:safe_level

DRbServer的安全级别。该属性为在main_loop中执行的方法设置$ SAFE。默认为0。

这些选项的默认值可以在类的基础上通过类方法default_argc_limit，default_load_limit，default_acl，default_id_conv和verbose =

如果config_or_acl不是散列，但不是零，则假定它是此服务器的访问控制列表。有关更多详细信息，请参阅：tcp_acl选项。

如果当前没有其他服务器被设置为主服务器，则这将成为主服务器。

服务器将立即开始在自己的线程中运行。

# File lib/drb/drb.rb, line 1392
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
    }
  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

  DRb.regist_server(self)
end

verbose()显示源文件

获取：verbose选项的默认值。

# File lib/drb/drb.rb, line 1330
def self.verbose
  @@verbose
end

verbose =（on）显示源文件

设置：verbose选项的默认值。

见new（）。初始默认值为false。

# File lib/drb/drb.rb, line 1325
def self.verbose=(on)
  @@verbose = on
end

公共实例方法

活着？（）显示源文件

这台服务器是否活着？

# File lib/drb/drb.rb, line 1454
def alive?
  @thread.alive?
end

check_insecure_method（obj，msg_id）显示源文件

检查一个方法是否可以通过dRuby调用。

obj是我们想调用该方法的对象。msg_id是方法名称，作为符号。

如果该方法是不安全的方法（请参阅insecure_method？），则会引发SecurityError。如果该方法是私有的或未定义的，则引发NameError。

# File lib/drb/drb.rb, line 1535
def check_insecure_method(obj, msg_id)
  return true if Proc === obj && msg_id == :__drb_yield
  raise(ArgumentError, "#{any_to_s(msg_id)} is not a symbol") unless Symbol == msg_id.class
  raise(SecurityError, "insecure method `#{msg_id}'") if insecure_method?(msg_id)

  if obj.private_methods.include?(msg_id)
    desc = any_to_s(obj)
    raise NoMethodError, "private method `#{msg_id}' called for #{desc}"
  elsif obj.protected_methods.include?(msg_id)
    desc = any_to_s(obj)
    raise NoMethodError, "protected method `#{msg_id}' called for #{desc}"
  else
    true
  end
end

这里？（uri）显示源代码

是uri的URI这个服务器？

# File lib/drb/drb.rb, line 1459
def here?(uri)
  @exported_uri.include?(uri)
end

stop_service()显示源文件

停止这台服务器。

# File lib/drb/drb.rb, line 1464
def stop_service
  DRb.remove_server(self)
  if  Thread.current['DRb'] && Thread.current['DRb']['server'] == self
    Thread.current['DRb']['stop_service'] = true
  else
    if @protocol.respond_to? :shutdown
      @protocol.shutdown
    else
      [@thread, *@grp.list].each {|thread| thread.kill} # xxx: Thread#kill
    end
    @thread.join
  end
end

to_id（obj）显示源代码

将本地对象转换为dRuby引用。

# File lib/drb/drb.rb, line 1486
def to_id(obj)
  return nil if obj.__id__ == front.__id__
  @idconv.to_id(obj)
end

to_obj（ref）显示源文件

将dRuby引用转换为它引用的本地对象。

# File lib/drb/drb.rb, line 1479
def to_obj(ref)
  return front if ref.nil?
  return front[ref.to_s] if DRbURIOption === ref
  @idconv.to_obj(ref)
end

verbose()显示源文件

获取服务器是否处于详细模式。

在详细模式下，失败的调用被记录到标准输出。

# File lib/drb/drb.rb, line 1451
def verbose; @config[:verbose]; end

verbose=(v) Show source

设置是否以详细模式操作。

在详细模式下，失败的调用被记录到标准输出。

# File lib/drb/drb.rb, line 1446
def verbose=(v); @config[:verbose]=v; end

私有实例方法

any_to_s(obj) Show source

将一个对象强制为一个字符串，如果to_s没有为该对象定义，则提供我们自己的表示。

# File lib/drb/drb.rb, line 1521
def any_to_s(obj)
  obj.to_s + ":#{obj.class}"
rescue
  sprintf("#<%s:0x%lx>", obj.class, obj.__id__)
end

error_print(exception) Show source

# File lib/drb/drb.rb, line 1634
def error_print(exception)
  exception.backtrace.inject(true) do |first, x|
    if first
      $stderr.puts "#{x}: #{exception} (#{exception.class})"
    else
      $stderr.puts "\tfrom #{x}"
    end
    false
  end
end

insecure_method?(msg_id) Show source

方法是否包含在不安全方法列表中？

# File lib/drb/drb.rb, line 1515
def insecure_method?(msg_id)
  INSECURE_METHOD.include?(msg_id)
end

main_loop() Show source

主循环由DRbServer的内部线程执行。

接受来自客户端的连接，并启动自己的线程来处理它。此线程循环，接收来自客户端的请求，在本地对象上调用它们，并返回响应，直到客户端关闭连接或本地方法调用失败。

# File lib/drb/drb.rb, line 1652
def main_loop
  client0 = @protocol.accept
  return nil if !client0
  Thread.start(client0) do |client|
    @grp.add Thread.current
    Thread.current['DRb'] = { 'client' => client ,
                              'server' => self }
    DRb.mutex.synchronize do
      client_uri = client.uri
      @exported_uri << client_uri unless @exported_uri.include?(client_uri)
    end
    loop do
      begin
        succ = false
        invoke_method = InvokeMethod.new(self, client)
        succ, result = invoke_method.perform
        error_print(result) if !succ && verbose
        client.send_reply(succ, result)
      rescue Exception => e
        error_print(e) if verbose
      ensure
        client.close unless succ
        if Thread.current['DRb']['stop_service']
          Thread.new { stop_service }
        end
        break unless succ
      end
    end
  end
end

run() Show source

在新线程中启动DRb主循环。

# File lib/drb/drb.rb, line 1496
def run
  Thread.start do
    begin
      while main_loop
      end
    ensure
      @protocol.close if @protocol
    end
  end
end