green 0.0.1 → 0.1

data/lib/green/hub/nio4r.rb

@@ -0,0 +1,147 @@
+require 'nio'
+require 'algorithms'
+
+class Green
+  class Hub
+    class Nio4r < Hub
+      class SocketWaiter < Green::SocketWaiter
+        attr_reader :reactor
+        def initialize(reactor, socket)
+          super socket
+          @reactor = reactor
+        end
+
+        def wait_read
+          make_monitor :r
+        end
+
+        def wait_write
+          make_monitor :w
+        end
+
+        def make_monitor(interest)
+          m = reactor.selector.register(socket, interest)
+          g = Green.current
+          m.value = proc { g.switch }
+          Green.hub.switch
+        ensure
+          reactor.selector.deregister socket
+        end
+      end
+
+      class Timer
+        attr_reader :reactor, :fire_at, :clb
+        def initialize(reactor, fire_at, &clb)
+          @reactor, @fire_at, @clb = reactor, fire_at, clb
+        end
+
+        def run
+          @runned = true
+          clb.call
+        end
+
+        def green_cancel
+          return if @canceled || @runned
+          @canceled = true
+          reactor.cancel_timer self
+        end
+
+        def <=>(v)
+          @fire_at <=> v.fire_at
+        end
+      end
+
+      MIN_TIMEOUT = 0.0001
+      MAX_TIMEOUT = 0.01
+
+      attr_reader :callbacks, :timers, :cancel_timers
+      def initialize(*args)
+        @callbacks = []
+        @timers = Containers::MinHeap.new
+        @cancel_timers = {}
+        super
+      end
+      
+      def reactor_running?
+        @reactor_running
+      end
+
+      def run
+        @reactor_running = true
+        @selector = NIO::Selector.new
+        while @reactor_running
+          run_callbacks
+          run_timers
+          @selector.select(time_till_first_event) do |m|
+            m.value.call
+          end
+        end
+      end
+
+      def run_timers
+        now = Time.now
+        while (t = @timers.next)
+          if t.fire_at <= now
+            @timers.pop
+            if @cancel_timers[t]
+              @cancel_timers.delete t
+            else
+              t.run
+            end
+          else
+            break
+          end
+        end
+      end
+
+      def run_callbacks
+        jobs, @callbacks = @callbacks, []
+        begin
+          i = 0
+          while i < jobs.size
+            job = jobs[i]
+            jobs[i] = nil
+            job.call
+            i += 1
+          end
+        ensure
+          @callbacks[0...0] = jobs[i..-1]  if i < jobs.size
+        end
+      end
+
+      def time_till_first_event
+        if @callbacks.size > 0
+          MIN_TIMEOUT
+        elsif @timers.size > 0
+          @timers.next.fire_at - Time.now + MIN_TIMEOUT
+        else
+          MAX_TIMEOUT
+        end
+      end
+
+      def selector
+        @selector
+      end
+
+      def cancel_timer(timer)
+        @cancel_timers[timer] = true
+      end
+
+      def timer(n, &blk)
+        @timers << Timer.new(self, Time.now + n, &blk)
+      end
+
+      def callback(cb=nil, &blk)
+        @callbacks << (cb || blk)
+      end
+
+      def socket_waiter(socket)
+        SocketWaiter.new self, socket
+      end
+
+      def stop
+        @reactor_running = false
+      end
+    end
+  end
+end

data/lib/green/hub.rb

@@ -14,17 +14,18 @@ class Green
       g.switch
     end
 
-    def wait(waiter, *args)
+    def wait(proc = nil, &cancel_clb)
       switch
     rescue => e
-      waiter.green_cancel(*args)
+      (proc || cancel_clb).call
       raise e
     end
 
     def sleep(n)
       g = Green.current
       t = timer(n) { g.switch }
-      wait t
+      wait { t.green_cancel }
+      t
     end
 
     def run
@@ -38,5 +39,13 @@ class Green
     def callback(&blk)
       raise "override"
     end
+
+    def socket_waiter(socket)
+      raise "override"
+    end
+
+    def stop
+      raise "override"
+    end
   end
 end

data/lib/green/monkey.rb

@@ -1,13 +1,11 @@
-class Green
-  module Monkey
-    extend self
-
-    def patch_constants
-      
-    end
-    
-    def patch_socket
-      
-    end
-  end
-end
+require 'green/socket'
+
+original_verbosity = $VERBOSE
+$VERBOSE = nil    
+
+Socket = Green::Socket
+TCPSocket = Green::TCPSocket
+TCPServer = Green::TCPServer
+
+
+$VERBOSE = original_verbosity

data/lib/green/mysql2.rb

@@ -0,0 +1,16 @@
+require 'mysql2'
+class Green
+  module Mysql2
+    class Client < ::Mysql2::Client
+      def query(sql, opts={})
+        super(sql, opts.merge(:async => true))
+        green_waiter.wait_read
+        async_result
+      end
+
+      def green_waiter
+        @green_waiter ||= Green.hub.socket_waiter(Socket.for_fd(self.socket))
+      end
+    end
+  end
+end

