green 0.0.1

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gem "eventmachine", "~> 1.0.0.beta.4"
+gem "em-http-request"
+gem "unicorn"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    green (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.7)
+    em-http-request (1.0.0)
+      addressable (>= 2.2.3)
+      em-socksify
+      eventmachine (>= 1.0.0.beta.3)
+      http_parser.rb (>= 0.5.2)
+    em-socksify (0.2.0)
+      eventmachine (>= 1.0.0.beta.4)
+    eventmachine (1.0.0.mail.7)
+    http_parser.rb (0.5.3)
+    kgio (2.7.4)
+    rack (1.4.1)
+    raindrops (0.8.0)
+    unicorn (4.2.1)
+      kgio (~> 2.6)
+      rack
+      raindrops (~> 0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  em-http-request
+  eventmachine (~> 1.0.0.beta.4)
+  green!
+  unicorn

data/README.md

@@ -0,0 +1,55 @@
+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.
+
+In comparison with EM-Synchrony it allows:
+- develop real complex cooperative multitasking apps;
+- timeouts. Yes, in common case you cannot add timeout with EM-Synchrony;
+- kill greens. And it safe unlike kill Threads;
+- works with REPL and debugger. EM-Synchrony uses Fiber.yield, so you cannot run  nothing in REPL;
+- works with every environment. You can run nonblock web-applications with Unicorn;
+- compatible with Ruby's Enumerator and with any other uses of Fibers themself (see https://github.com/igrigorik/em-synchrony/issues/114)
+
+```ruby
+require 'green'
+require 'green/group'
+require 'green-em/em-http'
+
+g = Green::Pool.new(size: 2)
+
+urls = ['http://google.com', 'http://yandex.ru']
+
+results = g.enumerator(urls) do |url|
+  EventMachine::HttpRequest.new(url).get
+end.map { |i| i.response }
+
+p results
+```
+
+You can run it from Irb! ;)
+
+You can add timeout:
+
+```ruby
+require 'green'
+require 'green/group'
+require 'green-em/em-http'
+
+g = Green::Pool.new(size: 2)
+
+urls = ['http://google.com', 'http://yandex.ru']
+
+begin
+  Green.timeout(1) do
+    results = g.enumerator(urls) do |url|
+      EventMachine::HttpRequest.new(url).get
+    end.map { |i| i.response }
+    p results
+  end
+rescue Timeout::Error
+  p "Timeout!"
+end
+```
+
+And much more soon ;)
+

data/Rakefile

@@ -0,0 +1,131 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+
+task :default => :spec
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |t|
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+desc "Generate RCov test coverage and open in your browser"
+task :coverage do
+  require 'rcov'
+  sh "rm -fr coverage"
+  sh "rcov test/test_*.rb"
+  sh "open coverage/index.html"
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/Readme.md

@@ -0,0 +1,55 @@
+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.
+
+In comparison with EM-Synchrony it allows:
+- develop real complex cooperative multitasking apps;
+- timeouts. Yes, in common case you cannot add timeout with EM-Synchrony;
+- kill greens. And it safe unlike kill Threads;
+- works with REPL and debugger. EM-Synchrony uses Fiber.yield, so you cannot run  nothing in REPL;
+- works with every environment. You can run nonblock web-applications with Unicorn;
+- compatible with Ruby's Enumerator and with any other uses of Fibers themself (see https://github.com/igrigorik/em-synchrony/issues/114)
+
+```ruby
+require 'green'
+require 'green/group'
+require 'green-em/em-http'
+
+g = Green::Pool.new(size: 2)
+
+urls = ['http://google.com', 'http://yandex.ru']
+
+results = g.enumerator(urls) do |url|
+  EventMachine::HttpRequest.new(url).get
+end.map { |i| i.response }
+
+p results
+```
+
+You can run it from Irb! ;)
+
+You can add timeout:
+
+```ruby
+require 'green'
+require 'green/group'
+require 'green-em/em-http'
+
+g = Green::Pool.new(size: 2)
+
+urls = ['http://google.com', 'http://yandex.ru']
+
+begin
+  Green.timeout(1) do
+    results = g.enumerator(urls) do |url|
+      EventMachine::HttpRequest.new(url).get
+    end.map { |i| i.response }
+    p results
+  end
+rescue Timeout::Error
+  p "Timeout!"
+end
+```
+
+And much more soon ;)
+

data/app.ru

@@ -0,0 +1,24 @@
+require 'bundler'
+
+Bundler.setup
+
+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 

data/green.gemspec

@@ -0,0 +1,48 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  s.name              = 'green'
+  s.version           = '0.0.1'
+  s.date              = '2012-05-09'
+  s.rubyforge_project = 'green'
+
+  s.summary     = "Cooperative multitasking fo Ruby"
+  s.description = "Cooperative multitasking fo Ruby"
+
+  s.authors  = ["Andrew Rudenko"]
+  s.email    = 'ceo@prepor.ru'
+  s.homepage = 'http://github.com/prepor/green'
+
+  s.require_paths = %w[lib]
+
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md]
+
+
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    Readme.md
+    app.ru
+    green.gemspec
+    lib/green-em/em-http.rb
+    lib/green.rb
+    lib/green/event.rb
+    lib/green/ext.rb
+    lib/green/group.rb
+    lib/green/hub.rb
+    lib/green/hub/em.rb
+    lib/green/monkey.rb
+    lib/green/semaphore.rb
+    lib/green/tcp_socket.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^spec\/.*_spec\.rb/ }
+end

data/lib/green/event.rb

@@ -0,0 +1,29 @@
+class Green
+  class Event
+    include Green::Waiter
+    attr_reader :waiters
+    def initialize
+      @waiters = []
+      @setted = false
+    end
+
+    def set(result = nil)
+      @setted = true
+      @result = result
+      waiters.each { |v| Green.hub.callback { v.switch } }
+    end
+
+    def wait
+      if @setted
+        @result
+      else
+        waiters << Green.current
+        Green.hub.wait self, Green.current
+      end
+    end
+
+    def green_cancel(waiter)
+      waiters.delete waiter
+    end
+  end
+end

data/lib/green/ext.rb

@@ -0,0 +1,25 @@
+class Fiber
+
+  # def self.new
+  #   super.tap { |o| o[:green] = Green.current }
+  # end
+
+  #Attribute Reference--Returns the value of a fiber-local variable, using
+  #either a symbol or a string name. If the specified variable does not exist,
+  #returns nil.
+  def [](key)
+    local_fiber_variables[key]
+  end
+  
+  #Attribute Assignment--Sets or creates the value of a fiber-local variable,
+  #using either a symbol or a string. See also Fiber#[].
+  def []=(key,value)
+    local_fiber_variables[key] = value
+  end
+  
+  private
+  
+  def local_fiber_variables
+    @local_fiber_variables ||= {}
+  end
+end

data/lib/green/group.rb

@@ -0,0 +1,78 @@
+require 'green/event'
+require 'green/semaphore'
+class Green
+  class Group
+    attr_reader :options, :greens
+    def initialize(options = {})      
+      @options = options
+      @greens = []
+    end
+
+    def spawn(*args, &blk)
+      g = Green.spawn do
+        blk.call(*args)
+      end
+      add g
+      g.callback { discard g }
+      g
+    end
+
+    def apply(&blk)
+      spawn(&blk).join
+    end
+
+    def add(green)
+      greens << green
+    end
+
+    def discard(green)
+      greens.delete green
+    end
+
+    def join
+      while (g = greens.pop)
+        g.join
+      end
+    end
+
+    def enumerator(iterable, &blk)
+      iter = iterable.each
+      Enumerator.new do |y|
+        e = Event.new
+        begin
+          waiting = 0
+          while true
+            i = iter.next
+            waiting += 1
+            spawn(i) do |item|
+              y << blk.call(item)
+              waiting -= 1
+              e.set if waiting == 0 
+            end
+          end          
+        rescue StopIteration
+          e.wait
+        end
+      end
+    end
+  end
+
+  class Pool < Group
+    attr_reader :semaphore
+    def initialize(*args)
+      super
+      @semaphore = Semaphore.new(options[:size])
+    end
+
+    def spawn(*args, &blk)
+      semaphore.acquire
+      super() do
+        begin
+          blk.call(*args)
+        ensure
+          semaphore.release
+        end
+      end
+    end
+  end
+end

data/lib/green/hub/em.rb

@@ -0,0 +1,44 @@
+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
+  end
+end
+
+class Green
+  class Hub
+    class EM < Hub
+      # если мы запускаем приложение внутри thin или rainbows с EM, то значит мы уже внутри EM-реактора, а hub должен переключиться в main тред.
+      def run
+        if ::EM.reactor_running?          
+          loop do
+            Green.main.switch
+          end
+        else
+          ::EM.run
+        end
+      end
+
+      def timer(n, &blk)
+        ::EM::Timer.new(n, &blk)
+      end
+
+      def callback(&blk)
+        ::EM.next_tick(&blk)
+      end
+    end
+  end
+end

data/lib/green/hub.rb

@@ -0,0 +1,42 @@
+class Green
+  class Hub
+    attr_reader :g
+    def initialize
+      c = Green.current
+      callback { c.switch }      
+      @g = Green.new do
+        run
+      end
+      g.switch
+    end
+
+    def switch
+      g.switch
+    end
+
+    def wait(waiter, *args)
+      switch
+    rescue => e
+      waiter.green_cancel(*args)
+      raise e
+    end
+
+    def sleep(n)
+      g = Green.current
+      t = timer(n) { g.switch }
+      wait t
+    end
+
+    def run
+      raise "override"
+    end
+
+    def timer(n, &blk)
+      raise "override"
+    end
+
+    def callback(&blk)
+      raise "override"
+    end
+  end
+end

data/lib/green/monkey.rb

