green 0.0.1 → 0.1

data/lib/green.rb

@@ -3,26 +3,65 @@ require 'pp'
 require 'thread'
 
 class Green
-  VERSION = "0.0.1"
+  VERSION = "0.1"
+
+  module GreenMethods
+    def switch(*args)
+      f.transfer(*args).tap do |*res|
+        if res.size == 1 && res.first.is_a?(ThrowException)
+          raise(res.first.exc)
+        end
+      end
+    end
+
+    def throw(exc = RuntimeException.new)
+      Green.hub.callback { switch(ThrowException.new exc) }
+    end
+
+    def kill
+      self.throw(GreenKill.new)
+    end
+
+    def locals
+      f.local_fiber_variables
+    end
+
+    def [](name)
+      locals[name]
+    end
+
+    def []=(name, val)
+      locals[name] = val
+    end
+  end
+
   class Proxy
+    include GreenMethods
     attr_reader :f
     def initialize
       @f = Fiber.current
     end
 
-    def switch(*args)
-      f.transfer(*args)
+    def alive?
+      f.alive?
     end
   end
 
-  module Waiter
-    def green_cancel
-      raise "override"
+  class SocketWaiter
+    attr_reader :socket
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def wait_read
+    end
+
+    def wait_write
     end
   end
 
   class << self
-    
+
     def thread_locals
       @thread_locals ||= {}
       @thread_locals[Thread.current] ||= {}
@@ -41,7 +80,10 @@ class Green
     end
 
     def make_hub
-      Hub::EM.new
+      hub_name = ENV['GREEN_HUB'] || 'Nio4r'
+      Hub.const_get(hub_name.to_sym).new
+      # Hub::Nio4r.new
+      # Hub::EM.new
     end
 
     def hub
@@ -50,68 +92,85 @@ class Green
     end
 
     def spawn(&blk)
-      Green.new(&blk).tap { |o| o.start }
+      new(&blk).tap { |o| o.start }
     end
 
     def timeout(n, &blk)
       g = current
       timer = hub.timer(n) do
-        g.switch Timeout::Error.new
+        g.throw Timeout::Error.new
       end
       res = blk.call
       timer.cancel
       res
     end
+
+    def list_hash
+      @list_hash ||= {}
+    end
+
+    def list
+      list_hash.values
+    end
   end
 
-  # class GreenError < StandardError; end
-  # class GreenKill < GreenError; end
+  class GreenError < StandardError; end
+  class GreenKill < GreenError; end
+
+  class ThrowException < Struct.new(:exc); end
 
   require 'green/ext'
   require 'green/hub'
 
   require 'green/hub/em'
+  require 'green/hub/nio4r'
+
+  include GreenMethods
 
   attr_reader :f, :callbacks
-  def initialize()
+  def initialize
     @callbacks = []
+    @alive = true
+    Green.list_hash[self] = self
     @f = Fiber.new do
-      res = yield
-      @callbacks.each { |c| c.call(*res) }
+      begin
+        res = yield
+      rescue GreenKill => e
+      rescue => e
+        Green.main.throw e
+      end
+      @alive = false
+      @callbacks.each { |c| 
+        c.call(res)
+      }
+      Green.list_hash.delete self
       Green.hub.switch
     end
     @f[:green] = self
   end
 
-
-  def switch(*args)
-    return unless f.alive?
-    f.transfer(*args).tap do |*res|
-      res.size == 1 && res.first.is_a?(Exception) && raise(res.first)
-    end
-  end
-
-  def throw(exc = RuntimeException.new)
-    switch(exc)
+  def alive?
+    @alive
   end
 
   def start
     Green.hub.callback { self.switch }
   end
 
-  def callback(&blk)
-    callbacks << blk
+  def callback(cb=nil, &blk)
+    cb ||= blk
+    if alive?
+      callbacks << cb
+    else
+      Green.hub.callback(cb)
+    end
   end
 
   def join
     g = Green.current
-    callback { |*res| g.switch(*res) }
+    callback { |res| Green.hub.callback { g.switch(res) } }
     Green.hub.switch
   end
 
-  # def kill
-  #   self.throw(GreenKill.new)
-  # end
-
   MAIN = Fiber.current[:green] = Proxy.new
-end
+end

data/spec/green/activerecord_spec.rb

