cod 0.3.0 → 0.3.1

data/Gemfile

@@ -1,5 +1,6 @@
 source "http://rubygems.org"
 
+gem 'uuid'
 gem 'beanstalk-client'
 
 group :test do
@@ -9,6 +10,7 @@ group :test do
   gem 'guard'
   gem 'guard-rspec'
   
+  gem 'rdoc'
   gem 'sdoc'
   
   gem 'growl'

data/HISTORY.txt

@@ -1,4 +1,17 @@
 
+== 0.3.1 / ???
+
+  + Large improvements in resilience to crashes, reconnects are now attempted
+    but can be improved further. 
+
+  + Both sides of an 1:n directory:topic structure can now crash without 
+    permanent message loss. 
+
+  + tcp channels now have a #connected? method that indicates permanent 
+    unrecoverable disconnection.
+    
+  - at_fork extension is now permanently gone. 
+
 == 0.3 / 20Jul2011
 
   + Cod.tcpserver and Cod.tcp channels. Allows direct connection via 

data/README

@@ -19,8 +19,8 @@ SYNOPSIS
   service.one { |msg| :response }               # Process A
   client.call :ruby_object    # => :response    # Process B
   
-  # And more: Publish/Subscribe, easy construction of more advanced distributed
-  # communication.
+  # And more: Publish/Subscribe, easy construction of more advanced
+  # distributed communication.
   
 STATUS
 
@@ -28,6 +28,6 @@ Becoming more useful by the day. Most things will work nicely already,
 although error handling is not production quality. Toy around with it now
 and give me feedback!
 
-At version 0.3 
+At version 0.3.1
 
 (c) 2011 Kaspar Schiess

data/Rakefile

@@ -1,6 +1,6 @@
 require 'psych'
 require "rubygems"
-require "rake/rdoctask"
+require "rdoc/task"
 require 'rspec/core/rake_task'
 require 'rubygems/package_task'
 
@@ -12,7 +12,7 @@ task :default => :spec
 require 'sdoc'
 
 # Generate documentation
-Rake::RDocTask.new do |rdoc|
+RDoc::Task.new do |rdoc|
   rdoc.title    = "parslet - construction of parsers made easy"
   rdoc.options << '--line-numbers'
   rdoc.options << '--fmt' << 'shtml' # explictly set shtml generator

data/examples/presence_client.rb

@@ -0,0 +1,15 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'cod'
+
+
+raise unless ARGV.first
+
+client = Cod.tcp('localhost:12345')
+client.put [client, ARGV.first]
+
+puts "Waiting..."
+$stdin.gets
+client.close
+$stdin.gets
+
+

data/examples/presence_server.rb

@@ -0,0 +1,30 @@
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'cod'
+
+
+present = {}
+server = Cod.tcpserver('localhost:12345')
+
+loop do
+  # Process connection requests
+  while server.waiting?
+    connection, attributes = server.get
+    
+    present[connection] = attributes
+  end
+
+  # Check if all connections are alive
+  remove = []
+  present.each do |conn, attrs|
+    if conn.connected?
+      puts "Alive: #{attrs.inspect}"
+    else
+      puts "Dead: #{attrs.inspect}"
+      remove << conn
+    end
+  end
+  
+  remove.each { |conn| present.delete(conn) }
+  sleep 1
+end

data/examples/pubsub/README

@@ -0,0 +1,12 @@
+
+This is an example of PUB/SUB style messaging. You should run one directory
+and any number of clients. All clients should receive timestamps from the directory, once every second. 
+
+Experiments that can be made using this setup: 
+
+1) Disconnect a client, restart it. It should start receiving updates
+immediately.
+
+2) Disconnect the directory, restart it. It should start redistributing
+updates to all clients within 5 seconds.
+

data/examples/pubsub/client.rb

@@ -0,0 +1,13 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'cod'
+
+channels = Struct.new(:directory, :answers).new(
+  Cod.beanstalk('localhost:11300', 'directory'), 
+  Cod.beanstalk('localhost:11300', 'directory.'+Cod.uuid))
+  
+topic = Cod::Topic.new('', channels.directory, channels.answers, :renew => 5)
+
+loop do
+  puts topic.get
+end
+

data/examples/pubsub/directory.rb

