abundance 1.2.2 → 1.2.3

data/lib/garden.rb

@@ -40,30 +40,31 @@ class Garden
       loop do
         seed_if_row_available
         
-        command, data, client_socket_path = socket_recv
-        case command
+        message_block = socket_recv
+        case message_block[0]
         when :seed
-          place_seed_in_queue(command,data,client_socket_path)
+          place_seed_in_queue(message_block)
         when :row
-          this_row_is_available(command,data,client_socket_path)  
+          this_row_is_available(message_block)  
         when :crop
-          save_crop_for(command,data,client_socket_path)
+          save_crop_for(message_block)
         when :growth
-          report_growth(command,data,client_socket_path)
+          report_growth(message_block)
         when :harvest
-          harvest_some(command,data,client_socket_path)
+          harvest_some(message_block)
         when :init
-          ask_for_init_status(command,data,client_socket_path)
+          ask_for_init_status(message_block)
         when :init_crop
-          answer_init_status(command,data,client_socket_path)
+          answer_init_status(message_block)
         when :seed_all
-          seed_for_all_rows(command,data,client_socket_path)
+          seed_for_all_rows(message_block)
         when :seed_all_crop
-          special_crop_seed_all(command,data,client_socket_path)
+          special_crop_seed_all(message_block)
         when :close
-          close_all(command,data,client_socket_path)
+          close_all(message_block)
         else
-          socket_send(command,false,client_socket_path)
+          message_block[2] = false
+          socket_send(message_block)
         end
       end
     end

data/lib/garden_cycles.rb

@@ -16,7 +16,7 @@ class Garden
            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)
+               socket_send(:seed_all,:garden,@seed_all[1],row_socket_path)
                @seed_all_done << row_socket_path
              else
                @rows_socket_paths << row_socket_path
@@ -24,7 +24,7 @@ class Garden
            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)
+               socket_send(:init,:garden,'init_status',row_socket_path)
                @init_done << row_socket_path
              else
                @rows_socket_paths << row_socket_path
@@ -33,11 +33,11 @@ class Garden
              seed = @seeds.shift
              @sprouts[seed[:id]] = seed
              row_socket_path = @rows_socket_paths.shift
-             socket_send(:sprout,seed,row_socket_path)
+             socket_send(:sprout,:garden,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)
+             socket_send(:quit,:garden,seed,row_socket_path)
            else
              throw :fill_rows
            end               
@@ -45,118 +45,119 @@ class Garden
        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)
+     def place_seed_in_queue(message_block)
+       @id += 1; @seeds << {:id => @id , :seed => message_block[2]}
+       socket_send(message_block[0],:garden,@id,message_block[3])
      end
      
-     def this_row_is_available(command,data,client_socket_path)
+     def this_row_is_available(message_block)
        if @quit
-         command = :quit; seed = nil
+         message_block[0] = :quit; seed = nil
        elsif @seeds.empty?
-         seed = nil; @rows_socket_paths << data
+         seed = nil; @rows_socket_paths << message_block[2]
        else
          seed = @seeds.shift; @sprouts[seed[:id]] = seed
        end
-       socket_send(command,seed,client_socket_path)
+       socket_send(message_block[0],:garden,seed,message_block[3])
      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
+     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(command,@crops.compact,@mem_client_socket_path)
+         socket_send(message_block[0],:garden,@crops.compact,@mem_client_socket_path)
          @crops.clear; @full_crop = false
        end
      end
      
-     def report_growth(command,data,client_socket_path)
-       case data
+     def report_growth(message_block)
+       case message_block[2]
        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)
+         socket_send(message_block[0],:garden,progress,message_block[3])
        when :seed
-         socket_send(command,@seeds.size,client_socket_path)
+         socket_send(message_block[0],:garden,@seeds.size,message_block[3])
        when :sprout
-         socket_send(command,@sprouts.compact.size,client_socket_path)
+         socket_send(message_block[0],:garden,@sprouts.compact.size,message_block[3])
        when :crop
-         socket_send(command,@crops.size,client_socket_path)
+         socket_send(message_block[0],:garden,@crops.size,message_block[3])
        else
-         socket_send(command,false,client_socket_path)
+         socket_send(message_block[0],:garden,false,message_block[3])
        end
      end
      
-     def harvest_some(command,data,client_socket_path)
-       case data
+     def harvest_some(message_block)
+       case message_block[2]
        when :all
-         socket_send(command,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact},client_socket_path)
+         socket_send(message_block[0],:garden,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact},message_block[3])
        when :seed
-         socket_send(command,@seeds,client_socket_path)
+         socket_send(message_block[0],:garden,@seeds,message_block[3])
        when :sprout
