abundance 1.2.1 → 1.2.2

data/lib/abundance.rb

@@ -47,11 +47,11 @@ class Abundance
   # with its garden supplied as a block.  The invocation block must include
   # the +grow+ class method and a preceeding optional initialisation section that may include and +init_status+ return message.
   # === Parameters
-  # * :wheelbarrow = the socket size for the garden communication packets, in bytes, range from 1024 to 8192, defaults to 8192
+  # * :wheelbarrow = the socket size for the garden communication packets, in bytes, up to 8192, defaults to 124
   # * :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( :wheelbarrow => 8192, :rows => 2, :init_timeout => 2) do
+  #  gardener = Abundance.gardener( :wheelbarrow => 124, :rows => 2, :init_timeout => 2) do
   # 
   #   processor = SpecialProcess.new
   #   if processor.started_successfully?

data/lib/garden.rb

@@ -15,6 +15,9 @@
 # :title:Garden
 
 class Garden
+  require 'garden_rows'
+  require 'garden_cycles'
+  include Cycles
   require 'toolshed'
   include Toolshed
   
@@ -31,239 +34,39 @@ class Garden
   
   def initialize
     @pid = fork do
-      @quit = false; @full_crop = false; @do_init = nil; @seed_all = nil; @init_all_crop = []
-      @harvest = []; @rows_socket_paths = []; @init_done = []; @seed_all_done = []; @seed_all_crop = []
-      @seeds = []; @sprouts = []; @crops = []; @id = 0
+      set_my_containers
       set_my_socket_as_a(:garden)
+      
       loop do
-        catch :fill_rows do
-          loop do
-            if ! @seed_all.nil? && ! @rows_socket_paths.empty? && @seed_all_done.size != @seed_all[0]
-              row_socket_path = @rows_socket_paths.shift
-              unless @seed_all_done.include?( row_socket_path )
-                socket_send(:seed_all,@seed_all[1],row_socket_path)
-                @seed_all_done << row_socket_path
-              else
-                @rows_socket_paths << row_socket_path
-              end
-            elsif ! @do_init.nil? && ! @rows_socket_paths.empty? && @init_done.size != @do_init
-              row_socket_path = @rows_socket_paths.shift
-              unless @init_done.include?( row_socket_path )
-                socket_send(:init,'init_status',row_socket_path)
-                @init_done << row_socket_path
-              else
-                @rows_socket_paths << row_socket_path
-              end
-            elsif ! @seeds.empty? && ! @rows_socket_paths.empty?
-              seed = @seeds.shift
-              @sprouts[seed[:id]] = seed
-              row_socket_path = @rows_socket_paths.shift
-              socket_send(:sprout,seed,row_socket_path)
-            elsif @quit && ! @rows_socket_paths.empty?
-              seed = nil
-              row_socket_path = @rows_socket_paths.shift
-              socket_send(:quit,seed,row_socket_path)
-            else
-              throw :fill_rows
-            end               
-          end
-        end
+        seed_if_row_available
+        
         command, data, client_socket_path = socket_recv
         case command
         when :seed
-          @id += 1; @seeds << {:id => @id , :seed => data}
-          socket_send(command,@id,client_socket_path)
+          place_seed_in_queue(command,data,client_socket_path)
         when :row
-          if @quit
-            command = :quit
-            seed = nil
-          elsif @seeds.empty?
-            seed = nil
-            @rows_socket_paths << data
-          else
-            seed = @seeds.shift
-            @sprouts[seed[:id]] = seed
-          end
-          socket_send(command,seed,client_socket_path)  
+          this_row_is_available(command,data,client_socket_path)  
         when :crop
-          @sprouts[data[:id]] = nil
-          @crops[data[:id]] = data
-          if @harvest[data[:id]]
-            socket_send(command,data, @harvest[data[:id]][:client_socket_path]) 
-            @crops[data[:id]] = @harvest[data[:id]] = nil
-          elsif @full_crop && @seeds.compact.empty? && @sprouts.compact.empty?
-            socket_send(command,@crops.compact,@mem_client_socket_path)
-            @crops.clear; @full_crop = false
-          end
+          save_crop_for(command,data,client_socket_path)
         when :growth
-          case data
-          when :progress
-            value = @crops.size.to_f / (@crops.size + @sprouts.compact.size + @seeds.size)
-            value = 1 if value.nan?; progress = sprintf( "%.2f", value)
-            socket_send(command,progress,client_socket_path)
-          when :seed
-            socket_send(command,@seeds.size,client_socket_path)
-          when :sprout
-            socket_send(command,@sprouts.compact.size,client_socket_path)
-          when :crop
-            socket_send(command,@crops.size,client_socket_path)
-          else
-            socket_send(command,false,client_socket_path)
-          end
+          report_growth(command,data,client_socket_path)
         when :harvest
-          case data
-          when :all
-            socket_send(command,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact},client_socket_path)
-          when :seed
-            socket_send(command,@seeds,client_socket_path)
-          when :sprout
-            socket_send(command,@sprouts.compact,client_socket_path)
-          when :crop
-            socket_send(command,@crops.compact,client_socket_path)
-            @crops.clear
-          when :full_crop
-            if @seeds.compact.empty? && @sprouts.compact.empty?
-              socket_send(command,@crops.compact,client_socket_path)
-              @crops.clear
-            else
-              @full_crop = true
-              @mem_client_socket_path = client_socket_path
-            end
-          else
-            if data.is_a? Integer
-              if @crops[data]
-                socket_send(command,@crops[data],client_socket_path)
-                @crops[data] = nil
-              else
-                @harvest[data] = {:client_socket_path => client_socket_path}
-              end
-            else
-              socket_send(command,false,client_socket_path)
-            end
-          end
+          harvest_some(command,data,client_socket_path)
         when :init
-          @do_init = data
-          @init_return = {:client_socket_path => client_socket_path}
+          ask_for_init_status(command,data,client_socket_path)
         when :init_crop
-          @init_all_crop << data
-          if @init_all_crop.size == @do_init
-            socket_send(command,@init_all_crop, @init_return[:client_socket_path])
-            @init_return = Hash.new; @init_done = Array.new; @do_init = nil; @init_all_crop = Array.new
-          end
+          answer_init_status(command,data,client_socket_path)
         when :seed_all
-          @seed_all = data
-          @seed_all_return = {:client_socket_path => client_socket_path, :data => []}
+          seed_for_all_rows(command,data,client_socket_path)
         when :seed_all_crop
-          @seed_all_crop << data
-          if @seed_all_crop.size == @seed_all[0]
-            socket_send(command,@seed_all_crop, @seed_all_return[:client_socket_path])
-            @seed_all = nil; @seed_all_return = Hash.new; @seed_all_done = Array.new; @seed_all_crop = Array.new
-          end
+          special_crop_seed_all(command,data,client_socket_path)
         when :close
-          if data[:level] == :garden
-            @seeds_pid = data[:pid]
-            @quit = true
-            @mem_client_socket_path = client_socket_path
-          else
-            @seeds_pid.delete(data[:pid].to_i)
-            if @seeds_pid.empty?
-              socket_send(:close,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}, @mem_client_socket_path)
-              exit
-            end
-          end
+          close_all(command,data,client_socket_path)
         else
           socket_send(command,false,client_socket_path)
         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,@pid,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
-    # * _garden_pid_ = the parent Garden's pid, for loopback communication purpose
-    # === Example
-    #  rows = Rows.new(4,2) { grow_block }
-    
-    def initialize(rows,init_timeout,garden_pid,gardener_block)
-      @pids = []
-      rows.times do
-        @pids << fork do
-          @seed_all = false
-          set_my_socket_as_a(:row,garden_pid)
-          t1 = Thread.new do
-            gardener_block.call
-          end
 
-          t2 = Thread.new do
-            loop do
-              if $seed.nil?
-                command, data = socket_duplex(:row,my_socket_path)
-                if command == :quit
-                  pid = Process.pid
-                  socket_send(:close,{:level => :seed, :pid => pid})
-                  exit
-                end
-                $seed = data
-                if $seed.nil?
-                  command, data, client_socket_path = socket_recv
-                  case command
-                  when :sprout
-                    $seed = data
-                  when :seed_all
-                    @seed_all = true
-                    $seed = {:id => Process.pid, :seed => data}
-                  when :init
-                    $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
-                    socket_send(:init_crop,$init)
-                  end
-                end
-              elsif ! $seed[:success].nil?
-                if @seed_all
-                  socket_send(:seed_all_crop,$seed)
-                  @seed_all = false
-                else
-                  socket_send(:crop,$seed)
-                end
-                $seed = nil;
-              else
-                t1.run
-              end
-            end
-          end
-          t2.join
-        end
-      end
-      sleep init_timeout
-    end
-  end
 end

data/lib/garden_cycles.rb

@@ -0,0 +1,166 @@
+class Garden
+  # Author:: lp (mailto:lp@spiralix.org)
+  # Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+  # :title:Cycles
+  module Cycles
+    
+    def set_my_containers
+      @quit = false; @full_crop = false; @do_init = nil; @seed_all = nil; @init_all_crop = []
+      @harvest = []; @rows_socket_paths = []; @init_done = []; @seed_all_done = []; @seed_all_crop = []
+      @seeds = []; @sprouts = []; @crops = []; @id = 0
+    end
+    
+    def seed_if_row_available
+       catch :fill_rows do
+         loop do
+           if ! @seed_all.nil? && ! @rows_socket_paths.empty? && @seed_all_done.size != @seed_all[0]
+             row_socket_path = @rows_socket_paths.shift
+             unless @seed_all_done.include?( row_socket_path )
+               socket_send(:seed_all,@seed_all[1],row_socket_path)
+               @seed_all_done << row_socket_path
+             else
+               @rows_socket_paths << row_socket_path
+             end
+           elsif ! @do_init.nil? && ! @rows_socket_paths.empty? && @init_done.size != @do_init
+             row_socket_path = @rows_socket_paths.shift
+             unless @init_done.include?( row_socket_path )
+               socket_send(:init,'init_status',row_socket_path)
+               @init_done << row_socket_path
+             else
+               @rows_socket_paths << row_socket_path
+             end
+           elsif ! @seeds.empty? && ! @rows_socket_paths.empty?
+             seed = @seeds.shift
+             @sprouts[seed[:id]] = seed
+             row_socket_path = @rows_socket_paths.shift
+             socket_send(:sprout,seed,row_socket_path)
+           elsif @quit && ! @rows_socket_paths.empty?
+             seed = nil
+             row_socket_path = @rows_socket_paths.shift
+             socket_send(:quit,seed,row_socket_path)
+           else
+             throw :fill_rows
+           end               
+         end
+       end
+     end
+     
+     def place_seed_in_queue(command,data,client_socket_path)
+       @id += 1; @seeds << {:id => @id , :seed => data}
+       socket_send(command,@id,client_socket_path)
+     end
+     
+     def this_row_is_available(command,data,client_socket_path)
+       if @quit
+         command = :quit; seed = nil
+       elsif @seeds.empty?
+         seed = nil; @rows_socket_paths << data
+       else
+         seed = @seeds.shift; @sprouts[seed[:id]] = seed
+       end
+       socket_send(command,seed,client_socket_path)
+     end
+     
+     def save_crop_for(command,data,client_socket_path)
+       @sprouts[data[:id]] = nil; @crops[data[:id]] = data
+       if @harvest[data[:id]]
+         socket_send(command,data, @harvest[data[:id]][:client_socket_path]) 
+         @crops[data[:id]] = @harvest[data[:id]] = nil
+       elsif @full_crop && @seeds.compact.empty? && @sprouts.compact.empty?
+         socket_send(command,@crops.compact,@mem_client_socket_path)
+         @crops.clear; @full_crop = false
+       end
+     end
+     
+     def report_growth(command,data,client_socket_path)
+       case data
+       when :progress
+         value = @crops.size.to_f / (@crops.size + @sprouts.compact.size + @seeds.size)
+         value = 1 if value.nan?; progress = sprintf( "%.2f", value)
+         socket_send(command,progress,client_socket_path)
+       when :seed
+         socket_send(command,@seeds.size,client_socket_path)
+       when :sprout
+         socket_send(command,@sprouts.compact.size,client_socket_path)
+       when :crop
+         socket_send(command,@crops.size,client_socket_path)
+       else
+         socket_send(command,false,client_socket_path)
+       end
+     end
+     
+     def harvest_some(command,data,client_socket_path)
+       case data
+       when :all
+         socket_send(command,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact},client_socket_path)
+       when :seed
+         socket_send(command,@seeds,client_socket_path)
+       when :sprout
+         socket_send(command,@sprouts.compact,client_socket_path)
+       when :crop
+         socket_send(command,@crops.compact,client_socket_path)
+         @crops.clear
+       when :full_crop
+         if @seeds.compact.empty? && @sprouts.compact.empty?
+           socket_send(command,@crops.compact,client_socket_path)
+           @crops.clear
+         else
+           @full_crop = true
+           @mem_client_socket_path = client_socket_path
+         end
+       else
+         if data.is_a? Integer
+           if @crops[data]
+             socket_send(command,@crops[data],client_socket_path)
+             @crops[data] = nil
+           else
+             @harvest[data] = {:client_socket_path => client_socket_path}
+           end
+         else
+           socket_send(command,false,client_socket_path)
+         end
+       end
+     end
+     
+     def ask_for_init_status(command,data,client_socket_path)
+       @do_init = data
+       @init_return = {:client_socket_path => client_socket_path}
+     end
+     
+     def answer_init_status(command,data,client_socket_path)
+       @init_all_crop << data
+       if @init_all_crop.size == @do_init
+         socket_send(command,@init_all_crop, @init_return[:client_socket_path])
+         @init_return = Hash.new; @init_done = Array.new; @do_init = nil; @init_all_crop = Array.new
+       end
+     end
+     
+     def seed_for_all_rows(command,data,client_socket_path)
+       @seed_all = data
+       @seed_all_return = {:client_socket_path => client_socket_path, :data => []}
+     end
+     
+     def special_crop_seed_all(command,data,client_socket_path)
+       @seed_all_crop << data
+       if @seed_all_crop.size == @seed_all[0]
+         socket_send(command,@seed_all_crop, @seed_all_return[:client_socket_path])
+         @seed_all = nil; @seed_all_return = Hash.new; @seed_all_done = Array.new; @seed_all_crop = Array.new
+       end
+     end
+     
+     def close_all(command,data,client_socket_path)
+       if data[:level] == :garden
+         @seeds_pid = data[:pid]
+         @quit = true
+         @mem_client_socket_path = client_socket_path
+       else
+         @seeds_pid.delete(data[:pid].to_i)
+         if @seeds_pid.empty?
+           socket_send(:close,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}, @mem_client_socket_path)
+           exit
+         end
+       end
+     end
+     
+  end
+end

data/lib/garden_rows.rb

@@ -0,0 +1,94 @@
+class Garden
+  
+  # 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,@pid,grow_block)
+  end
+  
+  # Author:: lp (mailto:lp@spiralix.org)
+  # Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+  # :title:Rows
+  
+  class Rows
+    require 'toolshed'
+    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
+    # * _garden_pid_ = the parent Garden's pid, for loopback communication purpose
+    # === Example
+    #  rows = Rows.new(4,2) { grow_block }
+    
+    def initialize(rows,init_timeout,garden_pid,gardener_block)
+      @pids = []
+      rows.times do
+        @pids << fork do
+          @seed_all = false
+          set_my_socket_as_a(:row,garden_pid)
+          t1 = Thread.new do
+            gardener_block.call
+          end
+
+          t2 = Thread.new do
+            loop do
+              if $seed.nil?
+                command, data = socket_duplex(:row,my_socket_path)
+                if command == :quit
+                  pid = Process.pid
+                  socket_send(:close,{:level => :seed, :pid => pid})
+                  exit
+                end
+                $seed = data
+                if $seed.nil?
+                  command, data, client_socket_path = socket_recv
+                  case command
+                  when :sprout
+                    $seed = data
+                  when :seed_all
+                    @seed_all = true
+                    $seed = {:id => Process.pid, :seed => data}
+                  when :init
+                    $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
+                    socket_send(:init_crop,$init)
+                  end
+                end
+              elsif ! $seed[:success].nil?
+                if @seed_all
+                  socket_send(:seed_all_crop,$seed)
+                  @seed_all = false
+                else
+                  socket_send(:crop,$seed)
+                end
+                $seed = nil;
+              else
+                t1.run
+              end
+            end
+          end
+          t2.join
+        end
+      end
+      sleep init_timeout
+    end
+  end
+  
+end

