Class: DRb::DRbTCPSocket

Class | DRb::DRbTCPSocket
In: | drb/drb.rb
Parent: | Object

The default drb protocol.

Communicates over a TCP socket.

### Methods

accept alive? close getservername new open open_server open_server_inaddr_any peeraddr recv_reply recv_request send_reply send_request stream uri_option

### Attributes

uri | [R] | Get the URI that we are connected to.

### Public Class methods

getservername()

[Source]

    # File drb/drb.rb, line 827
        def self.getservername
          host = Socket::gethostname
          begin
            Socket::gethostbyname(host)[0]
          rescue
            host
          end
        end

new(uri, soc, config={})

Create a new DRbTCPSocket instance.

`uri` is the URI we are connected to. `soc` is the tcp socket we are bound to. `config` is our configuration.

[Source]

    # File drb/drb.rb, line 880
        def initialize(uri, soc, config={})
          @uri = uri
          @socket = soc
          @config = config
          @acl = config[:tcp_acl]
          @msg = DRbMessage.new(config)
          set_sockopt(@socket)
        end

open(uri, config)

Open a client connection to `uri` using configuration `config`.

[Source]

    # File drb/drb.rb, line 819
        def self.open(uri, config)
          host, port, option = parse_uri(uri)
          host.untaint
          port.untaint
          soc = TCPSocket.open(host, port)
          self.new(uri, soc, config)
        end

open_server(uri, config)

Open a server listening for connections at `uri` using configuration `config`.

[Source]

    # File drb/drb.rb, line 855
        def self.open_server(uri, config)
          uri = 'druby://:0' unless uri
          host, port, opt = parse_uri(uri)
          if host.size == 0
            host = getservername
            soc = open_server_inaddr_any(host, port)
          else
            soc = TCPServer.open(host, port)
          end
          port = soc.addr[1] if port == 0
          uri = "druby://#{host}:#{port}"
          self.new(uri, soc, config)
        end

open_server_inaddr_any(host, port)

[Source]

    # File drb/drb.rb, line 836
        def self.open_server_inaddr_any(host, port)
          infos = Socket::getaddrinfo(host, nil,
                                      Socket::AF_UNSPEC,
                                      Socket::SOCK_STREAM,
                                      0,
                                      Socket::AI_PASSIVE)
          family = infos.collect { |af, *_| af }.uniq
          case family
          when ['AF_INET']
            return TCPServer.open('0.0.0.0', port)
          when ['AF_INET6']
            return TCPServer.open('::', port)
          else
            return TCPServer.open(port)
          end
        end

uri_option(uri, config)

Parse `uri` into a [uri, option] pair.

[Source]

    # File drb/drb.rb, line 870
        def self.uri_option(uri, config)
          host, port, option = parse_uri(uri)
          return "druby://#{host}:#{port}", option
        end

### Public Instance methods

accept()

On the server side, for an instance returned by open_server, accept a client connection and return a new instance to handle the server’s side of this client-server session.

[Source]

    # File drb/drb.rb, line 939
        def accept
          while true
            s = @socket.accept
            break if (@acl ? @acl.allow_socket?(s) : true)
            s.close
          end
          self.class.new(nil, s, @config)
        end

alive?()

Check to see if this connection is alive.

[Source]

    # File drb/drb.rb, line 949
        def alive?
          return false unless @socket
          if IO.select([@socket], nil, nil, 0)
            close
            return false
          end
          true
        end

close()

Close the connection.

If this is an instance returned by open_server, then this stops listening for new connections altogether. If this is an instance returned by open or by accept, then it closes this particular client-server session.

[Source]

    # File drb/drb.rb, line 929
        def close
          if @socket
            @socket.close
            @socket = nil
          end
        end

peeraddr()

Get the address of our TCP peer (the other end of the socket we are bound to.

[Source]

    # File drb/drb.rb, line 894
        def peeraddr
          @socket.peeraddr
        end

recv_reply()

On the client side, receive a reply from the server.

[Source]

    # File drb/drb.rb, line 917
        def recv_reply
          @msg.recv_reply(stream)
        end

recv_request()

On the server side, receive a request from the client.

[Source]

    # File drb/drb.rb, line 907
        def recv_request
          @msg.recv_request(stream)
        end

send_reply(succ, result)

On the server side, send a reply to the client.

[Source]

    # File drb/drb.rb, line 912
        def send_reply(succ, result)
          @msg.send_reply(stream, succ, result)
        end

send_request(ref, msg_id, arg, b)

On the client side, send a request to the server.

[Source]

    # File drb/drb.rb, line 902
        def send_request(ref, msg_id, arg, b)
          @msg.send_request(stream, ref, msg_id, arg, b)
        end

stream()

Get the socket.

[Source]

    # File drb/drb.rb, line 899
        def stream; @socket; end

[Validate]