em-xs 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+*.rbc
+.bundle
+Gemfile.lock
+coverage/
+doc/
+tests/
+

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+
+group(:test) do
+  gem 'schmurfy-bacon', '~> 1.4.0'
+  gem 'mocha',          '~> 0.10.0'
+  gem 'simplecov'
+  gem 'guard'
+  gem 'guard-bacon'
+  gem 'rb-fsevent'
+  gem 'growl'
+end

data/Guardfile

@@ -0,0 +1,8 @@
+
+# parameters:
+#  output     => the formatted to use
+#  backtrace  => number of lines, nil =  everything
+guard 'bacon', :output => "BetterOutput", :backtrace => nil do
+  watch(%r{^lib/em-xs/(.+)\.rb$})     { |m| "specs/unit/#{m[1]}_spec.rb" }
+  watch(%r{specs/.+\.rb$})
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Julien Ammous
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# em-xs
+
+Crossroads EventMachine library, I used em-zeromq as base but turned it into something slightly
+different.
+
+## Prerequesites
+
+You need to have libxs installed, on mac os x you can use homebrew:
+```bash
+brew install crossroads
+```
+
+
+## Example
+
+I decided to go for a long example to be closer than a "real" application, here it is:  
+you can view the source [here](https://github.com/schmurfy/em-xs/blob/master/examples/req_rep.rb) too
+
+```ruby
+require 'rubygems'
+require 'bundler/setup'
+
+require 'em-xs'
+
+ENDPOINT = 'inproc://socket'
+
+
+class Client
+  def initialize(context, endpoint, delay)
+    @context = context
+    @endpoint = endpoint
+    @delay = delay
+    
+    @socket = @context.socket(XS::REQ, self)
+    if @socket.connect(endpoint) == -1
+      raise XS::Util.error_string
+    end
+    
+    send_query
+  end
+  
+  def on_readable(s, parts)
+    puts "Client received: #{parts}"
+    send_query
+  end
+  
+private
+  def send_query
+    EM::add_timer(@delay) do
+      @socket.send_msg("ping")
+    end
+  end
+  
+end
+
+
+class EchoServer
+  def initialize(context, endpoint)
+    @context = context
+    @socket = @context.socket(XS::REP, self)
+    if @socket.bind(endpoint) == -1
+      raise XS::Util.error_string
+    end
+  end
+  
+  def on_readable(s, parts)
+    puts "Server received: #{parts}"
+    s.send_msg("re: #{parts[0]}")
+  end
+  
+end
+
+
+EM::run do
+  context = EM::XS::Context.new
+  
+  EchoServer.new(context, ENDPOINT)
+  Client.new(context, ENDPOINT, 1)
+end
+```
+
+
+## Contributing
+
+first install dependencies (thanks bundler !)
+```bash
+bundle
+```
+
+then you can run the specs:
+
+```bash
+bundle exec rake
+```
+
+and if you can to do some changes you can start guard to  
+watch the files and restart associated specs in the background:
+```bash
+bundle exec guard
+```
+

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler/setup'
+require "bundler/gem_tasks"
+
+task :default => :test
+
+task :test do
+  require 'bacon'
+  
+  ENV['COVERAGE'] = "1"
+  
+  Dir[File.expand_path('../specs/**/*_spec.rb', __FILE__)].each do |file|
+    puts "File: #{file}:"
+    load(file)
+  end
+  
+end
+

data/em-xs.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/em-xs/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Julien Ammous"]
+  gem.email         = ["schmurfy@gmail.com"]
+  gem.description   = %q{EventMachine wrapper for crossroads}
+  gem.summary       = %q{EventMachine wrapper for crossroads}
+  gem.homepage      = "https://github.com/schmurfy/em-xs"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.name          = "em-xs"
+  gem.require_paths = ["lib"]
+  gem.version       = EM::XS::VERSION
+  
+  gem.add_dependency 'ffi-rxs'
+  gem.add_dependency 'eventmachine', '~> 1.0.0.beta4'
+end

data/examples/req_rep.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'em-xs'
+
+ENDPOINT = 'inproc://socket'
+
+
+class Client
+  def initialize(context, endpoint, delay)
+    @context = context
+    @endpoint = endpoint
+    @delay = delay
+    
+    @socket = @context.socket(XS::REQ, self)
+    if @socket.connect(endpoint) == -1
+      raise XS::Util.error_string
+    end
+    
+    send_query
+  end
+  
+  def on_readable(s, parts)
+    puts "Client received: #{parts}"
+    send_query
+  end
+  
+private
+  def send_query
+    EM::add_timer(@delay) do
+      @socket.send_msg("ping")
+    end
+  end
+  
+end
+
+
+class EchoServer
+  def initialize(context, endpoint)
+    @context = context
+    @socket = @context.socket(XS::REP, self)
+    if @socket.bind(endpoint) == -1
+      raise XS::Util.error_string
+    end
+  end
+  
+  def on_readable(s, parts)
+    puts "Server received: #{parts}"
+    s.send_msg("re: #{parts[0]}")
+  end
+  
+end
+
+
+EM::run do
+  context = EM::XS::Context.new
+  
+  EchoServer.new(context, ENDPOINT)
+  Client.new(context, ENDPOINT, 1)
+end

data/lib/em-xs.rb

@@ -0,0 +1,14 @@
+require 'eventmachine'
+require 'ffi-rxs'
+
+require_relative 'em-xs/version'
+require_relative 'em-xs/context'
+
+require_relative 'em-xs/socket'
+require_relative 'em-xs/patterns/req_rep_pattern'
+require_relative 'em-xs/patterns/router_dealer_pattern'
+require_relative 'em-xs/patterns/surveyor_pattern'
+require_relative 'em-xs/patterns/push_pull_pattern'
+require_relative 'em-xs/patterns/pub_sub_pattern'
+
+require_relative 'em-xs/helpers'

data/lib/em-xs/context.rb

@@ -0,0 +1,53 @@
+module EventMachine
+  module XS
+        
+    class Context
+      READABLES = [ ::XS::SUB, ::XS::PULL, ::XS::ROUTER, ::XS::DEALER, ::XS::REP, ::XS::REQ, ::XS::RESPONDENT, ::XS::SURVEYOR ]
+      WRITABLES = [ ::XS::PUB, ::XS::PUSH, ::XS::ROUTER, ::XS::DEALER, ::XS::REP, ::XS::REQ, ::XS::RESPONDENT, ::XS::SURVEYOR ]
+      
+      def initialize(io_threads = nil)
+        @context = ::XS::Context.new
+        if io_threads
+          rc = @context.setctxopt(::XS::IO_THREADS, io_threads)
+          unless ::XS::Util.resultcode_ok?(rc)
+            ::XS::raise_error('xs_setctxopt', rc)
+          end
+        end
+      end
+      
+      
+      ##
+      # Create a socket in this context.
+      # 
+      # @param [Integer] socket_type One of ZMQ::REQ, ZMQ::REP, ZMQ::PULL, ZMQ::PUSH,
+      #   ZMQ::ROUTER, ZMQ::DEALER
+      # 
+      # @param [Object] handler an object which respond to on_readable(socket, parts)
+      #   and can respond to on_writeable(socket)
+      # 
+      def socket(socket_type, handler = nil)
+        klass = Socket.get_class_for_type(socket_type)
+        unless klass
+          raise "Unsupported socket type: #{socket_type}"
+        end
+        
+        socket = @context.socket(socket_type)
+        
+        fd = []
+        rc = socket.getsockopt(::XS::FD, fd)
+        unless ::XS::Util.resultcode_ok?(rc)
+          raise "Unable to get socket FD: #{::XS::Util.error_string}"
+        end
+        
+        EM.watch(fd[0], klass, socket, socket_type, handler).tap do |s|
+          s.register_readable if READABLES.include?(socket_type)
+          s.register_writable if WRITABLES.include?(socket_type)
+          
+          yield(s) if block_given?
+        end
+      end  
+    end
+    
+    
+  end
+end

data/lib/em-xs/helpers.rb

@@ -0,0 +1,24 @@
+module EventMachine
+  module XS
+    
+    class Socket
+      TYPES_MAPPING = {
+        ::XS::REQ         => Sockets::Request,
+        ::XS::REP         => Sockets::Reply,
+        ::XS::ROUTER      => Sockets::Router,
+        ::XS::DEALER      => Sockets::Dealer,
+        ::XS::SUB         => Sockets::Subscriber,
+        ::XS::PUB         => Sockets::Publisher,
+        ::XS::SURVEYOR    => Sockets::Surveyor,
+        ::XS::RESPONDENT  => Sockets::Respondent,
+        ::XS::PUSH        => Sockets::Push,
+        ::XS::PULL        => Sockets::Pull
+      }.freeze
+      
+      def self.get_class_for_type(socket_type)
+        TYPES_MAPPING[socket_type]
+      end
+    end
+    
+  end  
+end

data/lib/em-xs/patterns/pub_sub_pattern.rb

@@ -0,0 +1,25 @@
+module EventMachine
+  module XS
+    module Sockets
+      
+      class Publisher < Socket
+      
+      end
+    
+      class Subscriber < Socket
+      
+        def subscribe(what = '')
+          raise "only valid on sub socket type (was #{@socket.name})" unless @socket.name == 'SUB'
+          @socket.setsockopt(::XS::SUBSCRIBE, what)
+        end
+      
+        def unsubscribe(what)
+          raise "only valid on sub socket type (was #{@socket.name})" unless @socket.name == 'SUB'
+          @socket.setsockopt(::XS::UNSUBSCRIBE, what)
+        end
+      
+      end
+      
+    end
+  end
+end

data/lib/em-xs/patterns/push_pull_pattern.rb

@@ -0,0 +1,13 @@
+module EventMachine
+  module XS
+    module Sockets
+      
+      class Push < Socket
+      end
+    
+      class Pull < Socket
+      end
+    
+    end
+  end
+end

data/lib/em-xs/patterns/req_rep_pattern.rb

@@ -0,0 +1,13 @@
+module EventMachine
+  module XS
+    module Sockets
+      
+      class Request < Socket
+      end
+    
+      class Reply < Socket
+      end
+    
+    end
+  end
+end

data/lib/em-xs/patterns/router_dealer_pattern.rb

@@ -0,0 +1,13 @@
+module EventMachine
+  module XS
+    module Sockets
+      
+      class Router < Socket
+      end
+    
+      class Dealer < Socket
+      end
+      
+    end
+  end
+end

data/lib/em-xs/patterns/surveyor_pattern.rb

@@ -0,0 +1,15 @@
+module EventMachine
+  module XS
+    module Sockets
+      
+      class Surveyor < Socket
+        map_sockopt(::XS::SURVEY_TIMEOUT, :survey_timeout)
+      
+      end
+    
+      class Respondent < Surveyor
+      end
+      
+    end
+  end
+end

data/lib/em-xs/socket.rb

@@ -0,0 +1,192 @@
+module EventMachine
+  module XS
+    class Socket < EventMachine::Connection
+      attr_accessor :on_readable, :on_writable, :handler
+      attr_reader   :socket, :socket_type      
+      
+      def initialize(socket, socket_type, handler)
+        @socket      = socket
+        @socket_type = socket_type
+        @handler     = handler
+      end
+      
+      def self.map_sockopt(opt, name, writer = true)
+        define_method(name){ getsockopt(opt) }
+        if writer
+          define_method("#{name}="){|val| @socket.setsockopt(opt, val) }
+        end
+      end
+      
+      map_sockopt(::XS::AFFINITY, :affinity)
+      map_sockopt(::XS::IDENTITY, :identity)
+      map_sockopt(::XS::SNDBUF, :sndbuf)
+      map_sockopt(::XS::RCVBUF, :rcvbuf)
+      map_sockopt(::XS::TYPE, :type, false)
+      map_sockopt(::XS::LINGER, :linger)
+      map_sockopt(::XS::RECONNECT_IVL, :reconnect_interval)
+      map_sockopt(::XS::RECONNECT_IVL_MAX, :max_reconnect_interval)
+      map_sockopt(::XS::BACKLOG, :backlog)
+      map_sockopt(::XS::MAXMSGSIZE, :max_msgsize)
+      map_sockopt(::XS::SNDHWM, :snd_hwm)
+      map_sockopt(::XS::RCVHWM, :rcv_hwm)
+      map_sockopt(::XS::RCVTIMEO, :rcv_timeout)
+      map_sockopt(::XS::SNDTIMEO, :snd_timeout)
+      map_sockopt(::XS::IPV4ONLY, :ipv4only)
+      map_sockopt(::XS::KEEPALIVE, :keepalive)
+      
+      
+      # pgm
+      map_sockopt(::XS::RATE, :rate)
+      map_sockopt(::XS::MULTICAST_HOPS, :max_multicast_hops)
+      map_sockopt(::XS::RECOVERY_IVL, :recovery_interval)
+      
+      # User method
+      def bind(address)
+        @socket.bind(address)
+      end
+      
+      def connect(address)
+        @socket.connect(address)
+      end
+      
+      # send a non blocking message
+      # parts:  if only one argument is given a signle part message is sent
+      #         if more than one arguments is given a multipart message is sent
+      #
+      # return: true is message was queued, false otherwise
+      #
+      def send_msg(*parts)
+        parts = Array(parts[0]) if parts.size == 0
+        sent = true
+        
+        # multipart
+        parts[0...-1].each do |msg|
+          sent = @socket.send_string(msg, ::XS::DONTWAIT | ::XS::SNDMORE)
+          if sent == false
+            break
+          end
+        end
+        
+        if sent
+          # all the previous parts were queued, send
+          # the last one
+          ret = @socket.send_string(parts[-1], ::XS::DONTWAIT)
+          if ret < 0
+            raise "Unable to send message: #{::XS::Util.error_string}"
+          end
+        else
+          # error while sending the previous parts
+          # register the socket for writability
+          self.notify_writable = true
+          sent = false
+        end
+        
+        notify_readable()
+        
+        sent
+      end
+      
+      def getsockopt(opt)
+        ret = []
+        rc = @socket.getsockopt(opt, ret)
+        unless ::XS::Util.resultcode_ok?(rc)
+          ::XS::Util.raise_error('getsockopt', rc)
+        end
+
+        (ret.size == 1) ? ret[0] : ret    
+      end
+      
+      def setsockopt(opt, value)
+        @socket.setsockopt(opt, value)
+      end
+      
+      # cleanup when ending loop
+      def unbind
+        detach_and_close
+      end
+      
+      # Make this socket available for reads
+      def register_readable
+        if readable?
+          notify_readable
+        end
+        
+        # Subscribe to EM read notifications
+        self.notify_readable = true
+      end
+
+      # Trigger on_readable when socket is readable
+      def register_writable
+        # Subscribe to EM write notifications
+        self.notify_writable = true
+      end
+
+      def notify_readable
+        # Not sure if this is actually necessary. I suppose it prevents us
+        # from having to to instantiate a XS::Message unnecessarily.
+        # I'm leaving this is because its in the docs, but it could probably
+        # be taken out.
+        return unless readable?
+         
+        loop do
+          msg_parts = []
+          msg       = get_message
+          if msg
+            msg_parts << msg
+            while @socket.more_parts?
+              msg = get_message
+              if msg
+                msg_parts << msg
+              else
+                raise "Multi-part message missing a message!"
+              end
+            end
+            
+            @handler.on_readable(self, msg_parts)
+          else
+            break
+          end
+        end
+      end
+      
+      def notify_writable
+        return unless writable?
+        
+        # once a writable event is successfully received the socket
+        # should be accepting messages again so stop triggering
+        # write events
+        self.notify_writable = false
+        
+        if @handler.respond_to?(:on_writable)
+          @handler.on_writable(self)
+        end
+      end
+      def readable?
+        (getsockopt(::XS::EVENTS) & ::XS::POLLIN) == ::XS::POLLIN
+      end
+      
+      def writable?
+        true
+        # return false
+        # (getsockopt(::XS::EVENTS) & ::XS::POLLOUT) == ::XS::POLLOUT
+      end
+      
+      
+    private
+    
+      # internal methods
+      def get_message
+        msg = ""
+        msg_recvd = @socket.recv_string(msg, ::XS::DONTWAIT)
+        msg_recvd != -1 ? msg : nil
+      end
+      
+      # Detaches the socket from the EM loop,
+      # then closes the socket
+      def detach_and_close
+        detach
+        @socket.close
+      end
+    end
+  end
+end

data/lib/em-xs/version.rb

@@ -0,0 +1,5 @@
+module EM
+  module XS
+    VERSION = "0.0.1"
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'bacon'
+
+if ENV['COVERAGE']
+  Bacon.allow_focused_run = false
+  
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter ".*_spec"
+    add_filter "/helpers/"
+  end
+  
+end
+
+$LOAD_PATH.unshift( File.expand_path('../../lib' , __FILE__) )
+require 'em-xs'
+
+require 'bacon/ext/mocha'
+require 'bacon/ext/em'
+
+Thread.abort_on_exception = true
+
+Bacon.summary_on_exit()
+
+ENDPOINTS = {
+  'inproc'  => 'inproc://socket',
+  'ipc'     => 'ipc:///tmp/socket',
+  'tcp'     => 'tcp://127.0.0.1:1234'
+}.freeze

data/specs/unit/context_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../spec_helper'
+
+require 'em-xs/context'
+
+describe 'Context' do
+  before do
+    @ctx = EM::XS::Context.new
+  end
+  
+  it 'can create socket' do
+    s = @ctx.socket(XS::ROUTER)
+    s.class.should == EM::XS::Sockets::Router
+    s.socket_type.should == XS::ROUTER
+  end
+  
+  should 'set io threads count' do
+    proc{
+      EM::XS::Context.new(2)
+    }.should.not.raise
+  end
+  
+  should 'raise an error if socket type is unsupported' do
+    err = proc {
+      @ctx.socket(99)
+    }.should.raise(RuntimeError)
+    
+    err.message.should == "Unsupported socket type: 99"
+    
+  end
+  
+end
+

data/specs/unit/helpers_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../spec_helper'
+
+require 'em-xs'
+
+describe 'Socket' do
+
+  should 'return correct types' do
+    EM::XS::Socket.get_class_for_type(XS::REQ).should == EM::XS::Sockets::Request
+    EM::XS::Socket.get_class_for_type(XS::REP).should == EM::XS::Sockets::Reply
+    
+    EM::XS::Socket.get_class_for_type(XS::ROUTER).should == EM::XS::Sockets::Router
+    EM::XS::Socket.get_class_for_type(XS::DEALER).should == EM::XS::Sockets::Dealer
+    
+    EM::XS::Socket.get_class_for_type(XS::PUB).should == EM::XS::Sockets::Publisher
+    EM::XS::Socket.get_class_for_type(XS::SUB).should == EM::XS::Sockets::Subscriber
+    
+    EM::XS::Socket.get_class_for_type(XS::SURVEYOR).should == EM::XS::Sockets::Surveyor
+    EM::XS::Socket.get_class_for_type(XS::RESPONDENT).should == EM::XS::Sockets::Respondent
+    
+    EM::XS::Socket.get_class_for_type(XS::PUSH).should == EM::XS::Sockets::Push
+    EM::XS::Socket.get_class_for_type(XS::PULL).should == EM::XS::Sockets::Pull
+  end
+
+end

data/specs/unit/patterns/pub_sub_pattern_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../spec_helper'
+
+describe 'Pattern: Publisher/Subscriber' do
+  before do
+    @ctx = EM::XS::Context.new    
+  end
+  
+  describe 'PUB/SUB' do
+    before do
+      @client_handler = stub()
+      @server1_handler = stub()
+      @server2_handler = stub()
+      @client = @ctx.socket(XS::PUB, @client_handler)
+      @server1 = @ctx.socket(XS::SUB, @server1_handler)
+      @server2 = @ctx.socket(XS::SUB, @server2_handler)
+    end
+    
+    after do
+      @client.send(:detach_and_close)
+      @server1.send(:detach_and_close)
+      @server2.send(:detach_and_close)
+    end
+    
+    ENDPOINTS.each do |label, endpoint|
+      should "works with #{label} endpoints" do
+        @client.bind(endpoint).should >= 0
+        @server1.connect(endpoint).should >= 0
+        @server2.connect(endpoint).should >= 0
+        
+        @server1.subscribe('')
+        @server2.subscribe('')
+        
+        @server1_handler.expects(:on_readable).with(@server1, ['1: some message'])
+        @server2_handler.expects(:on_readable).with(@server2, ['3: some message'])
+        
+        EM::add_timer(0.1) do
+          @client.send_msg("1: some message")
+          # @client.send_msg("2: some message")
+        end
+      
+        wait(0.2)
+      end  
+    end
+    
+  end
+  
+end

data/specs/unit/patterns/push_pull_pattern_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../../spec_helper'
+
+describe 'Pattern: Push/Pull' do
+  before do
+    @ctx = EM::XS::Context.new    
+  end
+    
+  describe 'PUSH/PULL' do
+    before do
+      @client_handler = stub()
+      @server_handler = stub()
+      @client = @ctx.socket(XS::PUSH, @client_handler)
+      @server = @ctx.socket(XS::PULL, @server_handler)
+    end
+    
+    after do
+      @client.send(:detach_and_close)
+      @server.send(:detach_and_close)
+    end
+    
+    ENDPOINTS.each do |label, endpoint|
+      should "works with #{label} endpoints" do
+        @server.bind(endpoint).should >= 0
+        @client.connect(endpoint).should >= 0
+      
+        @server_handler.expects(:on_readable).with(@server, ['some message'])
+        @client.send_msg("some message")
+      
+        wait(0.1)
+      end  
+    end
+    
+  end
+  
+end

data/specs/unit/patterns/req_rep_pattern_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../../spec_helper'
+
+describe 'Pattern: Request/Reply' do
+  before do
+    @ctx = EM::XS::Context.new    
+  end
+    
+  describe 'REQ/REP' do
+    before do
+      @client_handler = stub()
+      @server_handler = stub()
+      @client = @ctx.socket(XS::REQ, @client_handler)
+      @server = @ctx.socket(XS::REP, @server_handler)
+    end
+    
+    after do
+      @client.send(:detach_and_close)
+      @server.send(:detach_and_close)
+    end
+    
+    ENDPOINTS.each do |label, endpoint|
+      should "works with #{label} endpoints" do
+        @server.bind(endpoint).should >= 0
+        @client.connect(endpoint).should >= 0
+      
+        @server_handler.expects(:on_readable).with(@server, ['hello server'])
+        @client.send_msg("hello server")
+      
+        EM::add_timer(0.1) do
+          @client_handler.expects(:on_readable).with(@client, ['yo !'])
+          @server.send_msg("yo !")
+        end
+      
+        wait(0.3)
+      end  
+    end
+    
+  end
+  
+end
+

data/specs/unit/patterns/router_dealer_pattern_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../../spec_helper'
+
+describe 'Pattern: Router/Dealer' do
+  before do
+    @ctx = EM::XS::Context.new    
+  end
+
+  describe 'XREQ/XREP' do
+    before do
+      @client_handler = stub()
+      
+      @server_handler = Class.new do
+        def on_readable(sock, parts)
+          id, *parts = parts
+          sock.send_msg(id, "re: #{parts[0]}")
+        end
+      end.new
+      
+      @client = @ctx.socket(XS::XREQ, @client_handler)
+      @server = @ctx.socket(XS::XREP, @server_handler)
+    end
+    
+    after do
+      @client.send(:detach_and_close)
+      @server.send(:detach_and_close)
+    end
+    
+    ENDPOINTS.each do |label, endpoint|
+      should "works with #{label} endpoints" do
+        @server.bind(endpoint).should >= 0        
+        @client.connect(endpoint).should >= 0
+      
+        @client_handler.expects(:on_readable).with(@client, ['re: first question'])
+        @client.send_msg("first question")
+      
+        @client_handler.expects(:on_readable).with(@client, ['re: second question'])
+        @client.send_msg("second question")
+      
+        wait(0.2)
+      end
+    end
+    
+  end
+  
+end

data/specs/unit/patterns/surveyor_pattern_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../spec_helper'
+
+describe 'Pattern: Surveyor/Respondent' do
+  before do
+    @ctx = EM::XS::Context.new    
+  end
+    
+  describe 'SURVEYOR/RESPONDENT' do
+    before do
+      @client_handler = stub()
+      
+      @server_handler_class = Class.new do
+        def initialize(id)
+          @id = id
+        end
+        
+        def on_readable(sock, parts)
+          p parts
+          sock.send_msg("#{parts[0]} : #{@id}")
+        end
+      end
+      
+      @server1 = @ctx.socket(XS::RESPONDENT, @server_handler)
+      @server2 = @ctx.socket(XS::RESPONDENT, @server_handler)      
+      @client = @ctx.socket(XS::SURVEYOR, @client_handler)
+    end
+
+    # => CRASH
+    # ENDPOINTS.each do |label, endpoint|
+    #   should "works with #{label} endpoints" do
+    #     @server1.connect(endpoint).should == 0
+    #     @server2.connect(endpoint).should == 0
+    #     @client.bind(endpoint).should == 0
+    #   
+    #     @client_handler.expects(:on_readable).with(@server, ['msg : 1'])
+    #     @client_handler.expects(:on_readable).with(@server, ['msg : 2'])
+    #     @client.send_msg("msg")
+    #   
+    #   
+    #     wait(0.2)
+    #   end
+    # end
+    
+  end
+  
+end
+

data/specs/unit/socket_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../spec_helper'
+
+describe 'Socket' do
+  before do
+    @ctx = EM::XS::Context.new    
+  end
+  
+end
+

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: em-xs
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Julien Ammous
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-rxs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta4
+description: EventMachine wrapper for crossroads
+email:
+- schmurfy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- em-xs.gemspec
+- examples/req_rep.rb
+- lib/em-xs.rb
+- lib/em-xs/context.rb
+- lib/em-xs/helpers.rb
+- lib/em-xs/patterns/pub_sub_pattern.rb
+- lib/em-xs/patterns/push_pull_pattern.rb
+- lib/em-xs/patterns/req_rep_pattern.rb
+- lib/em-xs/patterns/router_dealer_pattern.rb
+- lib/em-xs/patterns/surveyor_pattern.rb
+- lib/em-xs/socket.rb
+- lib/em-xs/version.rb
+- specs/spec_helper.rb
+- specs/unit/context_spec.rb
+- specs/unit/helpers_spec.rb
+- specs/unit/patterns/pub_sub_pattern_spec.rb
+- specs/unit/patterns/push_pull_pattern_spec.rb
+- specs/unit/patterns/req_rep_pattern_spec.rb
+- specs/unit/patterns/router_dealer_pattern_spec.rb
+- specs/unit/patterns/surveyor_pattern_spec.rb
+- specs/unit/socket_spec.rb
+homepage: https://github.com/schmurfy/em-xs
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2028971236709690266
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2028971236709690266
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: EventMachine wrapper for crossroads
+test_files: []