Method: EventMachine.open_datagram_socket

Defined in:

lib/eventmachine.rb

.open_datagram_socket(address, port, handler = nil) ⇒ Object

EventMachine#open_datagram_socket is for support of UDP-based protocols. Its usage is similar to that of EventMachine#start_server. It takes three parameters: an IP address (which must be valid on the machine which executes the method), a port number, and an optional Module name which will handle the data. This method will create a new UDP (datagram) socket and bind it to the address and port that you specify. The normal callbacks (see EventMachine#start_server) will be called as events of interest occur on the newly-created socket, but there are some differences in how they behave.

Connection#receive_data will be called when a datagram packet is received on the socket, but unlike TCP sockets, the message boundaries of the received data will be respected. In other words, if the remote peer sent you a datagram of a particular size, you may rely on Connection#receive_data to give you the exact data in the packet, with the original data length. Also observe that Connection#receive_data may be called with a zero-length data payload, since empty datagrams are permitted in UDP.

Connection#send_data is available with UDP packets as with TCP, but there is an important difference. Because UDP communications are connectionless, there is no implicit recipient for the packets you send. Ordinarily you must specify the recipient for each packet you send. However, EventMachine provides for the typical pattern of receiving a UDP datagram from a remote peer, performing some operation, and then sending one or more packets in response to the same remote peer. To support this model easily, just use Connection#send_data in the code that you supply for Connection:receive_data. EventMachine will provide an implicit return address for any messages sent to Connection#send_data within the context of a Connection#receive_data callback, and your response will automatically go to the correct remote peer. (TODO: Example-code needed!)

Observe that the port number that you supply to EventMachine#open_datagram_socket may be zero. In this case, EventMachine will create a UDP socket that is bound to an ephemeral (not well-known) port. This is not appropriate for servers that must publish a well-known port to which remote peers may send datagrams. But it can be useful for clients that send datagrams to other servers. If you do this, you will receive any responses from the remote servers through the normal Connection#receive_data callback. Observe that you will probably have issues with firewalls blocking the ephemeral port numbers, so this technique is most appropriate for LANs. (TODO: Need an example!)

If you wish to send datagrams to arbitrary remote peers (not necessarily ones that have sent data to which you are responding), then see Connection#send_datagram.

DO NOT call send_data from a datagram socket outside of a #receive_data method. Use #send_datagram. If you do use #send_data outside of a #receive_data method, you’ll get a confusing error because there is no “peer,” as #send_data requires. (Inside of #receive_data, #send_data “fakes” the peer as described above.)

– Replaced the implementation on 01Oct06. Thanks to Tobias Gustafsson for pointing out that this originally did not take a class but only a module.

# File 'lib/eventmachine.rb', line 749

def self::open_datagram_socket address, port, handler=nil
  klass = if (handler and handler.is_a?(Class))
    handler
  else
    Class.new( Connection ) {handler and include handler}
  end

  s = open_udp_socket address, port
  c = klass.new s
  @conns[s] = c
  block_given? and yield c
  c
end