@@ -0,0 +1,13 @@
+class Green
+  module Monkey
+    extend self
+
+    def patch_constants
+      
+    end
+    
+    def patch_socket
+      
+    end
+  end
+end

data/lib/green/semaphore.rb

@@ -0,0 +1,44 @@
+class Green
+  class Semaphore
+    include Green::Waiter
+    attr_accessor :counter
+    def initialize(value = 1)
+      @counter = value
+      @links = []
+    end
+
+    def acquire
+      if counter > 0
+        self.counter -= 1
+        true
+      else
+        g = Green.current
+        clb = rawlink { g.switch }
+        Green.hub.wait self, clb
+        self.counter -= 1
+        true
+      end
+    end
+
+    def release
+      self.counter += 1
+      if @links.size > 0
+        l = @links.pop
+        Green.hub.callback { l.call }
+      end
+    end
+
+    def rawlink(&clb)
+      @links << clb
+      clb
+    end
+
+    def unlink(clb)
+      @links.delete clb
+    end
+
+    def green_cancel(clb)
+      unlink clb
+    end
+  end
+end

data/lib/green/tcp_socket.rb

@@ -0,0 +1,25 @@
+class Green
+  class Socket < ::Socket
+    def accept
+      accept_nonblock
+    end
+
+    def connect(sock_addr)
+      connect_nonblock(sock_addr)
+    end
+
+    def send(mesg, flags = 0, dest_sockaddr = nil)
+      super(mesg, flags, dest_sockaddr)
+    rescue Errno::EAGAIN => e
+      wait_write
+      retry
+    end
+
+    def recv(maxlen, flags = 0)
+      super(maxlen, flags = 0)
+    rescue Errno::EAGAIN => e
+      wait_read
+      retry
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+begin
+  require "em-http-request"
+rescue LoadError => error
+  raise "Missing EM-Synchrony dependency: gem install em-http-request"
+end
+
+module EventMachine
+  class HTTPException < RuntimeError; end
+  module HTTPMethods
+     %w[get head post delete put].each do |type|
+       class_eval %[
+         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)) }
+             
+             Green.hub.wait(conn)
+           else
+             raise HTTPException.new(conn)
+           end
+         end
+      ]
+    end
+  end
+end

data/lib/green.rb

@@ -0,0 +1,117 @@
+require 'fiber'
+require 'pp'
+require 'thread'
+
+class Green
+  VERSION = "0.0.1"
+  class Proxy
+    attr_reader :f
+    def initialize
+      @f = Fiber.current
+    end
+
+    def switch(*args)
+      f.transfer(*args)
+    end
+  end
+
+  module Waiter
+    def green_cancel
+      raise "override"
+    end
+  end
+
+  class << self
+    
+    def thread_locals
+      @thread_locals ||= {}
+      @thread_locals[Thread.current] ||= {}
+    end
+
+    def sleep(n)
+      Green.hub.sleep(n)
+    end
+
+    def main
+      MAIN
+    end
+
+    def current
+      Fiber.current[:green] || Proxy.new
+    end
+
+    def make_hub
+      Hub::EM.new
+    end
+
+    def hub
+      # thread_locals[:hub] ||= make_hub
+      @hub ||= make_hub
+    end
+
+    def spawn(&blk)
+      Green.new(&blk).tap { |o| o.start }
+    end
+
+    def timeout(n, &blk)
+      g = current
+      timer = hub.timer(n) do
+        g.switch Timeout::Error.new
+      end
+      res = blk.call
+      timer.cancel
+      res
+    end
+  end
+
+  # class GreenError < StandardError; end
+  # class GreenKill < GreenError; end
+
+  require 'green/ext'
+  require 'green/hub'
+
+  require 'green/hub/em'
+
+  attr_reader :f, :callbacks
+  def initialize()
+    @callbacks = []
+    @f = Fiber.new do
+      res = yield
+      @callbacks.each { |c| c.call(*res) }
+      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)
+  end
+
+  def start
+    Green.hub.callback { self.switch }
+  end
+
+  def callback(&blk)
+    callbacks << blk
+  end
+
+  def join
+    g = Green.current
+    callback { |*res| g.switch(*res) }
+    Green.hub.switch
+  end
+
+  # def kill
+  #   self.throw(GreenKill.new)
+  # end
+
+  MAIN = Fiber.current[:green] = Proxy.new
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: green
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Rudenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-09 00:00:00.000000000Z
+dependencies: []
+description: Cooperative multitasking fo Ruby
+email: ceo@prepor.ru
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- Readme.md
+- app.ru
+- green.gemspec
+- lib/green-em/em-http.rb
+- lib/green.rb
+- lib/green/event.rb
+- lib/green/ext.rb
+- lib/green/group.rb
+- lib/green/hub.rb
+- lib/green/hub/em.rb
+- lib/green/monkey.rb
+- lib/green/semaphore.rb
+- lib/green/tcp_socket.rb
+- README.md
+homepage: http://github.com/prepor/green
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: green
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 2
+summary: Cooperative multitasking fo Ruby
+test_files: []
+has_rdoc: