journeta 0.1.1 → 0.1.2

data/History.txt

@@ -1,3 +1,13 @@
+== 0.1.2 2008-09-08
+
+* Preemptive peer reaping. Peers now automatically "expire" from the local registry when they haven't been heard from in a while.
+* Non-significant fixes.
+
+
+== 0.1.1 2008-09-05
+
+* Figuring out how to deploy properly with hoe :)
+
 == 0.1.0 2008-09-05
 
 * Renamed Journeta::JournetaEngine to Journeta::Engine

data/examples/network_status.rb

@@ -23,9 +23,15 @@ begin
   puts "Displays infromation on all known peers."
   puts "Updated: #{Time.now}"
   puts "\n"
-  puts "UUID\t\tVersion\t\tIP Address\t\tPort\t\tDiscovered\t\tUpdated\t\tGroups\n"
-  all.keys.sort.each do |uuid|
-    puts "#{all[uuid].uuid}\t#{all[uuid].version}\t\t#{all[uuid].ip_address}\t\t#{all[uuid].peer_port}\t\t#{all[uuid].created_at || 'TODO'}\t\t#{all[uuid].updated_at || 'TODO'}\t[#{all[uuid].groups.join(',')}]"
+  puts "UUID\t\tVersion\t\tIP Address\t\tPort\t\tDiscovered\t\t\tUpdated\t\t\t\tGroups\n"
+#  require 'pp'
+#  pp all
+  all.each do |uuid, peer|
+  groups = '...'
+  if !all[uuid].groups.nil?
+  groups = all[uuid].groups.join(',')
+  end
+    puts "#{all[uuid].uuid}\t#{all[uuid].version}\t\t#{all[uuid].ip_address}\t\t#{all[uuid].peer_port}\t\t#{all[uuid].created_at || 'TODO'}\t#{all[uuid].updated_at || 'TODO'}\t[#{groups}]"
   end
   sleep(0.2)
 end     while true

data/lib/journeta/asynchronous.rb

@@ -15,15 +15,11 @@ module Journeta
     
     attr_accessor :thread, :engine
     
-    
-    
     def initialize(engine)
       @engine = engine
       @thread_lock = Mutex.new
       @thread = nil
-    end
-    
-    
+    end   
     
     # Start the +Thread+ for this instance, iff not already running.
     def start
@@ -52,7 +48,7 @@ module Journeta
     def stop
       @thread_lock.synchronize do
         if @thread
-          Thread.kill(@thread)
+          Thread.kill(@thread) # nasty pants!
           @thread.join
           @thread = nil
         end

data/lib/journeta/journeta_engine.rb

@@ -95,6 +95,8 @@ module Journeta
     # Starts sub-comonents which have their own life-cycle requirements.
     # The registry itself does not have a dedication thread, and thus does not need to be started.
     def start
+      @peer_registry.start
+      
       # Start a peer listener first so we don't risk missing a connection attempt.
       putsd "Starting #{@peer_listener.class.to_s}"
       @peer_listener.start
@@ -121,7 +123,8 @@ module Journeta
       # While the registry does not have its own thread, it is in charge of managing
       # +PeerConnection+s which DO have individual threads. This call
       # forcefully terminates all connections, which may or may not be actively passing data.
-      @peer_registry.unregister_all
+#      @peer_registry.unregister_all
+      @peer_registry.stop
     end
     
     # Sends the given object to all peers in one of the #groups associated with this instance.
@@ -148,7 +151,7 @@ module Journeta
     def known_groups()
       s = Set.new
       self.known_peers(true).each do |uuid, peer|
-        s.merge peer.groups
+        s.merge peer.groups unless peer.groups.nil?
       end
       s.to_a
     end

data/lib/journeta/peer_connection.rb

@@ -22,9 +22,8 @@ module Journeta
     
     # integer.
     attr_accessor :peer_port
-    
-    
-    
+
+
     def initialize(engine)
       super(engine)
       @queue = Queue.new

data/lib/journeta/peer_listener.rb

@@ -29,9 +29,13 @@ module Journeta
               while more = session.gets
                 data += more
               end
-              msg     = YAML::load(data)
-              h = @engine.peer_handler
-              h.call msg              
+              begin
+                msg     = YAML::load(data)
+                h = @engine.peer_handler
+                h.call msg              
+              rescue
+                putsd "YAML could not be deserialized! The data will not be passed up to the application."
+              end
             end
           end
         rescue

data/lib/journeta/peer_registry.rb

@@ -3,18 +3,28 @@ require 'thread'
 module Journeta
   
   # Responsible for keeping in-memory metadata on known peers in the form of PeerConnections.
-  # TODO Add dead peer reaper functionality.
-  class PeerRegistry #<< Journeta::Asynchronous
+  class PeerRegistry < Journeta::Asynchronous
     
     include Logger
     
     # {<:uuid> => PeerConnection}
     #    attr_reader :peers
     
+    
+    # Minimum period between reaper invocations, in seconds.
+    #attr_accessor :reaper_period
+    
+    # The minimun time, in seconds, after a given presence notification arrive that it may be considered for reaping. 
+    #attr_accessor :reaper_tolerance
+    
+    @@DEFAULT_REAPER_PERIOD = 1
+    
     def initialize(engine)
-      @engine = engine
+      super(engine)
       @peers = {}
       @mutex = Mutex.new
+      @reaper_period = @@DEFAULT_REAPER_PERIOD
+      @reaper_tolerance = engine.presence_period + 2.0
     end
     
     def clear
@@ -23,6 +33,26 @@ module Journeta
       end
     end
     
+    def go
+      loop do
+        @mutex.synchronize do
+          to_reap = []
+          @peers.each do |uuid, peer|
+            tolerance = Time.now - @reaper_tolerance
+            if peer.updated_at < tolerance
+              to_reap << peer
+            end
+          end
+          to_reap.each do |peer|
+            peer.stop
+            @peers.delete peer.uuid
+          end
+        end
+        sleep @reaper_period
+      end
+    end
+    
+    
     def all(all_groups = false)
       r = nil
       @mutex.synchronize do
@@ -46,6 +76,8 @@ module Journeta
         else
           putsd "Updating peer #{peer.uuid}."
           peer.stop
+          # Make sure we're not overriding the creation date of the original entry.
+          peer.created_at = nil
           existing.update_settings peer
         end
         

data/lib/journeta/presence_listener.rb

@@ -45,6 +45,7 @@ module Journeta
               peer.uuid = m.uuid
               peer.version = m.version
               peer.groups = m.groups
+              peer.created_at = peer.updated_at = Time.now
               
               # We should not start the #PeerConnection before registering because
               # the peer might already be registered. In this case, we'd have wasted a thread,

data/lib/journeta/version.rb

@@ -2,7 +2,7 @@ module Journeta #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: journeta
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Preston Lee
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-05 00:00:00 -07:00
+date: 2008-09-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency