abundance 1.2.4 → 1.2.5

data/lib/abundance.rb

@@ -9,7 +9,7 @@
 # 
 # And not:
 # * a replacement for Thread.new invocations
-# * a replacement for Thread friendly programming languages like Erlang
+# * a replacement for concurrent programming languages like Erlang
 # 
 # Its initial implementation uses:
 # * pure ruby
@@ -71,8 +71,8 @@ class Abundance
   #  id1 = gardener.seed('command1')
   #  id2 = gardener.seed('command2')
   # 
-  #  result1 = gardener.harvest(id1)
-  #  result2 = gardener.harvest(id2)
+  #  result1 = gardener.harvest(:one,id1)
+  #  result2 = gardener.harvest(:one,id2)
   # 
   #  # with many more seeds over here
   # 

data/lib/garden.rb

@@ -15,7 +15,7 @@
 # :title:Garden
 
 class Garden
-  require 'garden_rows'
+  require 'rows'
   require 'garden_cycles'
   include Cycles
   require 'toolshed'
@@ -52,12 +52,6 @@ class Garden
           report_growth(message_block)
         when :harvest
           harvest_some(message_block)
-        when :init
-          ask_for_init_status(message_block)
-        when :init_crop
-          answer_init_status(message_block)
-        when :seed_all_crop
-          special_crop_seed_all(message_block)
         when :close
           close_all(message_block)
         else

data/lib/garden_cycles.rb

@@ -1,43 +1,43 @@
 class Garden
+  # The Cycles module is a set of method used by the Garden's fork.
+  # You will not need to use these methods unless you plan on refactoring the 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_message_block = nil; @init_all_crop = []
-      @harvest = []; @rows_socket_paths = []; @init_done = []; @seed_all_done = []; @seed_all_crop = []
-      @seeds = []; @sprouts = []; @crops = []; @id = 0
+      @close_message_block = nil; @full_crop_message_block = nil
+      @init_message_block = nil; @seed_all_message_block = nil
+      @harvest_queue = []; @waiting_rows = []; @id = 0
+      @seeds = []; @sprouts = []; @crops = []
     end
     
     def seed_if_row_available
        catch :fill_rows do
          loop do
-           if ! @seed_all_message_block.nil? && ! @rows_socket_paths.empty? && @seed_all_done.size != @seed_all_message_block[1]
-             row_socket_path = @rows_socket_paths.shift
-             unless @seed_all_done.include?( row_socket_path )
+           if @seed_all_message_block && ! @waiting_rows.empty? && @seed_all_message_block[4][:row_done].size != @seed_all_message_block[1]
+             row_socket_path = @waiting_rows.shift
+             unless @seed_all_message_block[4][:row_done].include?( row_socket_path )
                socket_send([:seed,:all,@seed_all_message_block[2],row_socket_path])
-               @seed_all_done << row_socket_path
+               @seed_all_message_block[4][:row_done] << row_socket_path
              else
-               @rows_socket_paths << row_socket_path
+               @waiting_rows << 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 )
+           elsif @init_message_block && ! @waiting_rows.empty? && @init_message_block[4][:row_done].size != @init_message_block[2]
+             row_socket_path = @waiting_rows.shift
+             unless @init_message_block[4][:row_done].include?( row_socket_path )
                socket_send([:seed,:init,'init_status',row_socket_path])
-               @init_done << row_socket_path
+               @init_message_block[4][:row_done] << row_socket_path
              else
-               @rows_socket_paths << row_socket_path
+               @waiting_rows << 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([:seed,:sprout,seed,row_socket_path])
-           elsif @quit && ! @rows_socket_paths.empty?
-             seed = nil
-             row_socket_path = @rows_socket_paths.shift
-             socket_send([:seed,:quit,seed,row_socket_path])
+           elsif ! @seeds.empty? && ! @waiting_rows.empty?
+             seed = @seeds.shift; @sprouts[seed[:id]] = seed
+             socket_send([:seed,:sprout,seed,@waiting_rows.shift])
+           elsif @close_message_block && ! @waiting_rows.empty?
+             socket_send([:seed,:quit,nil,@waiting_rows.shift])
            else
              throw :fill_rows
            end               
