module Alo7::Net

Constants

VERSION

Public Class Methods

await(defer) click to toggle source

Wait the defer succeed and then return anything the defer returns. Or raise the exception from the defer.

@param defer [Defer] defer to wait @return anything the defer returns

@raise [Exception] the exception returns from defer

# File lib/alo7/net.rb, line 160
def self.await(defer)
  result = EM::Synchrony.sync defer
  raise result if result.is_a? Exception
  result
end
connect(handler, host, port, *args) click to toggle source

Initiate a TCP connection to a remote server and set up event handling for the connection.

@param handler [ClassObject] a module or class that has an innerclass named ‘Impl` @param host [String] host to connect to @param port [Integer] port to connect to @return [handler] the initiated handler instance

@raise (see check_handler!)

@note This requires event loop to be running. (see {run}).

@see listen @see reconnect

# File lib/alo7/net.rb, line 130
def self.connect(handler, host, port, *args)
  check_handler! handler
  connection = EM.connect host, port, handler::Impl, handler, *args
  connection.handler
end
fiber_block(*args) { |*args| ... } click to toggle source

Execute the block in a fiber.

@param args passed as arguments to the block that are executed @yieldparam *args arguments passed from outside @yieldreturn [Object] anything @return [Object] anything returned from the block

# File lib/alo7/net.rb, line 172
def self.fiber_block(*args)
  Fiber.new { yield(*args) }.resume
end
listen(handler, host_or_port, port = nil, *args) { |handler| ... } click to toggle source

Initiate a TCP server on the specified IP address and port.

@overload listen(handler, host, port, *args)

@param handler [ClassObject] a module or class that has an innerclass named `Impl`
@param host [String] host to listen on
@param port [Integer] port to listen on
@param *args passed to the initializer of the handler

@overload listen(handler, port, *args)

@param handler [ClassObject] a module or class that has an innerclass named `Impl`
@param port [Integer] port to listen on
@param *args passed to the initializer of the handler

@yield [handler] initiated when a connection is made @return [Integer] the internal signature

@raise (see check_handler!)

@see connect

# File lib/alo7/net.rb, line 103
def self.listen(handler, host_or_port, port = nil, *args)
  check_handler! handler
  if port
    host = host_or_port
  else
    host = 'localhost'
    port = host_or_port
  end
  EM.start_server host, port, handler::Impl, handler, *args do |server|
    yield server.handler if block_given?
  end
end
reconnect(handler, host, port) click to toggle source

Connect to a given host/port and re-use the provided handler instance.

@param handler [#impl] a instance that has a property named ‘impl` @param host [String] host to reconnect to @param port [Integer] port to reconnect to @return [handler] the previous handler instance

@raise [ArgumentError] if the handler doesn’t implement a method named impl

@see connect @see listen

# File lib/alo7/net.rb, line 147
def self.reconnect(handler, host, port)
  raise ArgumentError, 'must provide a impl property' unless handler.respond_to? :impl
  connection = EM.reconnect host, port, handler.impl
  connection.handler
end
run(blk = nil, &block) click to toggle source

Run an event loop in the fiber way.

@overload run(block) @overload run(&block)

@param block [MethodObject] the block to run @return [void]

@example Starting an event loop in the current thread to run the “Hello, world”-like Echo server example

!!!ruby
require 'alo7-net'

class EchoServer < Alo7::Net::Server
  def receive_data(data)
    send_data data
  end
end

Alo7::Net.run do
  EchoServer.listen 3000
end

@note This method blocks the calling thread. @note This method only returns if the event loop stopped.

@see stop

# File lib/alo7/net.rb, line 40
def self.run(blk = nil, &block)
  EM.synchrony(blk || block)
end
run_once(&block) click to toggle source

Run an event loop and then terminate the loop as soon as the block completes.

@param block [MethodObject] the block to run once @return [void]

# File lib/alo7/net.rb, line 48
def self.run_once(&block)
  run do
    block.call
    stop
  end
end
stop() click to toggle source

Stop the running event loop.

@return [void]

@example Stopping a running event loop.

!!!ruby
require 'alo7-net'

class OnceClient < Alo7::Net::Client
  def post_init
    puts 'sending a dump HTTP request'
    send_data "GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n"
  end

  def receive_data(data)
    puts "data.length: #{data.length}"
    puts 'stopping the event loop now'
    Net.stop
  end
end

Alo7::Net.run do
  OnceClient.connect 'www.google.com', 80
end

@see run

# File lib/alo7/net.rb, line 82
def self.stop
  EM.stop_event_loop
end

Private Class Methods

check_handler!(handler) click to toggle source

@raise [ArgumentError] if the handler doesn’t have a innerclass named Impl

# File lib/alo7/net.rb, line 180
def check_handler!(handler)
  raise ArgumentError, 'must provide a innerclass of Impl' unless defined? handler::Impl
end