Skip to content

class SF::SocketSelector
inherits Reference #

Multiplexer that allows to read from multiple sockets

Socket selectors provide a way to wait until some data is available on a set of sockets, instead of just one. This is convenient when you have multiple sockets that may possibly receive data, but you don't know which one will be ready first. In particular, it avoids to use a thread for each socket; with selectors, a single thread can handle all the sockets.

All types of sockets can be used in a selector:

A selector doesn't store its own copies of the sockets (socket classes are not copyable anyway), it simply keeps a reference to the original sockets that you pass to the "add" function. Therefore, you can't use the selector as a socket container, you must store them outside and make sure that they are alive as long as they are used in the selector.

Using a selector is simple:

  • populate the selector with all the sockets that you want to observe
  • make it wait until there is data available on any of the sockets
  • test each socket to find out which ones are ready

Usage example:

# Create a socket to listen to new connections
listener = SF::TcpListener.new
listener.listen(55001)

# Create an array to store the future clients
clients = [] of SF::TcpSocket

# Create a selector
selector = SF::SocketSelector.new

# Add the listener to the selector
selector.add listener

# Endless loop that waits for new connections
while running
  # Make the selector wait for data on any socket
  if selector.wait()
    # Test the listener
    if selector.ready?(listener)
      # The listener is ready: there is a pending connection
      client = SF::TcpSocket.new
      if listener.accept(client) == SF::Socket::Done
        # Add the new client to the clients list
        clients << client

        # Add the new client to the selector so that we will
        # be notified when he sends something
        selector.add client
      end
    else
      # The listener socket is not ready, test all other sockets (the clients)
      clients.each do |client|
        if selector.ready?(client)
          # The client has sent some data, we can receive it
          packet = SF::Packet.new
          if client.receive(packet) == SF::Socket::Done
              ...
          end
        end
      end
    end
  end
end

See also: SF::Socket

Class methods#

.new #

Default constructor

View source

Methods#

#add(socket : Socket) #

Add a new socket to the selector

This function keeps a weak reference to the socket, so you have to make sure that the socket is not destroyed while it is stored in the selector. This function does nothing if the socket is not valid.

  • socket - Reference to the socket to add

See also: remove, clear

View source

#clear #

Remove all the sockets stored in the selector

This function doesn't destroy any instance, it simply removes all the references that the selector has to external sockets.

See also: add, remove

View source

#dup : SocketSelector #

Returns a shallow copy of this object.

This allocates a new object and copies the contents of self into it.

View source

#finalize #

Destructor

View source

#ready?(socket : Socket) : Bool #

Test a socket to know if it is ready to receive data

This function must be used after a call to Wait, to know which sockets are ready to receive data. If a socket is ready, a call to receive will never block because we know that there is data available to read. Note that if this function returns true for a TcpListener, this means that it is ready to accept a new connection.

  • socket - Socket to test

Returns: True if the socket is ready to read, false otherwise

See also: ready?

View source

#remove(socket : Socket) #

Remove a socket from the selector

This function doesn't destroy the socket, it simply removes the reference that the selector has to it.

  • socket - Reference to the socket to remove

See also: add, clear

View source

#wait(timeout : Time = Time::Zero) : Bool #

Wait until one or more sockets are ready to receive

This function returns as soon as at least one socket has some data available to be received. To know which sockets are ready, use the ready? function. If you use a timeout and no socket is ready before the timeout is over, the function returns false.

  • timeout - Maximum time to wait, (use Time::Zero for infinity)

Returns: True if there are sockets ready, false otherwise

See also: ready?

View source