abundance 1.2.6 → 1.3.0

data/lib/garden.rb

@@ -38,25 +38,15 @@ class Garden
       set_my_socket_as_a(:garden)
       
       loop do
-        seed_if_row_available
-        
-        message_block = socket_recv
-        case message_block[0]
-        when :seed
-          place_seed_in_queue(message_block)
-        when :row
-          this_row_is_available(message_block)  
-        when :crop
-          save_crop_for(message_block)
-        when :growth
-          report_growth(message_block)
-        when :harvest
-          harvest_some(message_block)
-        when :close
-          close_all(message_block)
-        else
-          message_block[2] = false
-          socket_send(message_block)
+				route_message_blocks
+				seed_available_rows
+				
+        ready = select(@reader[:sockets],@writer[:sockets],nil,10)
+        unless ready.nil?
+          readable, writable = ready[0..1]
+
+          crop_writable(writable) if writable
+          sprout_readable(readable) if readable
         end
       end
     end

data/lib/garden_cycles.rb

@@ -10,46 +10,98 @@ class Garden
     def set_my_containers
       @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 = []
+      @harvest_queue = []; @waiting_rows = []; @message_block_queue = []
+      @seeds = []; @sprouts = []; @crops = []; @id = 0
     end
     
-    def seed_if_row_available
-       catch :fill_rows do
-         loop do
-           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_message_block[4][:row_done] << row_socket_path
-             else
-               @waiting_rows << row_socket_path
-             end
-           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_message_block[4][:row_done] << row_socket_path
-             else
-               @waiting_rows << row_socket_path
-             end
-           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               
-         end
-       end
+    def sprout_readable(readable)
+      readable.each do |i_socket|
+        if i_socket == @my_socket
+          add_readable(i_socket)
+        else
+          readable_main(i_socket)
+        end
+      end
+    end
+    
+    def crop_writable(writable)
+      writable.each do |o_socket|
+        if @writer[:buffer][o_socket.to_s] == '' || @writer[:buffer][o_socket.to_s] == nil
+          remove_writable(o_socket)
+        else
+          write_raw(o_socket)
+        end
+      end
+    end
+    
+    def route_message_blocks
+      until @message_block_queue.empty?
+        message_block = @message_block_queue.shift
+        case message_block[0]
+        when :seed
+          place_seed_in_queue(message_block)
+        when :row
+          this_row_is_available(message_block)  
+        when :crop
+          save_crop_for(message_block)
+        when :growth
+          report_growth(message_block)
+        when :harvest
+          harvest_some(message_block)
+        when :close
+          close_all(message_block)
+        else
+          message_block[2] = false
+          add_writable(message_block)
+        end
+      end
+    end
+
+		def seed_available_rows
+        catch :fill_rows do
+          loop do
+						throw :fill_rows if @waiting_rows.empty?
+            if @seed_all_message_block && @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 )
+                add_writable([:seed,:all,@seed_all_message_block[2],row_socket_path])
+                @seed_all_message_block[4][:row_done] << row_socket_path
+              else
+                @waiting_rows << row_socket_path
+              end
+            elsif @init_message_block && @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 )
+                add_writable([:seed,:init,'init_status',row_socket_path])
+                @init_message_block[4][:row_done] << row_socket_path
+              else
+                @waiting_rows << row_socket_path
+              end
+            elsif ! @seeds.empty?
+              seed = @seeds.shift; @sprouts[seed[:id]] = seed
+              add_writable([:seed,:sprout,seed,@waiting_rows.shift])
+            elsif @close_message_block && ! @waiting_rows.empty?
+              add_writable([:seed,:quit,nil,@waiting_rows.shift])
+            else
+              throw :fill_rows
+            end               
+          end
+        end
+      end
+     
+     private
+     
+     def readable_main(i_socket)
+       message_block = read_message_block(i_socket)
+       @message_block_queue << message_block
+       @reader[:sockets].delete(i_socket) if @reader[:sockets].include?(i_socket)
      end
      
      def place_seed_in_queue(message_block)
        case message_block[1]
        when :one
          @id += 1; @seeds << {:id => @id , :seed => message_block[2]}
