em-synchrony 1.0.0 → 1.0.1

data/lib/em-synchrony/em-mongo.rb

@@ -7,6 +7,25 @@ end
 module EM
   module Mongo
 
+    class Database
+      def authenticate(username, password)
+        auth_result = self.collection(SYSTEM_COMMAND_COLLECTION).first({'getnonce' => 1})
+
+        auth                 = BSON::OrderedHash.new
+        auth['authenticate'] = 1
+        auth['user']         = username
+        auth['nonce']        = auth_result['nonce']
+        auth['key']          = EM::Mongo::Support.auth_key(username, password, auth_result['nonce'])
+
+        auth_result2 = self.collection(SYSTEM_COMMAND_COLLECTION).first(auth)
+        if EM::Mongo::Support.ok?(auth_result2)
+          true
+        else
+          raise AuthenticationError, auth_result2["errmsg"]
+        end
+      end
+    end
+
     class Connection
       def initialize(host = DEFAULT_IP, port = DEFAULT_PORT, timeout = nil, opts = {})
         f = Fiber.current

data/lib/em-synchrony/em-multi.rb

@@ -6,16 +6,18 @@ module EventMachine
       attr_reader :requests, :responses
 
       def initialize
-        @requests = []
+        @requests = {}
         @responses = {:callback => {}, :errback => {}}
       end
 
       def add(name, conn)
+        raise 'Duplicate Multi key' if @requests.key? name
+
         fiber = Fiber.current
         conn.callback { @responses[:callback][name] = conn; check_progress(fiber) }
         conn.errback  { @responses[:errback][name]  = conn; check_progress(fiber) }
 
-        @requests.push(conn)
+        @requests[name] = conn
       end
 
       def finished?

data/lib/em-synchrony/mongo.rb

@@ -5,7 +5,9 @@ rescue LoadError => error
 end
 
 # monkey-patch Mongo to use em-synchrony's socket and thread classs
-silence_warnings do
+old_verbose = $VERBOSE
+begin
+  $VERBOSE = nil
   class Mongo::Connection
     TCPSocket = ::EventMachine::Synchrony::TCPSocket
     Mutex = ::EventMachine::Synchrony::Thread::Mutex
@@ -29,4 +31,6 @@ silence_warnings do
   end
 
   Mongo::TimeoutHandler = EventMachine::Synchrony::MongoTimeoutHandler
-end
+ensure
+  $VERBOSE = old_verbose
+end

data/lib/em-synchrony/mysql2.rb

@@ -7,11 +7,27 @@ end
 module Mysql2
   module EM
     class Client
+      module Watcher
+        def notify_readable
+          detach
+          begin
+            result = @client.async_result
+          rescue Exception => e
+            @deferable.fail(e)
+          else
+            @deferable.succeed(result)
+          end
+        end
+      end
 
       alias :aquery :query
       def query(sql, opts={})
         deferable = aquery(sql, opts)
 
+        # if EM is not running, we just get the sql result directly
+        # if we get a deferable, then let's do the deferable thing.
+        return deferable unless deferable.kind_of? ::EM::DefaultDeferrable
+
         f = Fiber.current
         deferable.callback { |res| f.resume(res) }
         deferable.errback  { |err| f.resume(err) }

data/lib/em-synchrony/tcpsocket.rb

@@ -5,9 +5,9 @@ module EventMachine
         alias_method :_old_new, :new
         def new(*args)
           if args.size == 1
-            _old_new *args
+            _old_new(*args)
           else
-            socket = EventMachine::connect( *args[0..1], self )
+            socket = EventMachine::connect(*args[0..1], self)
             raise SocketError unless socket.sync(:in)  # wait for connection
             socket
           end
@@ -34,7 +34,7 @@ module EventMachine
       def setsockopt(level, name, value); end
 
       def send(msg, flags = 0)
-        raise "Unknown flags in send(): #{flags}"  if flags.nonzero?
+        raise "Unknown flags in send(): #{flags}" if flags.nonzero?
         len = msg.bytesize
         write_data(msg) or sync(:out) or raise(IOError)
         len
@@ -60,6 +60,7 @@ module EventMachine
       def unbind
         @in_req.fail  nil if @in_req
         @out_req.fail nil if @out_req
