cod 0.2.0 → 0.3.0

data/lib/cod/channel/beanstalk.rb

@@ -6,6 +6,8 @@ rescue LoadError
 end
 
 module Cod
+  # Also see Channel::Base for more documentation. 
+  #
   class Channel::Beanstalk < Channel::Base
     NONBLOCK_TIMEOUT = 0.01
     
@@ -15,18 +17,19 @@ module Cod
     # Name of the queue on the beanstalk server
     attr_reader :tube_name
     
-    def initialize(connection, name=nil)
+    def initialize(connection, name)
       @connection = connection
-      @tube_name = (name || gen_anonymous_name('beanstalk')).freeze
+      @tube_name = name.freeze
+      @serializer = ObjectIO::Serializer.new
     end
     
     def initialize_copy(from)
-      @connection = from.connection
+      @connection = from.connection.dup
       @tube_name = from.tube_name
     end
     
     def put(message)
-      buffer = serialize(message)
+      buffer = @serializer.serialize(message)
       connection.put(tube_name, buffer)
     end
     
@@ -37,7 +40,7 @@ module Cod
     def get(opts={})
       message = connection.get(tube_name, 
         :timeout => opts[:timeout])
-      return deserialize(message)
+      return @serializer.deserialize(nil, message)
     rescue Beanstalk::TimedOut
       raise Channel::TimeoutError, "No messages waiting in #{tube_name}."
     end
@@ -49,10 +52,6 @@ module Cod
     def identifier
       identifier_class.new(connection.url, tube_name)
     end
-  private
-    def gen_anonymous_name(base)
-      base + ".anonymous"
-    end
   end
 
   class Channel::Beanstalk::Identifier

data/lib/cod/channel/pipe.rb

@@ -3,6 +3,8 @@ module Cod
   # you can only communicate within a single process hierarchy using this, 
   # since the file descriptors are not visible to the outside world. 
   #
+  # Also see Channel::Base for more documentation. 
+  #
   class Channel::Pipe < Channel::Base
     # A tuple storing the read and the write end of a IO.pipe. 
     #
@@ -12,7 +14,8 @@ module Cod
     
     def initialize(name=nil)
       @fds = Fds.new(*IO.pipe)
-      @waiting_messages = []
+      
+      init_in_and_out
     end
 
     def initialize_copy(old)
@@ -26,7 +29,7 @@ module Cod
         old_fds.r.dup, 
         old_fds.w.dup)
       
-      @waiting_messages = []
+      init_in_and_out
     end
     
     def put(message)
@@ -35,43 +38,37 @@ module Cod
       unless fds.w
         direction_error 'Cannot put data to pipe. Already closed that end?'
       end
-            
-      buffer = transport_pack(message)
-      fds.w.write(buffer)
+      
+      @out.put(message)
     rescue Errno::EPIPE
       direction_error "You should #dup before writing; Looks like no other copy exists currently."
     end
     
     def waiting?
-      process_inbound_nonblock
-      queued?
-    rescue Cod::Channel::CommunicationError
-      # Gets raised whenever communication fails permanently. This means that
-      # we probably wont be able to return any more messages. The only messages
-      # remaining in such a situation would be those queued.
-      return queued?
+      @in.waiting?
+    rescue EOFError
+      # We've just hit end of file in the pipe. That means that all write 
+      # ends have been closed. 
+      @in.queued?
     end
     
     def get(opts={})
       close_write
       
-      return @waiting_messages.shift if queued?
-
-      start_time = Time.now
-      loop do
-        IO.select([fds.r], nil, [fds.r], 0.1)
-        process_inbound_nonblock
-        return @waiting_messages.shift if queued?
-        
-        if opts[:timeout] && (Time.now-start_time) > opts[:timeout]
-          raise Cod::Channel::TimeoutError, 
-            "No messages waiting in pipe."
-        end
+      unless fds.r
+        direction_error 'Cannot get data from pipe. Already closed that end?'
       end