@@ -0,0 +1,100 @@
+# DO NOT WORK
+
+require "spec_helper"
+require "green/activerecord"
+require 'green/group'
+
+
+# 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 Green::ActiveRecord do
+  DELAY = 0.25
+  QUERY = "SELECT sleep(#{DELAY})"
+
+  def establish_connection
+    # ActiveRecord::Base.logger = Logger.new STDOUT
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'green_mysql2',
+      :database => 'widgets',
+      :username => 'root',
+      :pool => 50
+    )
+    Widget.delete_all
+  end
+
+  before do
+    establish_connection
+  end
+
+  after do
+    ActiveRecord::Base.connection_pool.disconnect!
+  end
+
+  it "should establish AR connection" do
+    result = Widget.find_by_sql(QUERY)
+    result.size.must_equal 1
+  end
+
+  it "should fire sequential, synchronous requests within single green" do
+    start = Time.now.to_f
+    res = []
+
+    res.push Widget.find_by_sql(QUERY)
+    res.push Widget.find_by_sql(QUERY)
+
+    (Time.now.to_f - start.to_f).must_be_within_delta DELAY * res.size, DELAY * res.size * 0.15
+    res.size.must_equal 2
+  end
+
+  # it "should fire 100 requests" do
+  #   pool = Green::Pool.new size: 40, klass: Green::ActiveRecord
+    
+  #   100.times do
+  #     pool.spawn do
+  #       widget = Widget.create title: 'hi'
+  #       widget.update_attributes title: 'hello'
+  #     end
+  #   end
+  #   pool.join
+  # end
+
+  it "should create widget" do
+    Widget.create
+    Widget.create
+    Widget.count.must_equal 2
+  end
+
+  it "should update widget" do
+    widget = Widget.create title: 'hi'
+    widget.update_attributes title: 'hello'
+    Widget.find(widget.id).title.must_equal 'hello'
+  end
+
+  # describe "transactions" do
+  #   it "should work properly" do
+  #     pool = Green::Pool.new size: 40, klass: Green::ActiveRecord
+  #     50.times do |i|
+  #       pool.spawn do
+  #         widget = Widget.create title: "hello"
+  #         ActiveRecord::Base.transaction do
+  #           widget.update_attributes title: "hi#{i}"
+  #           raise ActiveRecord::Rollback
+  #         end
+  #       end
+  #     end
+  #     pool.join
+  #     Widget.all.each do |widget|
+  #       widget.title.must_equal 'hello'
+  #     end
+  #   end
+  # end
+
+end

data/spec/green/connection_pool_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'green/connection_pool'
+require 'green/mysql2'
+require 'green/group'
+
+DELAY = 0.25
+QUERY = "select sleep(#{DELAY})"
+
+describe Green::ConnectionPool do
+
+  
+  let(:pool) { Green::ConnectionPool.new(size: size) { Green::Mysql2::Client.new } }
+
+  describe "pool size is exceeded" do
+    let(:size) { 1 }
+    it "should queue requests" do
+      start = Time.now.to_f
+
+      g = Green::Group.new
+      res = [] 
+      g.spawn { res << pool.query(QUERY) }
+      g.spawn { res << pool.query(QUERY) }
+      g.join
+
+      (Time.now.to_f - start.to_f).must_be_within_delta DELAY * 2, DELAY * 2 * 0.15
+      res.size.must_equal 2
+    end
+  end
+
+  describe "pool size is enough" do
+    let(:size) { 2 }
+    it "should parallel requests" do
+      start = Time.now.to_f
+
+      g = Green::Group.new
+      res = []
+      g.spawn { res << pool.query(QUERY) }
+      g.spawn { res << pool.query(QUERY) }
+      g.join
+
+      (Time.now.to_f - start.to_f).must_be_within_delta DELAY, DELAY * 0.30
+      res.size.must_equal 2
+    end
+  end
+end

data/spec/green/event_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'green/event'
+require 'green/group'
+describe Green::Event do
+  let(:e) { Green::Event.new }
+  let(:g) { Green::Group.new }
+  it "should wakeup all greens" do
+    i = 0
+    5.times do
+      g.spawn { e.wait; i += 1}
+    end
+    i.must_equal 0
+    e.set
+    g.join
+    i.must_equal 5
+  end
+
+  describe "set before wait" do
+    it "should work properly" do
+      e.set(:ok)
+      e.wait.must_equal :ok
+    end
+  end
+end

