abundance 1.1.2 → 1.2.0

data/lib/garden.rb

@@ -32,68 +32,67 @@ class Garden
   def initialize
     @pid = fork do
       @quit = false; @full_crop = false; @do_init = nil; @seed_all = nil; @init_all_crop = []
-      @harvest = []; @rows_port = []; @init_done = []; @seed_all_done = []; @seed_all_crop = []
+      @harvest = []; @rows_socket_paths = []; @init_done = []; @seed_all_done = []; @seed_all_crop = []
       @seeds = []; @sprouts = []; @crops = []; @id = 0
-      @socket_server = Toolshed.socket_server(Toolshed::garden_port)
-      @socket_client_temp = Toolshed.socket_client_temp
+      set_my_socket_as_a(:garden)
       loop do
         catch :fill_rows do
           loop do
-            if ! @seed_all.nil? && ! @rows_port.empty? && @seed_all_done.size != @seed_all[0]
-              row_port = @rows_port.shift
-              unless @seed_all_done.include?( row_port )
-                socket_client_temp(:seed_all,@seed_all[1],row_port)
-                @seed_all_done << row_port
+            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_port << row_port
+                @rows_socket_paths << row_socket_path
               end
-            elsif ! @do_init.nil? && ! @rows_port.empty? && @init_done.size != @do_init
-              row_port = @rows_port.shift
-              unless @init_done.include?( row_port )
-                socket_client_temp(:init,'init_status',row_port)
-                @init_done << row_port
+            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_port << row_port
+                @rows_socket_paths << row_socket_path
               end
-            elsif ! @seeds.empty? && ! @rows_port.empty?
+            elsif ! @seeds.empty? && ! @rows_socket_paths.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?
+              row_socket_path = @rows_socket_paths.shift
+              socket_send(:sprout,seed,row_socket_path)
+            elsif @quit && ! @rows_socket_paths.empty?
               seed = nil
-              row_port = @rows_port.shift
-              socket_client_temp(:quit,seed,row_port)
+              row_socket_path = @rows_socket_paths.shift
+              socket_send(:quit,seed,row_socket_path)
             else
               throw :fill_rows
             end               
           end
         end
-        command, data, clientport, clientname, clientaddr = socket_server_recv
+        command, data, client_socket_path = socket_recv
         case command
         when :seed
           @id += 1; @seeds << {:id => @id , :seed => data}
-          socket_server_send(command,@id,clientaddr,clientport)
+          socket_send(command,@id,client_socket_path)
         when :row
           if @quit
             command = :quit
             seed = nil
           elsif @seeds.empty?
             seed = nil
-            @rows_port << data
+            @rows_socket_paths << data
           else
             seed = @seeds.shift
             @sprouts[seed[:id]] = seed
           end
-          socket_server_send(command,seed,clientaddr,clientport)  
+          socket_send(command,seed,client_socket_path)  
         when :crop
           @sprouts[data[:id]] = nil
-          @crops[data[:id]] = data; socket_server_send(command,true,clientaddr,clientport)
+          @crops[data[:id]] = data
           if @harvest[data[:id]]
-            socket_server_send(command,data, @harvest[data[:id]][:clientaddr], @harvest[data[:id]][:clientport]) 
+            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_server_send(command,@crops.compact,@mem_addr,@mem_port)
+            socket_send(command,@crops.compact,@mem_client_socket_path)
             @crops.clear; @full_crop = false
           end
         when :growth
@@ -101,81 +100,79 @@ class Garden
           when :progress
             value = @crops.size.to_f / (@crops.size + @sprouts.compact.size + @seeds.size)
             value = 1 if value.nan?; progress = sprintf( "%.2f", value)
-            socket_server_send(command,progress,clientaddr,clientport)
+            socket_send(command,progress,client_socket_path)
           when :seed
-            socket_server_send(command,@seeds.size,clientaddr,clientport)
+            socket_send(command,@seeds.size,client_socket_path)
           when :sprout