-         socket_send(command,@sprouts.compact,client_socket_path)
+         socket_send(message_block[0],:garden,@sprouts.compact,message_block[3])
        when :crop
-         socket_send(command,@crops.compact,client_socket_path)
+         socket_send(message_block[0],:garden,@crops.compact,message_block[3])
          @crops.clear
        when :full_crop
          if @seeds.compact.empty? && @sprouts.compact.empty?
-           socket_send(command,@crops.compact,client_socket_path)
+           socket_send(message_block[0],:garden,@crops.compact,message_block[3])
            @crops.clear
          else
            @full_crop = true
-           @mem_client_socket_path = client_socket_path
+           @mem_client_socket_path = message_block[3]
          end
        else
-         if data.is_a? Integer
-           if @crops[data]
-             socket_send(command,@crops[data],client_socket_path)
-             @crops[data] = nil
+         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[data] = {:client_socket_path => client_socket_path}
+             @harvest[message_block[2]] = {:client_socket_path => message_block[3]}
            end
          else
-           socket_send(command,false,client_socket_path)
+           socket_send(message_block[0],:garden,false,message_block[3])
          end
        end
      end
      
-     def ask_for_init_status(command,data,client_socket_path)
-       @do_init = data
-       @init_return = {:client_socket_path => client_socket_path}
+     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(command,data,client_socket_path)
-       @init_all_crop << data
+     def answer_init_status(message_block)
+       @init_all_crop << message_block[2]
        if @init_all_crop.size == @do_init
-         socket_send(command,@init_all_crop, @init_return[:client_socket_path])
+         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 seed_for_all_rows(command,data,client_socket_path)
-       @seed_all = data
-       @seed_all_return = {:client_socket_path => client_socket_path, :data => []}
+     def seed_for_all_rows(message_block)
+       @seed_all = message_block[2]
+       @seed_all_return = {:client_socket_path => message_block[3], :data => []}
      end
      
-     def special_crop_seed_all(command,data,client_socket_path)
-       @seed_all_crop << data
+     def special_crop_seed_all(message_block)
+       @seed_all_crop << message_block[2]
        if @seed_all_crop.size == @seed_all[0]
-         socket_send(command,@seed_all_crop, @seed_all_return[:client_socket_path])
+         socket_send(message_block[0],:garden,@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]
+     def close_all(message_block)
+       if message_block[2][:level] == :garden
+         @seeds_pid = message_block[2][:pid]
          @quit = true
-         @mem_client_socket_path = client_socket_path
+         @mem_client_socket_path = message_block[3]
        else
-         @seeds_pid.delete(data[:pid].to_i)
+         @seeds_pid.delete(message_block[2][:pid].to_i)
          if @seeds_pid.empty?
-           socket_send(:close,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}, @mem_client_socket_path)
+           socket_send(:close,:garden,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}, @mem_client_socket_path)
            exit
          end
        end

data/lib/garden_rows.rb

@@ -51,32 +51,32 @@ class Garden
           t2 = Thread.new do
             loop do
               if $seed.nil?
-                command, data = socket_duplex(:row,my_socket_path)
-                if command == :quit
+                message_block = socket_duplex(:row,:row,my_socket_path)
+                if message_block[0] == :quit
                   pid = Process.pid
-                  socket_send(:close,{:level => :seed, :pid => pid})
+                  socket_send(:close,:row,{:level => :seed, :pid => pid})
                   exit
                 end
-                $seed = data
+                $seed = message_block[2]
                 if $seed.nil?
-                  command, data, client_socket_path = socket_recv
-                  case command
+                  message_block = socket_recv
+                  case message_block[0]
                   when :sprout
-                    $seed = data
+                    $seed = message_block[2]
                   when :seed_all
                     @seed_all = true
-                    $seed = {:id => Process.pid, :seed => data}
+                    $seed = {:id => Process.pid, :seed => message_block[2]}
                   when :init
                     $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
-                    socket_send(:init_crop,$init)
+                    socket_send(:init_crop,:row,$init)
                   end
                 end
               elsif ! $seed[:success].nil?
                 if @seed_all
-                  socket_send(:seed_all_crop,$seed)
+                  socket_send(:seed_all_crop,:row,$seed)
                   @seed_all = false
                 else
-                  socket_send(:crop,$seed)
+                  socket_send(:crop,:row,$seed)
                 end
                 $seed = nil;
               else

data/lib/gardener.rb

@@ -48,38 +48,38 @@ 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
-    command, data = socket_duplex(:init,@garden_rows.pids.size)
-    data.map! do |row|
+    message_block = socket_duplex(:init,:gardener,@garden_rows.pids.size)
+    message_block[2].map! do |row|
       {:success => row[:success], :message => row[:message], :pid => row[:id]}
     end
