Skip to content
Simple abstraction on top of EventMachine for easy create clients, servers, workers, ...
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
benchmark
examples
lib
spec
.gitignore
.rspec
.travis.yml
Gemfile
LICENSE.txt
README.md
Rakefile
em-nodes.gemspec

README.md

EM::Nodes

Simple abstraction on top of EventMachine for easy create clients, servers, workers, ...

Installation

Add this line to your application's Gemfile:

gem 'em-nodes'

How to use

Client should inherit from EM::Nodes::Client, Server should inherit from EM::Nodes::Server. Client and Server can define and use methods on_#{method_name} and send_#{method_name}, on_#{method_name} - receive value from send_#{method_name} call.

Example: client after connection to server, send i_connected to server, server send_client_request, client on_client_request send to server client_responce, and server output value.

simple_server.rb

class Server < EM::Nodes::Server
  def on_i_connected(value)
    puts "#{value} connected"
    send_client_request(1)
  end

  def on_client_responce(value)
    puts "client responce #{value}"
  end
end

EM.run do
  Server.start "/tmp/server.sock"
end

simple_client.rb

class Client < EM::Nodes::Client
  def on_client_request(value)
    send_client_responce(value + 1)
  end
end

EM.run do
  client = Client.connect "/tmp/server.sock"
  client.send_i_connected("hahaha")
end

HelloFeature

HelloFeature used to simple greetings between client and server. Client should define method info which return hash. Server had added method: ready_clients, which contain clients which answered on info method.

hello_server.rb

class Server < EM::Nodes::Server
  include HelloFeature
end

EM.run do
  Server.start "/tmp/server.sock"

  EM.add_periodic_timer(5) do
    vasya = Server.ready_clients.detect { |client| client.data.my_name == 'Vasya' }
    vasya.send_die if vasya
  end
end

hello_client.rb

class Client < EM::Nodes::Client
  include HelloFeature

  def initialize(name)
    @name = name
    super
  end

  def info
    { :my_name => @name }
  end

  def on_die
    puts "oops i should die"
    EM.stop
  end
end

EM.run do
  client = Client.connect "/tmp/server.sock", nil, "Vasya"
end

TaskFeature

TaskFeature is simple task sending, executing and getting results. Client should define method on_task(task_id, param), and when execute task and got results, should call send_task_result(task_id, result). Server should send task with method, send_task(param)

Example: Client after connection send to server get_me_task, server send_task to client with rand value, client execute on_task method and add to param 1 and call send_task_result, server receive on_task_result and output result.

task_server.rb

class Server < EM::Nodes::Server
  include TaskFeature

  def on_get_me_task
    param = rand
    puts "send to client #{param}"
    send_task(param)
  end

  def on_task_result(result)
    puts "client return result #{result}"
  end
end

EM.run do
  Server.start "/tmp/server.sock"
end

task_client.rb

class Client < EM::Nodes::Client
  include TaskFeature

  def on_task(task_id, param)
    EM.next_tick { send_task_result(task_id, param + 1) }
  end
end

EM.run do
  client = Client.connect "/tmp/server.sock"
  client.send_get_me_task
end

DefaultClient, DefaultServer

This is abstraction with HelloFeature and TaskFeature by default. Example how to create server and 10 workers. Server schedule for each client every 1 second, some value. Client just add 1 to value and return result to server, server puts value.

default_server.rb

class Server < EM::Nodes::DefaultServer
  def on_task_result(res)
    puts res
  end
end

EM.run do
  Server.start "127.0.0.1", 8888

  # periodical schedule tasks to clients
  EM.add_periodic_timer(1) do
    Server.ready_clients.each do |client|
      client.send_task(rand)
    end
  end
end

default_client.rb

class Client < EM::Nodes::DefaultClient
  def info
    { :name => 'bla' }
  end

  def on_task(task_id, param)
    res = do_something(param)
    send_task_result(task_id, res)
  end

  def do_something(x)
    x + 1
  end
end

EM.run do
  10.times do
    Client.connect "127.0.0.1", 8888
  end
end

More examples

You can’t perform that action at this time.