@@ -49,23 +49,24 @@ class Garden
        case message_block[1]
        when :one
          @id += 1; @seeds << {:id => @id , :seed => message_block[2]}
-         socket_send([message_block[0],:garden,@id,message_block[3]])
+         message_block[2] = @id; socket_send(message_block)
        else
          @seed_all_message_block = Array.new(message_block)
+         @seed_all_message_block[4] = {:row_done => [], :crops => []}
        end
      end
      
      def this_row_is_available(message_block)
-       if @quit
+       if @close_message_block
          message_block = [:row, :quit, nil, message_block[3]]
-       elsif ! @seed_all_message_block.nil? && @seed_all_done.size != @seed_all_message_block[1] && ! @seed_all_done.include?( message_block[3] )
+       elsif @seed_all_message_block && @seed_all_message_block[4][:row_done].size != @seed_all_message_block[1] && ! @seed_all_message_block[4][:row_done].include?( message_block[3] )
          message_block = [:row, :all, @seed_all_message_block[2], message_block[3]]
-         @seed_all_done << message_block[3]
-       elsif ! @do_init.nil? && @init_done.size != @do_init && ! @init_done.include?( message_block[3] )
+         @seed_all_message_block[4][:row_done] << message_block[3]
+       elsif @init_message_block && @init_message_block[4][:row_done].size != @init_message_block[2] && ! @init_message_block[4][:row_done].include?( message_block[3] )
          message_block = [:row, :init, 'init_status', message_block[3]]
-         @init_done << message_block[3]
+         @init_message_block[4][:row_done] << message_block[3]
        elsif @seeds.empty?
-         @rows_socket_paths << message_block[2]
+         @waiting_rows << message_block[2]
          message_block = [:row, :wait, nil, message_block[3]]
        else
          seed = @seeds.shift; @sprouts[seed[:id]] = seed
@@ -75,97 +76,95 @@ class Garden
      end
      
      def save_crop_for(message_block)
-       @sprouts[message_block[2][:id]] = nil
-       @crops[message_block[2][:id]] = message_block[2]
-       if @harvest[message_block[2][:id]]
-         socket_send([message_block[0],:garden,message_block[2], @harvest[message_block[2][:id]][:client_socket_path]]) 
-         @crops[message_block[2][:id]] = @harvest[message_block[2][:id]] = nil
-       elsif @full_crop && @seeds.compact.empty? && @sprouts.compact.empty?
-         socket_send([message_block[0],:garden,@crops.compact,@mem_client_socket_path])
-         @crops.clear; @full_crop = false
+       case message_block[1]
+       when :harvest
+         @sprouts[message_block[2][:id]] = nil
+         @crops[message_block[2][:id]] = message_block[2]
+         if @harvest_queue[message_block[2][:id]]
+           socket_send(message_block[0..2]+[@harvest_queue[message_block[2][:id]]]) 
+           @crops[message_block[2][:id]] = @harvest_queue[message_block[2][:id]] = nil
+         elsif @full_crop_message_block && @seeds.compact.empty? && @sprouts.compact.empty?
+           socket_send(message_block[0..1]+[@crops.compact,@full_crop_message_block[3]])
+           @crops.clear; @full_crop_message_block = nil
+         end
+       when :seed_all
+         @seed_all_message_block[4][:crops] << message_block[2]
+         if @seed_all_message_block[4][:crops].size == @seed_all_message_block[1]
+           @seed_all_message_block[2] = @seed_all_message_block[4][:crops]; @seed_all_message_block[4] = nil
+           socket_send(@seed_all_message_block.compact); @seed_all_message_block = nil
+         end
+       when :init
+         @init_message_block[4][:crops] << message_block[2]
+         if @init_message_block[4][:crops].size == @init_message_block[2]
+           @init_message_block[2] = @init_message_block[4][:crops]; @init_message_block[4] = nil
+           socket_send(@init_message_block.compact); @init_message_block = nil
+         end
        end
      end
      
      def report_growth(message_block)
