journeta 0.0.2 → 0.0.3

data/History.txt

@@ -1,3 +1,15 @@
+== 0.0.3 2008-08-21
+
+* Added peer 'groups' support to avoid peer message spamming.
+* Major refactoring to make outbound messages sent asynchonously to the sending thread.
+* Example and documentation updates.
+* Shared network queue example added!
+  * examples/queue_client.rb
+  * examples/queue_server.rb
+* Renaming..
+  * Session -> Peer
+  * Event -> Presence
+
 == 0.0.2 2008-08-19
 
 * First working RubyForge release:

data/Manifest.txt

@@ -5,17 +5,22 @@ README.txt
 Rakefile
 lib/journeta.rb
 examples/instant_messenger.rb
+examples/queue_client.rb
+examples/queue_server.rb
 lib/journeta/logger.rb
 lib/journeta/version.rb
 lib/journeta/asynchronous.rb
-lib/journeta/session_listener.rb
-lib/journeta/session_handler.rb
-lib/journeta/event_broadcaster.rb
-lib/journeta/event_listener.rb
-lib/journeta/presence_message.rb
+lib/journeta/peer_listener.rb
+lib/journeta/peer_handler.rb
 lib/journeta/peer_registry.rb
 lib/journeta/peer_connection.rb
+lib/journeta/presence_broadcaster.rb
+lib/journeta/presence_listener.rb
+lib/journeta/presence_message.rb
 lib/journeta/journeta_engine.rb
+lib/journeta/common/dummy_peer_handler.rb
+lib/journeta/common/job.rb
+lib/journeta/common/shutdown.rb
 scripts/txt2html
 setup.rb
 test/test_journeta.rb

data/README.txt

@@ -9,9 +9,9 @@ requiring no advanced networking knowledge to use.
 Only core Ruby libraries are required, making the library fairly light. As all data is sent accross
 the wire in YAML form, any arbitrary Ruby object can be sent to peers, provided they..
 
- * Are running a compatible Journeta version, and
+ * Are running a compatible Journeta version.
  * Have access to the same class definitions if you are sending your own custom objects.
- * Do not have a firewall preventing
+ * Do not have a firewall preventing network I/O.
 
 Journeta uses Ruby threading to manage the asynchonous nature of peer-to-peer I/O.
 For insight into events internal to the library, start ruby with the `--debug` options.

data/examples/instant_messenger.rb

@@ -17,28 +17,46 @@ end
 
 # A message handler will be called by the engine every time a message is received.
 # This code will be customized for your application-specific needs.
-class ExampleHandler < Journeta::DefaultSessionHandler
+class ExampleHandler < Journeta::DefaultPeerHandler
   def handle(message)
-    puts "#{message.name.chop}: #{message.text}"
+    if message.class == ExampleMessage
+      puts "#{message.name.chop}: #{message.text}"
+    else
+      putsd("Unsupported message type received from peer. (#{message})")
+    end
   end
 end
 
 # Now we'll create an instance of the Journeta P2P engine.
-# We'll change the default incoming session port to a
+#
+# :peer_port -- We'll change the default incoming session port to a
 # pseudo-randomly generated number so multiple instances
 # may be started on the same machine.
 #
 # You'll need to find an unused port if..
 # (1) you intend to run multiple peers on the same machine, or
-# (2) the default port (Journeta::JournetaEngine::DEFAULT_SESSION_PORT)
+# (2) the default port (Journeta::JournetaEngine::DEFAULT_PEER_PORT)
 #     is otherwise already taken on your machine.
-session_port = (2048 + rand( 2 ** 8))
-journeta = Journeta::JournetaEngine.new(:session_port => session_port, :session_handler => ExampleHandler.new)
+#
+# :peer_handler -- A piece of logic you must specify to process objects sent to you from peers.
+# :groups -- Defines the peer types which care about the objects you broadcast. (Optional: by default, all peers will receive all your object broadcasts.)
+peer_port = (2048 + rand( 2 ** 8))
+journeta = Journeta::JournetaEngine.new(:peer_port => peer_port, :peer_handler => ExampleHandler.new, :groups => ['im_example'])
 
 
 # Let the magic begin!
 journeta.start
 
+
+# You can use the following helper to automatically stop the given engine when the application is killed with CTRL-C.
+include Journeta::Common::Shutdown
+stop_on_shutdown(journeta)
+
+# Alternatively, you can stop the engine manually by calling +JournetaEngine#stop+.
+# Do this before exiting to broadcast a message stating you are going offline as a courtesy to your peers, like so..
+# @journeta.stop
+
+
 puts "What's your name?"
 name = gets
 
@@ -58,20 +76,19 @@ end
 # Sit around are watch events at the console until the user hits <enter>
 puts 'Text you enter here will automatically be shown on peers terminals.'
 begin
-   loop do
+  loop do
+    begin
       input = gets
       m = ExampleMessage.new
       m.name = name
       m.text = input
       journeta.send_to_known_peers(m)
-   end
-ensure
+    end
+  end  
 end
 
-# Please stop the engine when shutting down. This broadcasts a message
-# stating you are going offline as a courtesy to your peers.
-journeta.stop
+
 
 # The engine can be restarted and stopped as many times as you'd like.
-journeta.start
-journeta.stop
+#journeta.start
+#journeta.stop

data/examples/queue_client.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+current_dir = File.dirname(File.expand_path(__FILE__))
+lib_path = File.join(current_dir, '..', 'lib')
+$LOAD_PATH.unshift lib_path
+
+require 'journeta'
+include Journeta
+include Journeta::Common
+include Journeta::Common::Shutdown
+
+class JobProcessor
+  def handle(msg)
+    if msg.class == Job && !msg.submission
+      puts "Processing job ##{msg.name} from peer ##{msg.owner}."
+    end
+  end
+end
+
+peer_port = (2048 + rand( 2 ** 8))
+journeta = Journeta::JournetaEngine.new(:peer_port => peer_port, :peer_handler => JobProcessor.new, :groups => ['queue_example'])
+stop_on_shutdown(journeta)
+journeta.start
+
+
+# Keep creating random jobs.
+puts "Don't forget to start a server at some point! CTRL-C to exit this client."
+while true
+  num = rand(1024)
+  puts "Creating random job ##{num}."
+  job = Job.new
+  job.owner = journeta.uuid
+  job.name = num
+  job.description = 'whatever'
+  job.data = 'Anything YAML serializable!'
+  job.submission = true
+  journeta.send_to_known_peers(job) # All servers will get it.
+  sleep 4
+end

data/examples/queue_server.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+current_dir = File.dirname(File.expand_path(__FILE__))
+lib_path = File.join(current_dir, '..', 'lib')
+$LOAD_PATH.unshift lib_path
+
+require 'thread'
+require 'journeta'
+include Journeta
+include Journeta::Common
+include Journeta::Common::Shutdown
+
+@queue = Queue.new
+
+class JobQueuer
+  def initialize(queue)
+    @queue = queue
+  end
+  def handle(msg)
+    if msg.class == Job && msg.submission
+      puts "Enqueing job '##{msg.name}' from peer ##{msg.owner}."
+      msg.submission = false
+      @queue.push msg
+    end
+  end
+end
+
+peer_port = (2048 + rand( 2 ** 8))
+journeta = Journeta::JournetaEngine.new(:peer_port => peer_port, :peer_handler => JobQueuer.new(@queue), :groups => ['queue_example'])
+stop_on_shutdown(journeta)
+journeta.start
+
+
+puts "Start multiple peers to see the server doing stuff! CTRL-C to stop this server. "
+total = 0
+while true
+  job = @queue.pop
+  puts "Job found! (#{job.name})"
+  all = journeta.known_peers.values
+  # Note that this list might already be outdated by the time we reach the next line!
+  
+  if all.size > 0
+    # Pick a random client
+    worker = all[rand(all.size)]
+    puts "Sending to peer ##{worker.uuid}."
+    journeta.send_to_peer(worker.uuid, job)
+  else
+    puts "No workers found :(  Will check again soon!"
+    @queue.push job
+    sleep 4 # Wait for peers to join
+  end
+end

data/lib/journeta.rb

@@ -1,16 +1,21 @@
 
 require 'yaml'
+require 'thread'
 
 
 require 'journeta/logger'
 require 'journeta/version'
 require 'journeta/asynchronous'
 
-require 'journeta/session_listener'
-require 'journeta/session_handler'
-require 'journeta/event_broadcaster'
-require 'journeta/event_listener'
+require 'journeta/peer_listener'
+require 'journeta/peer_handler'
+require 'journeta/presence_broadcaster'
+require 'journeta/presence_listener'
 require 'journeta/presence_message'
 require 'journeta/peer_registry'
 require 'journeta/peer_connection'
 require 'journeta/journeta_engine'
+
+require 'journeta/common/job'
+require 'journeta/common/shutdown'
+require 'journeta/common/dummy_peer_handler'

data/lib/journeta/asynchronous.rb

@@ -1,34 +1,65 @@
-require 'journeta/logger'
+# Copyright 2007, OpenRain, LLC. All rights reserved.
 
-module Journeta
 
-   class Asynchronous
-      
-      include Logger
-      
-      attr_accessor :thread, :engine
+require 'journeta/logger'
 
-      def initialize(engine)
-         @engine = engine
+module Journeta
+  
+  class Asynchronous
+    
+    include Logger
+    
+    attr_accessor :thread, :engine
+    
+    
+    
+    def initialize(engine)
+      @engine = engine
+      @thread_lock = Mutex.new
+      @thread = nil
+    end
+    
+    
+    
+    # Start the +Thread+ for this instance, iff not already running.
+    def start
+      @thread_lock.synchronize do
+        if @thread
+          # Do not restart it.
+        else
+          putsd "Creating asynchronous thread for I/O: #{self.class.to_s}."
+          @thread = Thread.new {
+            go
+          }
+        end
       end
-      
-      def start
-         putsd "Creating asynchronous thread for I/O: #{self.class.to_s}."
-         @thread = Thread.new {
-            go # @engine
-         }
+    end
+    
+    # This method is intentionally not present because it would be of no real value. By the time a boolean is returned, the instance could be in a totally different state.
+    #    def started  
+    #      stopped = true
+    #      @thread_lock.synchronize do
+    #        stopped = @thread.nil?
+    #      end
+    #      return stopped
+    #    end
+    
+    # Stop the +Thread+ associated with this instance, iff not already stopped.
+    def stop
+      @thread_lock.synchronize do
+        if @thread
+          Thread.kill(@thread)
+          @thread.join
+          @thread = nil
+        end
       end
-      	      
-      def stop
-         Thread.kill(@thread)
-         @thread.join
-         @thread = nil
-   	end
-   	
-   	def go #(engine)
-   	   raise NotImplementedException
-	   end
-	   
-	end
-	
+    end
+    
+    # Abstract thread logic method which must be implemented by the sub-class.
+    def go
+      raise NotImplementedException
+    end
+    
+  end
+  
 end

data/lib/journeta/common/dummy_peer_handler.rb

@@ -0,0 +1,13 @@
+module Journeta
+  
+  module Common
+    
+    class DummyPeerHandler
+      def handle(message)
+        # Intentionally ingore all messages.
+      end
+    end
+    
+  end
+  
+end

data/lib/journeta/common/job.rb

@@ -0,0 +1,15 @@
+module Journeta
+  
+  module Common
+    
+    class Job
+      attr_accessor :owner    
+      attr_accessor :name
+      attr_accessor :description
+      attr_accessor :data
+      attr_accessor :submission
+    end
+    
+  end
+  
+end

data/lib/journeta/common/shutdown.rb

@@ -0,0 +1,21 @@
+module Journeta
+  
+  module Common
+    
+    module Shutdown
+      
+      def stop_on_shutdown(engine)
+        bye = Proc.new {
+          engine.stop
+          exit 0
+        }
+        Signal::trap("HUP", bye)
+        Signal::trap("INT", bye)
+        Signal::trap("KILL", bye)
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/journeta/journeta_engine.rb

@@ -5,87 +5,111 @@
 
 module Journeta
   
+  # The primary fascade of the entire +Journeta+ library, which composite a number of objects that may or may not have code running asynchronously to the primary application +Thread+.
   class JournetaEngine
     
     include Logger
-
+    
+    # A supposedly universally unique id for this instance.
+    attr_reader :uuid
+    
+    # An array of peer network names. Ex: ['OpenRain Test', 'quick_chat_app']
+    # An empty array indicates implicit membership in all discovered groups.
+    attr_reader :groups
+    
+    
     # Continuously sends out "i'm here" presence messages to the local network
-    attr_accessor :event_broadcaster
+    attr_reader :presence_broadcaster
+    
     # continuously listens for "i'm here" presence messages from other peers
-    attr_accessor :event_listener
-
+    attr_reader :presence_listener
+    
+    # The UDP port for event broadcast messages.
+    attr_reader :presence_port
+    
+    # The UDP network address used for broadcast messages.
+    attr_reader :presence_address
+    
+    # The amount of time between presence broadcasts.
+    attr_reader :presence_period
+    
+    
+    
     # Constantly listens for incoming peer sessions
-    attr_accessor :session_listener
+    attr_reader :peer_listener
+    
     # Application logic which processes session data.
-    attr_accessor :session_handler
-
+    attr_reader :peer_handler
+    
+    # The TCP port used to receive direct peer messages.
+    attr_reader :peer_port
+    
     # Authoritative peer availability database.
-    attr_accessor :peer_registry
-
-    # Instance-specific configuration which may be overriden at initialization time by the application
-    attr_reader :configuration
-
-    # The universally-unique ID of this instance.
-    attr_reader :uuid
+    attr_reader :peer_registry
+    
+    
+    
+    
+    
+    # Incoming direct peer TCP connections will use this port.
+    @@DEFAULT_PEER_PORT = 31338
+    
+    # The application message callback handler.
+    @@DEFAULT_PEER_HANDLER = DefaultPeerHandler.new
     
-    @@DEFAULT_SESSION_PORT = 31338
-    @@DEFAULT_EVENT_PORT = 31337
-    @@DEFAULT_SESSION_HANDLER = DefaultSessionHandler.new
+    @@DEFAULT_PRESENCE_PORT = 31337
     
     # Addresses 224.0.0.0 through 239.255.255.255 are reserved for multicast messages.
-    @@DEFAULT_EVENT_NETWORK = '224.220.221.222'
-    @@DEFAULT_EVENT_PERIOD = 4
+    @@DEFAULT_PRESENCE_NETWORK = '224.220.221.222'
+    
+    # The wait time, in seconds, between rebroadcasts of peer presence.
+    @@DEFAULT_PRESENCE_PERIOD = 4
     
     
     def initialize(configuration ={})
       putsd "CON: #{configuration}"
-      @configuration = Hash.new
       
-      # A supposedly universally unique id for this instance. not technically gauranteed but close enough for now.
       # TODO make guaranteed to be unique.
-      @configuration[:uuid] = configuration[:uuid] || rand(2 ** 31)
-      # the tcp port to use for direct peer connections
-      @configuration[:session_port] = configuration[:session_port] || @@DEFAULT_SESSION_PORT
-
-      @session_handler = configuration[:session_handler] || @@DEFAULT_SESSION_HANDLER
+      @uuid = configuration[:uuid] || rand(2 ** 31)
+      @groups = configuration[:groups]
       
-      # The UDP port for event broadcast messages.
-      @configuration[:event_port] = configuration[:event_port] || @@DEFAULT_EVENT_PORT
-
-      # The UDP network address used for broadcast messages.
-      @configuration[:event_address] = configuration[:event_address] || @@DEFAULT_EVENT_NETWORK
-
-      # The delay, in seconds, between presence notification broadcasts.
-      @configuration[:event_period] = configuration[:event_period] || @@DEFAULT_EVENT_PERIOD
       
-      # Initialize sub-components.
-      @session_listener = Journeta::SessionListener.new self
-      @event_listener = EventListener.new self
-      @event_broadcaster = EventBroadcaster.new self
+      @peer_port = configuration[:peer_port] || @@DEFAULT_PEER_PORT
+      @peer_handler = configuration[:peer_handler] || @@DEFAULT_PEER_HANDLER
+      @peer_listener = Journeta::PeerListener.new self
+      
+      @presence_port = configuration[:presence_port] || @@DEFAULT_PRESENCE_PORT    
+      @presence_address = configuration[:presence_address] || @@DEFAULT_PRESENCE_NETWORK      
+      @presence_period = configuration[:presence_period] || @@DEFAULT_PRESENCE_PERIOD
+      @presence_listener = EventListener.new self
+      @presence_broadcaster = EventBroadcaster.new self
+      
       @peer_registry = PeerRegistry.new self
     end
     
     def start
-      # start a session listener first so we don't risk missing a connection attempt
-      putsd "Starting #{@session_listener.class.to_s}"
-      @session_listener.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
       
-      # start listening for peer events
-      putsd "Starting #{@event_listener.class.to_s}"
-      @event_listener.start
+      # Start listening for presence events.
+      putsd "Starting #{@presence_listener.class.to_s}"
+      @presence_listener.start
       
-      # start sending our own events
-      putsd "Starting #{@event_broadcaster.class.to_s}"
-      @event_broadcaster.start
+      # Start sending our own presence events!
+      putsd "Starting #{@presence_broadcaster.class.to_s}"
+      @presence_broadcaster.start
     end
     
     def stop
-      # stop broadcasting events
-      @event_broadcaster.stop
-      # stop listener for events
-      @event_listener.stop
-      # stop listening for incoming peer sessions
-      @session_listener.stop
+      # Stop broadcasting presence.
+      @presence_broadcaster.stop
+      # Stop listening for presence events, which prevents new peer registrations
+      @presence_listener.stop
+      # Stop listening for incoming peer data.
+      @peer_listener.stop
+      # Forcefull terminate all connections, which may be actively passing data.
+      @peer_registry.unregister_all
     end
     
     def send_to_known_peers(payload)
@@ -100,13 +124,17 @@ module Journeta
     
     # Returns metadata on all known peers in a hash, keyed by the uuid of each.
     # A record corresponding to this peer is not included.
-    def known_peers()
-      peer_registry.peers # FIXME Returns objects outside of synchronized context.
+    def known_peers(all_groups = false)
+      peer_registry.all(all_groups)
     end
     
     # Adds (or updates) the given +PeerConnection+.
     def register_peer(peer)
-      peer_registry.add(peer)
+      peer_registry.register(peer)
+    end
+    
+    def unregister_peer(peer)
+      peer_registry.unregister(peer)
     end
     
   end

data/lib/journeta/logger.rb

@@ -1,3 +1,6 @@
+# Copyright 2007, OpenRain, LLC. All rights reserved.
+
+
 module Journeta
    
    module Logger

data/lib/journeta/peer_connection.rb

@@ -1,32 +1,63 @@
+# Copyright 2007, OpenRain, LLC. All rights reserved.
+
 module Journeta
   
   # An outgoing message tube. Messages may or may not arrive at the destination, but if they do they'll be in order.
-  class PeerConnection
+  class PeerConnection < Journeta::Asynchronous
     
     include Logger
     
     attr_accessor :uuid
     attr_accessor :ip_address
-    attr_accessor :session_port
+    attr_accessor :peer_port
     attr_accessor :version
     attr_accessor :created_at
     attr_accessor :updated_at
+    attr_accessor :groups
     
-    # Returns whether or not the payload was sent successfully.
+    def initialize(engine)
+      super(engine)
+      @queue = Queue.new
+      @settings_lock = Mutex.new      
+    end
+    
+    # Adds the given payload to the outbound message queue and immediately returns.
     def send_payload(payload)
       raise "Don't try to send nil payloads!" if payload.nil?
-      ok = true
+      @queue.push payload
+    end
+    
+    def update_settings(other)
+      @settings_lock.synchronize do
+        self.ip_address = other.ip_address
+        self.peer_port = other.peer_port
+        self.version = other.version
+        self.created_at = other.created_at
+        self.updated_at = other.updated_at
+      end
+    end
+    
+    def go
       begin
-        s = TCPSocket.new(ip_address, session_port)
-        data = YAML::dump(payload)
-#        pp data
-        s.send(data , 0)
-        s.close
+        while true
+          # TODO Reuse TCP connections between pops!
+          payload = @queue.pop
+          s = nil
+          @settings_lock.synchronize do # To prevent corruption of settings.
+            s = TCPSocket.new(ip_address, peer_port)       
+          end
+          data = YAML::dump(payload)
+          #        pp data
+          s.send(data , 0)
+          s.close
+        end
       rescue
-        putsd "Peer #{uuid} has gone away."
-        ok = false
+        putsd "Peer #{uuid} has gone away. Deregistering self."
+        # Yeah... kindof wierd, I know.
+        Thread.new {
+          @engine.unregister_peer(self)
+        }
       end
-      return ok
     end
     
   end

data/lib/journeta/{session_handler.rb → peer_handler.rb}

@@ -1,6 +1,6 @@
 module Journeta
   
-  class DefaultSessionHandler
+  class DefaultPeerHandler
     
     include Logger
     

data/lib/journeta/{session_listener.rb → peer_listener.rb}

@@ -2,11 +2,11 @@ require 'socket'
 
 module Journeta
   
-  class SessionListener < Journeta::Asynchronous
+  class PeerListener < Journeta::Asynchronous
     
-    def go #(engine)
+    def go
       begin
-        port = engine.configuration[:session_port]
+        port = @engine.peer_port
         socket = TCPServer.new(port) 
         putsd "Listening on port #{port}"
         
@@ -21,7 +21,7 @@ module Journeta
               end
 #              pp data
               msg     = YAML::load(data)
-              h = @engine.session_handler
+              h = @engine.peer_handler
               h.handle msg              
             end
           end

data/lib/journeta/peer_registry.rb

@@ -9,7 +9,7 @@ module Journeta
     include Logger
     
     # {<:uuid> => PeerConnection}
-    attr_reader :peers
+    #    attr_reader :peers
     
     def initialize(engine)
       @engine = engine
@@ -23,7 +23,17 @@ module Journeta
       end
     end
     
-    def add(peer)
+    def all(all_groups = false)
+      r = nil
+      @mutex.synchronize do
+        r = all_do(all_groups)
+      end
+      return r
+    end
+    
+    # Adds a +PeerConnection+ to the registry. It is optional but not necessary to call +PeerConnection#start+ before manually adding it to the registry!
+    # If a peer with the same UUID is already registered, the given peer will be stopped and the existing one updated.
+    def register(peer)
       raise "Do not try to register a nil peer!" if peer.nil?
       raise "You can only add #{PeerConnection} instances to this registry, not #{peer.class}!" unless peer.class == PeerConnection
       @mutex.synchronize do
@@ -31,40 +41,84 @@ module Journeta
         existing = @peers[peer.uuid]
         if existing.nil?
           putsd "Adding peer #{peer.uuid}."
+          peer.start
+          @peers[peer.uuid] = peer
         else
           putsd "Updating peer #{peer.uuid}."
+          peer.stop
+          existing.update_settings peer
+        end
+        
+      end
+    end
+    
+    # Removes a +PeerConnection+ from the registry. If the peer is still broadcasting presence, it will magically become reregistered at some point!
+    def unregister(peer)
+      return unless !peer.nil? and peer.class == PeerConnection
+      @mutex.synchronize do 
+        peer.stop
+        if peer.uuid
+          @peers.delete peer.uuid
         end
-        @peers[peer.uuid] = peer
       end
     end
     
     def send_to_known_peers(payload)
       # Iterate over each currently known peer and stuff the payload into each peers outgoing data queue.
       @mutex.synchronize do
-        if peers.count > 0
-          peers.each do |uuid, conn|
-            sent = conn.send_payload payload
-            if !sent
-              # The peer probably went away, so unregister it.
-              peers.delete uuid
-            end
+        # Grab all peers in relevant groups.
+        group = all_do
+        n= group.count
+        if n > 0
+          putsd "Sending payload to #{n} peers."
+          group.each do |uuid, conn|
+            conn.send_payload payload
           end
         else