+        close
       end
 
       def receive_data(data)
@@ -107,4 +108,4 @@ module EventMachine
         end
     end
   end
-end
+end

data/lib/em-synchrony/thread.rb

@@ -4,20 +4,121 @@ module EventMachine
 
       # Fiber-aware drop-in replacements for thread objects
       class Mutex
-        def synchronize( &blk )
-          blk.call
+        def initialize
+          @waiters = []
+          @slept = {}
         end
+
+        def lock
+          current = Fiber.current
+          raise FiberError if @waiters.include?(current)
+          @waiters << current
+          Fiber.yield unless @waiters.first == current
+          true
+        end
+
+        def locked?
+          !@waiters.empty?
+        end
+
+        def _wakeup(fiber)
+          fiber.resume if @slept.delete(fiber)
+        end
+
+        def sleep(timeout = nil)
+          unlock    
+          beg = Time.now
+          current = Fiber.current
+          @slept[current] = true
+          if timeout
+            timer = EM.add_timer(timeout) do
+              _wakeup(current)
+            end
+            Fiber.yield
+            EM.cancel_timer timer # if we resumes not via timer
+          else
+            Fiber.yield
+          end
+          @slept.delete current
+          yield if block_given?
+          lock
+          Time.now - beg
+        end
+
+        def try_lock
+          lock unless locked?
+        end
+
+        def unlock
+          raise FiberError unless @waiters.first == Fiber.current  
+          @waiters.shift
+          unless @waiters.empty?
+            EM.next_tick{ @waiters.first.resume }
+          end
+          self
+        end
+
+        def synchronize
+          lock
+          yield
+        ensure
+          unlock
+        end
+
       end
 
       class ConditionVariable
-        def wait( mutex )
-          @deferrable = EventMachine::DefaultDeferrable.new
-          EventMachine::Synchrony.sync @deferrable
-          @deferrable = nil
+        #
+        # Creates a new ConditionVariable
+        #
+        def initialize
+          @waiters = []
+        end
+
+        #
+        # Releases the lock held in +mutex+ and waits; reacquires the lock on wakeup.
+        #
+        # If +timeout+ is given, this method returns after +timeout+ seconds passed,
+        # even if no other thread doesn't signal.
+        #
+        def wait(mutex, timeout=nil)
+          current = Fiber.current
+          pair = [mutex, current]
+          @waiters << pair
+          mutex.sleep timeout do
+            @waiters.delete pair
+          end
+          self
+        end
+
+        def _wakeup(mutex, fiber)
+          if alive = fiber.alive?
+            EM.next_tick {
+              mutex._wakeup(fiber)
+            }
+          end
+          alive
         end
 
+        #
+        # Wakes up the first thread in line waiting for this lock.
+        #
         def signal
-          @deferrable and @deferrable.succeed
+          while (pair = @waiters.shift)
+            break if _wakeup(*pair)
+          end
+          self
+        end
+
+        #
+        # Wakes up all threads waiting for this lock.
+        #
+        def broadcast
+          @waiters.each do |mutex, fiber|
+            _wakeup(mutex, fiber)
+          end
+          @waiters.clear
+          self
         end
       end
 

data/spec/activerecord_spec.rb

