cod 0.3.1 → 0.4.0

data/lib/cod/channel/beanstalk.rb

@@ -1,69 +0,0 @@
-
-begin
-  require 'beanstalk-client'
-rescue LoadError
-  fail "You should install the gem 'beanstalk-client' to use Cod::Channel::Beanstalk."
-end
-
-module Cod
-  # Also see Channel::Base for more documentation. 
-  #
-  class Channel::Beanstalk < Channel::Base
-    NONBLOCK_TIMEOUT = 0.01
-    
-    # Connection instance that is in use for this channel.
-    attr_reader :connection
-
-    # Name of the queue on the beanstalk server
-    attr_reader :tube_name
-    
-    def initialize(connection, name)
-      @connection = connection
-      @tube_name = name.freeze
-      @serializer = ObjectIO::Serializer.new
-    end
-    
-    def initialize_copy(from)
-      @connection = from.connection.dup
-      @tube_name = from.tube_name
-    end
-    
-    def put(message)
-      buffer = @serializer.serialize(message)
-      connection.put(tube_name, buffer)
-    end
-    
-    def waiting?
-      connection.waiting?(tube_name)
-    end
-    
-    def get(opts={})
-      message = connection.get(tube_name, 
-        :timeout => opts[:timeout])
-      return @serializer.deserialize(nil, message)
-    rescue Beanstalk::TimedOut
-      raise Channel::TimeoutError, "No messages waiting in #{tube_name}."
-    end
-    
-    def close
-      connection.close
-    end
-
-    def identifier
-      identifier_class.new(connection.url, tube_name)
-    end
-  end
-
-  class Channel::Beanstalk::Identifier
-    def initialize(url, tube_name)
-      @url, @tube_name = url, tube_name
-    end
-    
-    def resolve(ctxt=nil)
-      raise NotImplementedError, "Explicit context not yet implemented." \
-        if ctxt
-          
-      Cod.beanstalk(@url, @tube_name)
-    end
-  end
-end

data/lib/cod/channel/pipe.rb

@@ -1,137 +0,0 @@
-module Cod
-  # A channel that uses IO.pipe as its transport mechanism. This means that
-  # 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. 
-    #
-    Fds = Struct.new(:r, :w)
-    
-    attr_reader :fds
-    
-    def initialize(name=nil)
-      @fds = Fds.new(*IO.pipe)
-      
-      init_in_and_out
-    end
-
-    def initialize_copy(old)
-      old_fds = old.fds
-
-      raise ArgumentError, 
-        "Dupping a pipe channel only makes sense if it is still unused." \
-          unless old_fds.r && old_fds.w
-
-      @fds = Fds.new(
-        old_fds.r.dup, 
-        old_fds.w.dup)
-      
-      init_in_and_out
-    end
-    
-    def put(message)
-      close_read
-      
-      unless fds.w
-        direction_error 'Cannot put data to pipe. Already closed that end?'
-      end
-      
-      @out.put(message)
-    rescue Errno::EPIPE
-      direction_error "You should #dup before writing; Looks like no other copy exists currently."
-    end
-    
-    def waiting?
-      @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
-      
-      unless fds.r
-        direction_error 'Cannot get data from pipe. Already closed that end?'
-      end
-      
-      @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?'
-    end
-    
-    def close
-      close_write
-      close_read
-    end
-
-  private
-    def init_in_and_out
-      serializer = ObjectIO::Serializer.new
-      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
-      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
-    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
-  end
-  
-  class Channel::Pipe::Identifier
-    def initialize(channel)
-      @objid = channel.object_id
-    end
-    
-    def resolve
-      ObjectSpace._id2ref(@objid).dup
-    rescue RangeError
-      raise Cod::InvalidIdentifier, 
-        "Could not reference channel. Either it was garbage collected "+
-        "or it never existed in this process."
-    end
-  end
-end

data/lib/cod/channel/tcp.rb

@@ -1,16 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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
-    
-    attr_reader :connection_pool
-    
-    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
-      @connection_pool = ObjectIO::Connection::Single.new { connect }
-      
-      super(
-        ObjectIO::Reader.new(serializer, @connection_pool), 
-        ObjectIO::Writer.new(serializer, @connection_pool))
-    end
-        
-    def connected?
-      waiting?
-      connection_pool.size > 0
-    end
-    
-    def identifier
-      Identifier.new(destination)
-    end
-    
-  private
-    def connect
-      if destination
-        TCPSocket.new(*destination) 
-      else
-        @connection
-      end
-    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

@@ -1,84 +0,0 @@
-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)
-
-      connection_pool = ObjectIO::Connection::Pool.new { accept_connections(server) }
-      serializer = ObjectIO::Serializer.new(self)
-      
-      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 close
-      super
-      
-      server.close if server
-      @server = nil
-    end
-
-    def transform(socket, 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
-        # 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
-      
-      fail "NOTREACHED: return should be from loop."
-    end
-  end
-end

data/lib/cod/client.rb

@@ -1,81 +0,0 @@
-
-module Cod
-  # A client that consumes a service (Cod::Service).
-  #
-  class Client
-    attr_reader :incoming
-    attr_reader :outgoing
-    
-    # Create a new client and tie it to an answer channel. The answer channel
-    # will often be anonymous - no one except the service needs to write
-    # there. 
-    #
-    def initialize(requests, answers, timeout=1)
-      @timeout = timeout
-      @incoming = answers
-      @outgoing = requests
-      @request_id = 0
-    end
-
-    # Calls the service in a synchronous fashion. Returns the message the
-    # server sends back. 
-    #
-    def call(message=nil)
-      expected_id = next_request_id
-      outgoing.put envelope(expected_id, message, incoming, true)
-      
-      start_time = Time.now
-      loop do
-        received_id, answer = incoming.get(:timeout => @timeout)
-        return answer if received_id == expected_id
-        
-        # We're receiving answers with request_ids that are outside the 
-        # window that we would expect. Something is seriously amiss. 
-        raise Cod::Channel::CommunicationError, 
-          "Missed request." unless earlier?(expected_id, received_id)
-          
-        # We've been waiting (and consuming answers) for too long - overall
-        # timeout has elapsed. 
-        raise Cod::Channel::TimeoutError, 
-          "Timed out while waiting for service request answer." \
-            if (Time.now-start_time) > @timeout
-      end
-    end
-    
-    # This sends the server a message without waiting for an answer. The
-    # server will throw away the answer produced. 
-    #
-    def notify(message=nil)
-      outgoing.put envelope(next_request_id, message, incoming, false)
-      nil
-    end
-    
-    # Closes all resources that are held in the client. 
-    #
-    def close
-      incoming.close
-      outgoing.close
-    end
-    
-  private
-  
-    # Creates a message to send to the service. 
-    #
-    def envelope(id, message, incoming_channel, needs_answer)
-      [id, message, incoming_channel, needs_answer]
-    end
-  
-    # Returns a sequence of request ids.
-    #
-    def next_request_id
-      @request_id += 1
-    end
-    
-    # True if the received request id answers a request that has been 
-    # earlier than the expected request id.
-    #
-    def earlier?(expected, received)
-      expected > received
-    end
-  end
-end