data/lib/green/semaphore.rb

@@ -1,12 +1,16 @@
 class Green
   class Semaphore
-    include Green::Waiter
-    attr_accessor :counter
+    attr_accessor :counter, :value
     def initialize(value = 1)
+      @value = value
       @counter = value
       @links = []
     end
 
+    def wait_links
+      @wait_links ||= []
+    end
+
     def acquire
       if counter > 0
         self.counter -= 1
@@ -14,7 +18,7 @@ class Green
       else
         g = Green.current
         clb = rawlink { g.switch }
-        Green.hub.wait self, clb
+        Green.hub.wait { unlink clb }
         self.counter -= 1
         true
       end
@@ -22,10 +26,11 @@ class Green
 
     def release
       self.counter += 1
+      wait_links.dup.each(&:call)
       if @links.size > 0
         l = @links.pop
         Green.hub.callback { l.call }
-      end
+      end      
     end
 
     def rawlink(&clb)
@@ -37,8 +42,133 @@ class Green
       @links.delete clb
     end
 
-    def green_cancel(clb)
-      unlink clb
+    def wait(v = value)
+      if counter >= v
+        return counter
+      else
+        g = Green.current
+        clb = proc do 
+          if counter >= v && @links.size == 0
+            wait_links.delete clb
+            Green.hub.callback { g.switch }            
+          end
+        end
+        wait_links << clb
+        Green.hub.wait { wait_links.delete clb }
+      end
+    end
+
+    def wait_avaliable
+      wait value - 1
+    end
+  end
+
+  # With Ruby compatible API
+  class Mutex < Semaphore
+    def initialize
+      super 1
+      @slept = {}
+    end
+
+    def synchronize
+      lock
+      yield
+    ensure
+      unlock
+    end
+
+    def lock
+      if Green.current.locals["mutex_locked_#{self.object_id}"]
+        Green.current.locals.delete "mutex_locked_#{self.object_id}"
+        raise Green::GreenError.new
+      end
+      Green.current.locals["mutex_locked_#{self.object_id}"] = true
+      acquire
+    end
+
+    def unlock
+      raise Green::GreenError.new unless Green.current.locals["mutex_locked_#{self.object_id}"]
+      Green.current.locals.delete "mutex_locked_#{self.object_id}"
+      release
+    end
+
+    def _wakeup(green)
+      if @slept.delete(green)
+        Green.hub.callback { green.switch }
+      end
+    end
+
+    def sleep(timeout = nil)
+      unlock    
+      beg = Time.now
+      current = Green.current
+      @slept[current] = true
+      begin
+        if timeout
+          t = Green.hub.timer(timeout) { _wakeup(current) }
+          Green.hub.switch
+          t.green_cancel
+        else
+          Green.hub.switch
+        end
+      ensure
+        @slept.delete current
+      end
+      yield if block_given?
+      lock
+      Time.now - beg
+    end
+  end
+
+  class 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 = Green.current
+      pair = [mutex, current]
+      @waiters << pair
+      mutex.sleep timeout do
+        @waiters.delete pair
+      end
+      self
+    end
+
+    def _wakeup(mutex, green)
+      if alive = green.alive?
+        Green.hub.callback {
+          mutex._wakeup(green)
+        }
+      end
+      alive
+    end
+
+    #
+    # Wakes up the first thread in line waiting for this lock.
+    #
+    def signal
+      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, green|
+        _wakeup(mutex, green)
+      end
+      @waiters.clear
+      self
     end
   end
 end

data/lib/green/socket.rb

@@ -0,0 +1,124 @@
+require "fcntl"
+require 'socket'
+require 'kgio'
+
+class Green
+  
+  ERRORS = Errno::constants.each_with_object({}) do |c, h|
+    const = Errno.const_get(c)
+    h[const::Errno] = const    
+  end
+
+  # TODO puts
+  class Socket < ::Socket
+    READ_BUFFER_SIZE = 65536
+
+    include Kgio::SocketMethods
+
+    def write(str)
+      kgio_write(str)
+      str.bytesize
+    end
+
+    def read(length = nil, buffer = nil)
+      res = []
+      readed = 0
+      begin # begin ... while
+        need_read = if length
+          length - readed
+        else
+          READ_BUFFER_SIZE
+        end        
+        data = kgio_read(need_read)
+        if data.nil? && length.nil? && readed == 0
+          return ''
+        elsif data.nil? && readed == 0
+          return nil
+        elsif data.nil?
+          return buffer ? buffer.replace(res * '') : res * ''
+        else
+          readed += data.size
+          res << data
+        end
+      end while length != readed
+      return buffer ? buffer.replace(res * '') : res * ''
+    end
+
+    def recv(maxlen, flags = 0)
+      recv_nonblock(maxlen)
+    rescue Errno::EAGAIN
+      waiter.wait_read
+      retry
+    end
+
+    def send(mesg, flags, dest_sockaddr = nil)
+      # FIXME
+      write mesg
+    end
+
+    def kgio_wait_readable
+      waiter.wait_write
+    end
+
+    def kgio_wait_readable
+      waiter.wait_read
+    end
+
+    def self.accept_socket_class
+      self
+    end
+
+    def accept
+      s, a = accept_nonblock
+      [self.class.accept_socket_class.for_fd(s.fileno), a]
+    rescue Errno::EAGAIN
+      waiter.wait_read
+      retry
+    end
+
+    def connect(sock_addr)
+      connect_nonblock(sock_addr)
+    rescue Errno::EINPROGRESS
+      error, = getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR).unpack('i')
+      if error != 0
+        raise ERRORS[error]
+      else
+        waiter.wait_write
+      end
+    end
+
+    def waiter
+      @waiter ||= Green.hub.socket_waiter(self)
+    end
+  end
+
+  class TCPSocket < Socket
+    def initialize(remote_host, remote_port, local_host = nil, local_port = nil)
+      addrinfo = Addrinfo.tcp(remote_host, remote_port)
+      super(addrinfo.ipv4? ? :INET : :INET6, :STREAM, 0)
+      if local_host && local_port
+        bind(Addrinfo.tcp(local_host, local_port))
+      end
+      connect addrinfo
+    end
+  end
+
+  class TCPServer < Socket
+    def initialize(host, port)
+      addrinfo = Addrinfo.tcp(host, port)
+      super(addrinfo.ipv4? ? :INET : :INET6, :STREAM, 0)
+      setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+      bind(addrinfo)
+      listen(5)
+    end
+
+
+    def self.accept_socket_class
+      TCPSocket
+    end
+
+    def accept
+      super[0]
+    end
+  end
+end

data/lib/green/zmq.rb

@@ -0,0 +1,92 @@
+require 'green'
+require 'ffi-rzmq'
+
+class Green
+  module ZMQ
+    class Waiter
+      attr_reader :socket_waiter, :waiters
+      def initialize(fd)
+        @socket_waiter = Green.hub.socket_waiter(Socket.for_fd(fd))
+        @waiters = []
+        @notifier = Green.spawn do
+          while true
+            @socket_waiter.wait_read
+            wake
+          end
+        end
+      end
+
+      def lock
+        g = Green.current
+        @waiters << g
+        Green.hub.wait { @waiters.delete g }
+      end
+
+      def wake
+        w = @waiters.shift
+        Green.hub.callback { w.switch } if w
+      end
+
+      def cancel
+        @notifier.kill
+      end
+    end
+  end
+end
+
+module ZMQ
+  class Context
+    alias :original_terminate :terminate
+    def terminate
+      Green.hub.callback do
+        original_terminate
+      end
+    end
+  end
+
+  class Socket
+    def initialize(*args)
+      super
+      fd, = [].tap { |a| getsockopt(ZMQ::FD, a) }
+      @waiter = Green::ZMQ::Waiter.new fd
+    end
+
+    alias :bsendmsg :sendmsg
+    def sendmsg(message, flags = 0)
+      return bsendmsg(message, flags) if (flags & ZMQ::NonBlocking) != 0
+      flags |= ZMQ::NonBlocking
+      loop do
+        rc = bsendmsg message, flags
+        if rc == -1 && ZMQ::Util.errno == EAGAIN
+          @waiter.lock
+        else
+          @waiter.wake
+          return rc
+        end
+      end
+    end
+
+    alias :brecvmsg :recvmsg
+    def recvmsg(message, flags = 0)
+      return brecvmsg(message, flags) if (flags & ZMQ::NonBlocking) != 0
+      flags |= ZMQ::NonBlocking
+      loop do
+        rc = brecvmsg message, flags
+        if rc == -1 && ZMQ::Util.errno == EAGAIN
+          @waiter.lock
+        else
+          @waiter.wake
+          return rc
+        end
+      end
+    end
+
+    alias :original_close :close
+    def close
+      @waiter.cancel
+      Green.hub.callback do
+        original_close
+      end
+    end
+  end
+end

data/lib/green-em/em-http.rb

@@ -12,15 +12,14 @@ module EventMachine
          alias :a#{type} :#{type}
          def #{type}(options = {}, &blk)
            g = Green.current
-
            conn = setup_request(:#{type}, options, &blk)
            if conn.error.nil?
              conn.callback { g.switch(conn) }
-             conn.errback  { g.throw(HTTPException.new(conn)) }
+             conn.errback  { g.throw(HTTPException.new) }
              
-             Green.hub.wait(conn)
+             Green.hub.wait { conn.green_cancel }
            else
-             raise HTTPException.new(conn)
+             raise HTTPException.new
            end
          end
       ]