-       case message_block[2]
+       case message_block[1]
        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([message_block[0],:garden,progress,message_block[3]])
+         message_block[2] = progress
        when :seed
-         socket_send([message_block[0],:garden,@seeds.size,message_block[3]])
+         message_block[2] = @seeds.size
        when :sprout
-         socket_send([message_block[0],:garden,@sprouts.compact.size,message_block[3]])
+         message_block[2] = @sprouts.compact.size
        when :crop
-         socket_send([message_block[0],:garden,@crops.size,message_block[3]])
+         message_block[2] = @crops.size
        else
-         socket_send([message_block[0],:garden,false,message_block[3]])
+         message_block[2] = false
        end
+       socket_send(message_block)
      end
      
      def harvest_some(message_block)
-       case message_block[2]
+       case message_block[1]
+       when :one
+         unless message_block[2].nil?
+           if @crops[message_block[2]]
+             socket_send(message_block[0..1]+[@crops[message_block[2]],message_block[3]])
+             @crops[message_block[2]] = nil
+           else
+             @harvest_queue[message_block[2]] = message_block[3]
+           end
+         else
+           message_block[2] = false; socket_send(message_block)
+         end
        when :all
-         socket_send([message_block[0],:garden,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact},message_block[3]])
+         message_block[2] = {:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}
+         socket_send(message_block)
        when :seed
-         socket_send([message_block[0],:garden,@seeds,message_block[3]])
+         message_block[2] = @seeds; socket_send(message_block)
        when :sprout
-         socket_send([message_block[0],:garden,@sprouts.compact,message_block[3]])
+         message_block[2] = @sprouts.compact; socket_send(message_block)
        when :crop
-         socket_send([message_block[0],:garden,@crops.compact,message_block[3]])
-         @crops.clear
+         message_block[2] = @crops.compact; socket_send(message_block); @crops.clear
        when :full_crop
          if @seeds.compact.empty? && @sprouts.compact.empty?
-           socket_send([message_block[0],:garden,@crops.compact,message_block[3]])
-           @crops.clear
+           message_block[2] = @crops.compact; socket_send(message_block); @crops.clear
          else
-           @full_crop = true
-           @mem_client_socket_path = message_block[3]
+           @full_crop_message_block = Array.new(message_block)
          end
+       when :init
+         @init_message_block = Array.new(message_block)
+         @init_message_block[4] = {:row_done => [], :crops => []}
        else
-         if message_block[2].is_a? Integer
-           if @crops[message_block[2]]
-             socket_send([message_block[0],:garden,@crops[message_block[2]],message_block[3]])
-             @crops[message_block[2]] = nil
-           else
-             @harvest[message_block[2]] = {:client_socket_path => message_block[3]}
-           end
-         else
-           socket_send([message_block[0],:garden,false,message_block[3]])
-         end
+         message_block[2] = false; socket_send(message_block)
        end
      end