-         message_block[2] = @id; socket_send(message_block)
+         message_block[2] = @id; add_writable(message_block)
        else
          @seed_all_message_block = Array.new(message_block)
          @seed_all_message_block[4] = {:row_done => [], :crops => []}
@@ -72,7 +124,7 @@ class Garden
          seed = @seeds.shift; @sprouts[seed[:id]] = seed
          message_block = [:row, :sprout, seed, message_block[3]]
        end
-       socket_send(message_block)
+       add_writable(message_block)
      end
      
      def save_crop_for(message_block)
@@ -81,23 +133,23 @@ class Garden
          @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]]]) 
+           add_writable(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]])
+           add_writable(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
+           add_writable(@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
+           add_writable(@init_message_block.compact); @init_message_block = nil
          end
        end
      end
@@ -117,7 +169,7 @@ class Garden
        else
          message_block[2] = false
        end
-       socket_send(message_block)
+       add_writable(message_block)
      end
      
      def harvest_some(message_block)
@@ -125,26 +177,26 @@ class Garden
        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]])
+             add_writable(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)
+           message_block[2] = false; add_writable(message_block)
          end
        when :all
          message_block[2] = {:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}
-         socket_send(message_block)
+         add_writable(message_block)
        when :seed
-         message_block[2] = @seeds; socket_send(message_block)
+         message_block[2] = @seeds; add_writable(message_block)
        when :sprout
-         message_block[2] = @sprouts.compact; socket_send(message_block)
+         message_block[2] = @sprouts.compact; add_writable(message_block)
        when :crop
-         message_block[2] = @crops.compact; socket_send(message_block); @crops.clear
+         message_block[2] = @crops.compact; add_writable(message_block); @crops.clear
        when :full_crop
          if @seeds.compact.empty? && @sprouts.compact.empty?
-           message_block[2] = @crops.compact; socket_send(message_block); @crops.clear
+           message_block[2] = @crops.compact; add_writable(message_block); @crops.clear
          else
            @full_crop_message_block = Array.new(message_block)
          end
@@ -152,7 +204,7 @@ class Garden
          @init_message_block = Array.new(message_block)
          @init_message_block[4] = {:row_done => [], :crops => []}
        else
-         message_block[2] = false; socket_send(message_block)
+         message_block[2] = false; add_writable(message_block)
        end
      end
            

data/lib/rows.rb

@@ -52,7 +52,7 @@ class Garden
           t2 = Thread.new do
             loop do
               if $seed.nil?
-                message_block = socket_duplex([:row,:row,my_socket_path,@garden_path])
+                message_block = socket_duplex([:row,:row,@my_socket_path,@garden_path])
                 case message_block[1]
                 when :sprout
                   sprout(message_block)

data/lib/rows_paths.rb

@@ -22,7 +22,7 @@ class Garden
       end
       
       def init
-        $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
+        $init = {:seed => 'init_status', :success => false, :message => 'No Init Message', :id => Process.pid} if $init.nil?
         socket_send([:crop,:init,$init,@garden_path])
       end
       

data/lib/toolshed.rb

@@ -32,10 +32,12 @@ module Toolshed
     case role
     when :garden
       set_my_socket(Process.pid.to_s)
+      @reader = {:sockets => [@my_socket], :buffer => {}}
+      @writer = {:sockets => [], :buffer => {}}
     when :gardener
       set_garden_path(garden_pid)
       set_my_socket(Process.pid.to_s + Time.now.to_i.to_s + rand(10000).to_s)
-    else
+    when :row
       set_garden_path(garden_pid)
       set_my_socket(Process.pid.to_s)
     end
@@ -63,12 +65,43 @@ module Toolshed
   # * _server_socket_path_ = a UNIXServer socket path for the packets to be sent to
   def socket_duplex(message_block)
     send_block(message_block)
-    Marshal.load(recv_whole_block)
+		client = @my_socket.accept
+    recv_whole_block(client)
   end
   
   # The +socket_recv+ method calls _accept_ on a UNIXServer socket, receives all the packets from a UNIXSocket sender, join the packets back as the original block message.
   def socket_recv
-    Marshal.load(recv_whole_block)
+		client = @my_socket.accept
+    recv_whole_block(client)
+  end
+  
+  def add_readable(socket)
+    client = socket.accept
+    @reader[:sockets] << client
+  end
+  
+  def add_writable(message_block)
+    client = UNIXSocket.open(message_block[3])
+    @writer[:sockets] << client
+    @writer[:buffer][client.to_s] = Marshal.dump(message_block)
+  end
+  
+  def remove_writable(client)
+    @writer[:sockets].delete(client)
+    @writer[:buffer].delete(client.to_s)
+    client.close
+  end
+  
+  def read_raw(client)
+    client.recvfrom(@@block_size)[0]
+  end
+  
+  def write_raw(client)
+    client.send(@writer[:buffer][client.to_s].slice!(0..@@block_size-1),0)
+  end
+  
+  def read_message_block(client)
+    recv_whole_block(client)
   end
     
   private 
@@ -96,10 +129,28 @@ module Toolshed
     @garden_path = socket_path(garden_pid.to_s)
   end
   
+  # The +send_block+ method sends a block to a server socket.
+  # === Parameters
+  # * _command_ = command part of the sent packet
+  # * _data_ = data part of the sent packet
+  # * _server_socket_path_ = the UNIXServer socket path to send to 
+  def send_block(message_block)
+    begin
+      client = UNIXSocket.open(message_block[3])
+      block = Marshal.dump(message_block[0..2] + [@my_socket_path])
+      client.send(block,0)
+      client.close
+    rescue Errno::EADDRINUSE
+      retry
+    rescue Errno::ECONNREFUSED
+      retry
+    end
+  end
+  
   # The +recv_whole_block+ method loops receiving a sent block as packets, rebuilding the whole block and joining it.
-  def recv_whole_block
+  def recv_whole_block(client)
+    block = String.new
     begin
-      client = @my_socket.accept; block = []
       catch :whole_block do
         loop do
           packet = client.recvfrom(@@block_size)[0]
@@ -110,26 +161,10 @@ module Toolshed
           end
         end
       end
-      return block.join
-    rescue Errno::EADDRINUSE
-      retry
-    end
-  end
-  
-  # The +send_block+ method sends a block to a server socket.
-  # === Parameters
-  # * _command_ = command part of the sent packet
-  # * _data_ = data part of the sent packet
-  # * _server_socket_path_ = the UNIXServer socket path to send to 
-  def send_block(message_block)
-    begin
-      client = UNIXSocket.open(message_block[3])
-      client.send(Marshal.dump(message_block[0..2] + [@my_socket_path]),0)
-      client.close
+      message_block =  Marshal.load(block)
+      return message_block
     rescue Errno::EADDRINUSE
       retry
-    rescue Errno::ECONNREFUSED
-      retry
     end
   end
       

data/test/tc_burst.rb

@@ -2,7 +2,7 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require 'test/unit'
 require 'abundance'
 
-class TestHighAPI < Test::Unit::TestCase
+class TestBurst < Test::Unit::TestCase
   
   def test_burst1
     check_init

data/test/tc_high_api.rb

@@ -24,11 +24,11 @@ class TestHighAPI < Test::Unit::TestCase
   
   def teardown
     final = @g.close
-    assert_kind_of(Hash,final)
-    assert_equal(3,final.size)
-    assert_not_nil(final[:seeds])
-    assert_not_nil(final[:sprouts])
-    assert_not_nil(final[:crops])
+    assert_kind_of(Hash,final,"close method didn't return a Hash, it returned: #{final.inspect}")
+    assert_equal(3,final.size,"Hash returned on close has wrong size, here it is: #{final.inspect}")
+    assert_not_nil(final[:seeds],"close Hash has Nil value for :seeds instead of an Array")
+    assert_not_nil(final[:sprouts],"close Hash has Nil value for :sprouts instead of an Array")
+    assert_not_nil(final[:crops],"close Hash has Nil value for :crops instead of an Array")
   end
   
   private
@@ -37,7 +37,11 @@ class TestHighAPI < Test::Unit::TestCase
     @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}")
+        if seed.sprout.nil?
+          seed.crop(false, "gardener has no seed")
+        else
+          seed.crop(true, "gardener: #{seed.sprout}")
+        end
       end      
     end
   end
@@ -45,7 +49,8 @@ class TestHighAPI < Test::Unit::TestCase
   def reality_check
     assert_instance_of(Gardener,@g)
     
-    check_init          
+    check_init
+    check_false     
     check_seed_harvest      # leaves no crops in the queue
     check_full_harvest         # also leaves no crops in the queue
     check_deep_harvest    # may leave crap behind, so needs to come last of the harvest
@@ -56,25 +61,31 @@ class TestHighAPI < Test::Unit::TestCase
   
   def check_init
     @g.init_status.each do |init|
-      assert_not_nil(init[:message])
-      assert_not_nil(init[:success])
-      assert_not_nil(init[:pid])
+      assert_not_nil(init[:message],"init :message value is Nil instead of String")
+      assert_not_nil(init[:success],"init :success value is Nil instead of True || False")
+      assert_not_nil(init[:pid],"init :pid value is Nil instead of Numeric")
     
-      assert_not_equal(Process.pid,init[:message])
-      assert_equal(init[:message],init[:pid])
+      assert_not_equal(Process.pid,init[:message],"init has same pid than test process, something has gone wrong in the forking...")
+      assert_equal(init[:message],init[:pid],"init :pid should be the row pid, it isn't")
     end
   end
   
+  def check_false
+    id = @g.seed(nil)
+    answer = @g.harvest(:one,id)
+    assert_equal(false,answer[:success],"failed returning a seed for which :success value was false")
+  end
+  
   def check_seed_harvest
     id = @g.seed(Process.pid)
-    assert_kind_of(Integer,id)
+    assert_kind_of(Integer,id,"seed method failed returning and Integer")
     
     answer = @g.harvest(:one,id)
-    assert_kind_of(Hash,answer)
-    assert_equal(Process.pid,answer[:seed])
-    assert_equal(id,answer[:id])
-    assert_equal(true,answer[:success])
-    assert_equal("gardener: #{Process.pid}",answer[:message])
+    assert_kind_of(Hash,answer,"harvest :one method failed to return a seed Hash, got #{answer.inspect} instead.")
+    assert_equal(Process.pid,answer[:seed], "harvesting showed a problem with seeding flow, seed[:seed] had wrong return value")
+    assert_equal(id,answer[:id], "harvesting showed a problem with seeding flow, seed[:id] had wrong return value")
+    assert_equal(true,answer[:success], "harvesting showed a problem with seeding flow, seed[:success] had wrong return value")
+    assert_equal("gardener: #{Process.pid}",answer[:message], "harvesting showed a problem with seeding flow, seed[:message] had wrong return value")
   end
   
   def check_full_harvest
@@ -83,7 +94,7 @@ class TestHighAPI < Test::Unit::TestCase
       queue_items[num] = @g.seed(num)
     end
     full_crop = @g.harvest(:full_crop)
-    assert_equal(25,full_crop.size)
+    assert_equal(25,full_crop.size, "a :full_crop harvest has shown some seeds were lost during processing")
     results = []
     queue_items.each do |num,id|
       success = false
@@ -92,20 +103,20 @@ class TestHighAPI < Test::Unit::TestCase
       end
       results << success
     end
-    assert(results[0] == true && results.uniq.size == 1)
+    assert(results[0] == true && results.uniq.size == 1, "a :full_crop harvest has shown processing to be inconsistent amongst rows")
   end
   
   def check_growth
     progress = @g.growth(:progress)
-    assert_kind_of(String,progress)
-    assert(progress.to_f >= 0 && progress.to_f <= 1)
+    assert_kind_of(String,progress, "the growth :progress method doesn't return proper value")
+    assert(progress.to_f >= 0 && progress.to_f <= 1, "the growth :progress method doesn't return a value between 0 and 1")
     
     seeds_growth = @g.growth(:seed)
-    assert_kind_of(Integer,seeds_growth)
+    assert_kind_of(Integer,seeds_growth, "the growth :seed method doesn't return proper value")
     sprouts_growth = @g.growth(:sprout)
-    assert_kind_of(Integer,sprouts_growth)
+    assert_kind_of(Integer,sprouts_growth, "the growth :sprout method doesn't return proper value")
     crops_growth = @g.growth(:crop)