data/spec/green/group_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'green/group'
+require 'green/event'
+require 'set'
+describe Green::Group do
+  let(:g) { Green::Group.new }
+
+  describe "join" do
+    it "should wait each task" do
+      result = ""
+      g.spawn { result << "fiz" }
+      g.spawn { result << "baz" }
+      g.join
+      result.must_equal "fizbaz"
+    end
+
+    # it "return each result" do
+    #   g.spawn { 1 }
+    #   g.spawn { 2 }
+    #   g.join.reduce(0, &:+).must_equal 3
+    # end
+  end
+
+  describe "apply" do
+    it "should wait result" do
+      g.apply { :foo }.must_equal :foo
+    end
+  end
+
+  describe "enumerator" do
+    it "should return enumerator" do
+      en = g.enumerator([1, 2, 3]) { |o| o }
+      en.must_be_instance_of Enumerator
+      en.map { |o| o }.must_equal [1, 2, 3]
+    end
+  end
+end
+
+describe Green::Pool do
+  let(:e1) { Green::Event.new }
+  let(:e2) { Green::Event.new }
+  let(:p) { Green::Pool.new size: 1}
+
+  it "should wait each task" do
+    result = ""
+    p.spawn { result << "fiz"; Green.sleep(0) }
+    Green.spawn { p.spawn { result << "baz"; Green.sleep(0) } }
+    p.join
+    result.must_equal "fizbaz"
+  end
+
+  # ugly test :(
+  it "should block after limit" do
+    i = 0
+    p.spawn { i += 1; e1.set; e2.wait }
+    Green.spawn { p.spawn { i += 1 } }
+    p.size.must_equal 1
+    e1.wait
+    i.must_equal 1
+    Green.sleep(0)
+    i.must_equal 1
+    p.size.must_equal 1
+    e2.set
+    p.join
+    i.must_equal 2
+  end
+end
+

data/spec/green/monkey_spec.rb

@@ -0,0 +1,22 @@
+# require 'spec_helper'
+# require 'green/monkey'
+
+# describe "green/monkey" do
+#   let(:server) { TCPServer.new("127.0.0.1", 2225) }
+#   let(:client) { TCPSocket.open("127.0.0.1", 2225) }
+
+#   after { server.close; client.close }
+#   it "should read and write" do
+#     Green.spawn do
+#       server.listen(1)
+#       c, a = server.accept
+#       c.write "hello"
+#       c.close
+#     end
+
+#     g = Green.spawn do
+#       client.read.must_equal "hello"
+#     end
+#     g.join
+#   end
+# end

data/spec/green/mysql2_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "green/mysql2"
+require "green/connection_pool"
+require "green/group"
+
+describe Green::Mysql2 do
+
+  DELAY = 0.25
+  QUERY = "SELECT sleep(#{DELAY})"
+
+  it "should support queries" do
+    res = []
+    db = Green::Mysql2::Client.new
+    res = db.query QUERY
+
+    res.first.keys.must_include "sleep(#{DELAY})"
+  end
+
+  it "should fire sequential, synchronous requests" do
+    db = Green::Mysql2::Client.new
+
+    start = Time.now.to_f
+    res = []
+
+    res.push db.query QUERY
+    res.push db.query QUERY
+    (Time.now.to_f - start.to_f).must_be_within_delta DELAY * res.size, DELAY * res.size * 0.15
+  end
+
+  it "should fire simultaneous requests via pool" do
+    db = Green::ConnectionPool.new(size: 2) do
+      Green::Mysql2::Client.new
+    end
+
+    start = Time.now.to_f
+    res = []
+    g = Green::Group.new
+    g.spawn { res << db.query(QUERY) }
+    g.spawn { res << db.query(QUERY) }
+    g.join
+
+    (Time.now.to_f - start.to_f).must_be_within_delta DELAY, DELAY * 0.30
+    res.size.must_equal 2
+  end
+
+  it "should raise Mysql::Error in case of error" do
+    db = Green::Mysql2::Client.new
+    proc {
+      db.query("SELECT * FROM i_hope_this_table_does_not_exist;")
+    }.must_raise(Mysql2::Error)
+  end
+end

