cod 0.3.1 → 0.4.0

data/lib/cod/connection/beanstalk.rb

@@ -1,77 +0,0 @@
-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
-    
-    # Connection to the beanstalk server. 
-    attr_reader :connection
-    
-    def initialize(url)
-      @url = 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)
-      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
-        
-        job.body
-      end
-    end
-    
-    # Closes the connection
-    #
-    def close
-      connection.close if connection
-      @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)
-      unless @watching == name
-        connection.ignore(@watching)
-        connection.watch(name)
-        @watching = name
-      end
-      
-      yield
-    end
-  end
-end

data/lib/cod/directory.rb

@@ -1,98 +0,0 @@
-module Cod
-  # A directory where one can publish messages given a topic string. 
-  #
-  # The channel given will be where people should subscribe.
-  #
-  class Directory
-    # The channel the directory receives subscription messages on. 
-    #
-    attr_reader :channel
-    
-    # Subscriptions this directory handles. 
-    #
-    attr_reader :subscriptions
-    
-    def initialize(channel)
-      @channel = channel
-      @subscriptions = Set.new
-    end
-    
-    # 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)
-      process_control_messages
-
-      n = 0
-      failed_subscriptions = []
-      for subscription in @subscriptions
-        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. 
-    #
-    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
-    
-    # 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?
-        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
-
-  private
-    def remove_subscriptions(&block)
-      @subscriptions.delete_if(&block)
-    end
-  end
-end
-
-require 'cod/directory/countdown'

data/lib/cod/directory/countdown.rb

@@ -1,31 +0,0 @@
-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,59 +0,0 @@
-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 Subscription
-    attr_reader :matcher
-    attr_reader :channel
-    attr_reader :countdown
-    
-    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)
-      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,6 +0,0 @@
-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

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

@@ -1,98 +0,0 @@
-module Cod::ObjectIO
-  # Reads objects from one or more IO streams. 
-  #
-  class Reader
-    attr_reader :waiting_messages
-    attr_reader :pool
-    
-    # Initializes an object reader that reads from one or several IO objects. 
-    #
-    # Example: 
-    #   connection = Connection::Pool.new { make_new_connection }
-    #   reader = Reader.new(serializer, connection)
-    #    
-    def initialize(serializer, conn_pool)
-      @serializer = serializer
-      @waiting_messages = []
-      @pool = conn_pool
-    end    
-    
-    def get(opts={})
-      return waiting_messages.shift if queued?
-      
-      start_time = Time.now
-      loop do
-        read_from_wire opts
-        
-        # Early return in case we have a message waiting
-        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
-      end
-      
-      fail "NOTREACHED"
-    end
-    
-    def waiting?
-      read_from_wire
-      queued?
-    rescue Cod::Channel::CommunicationError
-      queued?
-    end
-    
-    def queued?
-      ! waiting_messages.empty?
-    end
-    
-    def close
-      @pool.close
-    end
-    
-  private 
-    
-    # Checks if data is waiting and processes messages. 
-    #
-    def read_from_wire(opts={})
-      # Establish new connections and register them
-      @pool.accept
-
-      # Process all waiting data
-      process_nonblock(@pool.connections)
-    end
-    
-    # Reads all data waiting in each io in the ios array. 
-    #
-    def process_nonblock(ios)
-      ios.each do |io|
-        process_nonblock_single(io)
-      end
-    end
-    
-    # Reads all data waiting in a single io. 
-    #
-    def process_nonblock_single(io)
-      buffer = io.read_nonblock(1024*1024*1024)
-
-      sio = StringIO.new(buffer)
-      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
-      @pool.report_failed(io)
-    end
-        
-    # Deserializes a message (in message format, string) into the object that
-    # was transmitted. Overwrite this message if you want to control the 
-    # message format. 
-    #
-    def deserialize(*args)
-      @serializer.deserialize(*args)
-    end
-  end
-end