green 0.0.1 → 0.1

data/Gemfile

@@ -1,7 +1,23 @@
 source "http://rubygems.org"
 
-gem "eventmachine", "~> 1.0.0.beta.4"
+gem "eventmachine", "= 1.0.0.beta.4"
 gem "em-http-request"
+gem "ffi-rzmq"
+gem "mysql2"
 gem "unicorn"
+gem "activerecord"
+gem "algorithms"
+gem "nio4r"
+gem "rake"
+
+group :test do
+  gem "rr"
+  gem "minitest"  
+  gem "minitest-reporters"
+end
+
+group :development do
+  gem "debugger"
+end
 
 gemspec

data/Gemfile.lock

@@ -1,25 +1,68 @@
 PATH
   remote: .
   specs:
-    green (0.0.1)
+    green (0.1)
+      kgio (= 2.7.4)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    addressable (2.2.7)
-    em-http-request (1.0.0)
+    activemodel (3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+    activerecord (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.2.8)
+    algorithms (0.5.0)
+    ansi (1.4.2)
+    arel (3.0.2)
+    builder (3.0.0)
+    columnize (0.3.5)
+    cookiejar (0.3.0)
+    debugger (1.1.3)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.2)
+    debugger-linecache (1.1.1)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.2)
+    em-http-request (1.0.2)
       addressable (>= 2.2.3)
+      cookiejar
       em-socksify
-      eventmachine (>= 1.0.0.beta.3)
-      http_parser.rb (>= 0.5.2)
+      eventmachine (>= 1.0.0.beta.4)
+      http_parser.rb (>= 0.5.3)
     em-socksify (0.2.0)
       eventmachine (>= 1.0.0.beta.4)
-    eventmachine (1.0.0.mail.7)
+    eventmachine (1.0.0.beta.4)
+    ffi (1.2.0)
+    ffi-rzmq (0.9.6)
+      ffi
     http_parser.rb (0.5.3)
+    i18n (0.6.0)
     kgio (2.7.4)
+    minitest (3.0.0)
+    minitest-reporters (0.7.1)
+      ansi
+      builder
+      minitest (>= 2.0, < 4.0)
+      ruby-progressbar
+    multi_json (1.3.6)
+    mysql2 (0.3.11)
+    nio4r (0.3.3)
     rack (1.4.1)
     raindrops (0.8.0)
-    unicorn (4.2.1)
+    rake (0.9.2.2)
+    rr (1.0.4)
+    ruby-progressbar (0.0.10)
+    tzinfo (0.3.33)
+    unicorn (4.3.1)
       kgio (~> 2.6)
       rack
       raindrops (~> 0.7)
@@ -28,7 +71,17 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord
+  algorithms
+  debugger
   em-http-request
-  eventmachine (~> 1.0.0.beta.4)
+  eventmachine (= 1.0.0.beta.4)
+  ffi-rzmq
   green!
+  minitest
+  minitest-reporters
+  mysql2
+  nio4r
+  rake
+  rr
   unicorn

data/README.md