-      # NEVER REACHED
+      
+      @in.get(opts)
+    rescue EOFError
+      # We've just hit end of file in the pipe. That means that all write 
+      # ends have been closed. 
+      communication_error "All write ends for this pipe have been closed. "+
+        "Further #get's would block forever." \
+        unless @in.queued?
 
-    rescue Errno::EPIPE
-      direction_error 'Cannot get data from pipe. Already closed that end?'
+    # rescue Errno::EPIPE
+    #   direction_error 'Cannot get data from pipe. Already closed that end?'
     end
     
     def close
@@ -79,44 +76,47 @@ module Cod
       close_read
     end
 
-    def identifier
-      identifier_class.new(self)
-    end
   private
-    def queued?
-      not @waiting_messages.empty?
+    def init_in_and_out
+      serializer = ObjectIO::Serializer.new
+      @in = ObjectIO::Reader.new(serializer) { fds.r }
+      @out = ObjectIO::Writer.new(serializer) { fds.w }
     end
-    
+      
     def close_write
       return unless fds.w
       fds.w.close
+
       fds.w = nil
+      @out = nil
     end
     
     def close_read
       return unless fds.r
       fds.r.close
+
       fds.r = nil
+      @in = nil
     end
   
-    # Tries hard to empty the pipe and to store incoming messages in 
-    # @waiting_messages.
-    #
-    def process_inbound_nonblock
-      buffer = fds.r.read_nonblock(1024*1024*1024)
-
-      while buffer.size > 0
-        @waiting_messages << transport_unpack(buffer)
-      end
+    # # Tries hard to empty the pipe and to store incoming messages in 
+    # # @waiting_messages.
+    # #
+    # def process_inbound_nonblock
+    #   buffer = fds.r.read_nonblock(1024*1024*1024)
+    # 
+    #   while buffer.size > 0
+    #     @waiting_messages << transport_unpack(buffer)
+    #   end
     rescue EOFError
       # We've just hit end of file in the pipe. That means that all write 
       # ends have been closed. 
       communication_error "All write ends for this pipe have been closed. "+
         "Further #get's would block forever." \
         unless queued?
-    rescue Errno::EAGAIN
-      # Catch and ignore this: fds.r is not ready and read would block.
-    end
+    # rescue Errno::EAGAIN
+    #   # Catch and ignore this: fds.r is not ready and read would block.
+    # end
   end
   
   class Channel::Pipe::Identifier
@@ -125,7 +125,7 @@ module Cod
     end
     
     def resolve
-      ObjectSpace._id2ref(@objid)
+      ObjectSpace._id2ref(@objid).dup
     rescue RangeError
       raise Cod::InvalidIdentifier, 
         "Could not reference channel. Either it was garbage collected "+

data/lib/cod/channel/tcp.rb

@@ -0,0 +1,16 @@
+require 'socket'
+
+module Cod
+  module Channel::TCP
+    def split_uri(uri)
+      colon = uri.index(':')
+      raise ArgumentError, 
+        "TCP points must include a port number, #{uri.inspect} does not." \
+        unless colon
+      
+      [
+        colon == 0 ? nil : uri[0...colon], 
+        Integer(uri[colon+1..-1])]
+    end
+  end
+end

data/lib/cod/channel/tcpconnection.rb

@@ -0,0 +1,73 @@
+require 'cod/channel/tcp'
+
+module Cod
+  # A channel based on a tcp connection.
+  #
+  # Also see Channel::Base for more documentation. 
+  #
+  class Channel::TCPConnection < Channel::Base
+    include Channel::TCP
+    
+    # A <host, port> tuple: The target of this connection. 
+    #
+    attr_reader :destination
+    
+    def initialize(destination_or_connection)
+      if destination_or_connection.respond_to?(:to_str)
+        @destination = split_uri(destination_or_connection)
+        @connection = nil
+      else
+        @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)
+    end
+    
+    def close
+      @connection.close if @connection
+      @connection = nil
+    end
+    
+    def identifier
+      Identifier.new(destination)
+    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
+    end
+  end
+
+  class Channel::TCPConnection::Identifier
+    def initialize(destination)
+      @destination = destination
+    end
+    
+    def resolve
+      # If we've been sent to our own server end, assume the role of the
+      # socket on that side. This is achieved by inserting the self into 
+      # the stream of deserialized objects and having the transformer 
+      # (attached to the serializer, see ObjectIO::Serializer) transform
+      # it into a valid connection object. 
+      self
+    end
+  end
+end

data/lib/cod/channel/tcpserver.rb

@@ -0,0 +1,84 @@
+require 'cod/channel/tcp'
+
+module Cod
+  # A channel based on a passive tcp server (listening). 
+  #
+  # Also see Channel::Base for more documentation. 
+  #
+  class Channel::TCPServer < Channel::Base
+    include Channel::TCP
+    
+    # The <host, port> tuple this server is bound to. 
+    attr_reader :bind_to
+    
+    # The actual TCPServer instance
+    attr_reader :server
+    
+    # Sockets that are open to clients
+    attr_reader :connections
+    
+    def initialize(bind_to)
+      @bind_to = split_uri(bind_to)      
+      @server = TCPServer.new(*@bind_to)
+      
+      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) 
+    end
+    
+    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
+      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
+        # back there. 
+        return Channel::TCPConnection.new(socket)
+      end
+      
+      return obj
+    end
+    
+    def identifier
+      communication_error "TCP server channels cannot be transmitted."
+    end
+  
+  private
+    
+    # Accept all pending connects and stores them in the connections array. 
+    #
+    def accept_connections(server)
+      connections = []
+      loop do
+        connection = server.accept_nonblock
+        connections << connection
+      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
+    end
+  end
+end

data/lib/cod/connection/beanstalk.rb

@@ -2,6 +2,8 @@ module Cod
   # Wraps the lower level beanstalk connection and exposes only methods that
   # we need; also makes tube handling a bit more predictable. 
   #
+  # This class is NOT thread safe.
+  #
   class Connection::Beanstalk
     # The url that was used to connect to the beanstalk server. 
     attr_reader :url
@@ -11,27 +13,35 @@ module Cod
     
     def initialize(url)
       @url = url
-      @connection = Beanstalk::Connection.new(url)
+      connect
+    end
+    
+    def initialize_copy(from)
+      @url = from.url
+      connect
     end
     
     # Writes a raw message as a job to the tube given by name. 
     #
     def put(name, message)
       connection.use name
+      # TODO throws EOFError when the beanstalkd server goes away
       connection.put message
     end
     
     # Returns true if there are jobs waiting in the tube given by 'name'
     def waiting?(name)
-      watch(name) do  
-        !! connection.peek_ready
-      end
+      connection.stats_tube(name)['current-jobs-ready'] > 0
+    rescue Beanstalk::NotFoundError
+      # Tube could not be found. No one has written to it! Nothing is waiting.
+      false
     end
     
     # Removes and returns the next message waiting in the tube given by name.
     #
     def get(name, opts={})
       watch(name) do
+        # TODO throws EOFError when the beanstalkd queue goes away.
         job = connection.reserve(opts[:timeout])
         job.delete
         
@@ -42,15 +52,26 @@ module Cod
     # Closes the connection
     #
     def close
+      connection.close
       @connection = nil
     end
     
+    # Creates a connection 
+    # 
+    def connect
+      # TODO throws Errno::ECONNREFUSED if the beanstalkd doesn't answer
+      @connection = Beanstalk::Connection.new(url)
+      @watching = nil
+    end
   private
     def watch(name)
-      connection.watch(name)
+      unless @watching == name
+        connection.ignore(@watching)
+        connection.watch(name)
+        @watching = name
+      end
+      
       yield
-    ensure
-      connection.ignore(name)
     end
   end
 end