Abundance 1.0.0

data/lib/abundance.rb

@@ -0,0 +1,94 @@
+# This class provides a mean to parallelize the execution of your program processes.
+# 
+# Its caracteristics are:
+# * concurent
+# * non-blocking
+# * simple
+# * pure ruby
+# * no dependency installation
+# 
+# It:
+# * scales to multi core
+# * is intended for batch processing or other parallel ready operations
+# * can boost you program's performance
+# 
+# And not:
+# * a replacement for Thread.new invocations
+# * a replacement for Thread friendly programming languages like Erlang
+# 
+# 
+# Based on Gardener,Garden,Seed natural design patern
+# 
+# While there should be no use for this kind of class in most programs, there are some occasions where processes
+# cannot live inside serialized execution without blocking.  The built in threading model can save your execution in many occasions, but in many case green threading is not enough, or simply just won't work.
+# For a nice explanation on the subject of ruby green threading, you can refer to: http://www.igvita.com/2008/11/13/concurrency-is-a-myth-in-ruby/
+# 
+# Abundance is by no mean intended to equal or compete with the tools mentionned in the article, its rather a different
+# approach on the same problem.  I hope it will inspire some of you to hack out something that works even better,
+# and hopefully, eventually this tool will become obsolete because Ruby will get concurency built in.
+#  
+# So, the approach here is really simple, you require abundance in your program.
+# Then ask the Abundance.gardener class method to build you a garden built with a garden patch block you provide as part of the invocation.
+# This garden patch block includes an initialization block, which may be empty,
+# and the invocation of the Abundance.grow class method, the perpetual seed ready patch garden.
+# It becomes the threaded looping object, growing concurently on garden patch row forks.
+# 
+# The gardener objected is then available to seeds and harvest the multiple garden patch row forks,
+# allowing you to cultivate parallel garden rows where your seeds sprout till fruitful harvest time comes.
+# 
+# Author:: lp (mailto:lp@spiralix.org)
+# Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+# 
+# :title:Abundance
+
+class Abundance
+  require 'garden'
+  require 'gardener'
+  require 'seed'
+  
+  # The +gardener+ class method initializes a gardener instance
+  # with its garden supplied as a block.  The invocation block must include
+  # the +grow+ class method and a preceeding optional initialisation section.
+  # === Parameters
+  # * :seed_size = allowed seed size in bytes
+  # * :rows = garden rows number, the number of concurent threads
+  # * :init_timeout = allow to pause execution to allow for larger gardens to initialize
+  # === Example
+  #  gardener = Abundance.gardener( :block_size => 8192, :rows => 2, :init_timeout => 2) do
+  # 
+  #   processor = SpecialProcess.new
+  # 
+  #   Abundance.grow do |seed|
+  #     command = seed.sprout 
+  #     results = processor.parse(command) 
+  #     seed.crop( true, results)  
+  #   end
+  #  end
+  # 
+  #  id1 = gardener.seed('command1')
+  #  id2 = gardener.seed('command2')
+  # 
+  #  result1 = gardener.harvest(id1)
+  #  result2 = gardener.harvest(id2)
+  # 
+  #  # with many more seeds over here
+  # 
+  #  gardener.close
+  
+  def Abundance.gardener(options={:seed_size => 8192, :rows => 2, :init_timeout => 2},&gardener_block)
+    return Gardener.new(options,gardener_block)
+  end
+  
+  # The +grow+ class method needs to be used inside the gardener invocation.
+  # A seed instance is given each time, acting as getter/setter for your queued seed commands
+  
+  def Abundance.grow(&grow_block)
+    loop do
+      unless $seed.nil? || $seed.include?(:message) 
+        grow_block.call(Seed.new)
+      end
+      Thread.stop
+    end
+  end
+  
+end

data/lib/garden.rb

@@ -0,0 +1,206 @@
+# These classes provides the garden part of the Gardener,Garden,Seed natural design patern
+# 
+# The Garden is where the thread concurency is implemented,
+# offering itself as a thread queue manager,
+# dispatching seeds from the Gardener to its Rows child class and back again.
+# Since Ruby doesn't implement Native Threads, and only Native Threads scales to multi-core execution,
+# the way to implement concurent execution is through splitting the task at hand between multiple single threaded parallel executions.
+# The Rows system does exactly that, using the Ruby fork function, then connecting the isolated running
+# processes to the Garden, through a simple socket system provided by the Toolshed Module.
+# 
+# Author:: lp (mailto:lp@spiralix.org)
+# Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+# 
+# :title:Garden
+
+class Garden
+  require 'toolshed'
+  include Toolshed
+  
+  attr_reader :pid
+  
+  # The +new+ class method initializes the Garden.
+  # As part of the Abundance lib, Garden is not initialized directly, 
+  # but rather as a side effect of the Gardener's initialization.
+  # Its instance resides in the @garden Gardener's instance variable.
+  # Its real muscles are inaccessibles from instance method intervention,
+  # because of its nature as a forked Ruby process.
+  # === Example
+  #  garden = Garden.new
+  
+  def initialize
+    @pid = fork do
+      @quit = false
+      @harvest = []
+      @rows_port = []
+      @seeds = []; @sprouts = []; @crops = []; @id = 0
+      @socket_server = Toolshed.socket_server(Toolshed::garden_port)
+      @socket_client_temp = Toolshed.socket_client_temp
+      loop do
+        catch :fill_rows do
+          loop do
+            if ! @seeds.empty? && ! @rows_port.empty?
+              seed = @seeds.shift
+              @sprouts[seed[:id]] = seed
+              row_port = @rows_port.shift
+              socket_client_temp(:sprout,seed,row_port)
+            elsif @quit && ! @rows_port.empty?
+              seed = nil
+              row_port = @rows_port.shift
+              socket_client_temp(:quit,seed,row_port)
+            else
+              throw :fill_rows
+            end               
+          end
+        end
+        command, data, clientport, clientname, clientaddr = socket_server_recv
+        case command
+        when :seed 
+          @id += 1; @seeds << {:id => @id , :seed => data}
+          socket_server_send(command,@id,clientaddr,clientport)
+        when :row
+          if @quit
+            command = :quit
+            seed = nil
+          elsif @seeds.empty?
+            seed = nil
+            @rows_port << data
+          else
+            seed = @seeds.shift
+            @sprouts[seed[:id]] = seed
+          end
+          socket_server_send(command,seed,clientaddr,clientport)  
+        when :crop 
+          @sprouts[data[:id]] = nil
+          @crops[data[:id]] = data; socket_server_send(command,true,clientaddr,clientport)
+          socket_server_send(command,data, @harvest[data[:id]][:clientaddr], @harvest[data[:id]][:clientport]) if @harvest[data[:id]] 
+        when :growth
+          case data
+          when :progress
+            progress = sprintf( "%.2f", @crops.size.to_f / (@crops.size + @sprouts.compact.size + @seeds.size))
+            socket_server_send(command,progress,clientaddr,clientport)
+          when :seed
+            socket_server_send(command,@seeds.size,clientaddr,clientport)
+          when :sprout
+            socket_server_send(command,@sprouts.compact.size,clientaddr,clientport)
+          when :crop
+            socket_server_send(command,@crops.size,clientaddr,clientport)
+          else
+            socket_server_send(command,false,clientaddr,clientport)
+          end
+        when :harvest
+          case data
+          when :all
+            socket_server_send(command,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops},clientaddr,clientport)
+          when :seed
+            socket_server_send(command,@seeds,clientaddr,clientport)
+          when :sprout
+            socket_server_send(command,@sprouts.compact,clientaddr,clientport)
+          when :crop
+            socket_server_send(command,@crops,clientaddr,clientport)
+          else
+            if data.is_a? Integer
+              if @crops[data]
+                socket_server_send(command,@crops[data],clientaddr,clientport)
+              else
+                @harvest[data] = {:clientaddr => clientaddr, :clientport => clientport}
+              end
+            else
+              socket_server_send(command,false,clientaddr,clientport)
+            end
+          end
+        when :close
+          if data[:level] == :garden
+            @seeds_pid = data[:pid]
+            @quit = true
+            @mem_addr = clientaddr; @mem_port = clientport
+          else
+            @seeds_pid.delete(data[:pid].to_i)
+            if @seeds_pid.empty?
+              socket_server_send(:close,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops}, @mem_addr, @mem_port)
+              exit
+            end
+          end
+        else
+          socket_server_send(command,false,clientaddr,clientport)
+        end
+      end
+    end
+    return pid
+  end
+  
+  # The +rows+ method for the Garden instance allow instantiation of its child Rows.
+  # As part of the Abundance lib, Garden.rows is not invoked directly, 
+  # but rather as a side effect of the Gardener's initialization.
+  # Its in reality an indirect initializer for the Rows class.
+  # === Parameter
+  # * _rows_ = garden rows number, the number of concurent threads
+  # * _init_timeout_ = allow to pause execution to allow for larger garden rows to initialize
+  # === Example
+  #  rows = garden.rows(4,2) { grow_block }
+  # 
+  
+  def rows(rows,init_timeout,grow_block)
+    Rows.new(rows,init_timeout,grow_block)
+  end
+  
+  # :title:Rows
+  
+  class Rows
+    include Toolshed
+    attr_reader :pids
+    
+    # The +new+ class method initializes the Rows.
+    # As part of the Abundance lib, Rows is not initialized directly, 
+    # but rather as a side effect of the Gardener's initialization,
+    # through the +rows+ Garden instance method.
+    # Its instance resides in the @garden_rows Gardener's instance variable.
+    # Its real muscles are inaccessibles from instance method intervention,
+    # because of its nature as a forked Ruby process.
+    # === Parameter
+    # * _rows_ = garden rows number, the number of concurent threads
+    # * _init_timeout_ = allow to pause execution to allow for larger garden rows to initialize
+    # === Example
+    #  rows = Rows.new(4,2) { grow_block }
+    
+    def initialize(rows,init_timeout,gardener_block)
+      @pids = []
+      rows.times do
+        row_port = Toolshed.available_port
+        @pids << fork do
+          @socket_server = Toolshed.socket_server(row_port)
+          t1 = Thread.new do
+            gardener_block.call
+          end
+
+          t2 = Thread.new do
+            @socket_client_perm = Toolshed.socket_client_perm
+            loop do
+              if $seed.nil?
+                command, data = socket_client_perm_duplex(:row,row_port)
+                if command == :quit
+                  pid = Process.pid
+                  socket_client_perm_send(:close,{:level => :seed, :pid => pid})
+                  exit
+                end
+                $seed = data
+                if $seed.nil?
+                  command, data, clientport, clientname, clientaddr = socket_server_recv
+                  $seed = data
+                end
+              elsif $seed.include?(:success)
+                command, data = socket_client_perm_duplex(:crop,$seed)
+                $seed = nil
+              else
+                t1.run
+              end
+
+            end
+          end
+          t2.join
+        end
+      end
+      sleep init_timeout
+    end
+  end
+end

data/lib/gardener.rb

@@ -0,0 +1,99 @@
+# This class provides the gardener part of the Gardener,Garden,Seed natural design patern
+# 
+# The Gardener act as the client class for accessing and assessing the Garden ressources.
+# Its initialization occurs through the Abundance.gardener class method.
+# Its instance methods are fourthfold, following the 4 states of the garden.
+# Like the 4 seasons northern hemisphere gardening cycles:
+# * seed = the setting of your command cycle
+# * growth = the evolution of your command growing period
+# * harvest = the getting of your command results
+# * close = the closing and dying cycle
+# 
+# Author:: lp (mailto:lp@spiralix.org)
+# Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+# 
+# :title:Gardener
+
+class Gardener
+  require 'toolshed'
+  include Toolshed
+  
+  # The +new+ class method initializes the class.
+  # As part of the Abundance lib, Gardener is not initialized directly, 
+  # but rather through +Abundance.gardener+.
+  # === Parameters
+  # * :seed_size = allowed seed size in bytes
+  # * :rows = garden rows number, the number of concurent threads
+  # * :init_timeout = allow to pause execution to allow for larger gardens to initialize
+  # === Example
+  #  gardener = Gardener.new({:seed_size => 1024, :rows => 6, :init_timeout => 1}) do
+  #   Abundance.grow do |seed|
+  #     seed.crop(`#{seed.sprout}`)
+  #   end
+  #  end  
+  # 
+  
+  def initialize(options,gardener_block)
+    Toolshed::block_size = options[:seed_size]
+    Toolshed::garden_port = Toolshed.available_port
+    
+    @garden = Garden.new
+    @garden_rows = @garden.rows(options[:rows], options[:init_timeout], gardener_block)
+    
+    @socket_client_perm = Toolshed.socket_client_perm
+  end
+  
+  # The +seed+ method for the Gardener instance allow to sow a command in the Gardener's Garden.
+  # === Parameter
+  # * _command_ = a ruby expression or object
+  # === Example
+  #  id_seed_1 = gardener.seed('ruby -v')
+  
+  def seed(command)
+    command, data = socket_client_perm_duplex(:seed,command)
+    return data
+  end
+  
+  # The +growth+ method for the Gardener instance allow to get report of the growing process
+  # === Parameter
+  # The parameter given as a symbol specifies the level of growth report you wish to get:
+  # * :progress = return actual progress status, scaled between 0.00 and 1.00
+  # * :seed = return total seeds waiting to be processed
+  # * :sprout = return total seeds actually in process
+  # * :crop = return total seeds for which process has completed
+  # === Example
+  #  progress = gardener.growth(:progress)
+  #  puts "progress is now #{progress}"  # => progress is now 0.75
+  
+  def growth(crop=:progress)
+    command, data = socket_client_perm_duplex(:growth,crop)
+    return data
+  end
+  
+  # The +harvest+ method for the Gardener instance allow to get arrays of results for each queue level
+  # === Parameter
+  # The parameter given as a symbol specifies the level of queue results you wish to get:
+  # * _seedID_ = return the result for a specific seed, if seed hasn't processed it wait until completed
+  # * :crop = return an array of seed for which process has completed
+  # * :sprout = return an array of seed actually processing
+  # * :seed = return an array of seed waiting to be processed
+  # * :all = return a hash of respective arrays for crops, sprouts and seeds
+  # === Example
+  #  puts "result is: #{gardener.harvest(id_seed_1)}  #  => result is: ruby 1.8.6 (2007-09-24 patchlevel 111) [universal-darwin9.0]
+   
+  def harvest(crop)
+    command, data = socket_client_perm_duplex(:harvest,crop)
+    return data
+  end
+  
+  # The +close+ method for the Gardener instance allow to safely close the Garden and its Rows.
+  # It return a hash of respective arrays for crops, sprouts and seeds at the moment of closing.
+  # === Example
+  #  final_harvest = gardener.close
+  
+  def close
+    command, data = socket_client_perm_duplex(:close,{:level => :garden, :pid => @garden_rows.pids})
+    return data
+  end
+  
+end

data/lib/seed.rb

@@ -0,0 +1,42 @@
+# This class provides the seed part of the Gardener,Garden,Seed natural design patern
+# 
+# In nature, seed is usually small, and so is this class.
+# No attributes/variables of itself, its only a kind of localized getter/setter class for 
+# the global $seed variable.  Every garden row assess one fork-localized $seed variable, and
+# you get access to it from a +seed+ instance passed to every Abundance.grow iteration.
+# 
+# Author:: lp (mailto:lp@spiralix.org)
+# Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+# 
+# :title:Seed
+
+class Seed
+  
+  # The +new+ class method initializes the class.
+  # You don't have to initialize it inside of Abundance,
+  # as it gets initialized automatically inside the Abundance.grow method
+  
+  # The +sprout+ method for the Seed instance allow to get the passed command 
+  # from the inside the Abundance.grow block.
+  # === Example
+  #  system "#{seed.sprout}\n"
+  def sprout
+    return $seed[:seed]
+  end
+  
+  # The +crop+ method for the Seed instance allow to set a success status and
+  # a return message from the inside the Abundance.grow block.
+  # === Parameter
+  # * _success_ = success of the iteration, may be true or false
+  # * _message_ = a ruby expression or object
+  # === Example
+  #  if success
+  #   seed.crop(true,results)
+  #  else
+  #   seed.crop(false,results)
+  #  end
+  def crop(success,message)
+    $seed[:success] = success; $seed[:message] = message
+  end
+  
+end

data/lib/test.rb

@@ -0,0 +1,121 @@
+require 'pty'
+require 'expect'
+require 'abundance'
+
+# puts "Init pid #{Process.pid}"
+# 
+# g = Abundance.gardener(:seed_size => 8192, :rows => 1, :init_timeout => 1) do
+#   puts "Garden init done, pid: #{Process.pid}"
+#   puts "@@ yield just before growing..."
+#   Abundance.grow do |seed|
+#     puts "@@ yield #{Time.now}: got in here"
+#     puts "@@ yield job: #{seed.sprout}"
+#     seed.crop(true, "Bravo!!gadigooo!!")
+#   end
+#   puts "Garden seeded"  
+# end
+# 
+# g.seed("jobidoo")
+# puts "First chore sent"
+# g.seed("jobidaa")
+# puts "second chore sent"
+# g.seed("jobidob")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidoc")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# id = g.seed("jobidod")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# puts "!!!!!!!!!!!!!!!!!!!!!!!!!! waiting for harvest: #{id.class.to_s}"
+# har = g.harvest(id)
+# puts "!!!!!!!!!!!!!!!!!!!!!!!!!! famous harvest: #{har.inspect}"
+# g.seed("jobidoe")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidof")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidog")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidoh")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidoi")
+# puts "!!! some seeds: #{g.harvest(:seed).inspect}"
+# puts "!!! some sprouts: #{g.harvest(:sprout).inspect}"
+# puts "!!! some crops: #{g.harvest(:crop).inspect}"
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidoj")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidok")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidol")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidom")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# g.seed("jobidon")
+# g.seed("jobidop")
+# g.seed("jobidoq")
+# g.seed("jobidor")
+# g.seed("jobidos")
+# g.seed("jobidot")
+# g.seed("jobidou")
+# g.seed("jobidov")
+# g.seed("jobidow")
+# g.seed("jobidox")
+# g.seed("jobidoy")
+# g.seed("jobidoz")
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# sleep 30
+# puts "!!! some seeds: #{g.harvest(:seed).inspect}"
+# puts "!!! some sprouts: #{g.harvest(:sprout).inspect}"
+# puts "!!! some crops: #{g.harvest(:crop).inspect}"
+# sleep 5
+# puts "!!!!!!!!!!!!!!!!!!!!!!! growth: #{g.growth}"
+# fin = g.close
+# puts "on close #{fin.inspect}"
+
+puts "Init pid #{Process.pid}"
+
+g = Abundance.gardener(:seed_size => 8192, :rows => 1, :init_timeout => 3) do
+  puts "@@ yield just before growing..."
+  PTY.spawn('smbclient //spiralgemini/geminishare goLEELAubu -U leelasheel') do |r,w,pid|
+    w.sync = true
+    $expect_verbose = false
+    
+    r.expect(/.*smb: \\>.*/) do |text|
+      puts "!!! starter: #{text}"
+    end
+    Abundance.grow do |seed|
+      neew = seed.sprout
+      puts "??? will go for: #{neew}"
+      w.print "#{seed.sprout}\n"
+      
+      r.expect(/.*smb: \\>/) do |text|
+        puts "!!! got #{text}"
+        unless text
+          r.expect(/.*smb: \\>/) do |text|
+            puts "!!!2 got #{text}"
+            seed.crop(true, text)
+          end
+        else
+          seed.crop(true, text)
+        end
+        
+      end
+    end
+    
+  end
+end
+
+puts "Garden seeded"
+
+g.seed("ls")
+puts "First chore sent"
+g.seed("pwd")
+puts "second chore sent"
+g.seed("volume")
+g.seed("help")
+g.seed("du")
+g.seed("put inside.rb")
+sleep 20
+# r = g.harvest
+# puts r.inspect
+fin = g.close
+puts fin.inspect

data/lib/toolshed.rb

@@ -0,0 +1,95 @@
+# This module provides a toolkit of helper methods to Abundance
+# 
+# It uses the Socket Ruby standard library to provide a communication mechanism
+# between Abundance concurent processes.  It's used as both a namespace for init variables of 
+# the different Abundance Classes, using Toolshed's Class Method like qualified names,
+# and as mixins methods which access directly the instance variables of the client classes .
+# 
+# Author:: lp (mailto:lp@spiralix.org)
+# Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+# 
+# :title:Toolshed
+
+module Toolshed
+  require 'socket'
+  UDP_HOST = 'localhost'
+  @@start_port = 50000
+  
+  def Toolshed.available_port
+    port = @@start_port + 1
+    catch :scan_port do
+      loop do
+        begin
+          socket = UDPSocket.new
+          socket.connect(UDP_HOST,port)
+          socket.send('',0)
+          response,address = socket.recvfrom(1024)
+        rescue Errno::ECONNREFUSED
+          throw :scan_port
+        end
+        port += 1
+      end
+    end
+    @@start_port = port
+    return port
+  end
+  
+  def Toolshed.socket_client_perm
+    socket = UDPSocket.new
+    socket.connect(UDP_HOST,@@garden_port)
+    return socket
+  end
+  
+  def Toolshed.socket_client_temp
+    UDPSocket.new
+  end
+  
+  def Toolshed.socket_server(port)
+    socket_server = UDPSocket.new
+    socket_server.bind(nil,port)
+    return socket_server
+  end
+  
+  def Toolshed::block_size=(block_size)
+    @@block_size = block_size
+  end
+  
+  def Toolshed::block_size
+    @@block_size
+  end
+  
+  def Toolshed::garden_port=(garden_port)
+    @@garden_port = garden_port
+  end
+  
+  def Toolshed::garden_port
+    @@garden_port
+  end
+  
+  def socket_client_perm_duplex(command,data)
+    @socket_client_perm.send(Marshal.dump([command,data]),0)
+    recv_block,address = @socket_client_perm.recvfrom(@@block_size)
+    return Marshal.load(recv_block)
+  end
+  
+  def socket_client_perm_send(command,data)
+    @socket_client_perm.send(Marshal.dump([command,data]),0)
+  end
+  
+  def socket_client_temp(command,data,port)
+    @socket_client_temp.connect(UDP_HOST,port)
+    @socket_client_temp.send(Marshal.dump([command,data]),0)
+  end
+  
+  def socket_server_recv
+    block,address = @socket_server.recvfrom(@@block_size)
+    clientport = address[1]; clientname = address[2]; clientaddr = address[3] 
+    command, data = Marshal.load(block)
+    return command, data, clientport, clientname, clientaddr
+  end
+  
+  def socket_server_send(command,data,clientaddr,clientport)
+    @socket_server.send(Marshal.dump([command,data]), 0, clientaddr, clientport)
+  end
+  
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: Abundance
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Louis-Philippe Perron
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-03 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lp@spiralix.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/abundance.rb
+- lib/garden.rb
+- lib/gardener.rb
+- lib/seed.rb
+- lib/test.rb
+- lib/toolshed.rb
+has_rdoc: true
+homepage: http://abundance.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: Abundance
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby Parallel Processing, Concurent Native Threads
+test_files: []
+