data/lib/gardener.rb

@@ -23,16 +23,16 @@ class Gardener
   # As part of the Abundance lib, Gardener is not initialized directly, 
   # but rather through Abundance.gardener.
   # === Parameters
-  # * :wheelbarrow = the socket size for the garden communication packets, in bytes, range from 1024 to 8192, defaults to 8192
+  # * :wheelbarrow = the socket size for the garden communication packets, in bytes, up to 8192, defaults to 124
   # * :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({:wheelbarrow => 1024, :rows => 6, :init_timeout}) { your_special_garden function }
+  #  gardener = Gardener.new({:wheelbarrow => 124, :rows => 6, :init_timeout}) { your_special_garden function }
   # 
   
   def initialize(options,gardener_block)
-    Toolshed::block_size = if options[:wheelbarrow].nil? || options[:wheelbarrow] > 8192 then 8192
-                          elsif options[:wheelbarrow] < 1024 then 1024
+    Toolshed::block_size = if options[:wheelbarrow].nil? then 124
+                          elsif options[:wheelbarrow] > 8192 then 8192
                           else options[:wheelbarrow]
                           end
     

data/test/tc_high_api.rb

@@ -34,7 +34,7 @@ class TestHighAPI < Test::Unit::TestCase
   private
   
   def set_gardener
-    @g = Abundance.gardener(:wheelbarrow => 8192, :rows => @rows, :init_timeout => 3) do
+    @g = Abundance.gardener(:rows => @rows, :init_timeout => 3) do
       Abundance.init_status(true,Process.pid)
       Abundance.grow do |seed|
         seed.crop(true, "gardener: #{seed.sprout}")

data/test/tc_multi_gardener.rb

@@ -19,7 +19,7 @@ class TestHighAPI < Test::Unit::TestCase
   private
   
   def set_gardener1
-    @g1 = Abundance.gardener(:wheelbarrow => 128, :rows => @rows, :init_timeout => 3) do
+    @g1 = Abundance.gardener(:rows => @rows, :init_timeout => 3) do
       Abundance.init_status(true,Process.pid)
       Abundance.grow do |seed|
         seed.crop(true, "gardener1: #{seed.sprout}")
@@ -28,7 +28,7 @@ class TestHighAPI < Test::Unit::TestCase
   end
   
   def set_gardener2
-    @g2 = Abundance.gardener(:wheelbarrow => 128, :rows => @rows, :init_timeout => 3) do
+    @g2 = Abundance.gardener(:rows => @rows, :init_timeout => 3) do
       Abundance.init_status(true,Process.pid)
       Abundance.grow do |seed|
         seed.crop(true, "gardener2: #{seed.sprout}")
@@ -43,6 +43,7 @@ class TestHighAPI < Test::Unit::TestCase
     answer1 = @g1.harvest(id1)
     answer2 = @g2.harvest(id2)
     
+    assert(answer1[:message] != answer2[:message])
     assert(answer1[:message] =~ /gardener1.*/)
     assert(answer2[:message] =~ /gardener2.*/)
   end

data/test/tc_robustness.rb

@@ -5,7 +5,7 @@ require 'abundance'
 class TestHighAPI < Test::Unit::TestCase
   
   def test_abundance_robust
-    @seed_size = 8192
+    @seed_size = 124
     @rows = 8
     @init_timeout = 3
     hyper_gardener

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: abundance
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors: 
 - Louis-Philippe Perron
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-12 00:00:00 -05:00
+date: 2009-01-13 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,8 @@ extra_rdoc_files: []
 files: 
 - lib/abundance.rb
 - lib/garden.rb
+- lib/garden_cycles.rb
+- lib/garden_rows.rb
 - lib/gardener.rb
 - lib/seed.rb
 - lib/toolshed.rb