-    assert_kind_of(Integer,crops_growth)
+    assert_kind_of(Integer,crops_growth, "the growth :crop method doesn't return proper value")
   end
   
   def check_deep_harvest
@@ -115,11 +126,11 @@ class TestHighAPI < Test::Unit::TestCase
     end
     
     all = @g.harvest(:all)
-    assert_kind_of(Hash,all)
-    assert_equal(25,all[:seeds].size + all[:sprouts].size + all[:crops].size)
-    seeds_harvest = @g.harvest(:seed); assert_kind_of(Array,seeds_harvest)
-    sprouts_harvest = @g.harvest(:sprout); assert_kind_of(Array,sprouts_harvest)
-    crops_harvest = @g.harvest(:crop); assert_kind_of(Array,crops_harvest)
+    assert_kind_of(Hash,all, "the harvest :all method doesn't return a Hash as supposed")
+    assert_equal(25,all[:seeds].size + all[:sprouts].size + all[:crops].size, "the harvest :all method returns a total of items not coherent with amount of seeded items")
+    seeds_harvest = @g.harvest(:seed); assert_kind_of(Array,seeds_harvest, "the harvest :seed method doesn't return an Array as supposed")
+    sprouts_harvest = @g.harvest(:sprout); assert_kind_of(Array,sprouts_harvest, "the harvest :sprout method doesn't return an Array as supposed")
+    crops_harvest = @g.harvest(:crop); assert_kind_of(Array,crops_harvest, "the harvest :crop method doesn't return an Array as supposed")
     results = []
     queue_items.each do |num,id|
       success = false
@@ -134,14 +145,14 @@ class TestHighAPI < Test::Unit::TestCase
       end
       results << success
     end
-    assert(results[0] == true && results.uniq.size == 1)
+    assert(results[0] == true && results.uniq.size == 1, "the harvest :all method has shown processing to be inconsistent amongst rows")
   end
   
   def check_seed_all
     all = @g.seed_all("all")
-    assert_equal(@rows,all.size)
+    assert_equal(@rows,all.size, "the seed_all method has missed some rows in its seeding, harvesting, or both")
     all.map! { |seed| seed[:message] == "gardener: all" }
-    assert( all.uniq.size == 1 && all[0] == true )
+    assert( all.uniq.size == 1 && all[0] == true, "the seed_all method shows an inconsistency amongst row processing")
   end
   
 end

data/test/tc_multi_gardener.rb

@@ -2,7 +2,7 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require 'test/unit'
 require 'abundance'
 
-class TestHighAPI < Test::Unit::TestCase
+class TestMultiGardener < Test::Unit::TestCase
   
   def test_two_gardeners
     @rows = 2
@@ -43,9 +43,11 @@ class TestHighAPI < Test::Unit::TestCase
     answer1 = @g1.harvest(:one,id1)
     answer2 = @g2.harvest(:one,id2)
     
-    assert(answer1[:message] != answer2[:message])
-    assert(answer1[:message] =~ /gardener1.*/)
-    assert(answer2[:message] =~ /gardener2.*/)
+    assert_not_equal(answer1[:message],answer2[:message], "trouble getting two gardeners have their own answers... maybe it only one after all!")
+    assert_match(/gardener1.*/, answer1[:message], "looks like one of the gardener has got its answer wrong")
+    assert_match(/gardener2.*/, answer2[:message], "looks like one of the gardener has got its answer wrong")
+    assert_no_match(/gardener2.*/, answer1[:message], "looks like the gardeners are having trouble keeping their identities, one reference the other")
+    assert_no_match(/gardener1.*/, answer2[:message], "looks like the gardeners are having trouble keeping their identities, one reference the other")
   end
   
 end

data/test/tc_robustness.rb

@@ -2,7 +2,7 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require 'test/unit'
 require 'abundance'
 
-class TestHighAPI < Test::Unit::TestCase
+class TestRobustness < Test::Unit::TestCase
   
   def test_abundance_robust
     @seed_size = 124

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: abundance
 version: !ruby/object:Gem::Version 
-  version: 1.2.6
+  version: 1.3.0
 platform: ruby
 authors: 
 - Louis-Philippe Perron
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-18 00:00:00 -05:00
+date: 2009-01-24 00:00:00 -05:00
 default_executable: 
 dependencies: []