data/spec/green/semaphore_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+require 'green/semaphore'
+require 'green/event'
+require 'green/group'
+
+describe Green::Mutex do
+  let(:m) { Green::Mutex.new }
+  it "should synchronize" do
+    e = Green::Event.new
+    i = 0
+    Green.spawn do
+      m.synchronize do
+        e.wait
+        i += 1
+      end
+    end
+    Green.spawn do
+      e.set
+      m.synchronize do
+        i.must_equal 1
+      end
+    end.join
+  end
+
+  describe "lock" do
+    describe "when mutex already locked" do
+      it "should raise GreenError" do
+        proc {
+          m.lock
+          m.lock
+        }.must_raise Green::GreenError
+      end
+    end
+  end
+
+  describe "sleep" do
+    describe "without timeout" do
+      it "should sleep until switch" do
+        m.lock
+        i = 0
+        g = Green.current
+        Green.hub.callback { i += 1; g.switch }
+        res = m.sleep
+        i.must_equal 1
+      end
+
+      it "should release lock" do
+        i = 0
+        e = Green::Event.new
+        group = Green::Group.new
+        g1 = group.spawn do 
+          m.lock
+          e.wait
+          i += 1
+          m.sleep
+        end
+        group.spawn do
+          e.set
+          m.lock
+          i.must_equal 1
+          m.unlock
+          Green.hub.callback { g1.switch }
+        end
+        group.join
+      end
+
+      it "should wait unlock after switch" do
+        i = 0
+        group = Green::Group.new
+        g1 = group.spawn do 
+          m.lock
+          m.sleep
+          i.must_equal 1
+        end
+        group.spawn do 
+          m.lock          
+          i += 1
+          m.unlock
+          Green.hub.callback { g1.switch }
+        end
+        group.join
+      end
+    end
+      
+    describe "with timeout" do
+      it "should sleep for timeout" do
+        m.lock
+        i = 0
+        Green.hub.callback { i += 1 }
+        m.sleep(0.1)
+        i.must_equal 1
+      end
+      describe "and resume before timeout" do
+        it "should not raise any execptions" do
+          m.lock
+          g = Green.current
+          Green.hub.callback { g.switch }
+          m.sleep(0.05)
+          Green.spawn { Green.sleep(0.1) }.join
+        end
+        it "should resume in nested Green" do
+          Green.spawn do
+            m.synchronize do
+              t = m.sleep(0.05)
+              t.must_be :>=, 0.05
+            end
+          end.join
+        end
+      end
+    end
+  end
+  describe Green::ConditionVariable do
+    let(:c){ Green::ConditionVariable.new }
+    it "should wakeup waiter" do
+      i = ''
+      g = Green::Group.new
+      g.spawn do
+        m.synchronize do
+          i << 'a'
+          c.wait(m)
+          i << 'c'
+        end
+      end
+      g.spawn do
+        i << 'b'
+        c.signal
+      end
+      g.join
+      i.must_equal 'abc'
+    end
+
+    it 'should allow to play ping-pong' do
+      i = ''
+      g = Green::Group.new
+      g.spawn do
+        m.synchronize do
+          i << 'pi'
+          c.wait(m)
+          i << '-po'
+          c.signal
+        end
+      end
+      g.spawn do
+        m.synchronize do
+          i << 'ng'
+          c.signal
+          c.wait(m)
+          i << 'ng'
+        end
+      end
+      g.join
+      i.must_equal 'ping-pong'
+    end
+    it 'should not raise, when timer wakes up green between `signal` and `next_tick`' do
+      e = Green::Event.new
+      g = Green.spawn do
+        m.synchronize do
+          c.wait(m, 0.0001)
+        end
+      end
+      Green.hub.callback do
+        c.signal
+        Green.hub.callback { e.set }
+      end
+      e.wait
+      g.join
+    end
+  end
+end

data/spec/green/socket_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'green/socket'
+describe Green::Socket do
+  let(:s1) { Green::Socket.new(:INET, :STREAM, 0).tap { |s| s.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1) } }
+  let(:s2) { Green::Socket.new(:INET, :STREAM, 0) }
+
+  after do 
+    s1.close
+    s2.close
+  end
+  it "should read and write" do
+    Green.spawn do
+      s1.bind(Addrinfo.tcp("127.0.0.1", 2225))
+      s1.listen(1)
+      c, a = s1.accept
+      c.write "hello"
+      c.close
+    end
+
+    g = Green.spawn do
+      s2.connect(Addrinfo.tcp("127.0.0.1", 2225))
+      s2.read.must_equal "hello"
+    end
+    g.join
+  end
+end