-          putsd 'No peers known to send message to!'
+          putsd 'No peers (in relevant groups) to send message to!'
+        end
+      end
+    end
+    
+    # Destroys all active connections.
+    def unregister_all
+      @mutex.synchronize do
+        @peers.each do |uuid, n|
+          n.stop
         end
       end
     end
     
     def send_to_peer(uuid, payload)
-      sent = peers[uuid].send_payload(payload)
-      if !sent
-        # The peer probably went away, so unregister it.
-        @mutex.synchronize do
-          peers.remove uuid
+      @mutex.synchronize do
+        p = @peers[uuid]
+        if p
+          p.send_payload(payload)
         end
       end
     end
     
+    protected
+    
+    def all_do(all_groups = false)
+      res = nil
+      if all_groups
+        # Create a new structure to avoid corruption of the original.
+        res = Hash.new.update @peers
+      else
+        res = Hash.new
+        @peers.each do |uuid, n|
+          n.groups.each do |g|
+            if @engine.groups.include?(g)
+              res[uuid] = n
+            end  
+          end
+        end
+      end     
+      return res
+    end
+    
+    
   end
   
 end

data/lib/journeta/presence_broadcaster.rb

@@ -0,0 +1,41 @@
+#require 'yaml'
+
+require 'journeta/asynchronous'
+
+
+module Journeta
+  
+  class EventBroadcaster < Journeta::Asynchronous
+    
+    attr_accessor :thread
+    
+    def go #(engine)
+      address = @engine.presence_address
+      port = @engine.presence_port
+      delay = @engine.presence_period
+      uuid = @engine.uuid
+      peer_port = @engine.peer_port
+      groups = @engine.groups
+      begin
+        socket = UDPSocket.open
+        if PLATFORM[/linux/i]
+          socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, [1].pack("i_") )
+        else
+          # socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, [1].pack('i')) # Preston's original config for OS X.
+          socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, [1].pack("i_") ) # Remi's suggested default.
+        end
+        loop do
+          putsd "Sending presence event."
+          note = PresenceMessage.new uuid, peer_port, groups
+          socket.send(note.to_yaml, 0, address, port)
+          sleep delay
+        end
+      ensure
+        putsd "Closing event broadcaster socket."
+        socket.close
+      end
+    end
+    
+  end
+  
+end

data/lib/journeta/{event_listener.rb → presence_listener.rb}

@@ -10,10 +10,10 @@ module Journeta
   class EventListener < Journeta::Asynchronous
     
     
-    def go #(engine)
-      event_address = @engine.configuration[:event_address]
-      port = @engine.configuration[:event_port]
-      addresses =  IPAddr.new(event_address).hton + IPAddr.new("0.0.0.0").hton
+    def go
+      presence_address = @engine.presence_address
+      port = @engine.presence_port
+      addresses =  IPAddr.new(presence_address).hton + IPAddr.new("0.0.0.0").hton
       begin
         socket = UDPSocket.new
         # Remember how i said this was fucked up? yeaahhhhhh. i hope you like C.
@@ -29,18 +29,17 @@ module Journeta
           data, meta = socket.recvfrom 1024
           Thread.new(data) {
             event = YAML.load(data)
-            if event.uuid != @engine.configuration[:uuid]
-#              putsd "New Event: #{data} #{meta.inspect}"
-              # Update registry
+            if event.uuid != @engine.uuid
               m = YAML::load(data)
-              peer = PeerConnection.new
-#              require 'pp'
-#              pp m
+              peer = PeerConnection.new @engine
               # Why is this always [2]? Not sure.. they should have returned a hash instead.
               peer.ip_address = meta[2]
-              peer.session_port = m.session_port
+              peer.peer_port = m.peer_port
               peer.uuid = m.uuid
               peer.version = m.version
+              peer.groups = m.groups
+              # TODO validate peer entry is sane before registering it
+#              peer.start
               @engine.register_peer peer
             end
           }

data/lib/journeta/presence_message.rb

@@ -4,14 +4,16 @@ module Journeta
       
       attr_accessor :version
       attr_accessor :uuid
-      attr_accessor :session_port
-      attr_accessor :online
+      attr_accessor :peer_port
       