@@ -1,3 +1,6 @@
+Green [![Build Status](https://secure.travis-ci.org/prepor/green.png)](http://travis-ci.org/prepor/green)
+=====
+
 Cooperative multitasking for Ruby. Proof of concept.
 
 Based on Ruby 1.9 Fibers, but unlike EM::Synchrony it uses symmetric coroutines (only #current and #transfer used) and HUB-orientend architecture. So coroutines transfer control to HUB and HUB transfer control to coroutines. Coroutines never tranfer control to each other.
@@ -51,5 +54,47 @@ rescue Timeout::Error
 end
 ```
 
-And much more soon ;)
+You can use net/http (and any gem over it):
+
+```ruby
+require 'green'
+require 'green/group'
+require 'green/monkey'
+require 'net/http'
+
+g = Green::Pool.new(size: 2)
+
+hosts = ['google.com', 'yandex.ru']
+
+results = g.enumerator(hosts) do |host|
+  Net::HTTP.get host, '/'
+end.map { |i| i }
+
+p results
+```
+
+You can run nonblock Web application with any webserver:
+
+```ruby
+require 'green'
+require 'green/group'
+
+app = proc do |env|
+  start = Time.now
+  g = Green::Group.new
+  results = []
+  g.spawn do
+    Green.sleep 1
+    results << :fiz
+  end
+  g.spawn do
+    Green.sleep 1
+    results << :buz
+  end
+  g.join
+  [200, {"Content-Type" => 'plain/text'}, ["Execution time: #{Time.now - start}; Results: #{results.inspect}"]]
+end
+run app 
+```
 
+Run it with `unicorn app.ru`

data/green.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
 
   s.name              = 'green'
-  s.version           = '0.0.1'
-  s.date              = '2012-05-09'
+  s.version           = '0.1'
+  s.date              = '2012-12-13'
   s.rubyforge_project = 'green'
 
   s.summary     = "Cooperative multitasking fo Ruby"
@@ -20,25 +20,44 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.extra_rdoc_files = %w[README.md]
 
-
+  s.add_runtime_dependency("kgio", "2.7.4")
   # = MANIFEST =
   s.files = %w[
     Gemfile
     Gemfile.lock
+    README.md
     Rakefile
-    Readme.md
     app.ru
     green.gemspec
+    lib/active_record/connection_adapters/green_mysql2_adapter.rb
     lib/green-em/em-http.rb
     lib/green.rb
+    lib/green/activerecord.rb
+    lib/green/connection_pool.rb
     lib/green/event.rb
     lib/green/ext.rb
     lib/green/group.rb
     lib/green/hub.rb
     lib/green/hub/em.rb
+    lib/green/hub/nio4r.rb
     lib/green/monkey.rb
+    lib/green/mysql2.rb
     lib/green/semaphore.rb
-    lib/green/tcp_socket.rb
+    lib/green/socket.rb
+    lib/green/zmq.rb
+    spec/green/activerecord_spec.rb
+    spec/green/connection_pool_spec.rb
+    spec/green/event_spec.rb
+    spec/green/group_spec.rb
+    spec/green/monkey_spec.rb
+    spec/green/mysql2_spec.rb
+    spec/green/semaphore_spec.rb
+    spec/green/socket_spec.rb
+    spec/green/tcpsocket_spec.rb
+    spec/green/zmq_spec.rb
+    spec/green_spec.rb
+    spec/helpers.rb
+    spec/spec_helper.rb
   ]
   # = MANIFEST =
 

data/lib/active_record/connection_adapters/green_mysql2_adapter.rb

@@ -0,0 +1,92 @@
+# AR adapter for using a green mysql2 connection
+# Just update your database.yml's adapter to be 'green_mysql2'
+
+require 'green/mysql2'
+require 'green/activerecord'
+require 'active_record/connection_adapters/mysql2_adapter'
+
+# module ActiveRecord
+#   class Base
+#     def self.green_mysql2_connection(config)
+#       client = Green::ActiveRecord::ConnectionPool.new(size: config[:pool]) do
+#         conn = ActiveRecord::ConnectionAdapters::GreenMysql2Adapter::Client.new(config.symbolize_keys)
+#         # From Mysql2Adapter#configure_connection
+#         conn.query_options.merge!(:as => :array)
+
+#         # By default, MySQL 'where id is null' selects the last inserted id.
+#         # Turn this off. http://dev.rubyonrails.org/ticket/6778
+#         variable_assignments = ['SQL_AUTO_IS_NULL=0']
+#         encoding = config[:encoding]
+#         variable_assignments << "NAMES '#{encoding}'" if encoding
+
+#         wait_timeout = config[:wait_timeout]
+#         wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+#         variable_assignments << "@@wait_timeout = #{wait_timeout}"
+
+#         conn.query("SET #{variable_assignments.join(', ')}")
+#         conn
+#       end 
+#       options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+#       ActiveRecord::ConnectionAdapters::GreenMysql2Adapter.new(client, logger, options, config)
+#     end
+#   end
+
+#   module ConnectionAdapters
+#     class GreenMysql2Adapter < ::ActiveRecord::ConnectionAdapters::Mysql2Adapter
+
+#       class Column < AbstractMysqlAdapter::Column # :nodoc:
+#         def adapter
+#           GreenMysql2Adapter
+#         end
+#       end
+
+#       ADAPTER_NAME = 'GreenMysql2'
+
+#       class Client < Green::Mysql2::Client
+#         include Green::ActiveRecord::Client
+#       end
+
+#       include Green::ActiveRecord::Adapter
+
+#       def connect
+        
+#       end
+#     end
+#   end
+# end
+
+
+
+module ActiveRecord
+  class Base
+    def self.green_mysql2_connection(config)
+      config[:username] = 'root' if config[:username].nil?
+
+      if Mysql2::Client.const_defined? :FOUND_ROWS
+        config[:flags] = Mysql2::Client::FOUND_ROWS
+      end
+
+      client = Green::Mysql2::Client.new(config.symbolize_keys)
+      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+      ConnectionAdapters::GreenMysql2Adapter.new(client, logger, options, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class GreenMysql2Adapter < ::ActiveRecord::ConnectionAdapters::Mysql2Adapter
+
+      class Column < AbstractMysqlAdapter::Column # :nodoc:
+        def adapter
+          GreenMysql2Adapter
+        end
+      end
+
+      ADAPTER_NAME = 'GreenMysql2'
+
+      def connect
+        @connection = Green::Mysql2::Client.new(@config)
+        configure_connection
+      end
+    end
+  end
+end

data/lib/green/activerecord.rb

@@ -0,0 +1,21 @@
+require 'green'
+require 'active_record'
+require 'active_record/connection_adapters/abstract/connection_pool'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'green/semaphore'
+require 'green/connection_pool'
+
+suppress_warnings do
+  ::Thread = Green
+  ::Mutex = Green::Mutex
+  ::ConditionVariable = Green::ConditionVariable
+end
+
+class Green
+  class ActiveRecord < ::Green
+    def initialize
+      super
+      callback { ::ActiveRecord::Base.clear_active_connections! }
+    end
+  end
+end

data/lib/green/connection_pool.rb

@@ -0,0 +1,72 @@
+class Green
+  class ConnectionPool
+    undef :send
+
+    def initialize(opts, &block)
+      @reserved  = {}   # map of in-progress connections
+      @available = []   # pool of free connections
+      @pending   = []   # pending reservations (FIFO)
+
+      opts[:size].times do
+        @available.push(block.call) if block_given?
+      end
+    end
+
+    # Choose first available connection and pass it to the supplied
+    # block. This will block indefinitely until there is an available
+    # connection to service the request.
+    def execute
+      g = Green.current
+      begin
+        conn = acquire(g)
+        yield conn
+      ensure
+        release(g)
+      end
+    end
+
+    private
+
+      # Acquire a lock on a connection and assign it to executing fiber
+      # - if connection is available, pass it back to the calling block
+      # - if pool is full, yield the current fiber until connection is available
+      def acquire(green)
+        if conn = @available.pop
+          @reserved[green.object_id] = conn
+          conn
+        else
+          @pending.push green
+          Green.hub.wait { @pending.delete green }
+          acquire(green)
+        end
+      end
+
+      # Release connection assigned to the supplied fiber and
+      # resume any other pending connections (which will
+      # immediately try to run acquire on the pool)
+      def release(green)
+        conn = @reserved.delete(green.object_id)
+        @available.push(conn)
+
+        if pending = @pending.shift
+          Green.hub.callback { pending.switch }
+        end
+      end
+
+      # Allow the pool to behave as the underlying connection
+      #
+      # If the requesting method begins with "a" prefix, then
+      # hijack the callbacks and errbacks to fire a connection
+      # pool release whenever the request is complete. Otherwise
+      # yield the connection within execute method and release
+      # once it is complete (assumption: fiber will yield until
+      # data is available, or request is complete)
+      #
+      def method_missing(method, *args, &blk)
+        execute do |conn|
+          conn.__send__(method, *args, &blk)
+        end
+      end
+  end
+
+end

data/lib/green/event.rb

@@ -1,6 +1,5 @@
 class Green
   class Event
-    include Green::Waiter
     attr_reader :waiters
     def initialize
       @waiters = []
@@ -17,13 +16,10 @@ class Green
       if @setted
         @result
       else
-        waiters << Green.current
-        Green.hub.wait self, Green.current
+        g = Green.current
+        waiters << g
+        Green.hub.wait { waiters.delete g }
       end
     end
-
-    def green_cancel(waiter)
-      waiters.delete waiter
-    end
   end
 end

data/lib/green/ext.rb

@@ -17,9 +17,17 @@ class Fiber
     local_fiber_variables[key] = value
   end
   
-  private
-  
   def local_fiber_variables
     @local_fiber_variables ||= {}
   end
+end
+
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
 end

data/lib/green/group.rb

@@ -3,13 +3,14 @@ require 'green/semaphore'
 class Green
   class Group
     attr_reader :options, :greens
-    def initialize(options = {})      
+    def initialize(options = {})
       @options = options
+      @options[:klass] ||= ::Green
       @greens = []
     end
 
     def spawn(*args, &blk)
-      g = Green.spawn do
+      g = @options[:klass].spawn do
         blk.call(*args)
       end
       add g
@@ -30,11 +31,19 @@ class Green
     end
 
     def join
-      while (g = greens.pop)
+      while (g = greens.first)
         g.join
       end
     end
 
+    def kill
+      greens.each(&:kill)
+    end
+
+    def size
+      greens.size
+    end
+
     def enumerator(iterable, &blk)
       iter = iterable.each
       Enumerator.new do |y|
@@ -47,9 +56,9 @@ class Green
             spawn(i) do |item|
               y << blk.call(item)
               waiting -= 1
-              e.set if waiting == 0 
+              e.set if waiting == 0
             end
-          end          
+          end
         rescue StopIteration
           e.wait
         end
@@ -61,6 +70,7 @@ class Green
     attr_reader :semaphore
     def initialize(*args)
       super
+      raise ArgumentError.new("Undefined option :size") unless options[:size]
       @semaphore = Semaphore.new(options[:size])
     end
 
@@ -74,5 +84,9 @@ class Green
         end
       end
     end
+
+    def join
+      semaphore.wait
+    end
   end
-end
+end

data/lib/green/hub/em.rb

@@ -1,26 +1,58 @@
 require 'eventmachine'
 
 class ::EM::Timer
-  include Green::Waiter
-
   def green_cancel
     cancel
   end
 end
 
 module ::EM::Deferrable
-  include Green::Waiter
-
   def green_cancel
-    # instance_variable_get(:@callbacks).each { |c| cancel_callback c }
-    # instance_variable_get(:@errbacks).each { |c| cancel_errback c }
-    # cancel_timeout
+    instance_variable_get(:@callbacks).each { |c| cancel_callback c }
+    instance_variable_get(:@errbacks).each { |c| cancel_errback c }
+    cancel_timeout
   end
 end
 
 class Green
   class Hub
     class EM < Hub
+      class SocketWaiter < Green::SocketWaiter
+        class Handler < ::EM::Connection
+          attr_accessor :green
+          def notify_readable        
+            green.switch
+          end
+
+          def notify_writable
+            green.switch
+          end
+        end
+
+        def wait_read
+          make_handler(:readable)
+        end
+
+        def wait_write
+          make_handler(:writable)
+        end
+
+        def make_handler(mode)
+          h = ::EM.watch socket, Handler do |c|
+            c.green = Green.current
+          end
+          case mode
+          when :readable
+            h.notify_readable = true
+          when :writable
+            h.notify_writable = true
+          end
+          Green.hub.switch
+        ensure
+          h.detach
+        end
+
+      end
       # если мы запускаем приложение внутри thin или rainbows с EM, то значит мы уже внутри EM-реактора, а hub должен переключиться в main тред.
       def run
         if ::EM.reactor_running?          
@@ -36,8 +68,16 @@ class Green
         ::EM::Timer.new(n, &blk)
       end
 
-      def callback(&blk)
-        ::EM.next_tick(&blk)
+      def callback(cb=nil, &blk)
+        ::EM.next_tick(cb || blk)
+      end
+
+      def socket_waiter(socket)
+        SocketWaiter.new socket
+      end
+
+      def stop
+        EM.stop
       end
     end
   end