-            socket_server_send(command,@sprouts.compact.size,clientaddr,clientport)
+            socket_send(command,@sprouts.compact.size,client_socket_path)
           when :crop
-            socket_server_send(command,@crops.size,clientaddr,clientport)
+            socket_send(command,@crops.size,client_socket_path)
           else
-            socket_server_send(command,false,clientaddr,clientport)
+            socket_send(command,false,client_socket_path)
           end
         when :harvest
           case data
           when :all
-            socket_server_send(command,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact},clientaddr,clientport)
+            socket_send(command,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact},client_socket_path)
           when :seed
-            socket_server_send(command,@seeds,clientaddr,clientport)
+            socket_send(command,@seeds,client_socket_path)
           when :sprout
-            socket_server_send(command,@sprouts.compact,clientaddr,clientport)
+            socket_send(command,@sprouts.compact,client_socket_path)
           when :crop
-            socket_server_send(command,@crops.compact,clientaddr,clientport)
+            socket_send(command,@crops.compact,client_socket_path)
             @crops.clear
           when :full_crop
             if @seeds.compact.empty? && @sprouts.compact.empty?
-              socket_server_send(command,@crops.compact,clientaddr,clientport)
+              socket_send(command,@crops.compact,client_socket_path)
               @crops.clear
             else
               @full_crop = true
-              @mem_addr = clientaddr; @mem_port = clientport
+              @mem_client_socket_path = client_socket_path
             end
           else
             if data.is_a? Integer
               if @crops[data]
-                socket_server_send(command,@crops[data],clientaddr,clientport)
+                socket_send(command,@crops[data],client_socket_path)
                 @crops[data] = nil
               else
-                @harvest[data] = {:clientaddr => clientaddr, :clientport => clientport}
+                @harvest[data] = {:client_socket_path => client_socket_path}
               end
             else
-              socket_server_send(command,false,clientaddr,clientport)
+              socket_send(command,false,client_socket_path)
             end
           end
         when :init
           @do_init = data
-          @init_return = {:clientaddr => clientaddr, :clientport => clientport}
+          @init_return = {:client_socket_path => client_socket_path}
         when :init_crop
-          socket_server_send(command,true,clientaddr,clientport)
           @init_all_crop << data
           if @init_all_crop.size == @do_init
-            socket_server_send(command,@init_all_crop, @init_return[:clientaddr], @init_return[:clientport])
+            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
         when :seed_all
           @seed_all = data
-          @seed_all_return = {:clientaddr => clientaddr, :clientport => clientport, :data => []}
+          @seed_all_return = {:client_socket_path => client_socket_path, :data => []}
         when :seed_all_crop
-          socket_server_send(command,true,clientaddr,clientport)
           @seed_all_crop << data
           if @seed_all_crop.size == @seed_all[0]
-            socket_server_send(command,@seed_all_crop, @seed_all_return[:clientaddr], @seed_all_return[:clientport])
+            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
         when :close
           if data[:level] == :garden
             @seeds_pid = data[:pid]
             @quit = true
-            @mem_addr = clientaddr; @mem_port = clientport
+            @mem_client_socket_path = client_socket_path
           else
             @seeds_pid.delete(data[:pid].to_i)
             if @seeds_pid.empty?
-              socket_server_send(:close,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}, @mem_addr, @mem_port)
+              socket_send(:close,{:seeds => @seeds, :sprouts => @sprouts.compact, :crops => @crops.compact}, @mem_client_socket_path)
               exit
             end
           end
         else
-          socket_server_send(command,false,clientaddr,clientport)
+          socket_send(command,false,client_socket_path)
         end
       end
     end
@@ -194,7 +191,7 @@ class Garden
   # 
   
   def rows(rows,init_timeout,grow_block)
-    Rows.new(rows,init_timeout,grow_block)
+    Rows.new(rows,init_timeout,@pid,grow_block)
   end
   
   # :title:Rows