-      def initialize(uuid, session_port, online = true)
+      # An Array of strings. May be empty but not nil. Ex: ['quick_chat', 'Preston Demo 1']
+      attr_accessor :groups
+      
+      def initialize(uuid, peer_port, groups = [])
          @version = Journeta::VERSION::STRING
          @uuid = uuid
-         @session_port = session_port
-         @online = online
+         @peer_port = peer_port
+         @groups = groups
       end
       
    end

data/lib/journeta/version.rb

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

data/website/index.html

@@ -31,12 +31,12 @@
 <div id="main">
 
     <h1>Journeta</h1>
-    <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/journeta"; return false'>
-      <!--p>Get Version</p-->
-      <a href="http://rubyforge.org/projects/journeta" class="numbers">RubyForge Project</a>
-    </div>
+    <!--div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/journeta"; return false'>
+      <p>Get Version</p>
+      <a href="http://rubyforge.org/frs/?group_id=4138" class="numbers">sudo gem install journeta</a>
+    </div-->
     <h2>Ruby <span class="caps">P2P</span> for your <span class="caps">LAN</span>, yo.</h2>
-
+	<a href="http://rubyforge.org/frs/?group_id=4138" class="numbers">[RubyForge Project]</a>
 
 	<p>Journeta is a dirt simple library for peer discovery and message passing between Ruby applications on a <span class="caps">LAN</span>.</p>
 
@@ -74,10 +74,10 @@
 	Sweeeeet.</p>
 
 
-	<p>Email <a href="mailto:preston.lee@openrain.com">Preston Lee</a> and read the blog.</p>
     <p class="coda">
-      <!--a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 26th July 2007<br-->
-      Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
+	<a href="mailto:preston.lee@openrain.com">Preston Email</a>
+      <a href="http://prestonlee.com/">Preston Blog</a>
+      <a href="http://openrain.com/">Preston's Company</a>
     </p>
 </div>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: journeta
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Preston Lee
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-19 00:00:00 -07:00
+date: 2008-08-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,17 +42,22 @@ files:
 - Rakefile
 - lib/journeta.rb
 - examples/instant_messenger.rb
+- examples/queue_client.rb
+- examples/queue_server.rb
 - lib/journeta/logger.rb
 - lib/journeta/version.rb
 - lib/journeta/asynchronous.rb
-- lib/journeta/session_listener.rb
-- lib/journeta/session_handler.rb
-- lib/journeta/event_broadcaster.rb
-- lib/journeta/event_listener.rb
-- lib/journeta/presence_message.rb
+- lib/journeta/peer_listener.rb
+- lib/journeta/peer_handler.rb
 - lib/journeta/peer_registry.rb
 - lib/journeta/peer_connection.rb
+- lib/journeta/presence_broadcaster.rb
+- lib/journeta/presence_listener.rb
+- lib/journeta/presence_message.rb
 - lib/journeta/journeta_engine.rb
+- lib/journeta/common/dummy_peer_handler.rb
+- lib/journeta/common/job.rb
+- lib/journeta/common/shutdown.rb
 - scripts/txt2html
 - setup.rb
 - test/test_journeta.rb

data/lib/journeta/event_broadcaster.rb

@@ -1,36 +0,0 @@
-#require 'yaml'
-
-require 'journeta/asynchronous'
-
-
-module Journeta
-   
-   class EventBroadcaster < Journeta::Asynchronous
-      
-      attr_accessor :thread
-
-     	def go #(engine)
-           address = @engine.configuration[:event_address]
-           port = @engine.configuration[:event_port]
-           delay = @engine.configuration[:event_period]
-           uuid = @engine.configuration[:uuid]
-           session_port = @engine.configuration[:session_port]
-           begin
-              socket = UDPSocket.open
-              socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, [1].pack('i'))
-              loop do
-                 putsd "Sending presence event."
-                 note = PresenceMessage.new uuid, session_port
-                 socket.send(note.to_yaml, 0, address, port)
-                 sleep delay
-              end
-           ensure
-              putsd "Closing event broadcaster socket."
-              socket.close
-           end
-     	end
-
-   end
-   
-end
-