@@ -1,50 +1,109 @@
-require "spec/helper/all"
-require "em-synchrony/activerecord"
-
-# create database widgets;
-# use widgets;
-# create table widgets (idx INT);
-
-class Widget < ActiveRecord::Base; end;
-
-describe "Fiberized ActiveRecord driver for mysql2" do
-  DELAY = 0.25
-  QUERY = "SELECT sleep(#{DELAY})"
-
-  it "should establish AR connection" do
-    EventMachine.synchrony do
-      ActiveRecord::Base.establish_connection(
-        :adapter => 'em_mysql2',
-        :database => 'widgets',
-        :username => 'root'
-      )
-
-      result = Widget.find_by_sql(QUERY)
-      result.size.should == 1
-
-      EventMachine.stop
-    end
-  end
-
-  it "should fire sequential, synchronous requests within single fiber" do
-    EventMachine.synchrony do
-      ActiveRecord::Base.establish_connection(
-        :adapter => 'em_mysql2',
-        :database => 'widgets',
-        :username => 'root'
-      )
-
-      start = now
-      res = []
-
-      res.push Widget.find_by_sql(QUERY)
-      res.push Widget.find_by_sql(QUERY)
-
-      (now - start.to_f).should be_within(DELAY * res.size * 0.15).of(DELAY * res.size)
-      res.size.should == 2
-
-      EventMachine.stop
-    end
-  end
-
+require "spec/helper/all"
+require "em-synchrony/activerecord"
+require "em-synchrony/fiber_iterator"
+
+# create database widgets;
+# use widgets;
+# create table widgets (
+# id INT NOT NULL AUTO_INCREMENT,
+# title varchar(255),
+# PRIMARY KEY (`id`)
+# );
+
+class Widget < ActiveRecord::Base; end;
+
+describe "Fiberized ActiveRecord driver for mysql2" do
+  DELAY = 0.25
+  QUERY = "SELECT sleep(#{DELAY})"
+
+  def establish_connection
+      ActiveRecord::Base.establish_connection(
+        :adapter => 'em_mysql2',
+        :database => 'widgets',
+        :username => 'root',
+        :pool => 10
+      )
+      Widget.delete_all
+  end
+
+  it "should establish AR connection" do
+    EventMachine.synchrony do
+      establish_connection
+
+      result = Widget.find_by_sql(QUERY)
+      result.size.should eql(1)
+      EventMachine.stop
+    end
+  end
+
+  it "should fire sequential, synchronous requests within single fiber" do
+    EventMachine.synchrony do
+      establish_connection
+
+      start = now
+      res = []
+
+      res.push Widget.find_by_sql(QUERY)
+      res.push Widget.find_by_sql(QUERY)
+
+      (now - start.to_f).should be_within(DELAY * res.size * 0.15).of(DELAY * res.size)
+      res.size.should eql(2)
+
+      EventMachine.stop
+    end
+  end
+
+  it "should fire 100 requests in fibers" do
+    EM.synchrony do
+      establish_connection
+      EM::Synchrony::FiberIterator.new(1..100, 40).each do |i|
+        widget = Widget.create title: 'hi'
+        widget.update_attributes title: 'hello'
+      end
+      EM.stop
+    end
+  end
+
+  it "should create widget" do
+    EM.synchrony do
+      establish_connection
+      Widget.create
+      Widget.create
+      Widget.count.should eql(2)
+      EM.stop
+    end
+  end
+
+  it "should update widget" do
+    EM.synchrony do
+      establish_connection
+      ActiveRecord::Base.connection.execute("TRUNCATE TABLE widgets;")
+      widget = Widget.create title: 'hi'
+      widget.update_attributes title: 'hello'
+      Widget.find(widget.id).title.should eql('hello')
+      EM.stop
+    end
+  end
+
+  describe "transactions" do
+    it "should work properly" do
+      EM.synchrony do
+        establish_connection
+        EM::Synchrony::FiberIterator.new(1..50, 30).each do |i|
+          widget = Widget.create title: "hi#{i}"
+          ActiveRecord::Base.transaction do
+            widget.update_attributes title: "hello"
+          end
+          ActiveRecord::Base.transaction do
+            raise ActiveRecord::Rollback
+          end
+        end
+        Widget.all.each do |widget|
+          widget.title.should eq('hello')
+        end
+        EM.stop
+      end
+    end
+  end
+
 end

data/spec/amqp_spec.rb