@@ -213,17 +210,16 @@ class Garden
     # === 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,gardener_block)
+    def initialize(rows,init_timeout,garden_pid,gardener_block)
       @pids = []
       rows.times do
-        row_port = Toolshed.available_port
         @pids << fork do
-          @socket_client_perm = Toolshed.socket_client_perm
           @seed_all = false
-          @socket_server = Toolshed.socket_server(row_port)
+          set_my_socket_as_a(:row,garden_pid)
           t1 = Thread.new do
             gardener_block.call
           end
@@ -231,15 +227,15 @@ class Garden
           t2 = Thread.new do
             loop do
               if $seed.nil?
-                command, data = socket_client_perm_duplex(:row,row_port)
+                command, data = socket_duplex(:row,my_socket_path)
                 if command == :quit
                   pid = Process.pid
-                  socket_client_perm_send(:close,{:level => :seed, :pid => pid})
+                  socket_send(:close,{:level => :seed, :pid => pid})
                   exit
                 end
                 $seed = data
                 if $seed.nil?
-                  command, data, clientport, clientname, clientaddr = socket_server_recv
+                  command, data, client_socket_path = socket_recv
                   case command
                   when :sprout
                     $seed = data
@@ -248,15 +244,15 @@ class Garden
                     $seed = {:id => Process.pid, :seed => data}
                   when :init
                     $init = {:seed => 'init_status', :message => 'No Init Message', :id => Process.pid} if $init.nil?
-                    command, data = socket_client_perm_duplex(:init_crop,$init)
+                    socket_send(:init_crop,$init)
                   end
                 end
               elsif ! $seed[:success].nil?
                 if @seed_all
-                  command, data = socket_client_perm_duplex(:seed_all_crop,$seed)
+                  socket_send(:seed_all_crop,$seed)
                   @seed_all = false
                 else
-                  command, data = socket_client_perm_duplex(:crop,$seed)
+                  socket_send(:crop,$seed)
                 end
                 $seed = nil;
               else

data/lib/gardener.rb

@@ -35,12 +35,11 @@ class Gardener
                           elsif options[:wheelbarrow] < 1024 then 1024
                           else options[:wheelbarrow]
                           end
-    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
+    set_my_socket_as_a(:gardener,@garden.pid)
   end
   
   # The +init_status+ method for the Gardener instance allow to harvest an initialisation status message
@@ -49,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
-    command, data = socket_client_perm_duplex(:init,@garden_rows.pids.size)
+    command, data = socket_duplex(:init,@garden_rows.pids.size)
     data.map! do |row|
       {:success => row[:success], :message => row[:message], :pid => row[:id]}
     end
@@ -63,7 +62,7 @@ class Gardener
   #  id_seed_1 = gardener.seed("system 'ruby -v'")
   
   def seed(command)
-    command, data = socket_client_perm_duplex(:seed,command)
+    command, data = socket_duplex(:seed,command)
     return data
   end
   
@@ -76,7 +75,7 @@ class Gardener
   #                                               {: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_client_perm_duplex(:seed_all, seed)
+    command, data = socket_duplex(:seed_all, seed)
     data.map! do |row|
       {:success => row[:success], :message => row[:message], :pid => row[:id]}
     end
@@ -95,7 +94,7 @@ class Gardener
   #  puts "progress is now #{progress}"  # => progress is now 0.75
   
   def growth(crop=:progress)
-    command, data = socket_client_perm_duplex(:growth,crop)
+    command, data = socket_duplex(:growth,crop)
     return data
   end
   
@@ -114,7 +113,7 @@ class Gardener
   #  seed1_result = gardener.harvest(id_seed_1)
   
   def harvest(crop)
-    command, data = socket_client_perm_duplex(:harvest,crop)
+    command, data = socket_duplex(:harvest,crop)
     return data
   end
   
@@ -124,7 +123,7 @@ class Gardener
   #  final_harvest = gardener.close
   
   def close
-    command, data = socket_client_perm_duplex(:close,{:level => :garden, :pid => @garden_rows.pids})
+    command, data = socket_duplex(:close,{:level => :garden, :pid => @garden_rows.pids})
     return data
   end
   

data/lib/toolshed.rb

@@ -10,142 +10,96 @@
 # 
 # :title:Toolshed
 
+# TODO:
+# -dedicated server on garden for 'ready!' rows where rows go write their PID
+
 module Toolshed
+  require 'ftools'
   require 'socket'
-  UDP_HOST = 'localhost'
-  @@start_port = 50000
-  @@sessions = []
-  
-  # The Toolshed.available_port method scans for a an available UDP port and returns its value.
-  def Toolshed.available_port
-    port = @@start_port + 1
-    catch :scan_port do
-      stat = `netstat`
-      loop do
-        throw :scan_port unless stat =~ /localhost\.#{port}/
-        port += 1
-      end
-    end
-    @@start_port = port
-    return port
-  end
-  
-  # The Toolshed.socket_client_perm method creates a client socket permanently connected to the main server socket.  Returns the client socket object.
-  def Toolshed.socket_client_perm
-    socket = UDPSocket.new
-    socket.connect(UDP_HOST,@@garden_port)
-    return socket
-  end
-  
-  # The Toolshed.socket_client_temp method creates a client socket available for changing connections to multiple socket servers. Returns the client socket object.
-  def Toolshed.socket_client_temp
-    UDPSocket.new
-  end
-  
-  # The Toolshed.socket_server method creates a permanent main server socket.  Returns the server socket object.
-  def Toolshed.socket_server(port)
-    socket_server = UDPSocket.new
-    socket_server.bind(nil,port)
-    return socket_server
-  end
-  
+  SOCKET_ROOT = '/tmp/abundance/'
+  Dir.mkdir(SOCKET_ROOT) unless File.exist?(SOCKET_ROOT)
+        
   # The Toolshed::block_size= method sets the UDP block size for socket operations.
   def Toolshed::block_size=(block_size)
     @@block_size = block_size
   end
   
-  # The Toolshed::block_size method gets and returns the UDP block size for socket operations.
-  def Toolshed::block_size
-    @@block_size
-  end
+  # The +assign_sockets+ method assign a value client and server variables
   
-  # The Toolshed::garden_port= sets the UDP socket port for the garden server.
-  def Toolshed::garden_port=(garden_port)
-    @@garden_port = garden_port
+  def set_my_socket_as_a(role,garden_pid=Process.pid)
+    case role
+    when :garden
+      set_my_socket
+    else
+      set_garden_path(garden_pid)
+      set_my_socket
+    end
   end
   
-  # The Toolshed::garden_port gets the UDP socket port of the garden server.
-  def Toolshed::garden_port
-    @@garden_port
+  def my_socket_path
+    @my_socket_path
   end
   
-  # The +socket_client_perm_duplex+ method is used as the main Row loop send/receive method and for all gardener's send/receive
-  def socket_client_perm_duplex(command,data)
-    block_splitter([command,data]) do |block|
-      @socket_client_perm.send(block,0)
-    end
-    recv_block,address = block_filter { @socket_client_perm.recvfrom(@@block_size) }
-    return Marshal.load(recv_block)
+  # 
+  
+  def socket_send(command,data,server_socket_path=@garden_path)
+    send_block(command,data,server_socket_path)
   end
   
-  def socket_client_perm_send(command,data)
-    block_splitter([command,data]) do |block|
-      @socket_client_perm.send(block,0)
-    end
+  def socket_duplex(command,data,server_socket_path=@garden_path)
+    send_block(command,data,server_socket_path)
+    Marshal.load(recv_whole_block)
   end
+    
+  def socket_recv
+    Marshal.load(recv_whole_block)
+  end
+    
+  private 
   
-  # The +socket_client_temp+ method is used by the Garden for connecting with the Row idle socket for quick messages. 
-  def socket_client_temp(command,data,port)
-    @socket_client_temp.connect(UDP_HOST,port)
-    block_splitter([command,data]) do |block|
-      @socket_client_temp.send(block,0)
-    end
+  def socket_path(pid)
+    File.catname(pid.to_s,SOCKET_ROOT)
   end
   
-  # The +socket_server_recv+ method is used by the Garden permanent socket and by the Row idle socket to wait for incomming messages.
-  def socket_server_recv
-    block,address = block_filter { @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
+  def set_my_socket
+    @my_socket_path = socket_path(Process.pid)
+    File.delete(@my_socket_path) if File.exist?(@my_socket_path)
+    @my_socket = UNIXServer.open(@my_socket_path)
   end
   
-  # The +socket_server_send+ method is used by the Garden to answer back to socket clients.
-  def socket_server_send(command,data,clientaddr,clientport)
-    block_splitter([command,data]) do |block|
-      @socket_server.send(block, 0, clientaddr, clientport)
-    end
+  def set_garden_path(garden_pid)
+    @garden_path = socket_path(garden_pid)
   end
   
-  private 
-  # The +block_splitter+ method is used internally by the Toolshed method to split message into acceptable UDP block size.  Its operating as a block method, sending a message chunk on each iteration.
-  def block_splitter(data)
-    data_string = Marshal.dump(data)
-    if data_string.size >= @@block_size
-      parts = data_string.size / (@@block_size - @@block_size/32) + 1
-      yield Marshal.dump([:block_head,Process.pid,parts])
-      parts.times do |num|
-        part = [data_string[0,@@block_size - @@block_size/32]]; data_string[0,@@block_size - @@block_size/32] = ''
-        yield Marshal.dump([:block_part,Process.pid,num, part])
+  def recv_whole_block
+    begin
+      client = @my_socket.accept; block = []
+      catch :whole_block do
+        loop do
+          packet = client.recvfrom(@@block_size)[0]
+          if packet == ''
+            throw :whole_block
+          else
+            block << packet
+          end
+        end
       end
-    else
-      yield data_string
+      return block.join
+    rescue Errno::EADDRINUSE
+      retry
     end
   end
   
-  # The +block_filter+ method is used internally by the Toolshed method to filter splitted messages blocks, buffering them until the full message can be reconstructed.
-  def block_filter
-    loop do
-      block,address = yield
-      block_array = Marshal.load(block)
-      if block_array[0] == :block_head
-        @@sessions[block_array[1]] = {} if @@sessions[block_array[1]].nil?
-        @@sessions[block_array[1]][:size] = block_array[2]
-        @@sessions[block_array[1]][:address] = address
-      elsif block_array[0] == :block_part
-        @@sessions[block_array[1]] = {} if @@sessions[block_array[1]].nil?
-        @@sessions[block_array[1]][:data] = [] if @@sessions[block_array[1]][:data].nil?
-        @@sessions[block_array[1]][:data][block_array[2]] = block_array[3]
-      else
-        return block,address
-      end
-      if ! @@sessions[block_array[1]].nil? && ! @@sessions[block_array[1]][:data].nil? && @@sessions[block_array[1]][:data].size == @@sessions[block_array[1]][:size]
-        block = @@sessions[block_array[1]][:data].join
-        address = @@sessions[block_array[1]][:address]
-        @@sessions[block_array[1]] = nil
-        return block,address
-      end
+  def send_block(command,data,server_socket_path)
+    begin
+      client = UNIXSocket.open(server_socket_path)
+      client.send(Marshal.dump([command,data,@my_socket_path]),0)
+      client.close
+    rescue Errno::EADDRINUSE
+      retry
+    rescue Errno::ECONNREFUSED
+      retry
     end
   end
-  
+      
 end

metadata

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