@@ -0,0 +1,13 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'cod'
+
+channels = Struct.new(:directory).new(
+  Cod.beanstalk('localhost:11300', 'directory'))
+  
+directory = Cod::Directory.new(channels.directory)
+
+loop do
+  directory.publish '', Time.now
+  sleep 1
+end
+

data/lib/cod.rb

@@ -1,4 +1,4 @@
-require 'at_fork'
+require 'uuid'
 
 # The core concept of Cod are 'channels'. (Cod::Channel::Base) You can create
 # such channels on top of the various transport layers. Once you have such a
@@ -45,7 +45,9 @@ module Cod
   #   chan = Cod.beanstalk('localhost:11300', 'my_tube')
   #
   def beanstalk(url, name)
-    context.beanstalk(url, name)
+    Cod::Channel::Beanstalk.new(
+      Connection::Beanstalk.new(url), 
+      name)
   end
   module_function :beanstalk
   
@@ -66,31 +68,43 @@ module Cod
   #   chan = Cod.pipe
   # 
   def pipe(name=nil)
-    context.pipe(name)
+    Cod::Channel::Pipe.new(name)
   end
   module_function :pipe
   
+  # Creates a tcp connection to the destination and returns a channel for it. 
+  #
   def tcp(destination)
-    context.tcp(destination)
+    Cod::Channel::TCPConnection.new(destination)
   end
   module_function :tcp
   
+  # Creates a tcp listener on bind_to and returns a channel for it. 
+  #
   def tcpserver(bind_to)
-    context.tcpserver(bind_to)
+    Cod::Channel::TCPServer.new(bind_to)
   end
   module_function :tcpserver
   
-  def context # :nodoc: 
-    @convenience_context ||= Context.new
-  end
-  module_function :context
-  
-  # For testing mainly
+  # Returns a UUID that should be unique for this machine (based on MAC), this 
+  # Thread and Process. Even after a fork. 
+  # 
+  # This is used to create identity on the network. Internal method. 
   #
-  def reset # :nodoc: 
-    @convenience_context = nil
+  def uuid
+    uuid_generator.generate
+  end  
+  def uuid_generator
+    pid, generator = Thread.current[:_cod_uuid_generator]
+    
+    if pid && Process.pid == pid
+      return generator
+    end
+    
+    pid, generator = Thread.current[:_cod_uuid_generator] = [Process.pid, UUID.new]
+    return generator
   end
-  module_function :reset
+  module_function :uuid, :uuid_generator
 end
 
 module Cod::Connection; end
@@ -105,7 +119,6 @@ require 'cod/channel/beanstalk'
 require 'cod/channel/tcpconnection'
 require 'cod/channel/tcpserver'
 
-require 'cod/context'
 require 'cod/client'
 
 require 'cod/service'

data/lib/cod/channel/base.rb

@@ -40,6 +40,11 @@ module Cod
   #   channel.close
   #
   class Channel::Base
+    def initialize(reader, writer)
+      @reader = reader
+      @writer = writer
+    end
+    
     # Writes a Ruby object (the 'message') to the channel. This object will 
     # be queued in the channel and become available for #get in a FIFO manner.
     #
@@ -51,7 +56,8 @@ module Cod
     #   chan.put :symbol
     #
     def put(message)
-      not_implemented
+      # TODO Errno::EPIPE raised after a while when the receiver goes away. 
+      @writer.put(message)
     end
     
     # Reads a Ruby object (a message) from the channel. Some channels may not
@@ -60,17 +66,30 @@ module Cod
     # <code>:timeout</code> :: Time to wait before throwing Cod::Channel::TimeoutError.
     #
     def get(opts={})
-      not_implemented
+      @reader.get(opts)
     end
     
     # Returns true if there are messages waiting in the channel. 
     #
     def waiting?
+      # TODO EOFError is thrown when the other end has gone away
+      @reader.waiting?
+    end
+  
+    # Returns true if the channel is connected, and false if all hope must be
+    # given up of reconnecting this channel. 
+    #
+    def connected?
       not_implemented
     end
     
+    # Closes reader and writer. 
+    #
     def close
-      not_implemented
+      @reader.close if @reader
+      @writer.close if @writer
+      
+      @reader = @writer = nil
     end
     
     # Returns the Identifier class below the current channel class. This is 
@@ -154,9 +173,13 @@ module Cod
     end
     
     def not_implemented
-      raise NotImplementedError, 
+      trace = caller.reject {|l| l =~ %r{#{Regexp.escape(__FILE__)}}} # blatantly stolen from dependencies.rb in activesupport
+      exception = NotImplementedError.new(
         "You called a method in Cod::Channel::Base. Missing implementation in "+
-        "the subclass!"
+        "the subclass #{self.class.name}!")
+      exception.set_backtrace trace
+      
+      raise exception
     end
   end
 end

data/lib/cod/channel/beanstalk.rb

@@ -46,7 +46,7 @@ module Cod
     end
     
     def close
-      @connection = @reference = nil
+      connection.close
     end
 
     def identifier

data/lib/cod/channel/pipe.rb

@@ -79,8 +79,10 @@ module Cod
   private
     def init_in_and_out
       serializer = ObjectIO::Serializer.new
-      @in = ObjectIO::Reader.new(serializer) { fds.r }
-      @out = ObjectIO::Writer.new(serializer) { fds.w }
+      read_pool = ObjectIO::Connection::Single.new { fds.r }
+      write_pool = ObjectIO::Connection::Single.new { fds.w }
+      @in = ObjectIO::Reader.new(serializer, read_pool)
+      @out = ObjectIO::Writer.new(serializer, write_pool) { fds.w }
     end
       
     def close_write

data/lib/cod/channel/tcpconnection.rb

@@ -12,6 +12,8 @@ module Cod
     #
     attr_reader :destination
     
+    attr_reader :connection_pool
+    
     def initialize(destination_or_connection)
       if destination_or_connection.respond_to?(:to_str)
         @destination = split_uri(destination_or_connection)
@@ -20,23 +22,18 @@ module Cod
         @destination = nil
         @connection = destination_or_connection
       end
-    
+      
       serializer = ObjectIO::Serializer.new
-      @writer = ObjectIO::Writer.new(serializer, &method(:reconnect))
-      @reader = ObjectIO::Reader.new(serializer) { reconnect }
-    end
-    
-    def put(message)
-      @writer.put(message)
-    end
-    
-    def get(opts={})
-      @reader.get(opts)
+      @connection_pool = ObjectIO::Connection::Single.new { connect }
+      
+      super(
+        ObjectIO::Reader.new(serializer, @connection_pool), 
+        ObjectIO::Writer.new(serializer, @connection_pool))
     end
-    
-    def close
-      @connection.close if @connection
-      @connection = nil
+        
+    def connected?
+      waiting?
+      connection_pool.size > 0
     end
     
     def identifier
@@ -44,15 +41,12 @@ module Cod
     end
     
   private
-    # Establishes connection in @connection. If a previous connection is 
-    # in error state, it attempts to make a new connection. 
-    #
-    def reconnect
-      @connection ||= TCPSocket.new(*destination)
-    rescue Errno::ECONNREFUSED
-      # The other end doesn't exist as of this moment. Have the caller retry
-      # later on. 
-      nil
+    def connect
+      if destination
+        TCPSocket.new(*destination) 
+      else
+        @connection
+      end
     end
   end
 

data/lib/cod/channel/tcpserver.rb

@@ -20,37 +20,33 @@ module Cod
     def initialize(bind_to)
       @bind_to = split_uri(bind_to)      
       @server = TCPServer.new(*@bind_to)
-      
+
+      connection_pool = ObjectIO::Connection::Pool.new { accept_connections(server) }
       serializer = ObjectIO::Serializer.new(self)
-      @reader = ObjectIO::Reader.new(serializer) { 
-        accept_connections(server)
-      }
-    end
-    
-    def get(opts={})
-      # Read a message from the wire and transform all contained objects.
-      @reader.get(opts) 
+      
+      super(
+        ObjectIO::Reader.new(serializer, connection_pool), 
+        nil)
     end
-    
+        
+    # Sending a message to the server side of a socket is not supported.
+    # Transmit the client side channel instance to be able to write back to it
+    # on the server side. This overwrites #put in Base for the sole purpose of
+    # raising a better error. 
+    #
     def put(message)
       communication_error "You cannot write to the server directly, transmit a "
                           "channel to the server instead."
     end
     
-    def waiting?
-      @reader.waiting?
-    end
-    
     def close
-      @reader.close if @reader
+      super
+      
       server.close if server
-
       @server = nil
-      @reader = nil
     end
 
     def transform(socket, obj)
-      # p [:tcp_server_deserialize, obj]
       if obj.kind_of?(Channel::TCPConnection::Identifier)
         # We've been sent 'a' tcp channel. Assume that it's our own client end
         # that we've been sent and turn it into a channel that communicates
@@ -72,13 +68,17 @@ module Cod
     def accept_connections(server)
       connections = []
       loop do
-        connection = server.accept_nonblock
-        connections << connection
+        # Try connecting more sockets. 
+        begin
+          connections << server.accept_nonblock
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR  
+          # Means that no more connects are pending. Ignore, since this is exactly
+          # one of the termination conditions for this method. 
+          return connections
+        end
       end
-    rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
-      # Means that no more connects are pending. Ignore, since this is exactly
-      # one of the termination conditions for this method. 
-      return connections
+      
+      fail "NOTREACHED: return should be from loop."
     end
   end
 end

data/lib/cod/connection/beanstalk.rb

@@ -52,7 +52,7 @@ module Cod
     # Closes the connection
     #
     def close
-      connection.close
+      connection.close if connection
       @connection = nil
     end
     

data/lib/cod/directory.rb

@@ -8,19 +8,40 @@ module Cod
     #
     attr_reader :channel
     
+    # Subscriptions this directory handles. 
+    #
+    attr_reader :subscriptions
+    
     def initialize(channel)
       @channel = channel
-      @subscriptions = []
+      @subscriptions = Set.new
     end
     
-    # Sends the message to all subscribers that listen to this topic. 
+    # Sends the message to all subscribers that listen to this topic. Returns
+    # the number of subscribers this message has been sent to. 
     #
     def publish(topic, message)
-      handle_subscriptions
-      
+      process_control_messages
+
+      n = 0
+      failed_subscriptions = []
       for subscription in @subscriptions
-        subscription.put message if subscription === topic
+        begin
+          if subscription === topic
+            subscription.put message
+            n += 1
+          end
+        # TODO reenable this with more specific exception list.
+        rescue Cod::Channel::DirectionError
+          # Writing message failed; remove the subscription. 
+          failed_subscriptions << subscription
+        end
       end
+      
+      process_control_messages
+      
+      remove_subscriptions { |sub| failed_subscriptions.include?(sub) }
+      return n
     end
     
     # Closes all resources used by the directory. 
@@ -28,17 +49,50 @@ module Cod
     def close
       channel.close
     end
+
+    # Internal use: Subscribe a new topic to this directory. 
+    #
+    def subscribe(subscription, status=:new)
+      if status == :new && subscriptions.include?(subscription)
+        raise "UUID collision? I already have a subscription for #{subscription.identifier}."
+      end
+      
+      @subscriptions << subscription
+    end
     
-  private
-  
-    def handle_subscriptions
+    # Internal method to process messages that are inbound on the directory 
+    # control channel.
+    #
+    def process_control_messages(now = Time.now)
+      # Handle incoming messages on channel
       while channel.waiting?
-        subscribe channel.get
+        cmd, *rest = channel.get(timeout: 0.1)
+        case cmd
+          when :subscribe
+            subscription, status = *rest
+            subscribe subscription, status
+          when :ping
+            ping_id = rest.first
+            subscriptions.
+              find { |sub| sub.identifier == ping_id }.
+              ping
+        else 
+          warn "Unknown command received: #{cmd.inspect} (#{rest.inspect})"
+        end
       end
+
+      # Remove all stale subscriptions
+      remove_subscriptions { |sub| sub.stale?(now) }
+    rescue ArgumentError
+      # Probably we could not create a duplicate of a serialized channel. 
+      # Ignore this round of subscriptions. 
     end
-    
-    def subscribe(subscription)
-      @subscriptions << subscription
+
+  private
+    def remove_subscriptions(&block)
+      @subscriptions.delete_if(&block)
     end
   end
-end
+end
+
+require 'cod/directory/countdown'

data/lib/cod/directory/countdown.rb

@@ -0,0 +1,31 @@
+class Cod::Directory
+  class Countdown
+    attr_reader :run_time
+    
+    def initialize(run_time=30*60, now = Time.now)
+      @run_time = run_time
+      start(now); stop
+    end
+    
+    def elapsed?(now = Time.now)
+      if running?
+        return (now - @started_at) > @run_time
+      else
+        return (@stopped_at - @started_at) > @run_time
+      end
+    end
+    
+    def running?
+      @started_at && !@stopped_at
+    end
+    
+    def start(now = Time.now)
+      @started_at = now
+      @stopped_at = nil
+    end
+    
+    def stop(now = Time.now)
+      @stopped_at = now
+    end
+  end
+end

data/lib/cod/directory/subscription.rb

@@ -1,21 +1,59 @@
-module Cod
-  # Represents a subscription to a directory. 
+class Cod::Directory
+  # Represents a subscription to a directory. The subscription is what links
+  # the topic to the directory. It carries the topic id as identifier; this is
+  # what gives the subscription identity. If two subscriptions in a system
+  # have the same identifier, they link to the same topic instance and should
+  # not be sent the same message twice. 
   #
-  class Directory::Subscription
+  class Subscription
     attr_reader :matcher
     attr_reader :channel
+    attr_reader :countdown
     
-    def initialize(matcher, channel)
+    def initialize(matcher, channel, topic_id)
       @matcher = matcher
       @channel = channel
+      @countdown = Countdown.new
+      @identifier = topic_id
     end
     
     def ===(other)
       matcher === other
     end
     
+    def identifier
+      @identifier
+    end
+    def eql?(other)
+      hash == other.hash && 
+        identifier == other.identifier
+    end
+    alias == eql?
+    def hash
+      identifier.hash
+    end
+    
     def put(msg)
-      channel.put msg
+      countdown.start
+      
+      # Envelope the message to send this subscription id along
+      channel.put [identifier, msg]
+    end
+    
+    # Is this subscription stale? Staleness is determined by an internal
+    # countdown since last #put operation. 
+    #
+    def stale?(now=Time.now)
+      countdown.running? && countdown.elapsed?(now)
+    end
+   
+    # Tells the subscription that the other end has sent back a ping. This 
+    # always marks the subscription alive. 
+    #
+    def ping(now= Time.now)
+      # Stop the countdown where it is. If it has elapsed?, the subscription
+      # will be marked as stale?
+      countdown.stop(now)
     end
   end
 end

data/lib/cod/object_io.rb

@@ -1,3 +1,6 @@
+module Cod::ObjectIO; end
+
+require 'cod/objectio/connection'
 require 'cod/objectio/reader'
 require 'cod/objectio/writer'
 require 'cod/objectio/serializer'

data/lib/cod/objectio/connection.rb

@@ -0,0 +1,106 @@
+module Cod::ObjectIO::Connection
+  class Pool
+    include Enumerable 
+    
+    attr_reader :connect_action
+    attr_reader :connections
+    
+    # Example: 
+    #   Connection::Single.new { TCPSocket.new('...') }
+    #   Connection::Pool.new { socket.accept }
+    #   
+    def initialize(&connect_action)
+      raise ArgumentError unless connect_action
+      
+      @connect_action = connect_action
+      @connections = []
+    end
+    
+    def size
+      @connections.size
+    end
+    
+    def report_failed(connection)
+      @connections.delete_if { |e| e == connection }
+    end
+    
+    def accept
+      @connections += call_connect
+    end
+    
+    def each(&block)
+      @connections.each(&block)
+    end
+    
+    # Closes all connections in this pool. 
+    #
+    def close
+      self.each do |connection|
+        begin
+          connection.close 
+        rescue IOError
+          # Maybe someone else that shares this connection closed it already?
+          # DO NOTHING
+        end
+      end
+    end
+  private
+    # Calls the connect_action block and normalizes the result to be either
+    # an array or nil. 
+    #
+    def call_connect
+      result = connect_action[]
+      if result
+        return [result].flatten
+      end
+      
+      return nil
+    end
+  end
+    
+  # Implements a single connection that is retried on failure for a number
+  # of times. 
+  #
+  class Single < Pool
+    MAX_FAILURES = 10
+    
+    def initialize(&connect_action)
+      super
+      
+      @connected = false
+      @failures = 0
+    end
+    
+    def report_failed(connection)
+      super
+
+      @failures += 1
+      @connected = false
+    end
+    
+    def accept
+      return if @connected
+      
+      # How many times have we reconnected? Maybe just give up. 
+      permanent_connection_error if @failures >= MAX_FAILURES
+
+      # Try and make a new connection: Returns it on success.
+      new_connection = call_connect
+      if new_connection
+        @connected = true
+        @connections += new_connection
+        return
+      end
+      
+      # No new connection could be made. Count this as a failure. 
+      @failures += 1
+      return
+    end
+    
+  private
+    def permanent_connection_error
+      raise Cod::Channel::CommunicationError, 
+        "Permanent connection failure: Giving up."
+    end
+  end
+end

data/lib/cod/objectio/reader.rb

@@ -3,55 +3,25 @@ module Cod::ObjectIO
   #
   class Reader
     attr_reader :waiting_messages
-    attr_reader :registered_ios
+    attr_reader :pool
     
     # Initializes an object reader that reads from one or several IO objects. 
-    # You can either pass the io object in the constructor (io) or you can 
-    # provide the instance with a block that is called each time a read is
-    # attempted. The block should return an array of IO objects to also read
-    # from. 
     #
     # Example: 
-    #   reader = Reader.new { make_connection }
+    #   connection = Connection::Pool.new { make_new_connection }
+    #   reader = Reader.new(serializer, connection)
     #    
-    def initialize(serializer, io=nil, &block)
+    def initialize(serializer, conn_pool)
       @serializer = serializer
       @waiting_messages = []
-      @establish_block = block
-      @registered_ios = Set.new
-      
-      register io if io
+      @pool = conn_pool
     end    
     
-    # Called before each attempt to read from the wire. This should return 
-    # the IO objects that need to be considered when reading. 
-    #
-    def establish
-      sockets = @establish_block && @establish_block.call(@io) ||
-        nil
-      
-      [sockets].flatten
-    end
-    
-    def register(ios)
-      return unless ios
-      ios.each do |io|
-        registered_ios << io
-      end
-    end
-    
-    def unregister(ios)
-      ios.each do |io|
-        registered_ios.delete(io)
-      end
-    end
-    
     def get(opts={})
       return waiting_messages.shift if queued?
       
       start_time = Time.now
       loop do
-        # p [:looping, opts]
         read_from_wire opts
         
         # Early return in case we have a message waiting
@@ -69,6 +39,8 @@ module Cod::ObjectIO
     def waiting?
       read_from_wire
       queued?
+    rescue Cod::Channel::CommunicationError
+      queued?
     end
     
     def queued?
@@ -76,7 +48,7 @@ module Cod::ObjectIO
     end
     
     def close
-      @registered_ios.each { |io| io.close }
+      @pool.close
     end
     
   private 
@@ -85,13 +57,10 @@ module Cod::ObjectIO
     #
     def read_from_wire(opts={})
       # Establish new connections and register them
-      register establish
+      @pool.accept
 
-      # Wait for sockets to have data
-      ready_read, _, _ = IO.select(Array(registered_ios), nil, nil, 0.1)
-      
-      # Read all ready sockets
-      process_nonblock(ready_read) if ready_read
+      # Process all waiting data
+      process_nonblock(@pool.connections)
     end
     
     # Reads all data waiting in each io in the ios array. 
@@ -111,11 +80,11 @@ module Cod::ObjectIO
       while not sio.eof?
         waiting_messages << deserialize(io, sio)
       end
+    rescue Errno::EAGAIN
+      # read failed because there was no data. This is expected. 
+      return
     rescue EOFError
-      # Connection has failed/ been disconnected. 
-      # We will need to reconnect this. If possible. 
-      registered_ios.delete(io)
-      raise
+      @pool.report_failed(io)
     end
         
     # Deserializes a message (in message format, string) into the object that

data/lib/cod/objectio/writer.rb

@@ -2,29 +2,24 @@ module Cod::ObjectIO
   # Writes objects to an IO stream. 
   #
   class Writer    
-    def initialize(serializer, io=nil, &block)
+    def initialize(serializer, pool)
       @serializer = serializer
-      @io = io
-      @reconnect_block = block
+      @pool = pool
     end
     
     def put(message)
-      attempt_reconnect
+      @pool.accept
 
-      @io.write(serialize(message)) if @io
+      @pool.each do |connection|
+        connection.write(serialize(message))
+      end
     end
     
     def close
-      @io.close
+      @pool.close
     end
     
   private
-    def attempt_reconnect
-      if @reconnect_block
-        @io = @reconnect_block[]
-      end
-    end
-  
     def serialize(message)
       @serializer.serialize(message)
     end

data/lib/cod/topic.rb

@@ -4,9 +4,33 @@ module Cod
   class Topic
     attr_reader :answers, :directory
     attr_reader :match_expr
-    def initialize(match_expr, directory_channel, answer_channel)
+    attr_reader :identifier
+    attr_reader :subscription
+    attr_reader :renew_countdown
+    
+    # Creates a topic that subscribes to a part of a directory. The match_expr
+    # decides which messages get forwarded to this topic, it limits the 
+    # topic to a subset of the messages in the directory. 
+    # 
+    # Parameters: 
+    #   match_expr        :: Topic to subscribe
+    #   directory_channel :: Directory channel
+    #   answer_channel    :: Where the messages for this topic get sent
+    #   opts              :: See below
+    #
+    # Available options are: 
+    #   :renew            :: Renew the subscription every n seconds. 
+    # 
+    def initialize(match_expr, directory_channel, answer_channel, opts={})
       @directory, @answers = directory_channel, answer_channel
       @match_expr = match_expr
+      @identifier = Cod.uuid
+      @subscription = Directory::Subscription.new(
+        match_expr, answers, @identifier)
+      
+      # Default is to renew subscriptions every 30 minutes
+      @renew_countdown = Directory::Countdown.new(opts[:renew] || 30*60)
+      renew_countdown.start
       
       subscribe
     end
@@ -14,14 +38,51 @@ module Cod
     # Subscribes this topic to the directory's messages. This gets called upon
     # initialization and must not be called again. 
     #
-    def subscribe
-      directory.put Directory::Subscription.new(match_expr, answers)
+    def subscribe(status=:new)
+      directory.put [
+        :subscribe, subscription, status]
+
+      # Start counting down to next subscription renewal
+      renew_countdown.start
+    end
+    def renew_subscription
+      subscribe(:refresh)
+    end
+    def renewal_needed?
+      renew_countdown.elapsed?
     end
 
     # Reads the next message from the directory that matches this topic. 
     #
-    def get
-      answers.get
+    def get(opts={})
+      # Read one message from the channel
+      subscription_id, message = next_message(opts)
+      # Answer back with a ping (so the directory knows we're still there)
+      directory.put [:ping, subscription_id]
+      
+      return message
+    end
+    def next_message(opts)
+      if t=opts[:timeout]
+        timeout_at = Time.now + t
+        timeout    = [t, renew_countdown.run_time].min
+      else
+        timeout_at = nil
+        timeout    = renew_countdown.run_time
+      end
+
+      loop do
+        renew_subscription if renewal_needed?
+        
+        begin
+          return answers.get(opts.merge(:timeout => timeout))
+        rescue Cod::Channel::TimeoutError
+          raise if timeout_at && Time.now > timeout_at
+          # DO NOTHING
+        end
+      end
+
+      fail "NOT REACHED"
     end
     
     # Closes all resources used by the topic. 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cod
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-20 00:00:00.000000000 +02:00
-default_executable: 
+date: 2011-07-20 00:00:00.000000000Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: &70169583690420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70169583690420
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2154614480 !ruby/object:Gem::Requirement
+  requirement: &70169583689920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2154614480
+  version_requirements: *70169583689920
 - !ruby/object:Gem::Dependency
   name: flexmock
-  requirement: &2154476000 !ruby/object:Gem::Requirement
+  requirement: &70169583689340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2154476000
+  version_requirements: *70169583689340
 - !ruby/object:Gem::Dependency
   name: sdoc
-  requirement: &2154475480 !ruby/object:Gem::Requirement
+  requirement: &70169583688800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2154475480
+  version_requirements: *70169583688800
 description: 
 email: kaspar.schiess@absurd.li
 executables: []
@@ -57,8 +67,6 @@ files:
 - LICENSE
 - Rakefile
 - README
-- lib/at_fork.rb
-- lib/cod/channel/abstract.rb
 - lib/cod/channel/base.rb
 - lib/cod/channel/beanstalk.rb
 - lib/cod/channel/pipe.rb
@@ -68,7 +76,7 @@ files:
 - lib/cod/channel.rb
 - lib/cod/client.rb
 - lib/cod/connection/beanstalk.rb
-- lib/cod/context.rb
+- lib/cod/directory/countdown.rb
 - lib/cod/directory/subscription.rb
 - lib/cod/directory.rb
 - lib/cod/object_io.rb
@@ -83,10 +91,14 @@ files:
 - examples/master_child.rb
 - examples/ping.rb
 - examples/pong.rb
+- examples/presence_client.rb
+- examples/presence_server.rb
+- examples/pubsub/client.rb
+- examples/pubsub/directory.rb
+- examples/pubsub/README
 - examples/service.rb
 - examples/service_directory.rb
 - examples/tcp.rb
-has_rdoc: true
 homepage: http://kschiess.github.com/cod
 licenses: []
 post_install_message: 
@@ -109,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Really simple IPC.

data/lib/at_fork.rb

@@ -1,53 +0,0 @@
-# Extends the Kernel module with an at_fork method for installing at_fork
-# handlers. 
-#
-# NOTE: at_fork handlers are executed in the thread that does the forking and
-# that survives the process fork. 
-#
-# Usage: 
-# 
-#   at_fork do 
-#     # Do something on fork (in the forking process)
-#   end
-#   at_fork(:child) { ... }  # do something in the forked process 
-#   at_fork(:parent) { ... } # do something in the forking process
-# 
-module Kernel
-  # Child at_fork handlers
-  #
-  def self.at_fork_child
-    @at_fork_child ||= []
-  end
-  
-  # Parent at_fork handlers
-  #
-  def self.at_fork_parent
-    @at_fork_parent ||= []
-  end
-  
-  def at_fork(type=:parent,&block)
-    raise ArgumentError, "Must provide a handler block." unless block
-    
-    handler_array = (type == :child) ? 
-      Kernel.at_fork_child : Kernel.at_fork_parent
-      
-    handler_array << block
-  end
-  
-  def fork_with_at_fork(&block)
-    Kernel.at_fork_parent.each(&:call)
-    
-    fork_without_at_fork do
-      # From this point on, operation is single threaded.
-      
-      Kernel.at_fork_child.each(&:call)
-      
-      Kernel.at_fork_parent.replace([])
-      Kernel.at_fork_child.replace([])
-      
-      block.call
-    end
-  end
-  alias fork_without_at_fork  fork
-  alias fork                  fork_with_at_fork
-end

data/lib/cod/channel/abstract.rb

@@ -1,32 +0,0 @@
-module Cod
-  # This is mostly documentation: Use it as a template for new channels.
-  class Channel::Abstract < Channel::Base
-    def initialize(destination)
-      not_implemented
-    end
-    
-    def initialize_copy(from)
-      not_implemented
-    end
-    
-    def put(message)
-      not_implemented
-    end
-    
-    def get(opts={})
-      not_implemented
-    end
-    
-    def waiting?
-      not_implemented
-    end
-    
-    def close
-      not_implemented
-    end
-    
-    def identifier
-      not_implemented
-    end
-  end
-end

data/lib/cod/context.rb

@@ -1,25 +0,0 @@
-require 'weakref'
-
-module Cod
-  # Context will allow to produce channels retaining some state. Until now, 
-  # this hasn't been neccessary. 
-  #
-  class Context
-    def pipe(name=nil)
-      Cod::Channel::Pipe.new(name)
-    end
-    
-    def beanstalk(url, name=nil)
-      Cod::Channel::Beanstalk.new(
-        Connection::Beanstalk.new(url), name)
-    end
-    
-    def tcp(destination)
-      Cod::Channel::TCPConnection.new(destination)
-    end
-
-    def tcpserver(bind_to)
-      Cod::Channel::TCPServer.new(bind_to)
-    end
-  end
-end