-    return data
+    return message_block[2]
   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
+  # * _data_ = a ruby expression or object
   # === Example
   #  id_seed_1 = gardener.seed("system 'ruby -v'")
   
-  def seed(command)
-    command, data = socket_duplex(:seed,command)
-    return data
+  def seed(data)
+    message_block = socket_duplex(:seed,:gardener,data)
+    return message_block[2]
   end
   
   # The +seed_all+ method allow to send a command to all row processes, usefull for a parameter change
   # that needs to affect the prefered behaviour of all row.  It returns an array containing hashes for each rows results.
   # === Parameter
-  # * _command_ = a ruby expression or object
+  # * _data_ = a ruby expression or object
   # === Example
   #   result = gardener.seed_all("pref local")  # =>  [{:success=>true, :message=>["row pref changed to local"], :seed=>"pref local", :pid=>14915},
   #                                               {:success=>true, :message=>["row pref changed to local"], :seed=>"pref local", :pid=>14913}]
-  def seed_all(command)
-    seed = [@garden_rows.pids.size, command]
-    command, data = socket_duplex(:seed_all, seed)
-    data.map! do |row|
+  def seed_all(data)
+    seed = [@garden_rows.pids.size, data]
+    message_block = socket_duplex(:seed_all,:gardener,seed)
+    message_block[2].map! do |row|
       {:success => row[:success], :message => row[:message], :pid => row[:id]}
     end
-    return data
+    return message_block[2]
   end
   
   # The +growth+ method for the Gardener instance allow to get report of the growing process
@@ -93,9 +93,9 @@ class Gardener
   #  progress = gardener.growth(:progress)
   #  puts "progress is now #{progress}"  # => progress is now 0.75
   
-  def growth(crop=:progress)
-    command, data = socket_duplex(:growth,crop)
-    return data
+  def growth(data=:progress)
+    message_block = socket_duplex(:growth,:gardener,data)
+    return message_block[2]
   end
   
   # The +harvest+ method for the Gardener instance allow to get arrays of results for each queue level.
@@ -112,9 +112,9 @@ class Gardener
   # === Example
   #  seed1_result = gardener.harvest(id_seed_1)
   
-  def harvest(crop)
-    command, data = socket_duplex(:harvest,crop)
-    return data
+  def harvest(data)
+    message_block = socket_duplex(:harvest,:gardener,data)
+    return message_block[2]
   end
   
   # The +close+ method for the Gardener instance allow to safely close the Garden and its Rows.
@@ -123,8 +123,8 @@ class Gardener
   #  final_harvest = gardener.close
   
   def close
-    command, data = socket_duplex(:close,{:level => :garden, :pid => @garden_rows.pids})
-    return data
+    message_block = socket_duplex(:close,:gardener,{:level => :garden, :pid => @garden_rows.pids})
+    return message_block[2]
   end
   
 end

data/lib/toolshed.rb

@@ -52,8 +52,8 @@ module Toolshed
   # * _command_ = command part of the sent packet
   # * _data_ = data part of the sent packet
   # * _server_socket_path_ = a UNIXServer socket path for the packets to be sent to
-  def socket_send(command,data,server_socket_path=@garden_path)
-    send_block(command,data,server_socket_path)
+  def socket_send(command,option,data,server_socket_path=@garden_path)
+    send_block(command,option,data,server_socket_path)
   end
   
   # The +socket_duplex+ method open a UNIXSocket and send packets to a UNIXServer socket, then wait for loopback communication from destination and return results like +socket_recv+.
@@ -61,8 +61,8 @@ module Toolshed
   # * _command_ = command part of the sent packet
   # * _data_ = data part of the sent packet
   # * _server_socket_path_ = a UNIXServer socket path for the packets to be sent to
-  def socket_duplex(command,data,server_socket_path=@garden_path)
-    send_block(command,data,server_socket_path)
+  def socket_duplex(command,option,data,server_socket_path=@garden_path)
+    send_block(command,option,data,server_socket_path)
     Marshal.load(recv_whole_block)
   end
   
@@ -121,10 +121,10 @@ module Toolshed
   # * _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(command,data,server_socket_path)
+  def send_block(command,option,data,server_socket_path)
     begin
       client = UNIXSocket.open(server_socket_path)
-      client.send(Marshal.dump([command,data,@my_socket_path]),0)
+      client.send(Marshal.dump([command,option,data,@my_socket_path]),0)
       client.close
     rescue Errno::EADDRINUSE
       retry

metadata

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