-     
-     def ask_for_init_status(message_block)
-       @do_init = message_block[2]
-       @init_return = {:client_socket_path => message_block[3]}
-     end
-     
-     def answer_init_status(message_block)
-       @init_all_crop << message_block[2]
-       if @init_all_crop.size == @do_init
-         socket_send([message_block[0],:garden,@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 special_crop_seed_all(message_block)
-       @seed_all_crop << message_block[2]
-       if @seed_all_crop.size == @seed_all_message_block[1]
-         socket_send([message_block[0],:garden,@seed_all_crop, @seed_all_message_block[3]])
-         @seed_all_message_block = nil; @seed_all_done = Array.new; @seed_all_crop = Array.new
-       end
-     end
-     
+           
      def close_all(message_block)
-       if message_block[2][:level] == :garden
-         @seeds_pid = message_block[2][:pid]
-         @quit = true
-         @mem_client_socket_path = message_block[3]
-       else
-         @seeds_pid.delete(message_block[2][:pid].to_i)
-         if @seeds_pid.empty?
-           socket_send([:close,:garden,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}, @mem_client_socket_path])
+       case message_block[1]
+       when :garden
+         @close_message_block = Array.new(message_block)
+       when :row
+         @close_message_block[2].delete(message_block[2].to_i)
+         if @close_message_block[2].empty?
+           @close_message_block[2] = {:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}
+           socket_send(@close_message_block)
            exit
          end
        end

data/lib/gardener.rb

@@ -48,7 +48,7 @@ class Gardener
   # === Example
   #   puts gardener.init_status.inspect   # => [{:message=>"init ok", :success=>true, :pid=>4760}, {:message=>"init failed", :success=>false, :pid=>4761}] 
   def init_status
-    message_block = socket_duplex([:init,:gardener,@garden_rows.pids.size,@garden_path])
+    message_block = socket_duplex([:harvest,:init,@garden_rows.pids.size,@garden_path])
     message_block[2].map! do |row|
       {:success => row[:success], :message => row[:message], :pid => row[:id]}
     end
@@ -92,8 +92,8 @@ class Gardener
   #  progress = gardener.growth(:progress)
   #  puts "progress is now #{progress}"  # => progress is now 0.75
   
-  def growth(data=:progress)
-    message_block = socket_duplex([:growth,:gardener,data,@garden_path])
+  def growth(option=:progress)
+    message_block = socket_duplex([:growth,option,nil,@garden_path])
     return message_block[2]
   end
   
@@ -101,18 +101,20 @@ class Gardener
   # It has two different behaviour on queue data, one for ripe elements where it removes them from crop array ( on _seedID_ and :crop invocations ),
   # for all other methods of invocation it leaves the queue intact.
   # === 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, _seedID_ is removed from crop array
+  # The option given as a symbol specifies the level of queue results you wish to get:
   # * :crop = return an array of seed for which process has completed, empties the crop array.
   # * :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
   # * :full_crop = wait for all seeds to be done processing, then returns as in :crop.
+  # * :one = return the result for a specific seed, if seed hasn't processed it wait until completed, _seed_id_ is removed from crop array
+  # When specifying :one as option, a seed ID is also required:
+  # * _seedID_ = the id as returned by the +seed+ method
   # === Example
-  #  seed1_result = gardener.harvest(id_seed_1)
+  #  seed1_result = gardener.harvest(:one,id_seed_1)
   
-  def harvest(data)
-    message_block = socket_duplex([:harvest,:gardener,data,@garden_path])
+  def harvest(option,seed_id=nil)
+    message_block = socket_duplex([:harvest,option,seed_id,@garden_path])
     return message_block[2]
   end
   
@@ -122,7 +124,7 @@ class Gardener
   #  final_harvest = gardener.close
   
   def close
-    message_block = socket_duplex([:close,:gardener,{:level => :garden, :pid => @garden_rows.pids},@garden_path])
+    message_block = socket_duplex([:close,:garden,@garden_rows.pids,@garden_path])
     return message_block[2]
   end
   

data/lib/{garden_rows.rb → rows.rb}

@@ -20,6 +20,8 @@ class Garden
   # :title:Rows
   
   class Rows
+    require 'rows_paths'
+    include Paths
     require 'toolshed'
     include Toolshed
     attr_reader :pids
@@ -42,7 +44,6 @@ class Garden
       @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
@@ -54,42 +55,28 @@ class Garden
                 message_block = socket_duplex([:row,:row,my_socket_path,@garden_path])
                 case message_block[1]
                 when :sprout
-                  $seed = message_block[2]
+                  sprout(message_block)
                 when :all
-                  @seed_all = true
-                  $seed = {:id => Process.pid, :seed => message_block[2]}
+                  all(message_block)
                 when :wait
                   message_block = socket_recv
                   case message_block[1]
                   when :sprout
-                    $seed = message_block[2]
+                    sprout(message_block)
                   when :all
-                    @seed_all = true
-                    $seed = {:id => Process.pid, :seed => message_block[2]}
+                    all(message_block)
                   when :init
-                    $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
-                    socket_send([:init_crop,:row,$init,@garden_path])
+                    init
                   when :quit
-                    pid = Process.pid
-                    socket_send([:close,:row,{:level => :seed, :pid => pid},@garden_path])
-                    exit
+                    quit
                   end
                 when :init
-                  $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
-                  socket_send([:init_crop,:row,$init,@garden_path])
+                  init
                 when :quit
-                  pid = Process.pid
-                  socket_send([:close,:row,{:level => :seed, :pid => pid},@garden_path])
-                  exit
+                  quit
                 end
-              elsif ! $seed[:success].nil?
-                if @seed_all
-                  socket_send([:seed_all_crop,:row,$seed,@garden_path])
-                  @seed_all = false
-                else
-                  socket_send([:crop,:row,$seed,@garden_path])
-                end
-                $seed = nil;
+              elsif $seed[:success]
+                crop
               else
                 t1.run
               end

data/lib/rows_paths.rb

@@ -0,0 +1,40 @@
+class Garden
+  class Rows
+    # The Paths module is a set of method used by the Rows's forks.
+    # You will not need to use these methods unless you plan on refactoring the Rows.
+    #
+    # Author:: lp (mailto:lp@spiralix.org)
+    # Copyright:: 2008 Louis-Philippe Perron - Released under the terms of the MIT license
+    # :title:Rows
+    module Paths
+      
+      def all(message_block)
+        $seed = {:id => Process.pid, :seed => message_block[2], :all => true}
+      end
+      
+      def crop
+        if $seed[:all]
+          socket_send([:crop,:seed_all,$seed,@garden_path])
+        else
+          socket_send([:crop,:harvest,$seed,@garden_path])
+        end
+        $seed = nil
+      end
+      
+      def init
+        $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
+        socket_send([:crop,:init,$init,@garden_path])
+      end
+      
+      def quit
+        socket_send([:close,:row,Process.pid,@garden_path])
+        exit
+      end
+      
+      def sprout(message_block)
+        $seed = message_block[2]
+      end
+      
+    end
+  end
+end

data/test/tc_high_api.rb

@@ -69,7 +69,7 @@ class TestHighAPI < Test::Unit::TestCase
     id = @g.seed(Process.pid)
     assert_kind_of(Integer,id)
     
-    answer = @g.harvest(id)
+    answer = @g.harvest(:one,id)
     assert_kind_of(Hash,answer)
     assert_equal(Process.pid,answer[:seed])
     assert_equal(id,answer[:id])

data/test/tc_multi_gardener.rb

@@ -40,8 +40,8 @@ class TestHighAPI < Test::Unit::TestCase
     id1 = @g1.seed(Process.pid)
     id2 = @g2.seed(Process.pid)
     
-    answer1 = @g1.harvest(id1)
-    answer2 = @g2.harvest(id2)
+    answer1 = @g1.harvest(:one,id1)
+    answer2 = @g2.harvest(:one,id2)
     
     assert(answer1[:message] != answer2[:message])
     assert(answer1[:message] =~ /gardener1.*/)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: abundance
 version: !ruby/object:Gem::Version 
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors: 
 - Louis-Philippe Perron
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-16 00:00:00 -05:00
+date: 2009-01-18 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -25,8 +25,9 @@ files:
 - lib/abundance.rb
 - lib/garden.rb
 - lib/garden_cycles.rb
-- lib/garden_rows.rb
 - lib/gardener.rb
+- lib/rows.rb
+- lib/rows_paths.rb
 - lib/seed.rb
 - lib/toolshed.rb
 - test/tc_burst.rb