@@ -0,0 +1,146 @@
+require "spec/helper/all"
+
+describe EM::Synchrony::AMQP do
+
+  it "should yield until connection is ready" do
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      connection.connected?.should be_true
+      EM.stop
+    end
+  end
+
+  it "should yield until disconnection is complete" do
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      connection.disconnect
+      connection.connected?.should be_false
+      EM.stop
+    end
+  end
+
+  it "should yield until the channel is created" do
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      channel = EM::Synchrony::AMQP::Channel.new(connection)
+      channel.should be_kind_of(EM::Synchrony::AMQP::Channel)
+      EM.stop
+    end
+  end
+
+  it "should yield until the queue is created" do
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      channel = EM::Synchrony::AMQP::Channel.new(connection)
+      queue = EM::Synchrony::AMQP::Queue.new(channel, "test.em-synchrony.queue1", :auto_delete => true)
+      EM.stop
+    end
+  end
+
+  it "should yield when a queue is created from a channel" do
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      channel = EM::Synchrony::AMQP::Channel.new(connection)
+      queue = channel.queue("test.em-synchrony.queue1", :auto_delete => true)
+      EM.stop
+    end
+  end
+
+  it "should yield until the exchange is created" do
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      channel = EM::Synchrony::AMQP::Channel.new(connection)
+
+      exchange = EM::Synchrony::AMQP::Exchange.new(channel, :fanout, "test.em-synchrony.exchange")
+      exchange.should be_kind_of(EventMachine::Synchrony::AMQP::Exchange)
+
+      direct = channel.direct("test.em-synchrony.direct")
+      fanout = channel.fanout("test.em-synchrony.fanout")
+      topic = channel.topic("test.em-synchrony.topic")
+      headers = channel.headers("test.em-synchrony.headers")
+
+      direct.should be_kind_of(EventMachine::Synchrony::AMQP::Exchange)
+      fanout.should be_kind_of(EventMachine::Synchrony::AMQP::Exchange)
+      topic.should be_kind_of(EventMachine::Synchrony::AMQP::Exchange)
+      headers.should be_kind_of(EventMachine::Synchrony::AMQP::Exchange)
+      EM.stop
+    end
+  end
+
+  it "should publish and receive messages" do
+    nb_msg = 10
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      channel = EM::Synchrony::AMQP::Channel.new(connection)
+      ex = EM::Synchrony::AMQP::Exchange.new(channel, :fanout, "test.em-synchrony.fanout")
+
+      q1 = channel.queue("test.em-synchrony.queues.1", :auto_delete => true)
+      q2 = channel.queue("test.em-synchrony.queues.2", :auto_delete => true)
+
+      q1.bind(ex)
+      q2.bind(ex)
+
+      nb_q1, nb_q2 = 0, 0
+      stop_cb = proc { EM.stop if nb_q1 + nb_q2 == 2 * nb_msg }
+
+      q1.subscribe do |meta, msg|
+        msg.should match(/^Bonjour [0-9]+/)
+        nb_q1 += 1
+        stop_cb.call
+      end
+
+      q2.subscribe do |meta, msg|
+        msg.should match(/^Bonjour [0-9]+/)
+        nb_q2 += 1
+        stop_cb.call
+      end
+
+      Fiber.new do
+        nb_msg.times do |n|
+          ex.publish("Bonjour #{n}")
+          EM::Synchrony.sleep(0.1)
+        end
+      end.resume
+    end
+  end
+
+  it "should handle several consumers" do
+    nb_msg = 10
+    EM.synchrony do
+      connection = EM::Synchrony::AMQP.connect
+      channel = EM::Synchrony::AMQP::Channel.new(connection)
+      exchange = EM::Synchrony::AMQP::Exchange.new(channel, :fanout, "test.em-synchrony.consumers.fanout")
+
+      queue = channel.queue("test.em-synchrony.consumers.queue", :auto_delete => true)
+      queue.bind(exchange)
+
+      cons1 = EM::Synchrony::AMQP::Consumer.new(channel, queue)
+      cons2 = EM::Synchrony::AMQP::Consumer.new(channel, queue)
+
+      nb_cons1, nb_cons2 = 0, 0
+      stop_cb = Proc.new do
+        if nb_cons1 + nb_cons2 == nb_msg
+          nb_cons1.should eq(nb_cons2)
+          EM.stop
+        end
+      end
+
+      cons1.on_delivery do |meta, msg|
+        msg.should match(/^Bonjour [0-9]+/)
+        nb_cons1 += 1
+        stop_cb.call
+      end.consume
+
+      cons2.on_delivery do |meta, msg|
+        msg.should match(/^Bonjour [0-9]+/)
+        nb_cons2 += 1
+        stop_cb.call
+      end.consume
+
+      10.times do |n|
+        exchange.publish("Bonjour #{n}")
+        EM::Synchrony.sleep(0.1)
+      end
+   end
+  end
+end