cod 0.4.2 → 0.4.3

data/HISTORY.txt

@@ -1,3 +1,12 @@
+= 0.4.3 / 28Feb2012
+
+  ! Fixes a few bugs when using tcp channels (connection was not made or not
+    closed properly).
+    
+  + Cod::ConnectionLost should be raised when the connection goes down. This 
+    allows simply reconnecting on error, see 
+    examples/bs_ping_pong/{ping,pong}.rb on how to do this.
+
 = 0.4.2 / 15Feb2012
 
   ! Actively removes clients that have closed the sockets on their end

data/README

@@ -23,11 +23,18 @@ SYNOPSIS
     
 STATUS
 
-Complete rewrite of the code: Did away with some of the complexities that
-stemmed from early design work. The functionality that is there is much like
-that we had before, but some things have been designed more logically. 
+Working library. Some rough edges and potential for growth. Have a look at the 
+Cod module to get started.
 
-At version 0.4.0
+Working transports include: 
+
+* process (spawn, connecting to $stdout and $stdin)
+* stdio (connects to $stdout and $stdin of current process)
+* pipe (akin to IO.pipe)
+* tcp (server and client)
+* beanstalk (connects to beanstalkd)
+
+At version 0.4.3
 
 (c) 2011 Kaspar Schiess
 

data/Rakefile

@@ -2,6 +2,7 @@ require "rubygems"
 require "rdoc/task"
 require 'rspec/core/rake_task'
 require 'rubygems/package_task'
+require 'rake/clean'
 
 desc "Run all tests: Exhaustive."
 RSpec::Core::RakeTask.new
@@ -15,22 +16,12 @@ task :stats do
   end
 end
 
-require 'sdoc'
-
-# Generate documentation
-RDoc::Task.new do |rdoc|
-  rdoc.title    = "cod - IPC made really simple."
-  rdoc.options << '--line-numbers'
-  rdoc.options << '--fmt' << 'shtml' # explictly set shtml generator
-  rdoc.template = 'direct' # lighter template used on railsapi.com
-  rdoc.main = "README"
-  rdoc.rdoc_files.include("README", "lib/**/*.rb")
-  rdoc.rdoc_dir = "rdoc"
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  # t.files   = ['lib/**/*.rb']
+  # t.options = ['--any', '--extra', '--opts'] # optional
 end
 
-desc 'Clear out RDoc'
-task :clean => [:clobber_rdoc, :clobber_package]
-
 # This task actually builds the gem. 
 task :gem => :spec
 spec = eval(File.read('cod.gemspec'))
@@ -39,3 +30,6 @@ desc "Generate the gem package."
 Gem::PackageTask.new(spec) do |pkg|
   # pkg.need_tar = true
 end
+
+CLEAN << 'pkg'
+CLEAN << 'doc'

data/examples/bs_ping_pong/ping.rb

@@ -0,0 +1,15 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'cod'
+
+begin
+  pipe ||= Cod.beanstalk('pingpong', 'localhost:11300')
+
+  loop do
+    pipe.put Time.now
+    sleep 1
+  end
+rescue Cod::ConnectionLost
+  pipe.close
+  pipe = nil
+  retry
+end

data/examples/bs_ping_pong/pong.rb

@@ -0,0 +1,13 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'cod'
+
+begin
+  pipe ||= Cod.beanstalk("pingpong", 'localhost:11300')
+
+  loop do
+    puts "Received: "+pipe.get.inspect
+  end
+rescue Cod::ConnectionLost
+  pipe.close; pipe = nil
+  retry
+end  

data/examples/service.rb

@@ -9,7 +9,7 @@ service_channel = Cod.pipe
 answer_channel = Cod.pipe
 
 child_pid = fork do
-  service = Cod.service(service_channel)
+  service = service_channel.service()
   service.one { |call| 
     puts "Service got called with #{call.inspect}" 
     time = Time.now
@@ -17,7 +17,7 @@ child_pid = fork do
     time }
 end
 
-client = Cod.client(service_channel, answer_channel)
+client = service_channel.client(answer_channel)
 puts "Calling service..."
 answer = client.call('42')
 

data/lib/cod.rb

@@ -1,8 +1,10 @@
-# 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
-# channel, you #put messages into it and you #get messages out of it. Messages
-# are retrieved in FIFO manner, making channels look like a communication pipe
-# most of the time. 
+require 'stringio'
+
+# The core concept of Cod are 'channels'. (see {Cod::Channel::Base}) You can
+# create such channels on top of the various transport layers. Once you have
+# such a channel, you #put messages into it and you #get messages out of it.
+# Messages are retrieved in FIFO manner, making channels look like a
+# communication pipe most of the time. 
 #
 # Cod also brings a few abstractions layered on top of channels: You can use
 # channels to present 'services' (Cod::Service) to the network: A service is a
@@ -13,6 +15,12 @@
 # channel! This is really powerful and used extensively in constructing the
 # higher order primitives. 
 #
+# All Cod channels have a serializer. If you don't specify your own
+# serializer, they will use Marshal.dump and Marshal.load. (see
+# {Cod::SimpleSerializer}) This allows to send Ruby objects and not just
+# strings by default. If you want to, you can of course go back to very strict
+# wire formats, see {Cod::ProtocolBuffersSerializer} for an example of that.
+#
 # The goal of Cod is that you have to know only very few things about the
 # network (the various transports) to be able to construct complex things. It
 # handles reconnection and reliability for you. It also translates cryptic OS
@@ -22,18 +30,24 @@
 # Contribute your observations and we'll come up with a way of dealing with
 # most of the tricky stuff!
 #
+# @see Cod::Channel
+#
 module Cod
   # Creates a pipe connection that is visible to this process and its
-  # children. (see Cod::Pipe)
+  # children. 
+  #
+  # @see Cod::Pipe
   #
   def pipe(serializer=nil, pipe_pair=nil)
     Cod::Pipe.new(serializer)
   end
   module_function :pipe
   
-  # Creates two channels based on Cod.pipe (unidirectional IO.pipe) and links
+  # Creates two channels based on {Cod.pipe} (unidirectional IO.pipe) and links
   # things up so that you communication is bidirectional. Writes go to 
-  # #out and reads come from #in.
+  # #out and reads come from #in. 
+  #
+  # @see Cod::BidirPipe
   #
   def bidir_pipe(serializer=nil, pipe_pair=nil)
     Cod::BidirPipe.new(serializer, pipe_pair)
@@ -41,7 +55,8 @@ module Cod
   module_function :bidir_pipe
   
   # Creates a tcp connection to the destination and returns a channel for it.
-  # (see Cod::TcpClient)
+  # 
+  # @see Cod::TcpClient
   #
   def tcp(destination, serializer=nil)
     Cod::TcpClient.new(
@@ -50,16 +65,20 @@ module Cod
   end
   module_function :tcp
   
-  # Creates a tcp listener on bind_to and returns a channel for it. (see
-  # Cod::TcpServer)
+  # Creates a tcp listener on bind_to and returns a channel for it. 
+  #
+  # @see Cod::TcpServer
   #
-  def tcp_server(bind_to)
-    Cod::TcpServer.new(bind_to)
+  def tcp_server(bind_to, serializer=nil)
+    Cod::TcpServer.new(
+      bind_to, 
+      serializer || SimpleSerializer.new)
   end
   module_function :tcp_server
 
-  # Creates a channel based on the beanstalkd messaging queue. (see
-  # Cod::Beanstalk::Channel)
+  # Creates a channel based on the beanstalkd messaging queue. 
+  #
+  # @see Cod::Beanstalk::Channel
   # 
   def beanstalk(tube_name, server=nil)
     Cod::Beanstalk::Channel.new(tube_name, server||'localhost:11300')
@@ -71,6 +90,9 @@ module Cod
   #
   # Example: 
   #   pid, channel = Cod.process('cat')
+  #
+  # @see Cod::Process
+  #
   def process(command, serializer=nil)
     Cod::Process.new(command, serializer)
   end
@@ -80,6 +102,8 @@ module Cod
   # pipes #put method will print to stdout, and the #get method will read from 
   # stdin.
   #
+  # @see Cod::Pipe
+  #
   def stdio(serializer=nil)
     Cod::Pipe.new(serializer, [$stdin, $stdout])
   end
@@ -102,6 +126,14 @@ module Cod
       super("This channel is read only, attempted write operation.")
     end
   end
+  
+  # Indicates that a standing connection was lost and must be reconnected. 
+  # 
+  class ConnectionLost < StandardError
+    def initialize
+      super "Connection lost."
+    end
+  end
 end
 
 require 'cod/select_group'

data/lib/cod/beanstalk/channel.rb

@@ -1,14 +1,19 @@
 module Cod::Beanstalk
 
-  # NOTE: Beanstalk channels cannot currently be used in Cod.select. This is 
-  # due to limitations inherent in the beanstalkd protocol. We'll probably 
-  # try to get a patch into beanstalkd to change this. 
+  # A channel based on a beanstalkd tube. A {#put} will insert messages into 
+  # the tube, and a {#get} will fetch the next message that is pending on the
+  # tube. 
   #
-  # NOTE: If you embed a beanstalk channel into one of your messages, you will
-  # get a channel that connects to the same server and the same tube on the
-  # other end. This behaviour is useful for Cod::Service.
+  # @note Beanstalk channels cannot currently be used in Cod.select. This is 
+  #   due to limitations inherent in the beanstalkd protocol. We'll probably 
+  #   try to get a patch into beanstalkd to change this. 
+  #
+  # @note If you embed a beanstalk channel into one of your messages, you will
+  #   get a channel that connects to the same server and the same tube on the
+  #   other end. This behaviour is useful for {Cod::Service}.
   #
   class Channel < Cod::Channel
+    # All messages get inserted into the beanstalk queue as this priority. 
     JOB_PRIORITY = 0
     
     # Which tube this channel is connected to
@@ -55,6 +60,7 @@ module Cod::Beanstalk
       @transport.close
     end
     
+    # @private
     def to_read_fds
       fail "Cod.select not supported with beanstalkd channels.\n"+
         "To support this, we will have to extend the beanstalkd protocol."
@@ -69,6 +75,40 @@ module Cod::Beanstalk
     end
     
     # -------------------------------------------------------- queue interface     
+    
+    # Like {#get}, read next message from the channel but reserve the right 
+    # to put it back. This uses beanstalkds flow control features to be able
+    # to control message flow in the case of exceptions and the like. 
+    #
+    # If the block given to this message raises an exception, the message 
+    # is released unless a control command has been given. This means that
+    # other workers on the same tube will get the chance to see the message. 
+    #
+    # If the block is exited without specifying a fate for the message, it
+    # is deleted from the tube. 
+    # 
+    # @yield [Object, Cod::Beanstalk::Channel::Control]
+    # @return the blocks return value
+    #
+    # @example All the flow control that beanstalkd allows
+    #   channel.try_get { |msg, ctl|
+    #     if msg == 1
+    #       ctl.release # don't handle messages of type 1
+    #     else
+    #       ctl.bury    # for example
+    #     end
+    #   }
+    #
+    # @example Exceptions release the message
+    #   # Will release the message and allow other connected channels to 
+    #   # #get it.
+    #   channel.try_get { |msg, ctl|
+    #     fail "No such message handler"
+    #   }
+    #   
+    #
+    # @see Cod::Beanstalk::Channel::Control
+    #
     def try_get 
       fail "No block given to #try_get" unless block_given?
       
@@ -124,25 +164,31 @@ module Cod::Beanstalk
     end
         
     # ---------------------------------------------------------- serialization
+    # @private
     def _dump(level) # :nodoc:
       Marshal.dump(
         [@tube_name, @server_url])
     end
+    # @private
     def self._load(str) # :nodoc:
       tube_name, server_url = Marshal.load(str)
       Cod.beanstalk(tube_name, server_url)
     end
 
     # ----------------------------------------------------- beanstalk commands
-    def bs_delete(msg_id) # :nodoc:
+    # @private
+    def bs_delete(msg_id)
       bs_command([:delete, msg_id], :deleted)
     end
-    def bs_release(msg_id) # :nodoc:
+    # @private
+    def bs_release(msg_id)
       bs_command([:release, msg_id, JOB_PRIORITY, 0], :released)
     end
-    def bs_release_with_delay(msg_id, seconds) # :nodoc:
+    # @private
+    def bs_release_with_delay(msg_id, seconds)
       bs_command([:release, msg_id, JOB_PRIORITY, seconds], :released)
     end
+    # @private
     def bs_bury(msg_id)
       # NOTE: Why I need to assign a priority when burying I fail to
       # understand. Like a priority for rapture?

data/lib/cod/beanstalk/serializer.rb

@@ -36,6 +36,8 @@ module Cod::Beanstalk
     
     def de(io)
       str = io.gets("\r\n")
+      raise Cod::ConnectionLost unless str
+      
       raw = str.split
       
       cmd = convert_cmd(raw.first)

data/lib/cod/beanstalk/service.rb

@@ -1,4 +1,14 @@
 module Cod::Beanstalk
+  # Beanstalk services specialize for the beanstalk channels in that they
+  # support a second service block argument, the control. Using this argument,
+  # your service can refuse to accept a request or bury it for debugging
+  # inspection.
+  #
+  # @example Additional block argument
+  #   service.one { |request, control|
+  #     control.retry_in(1) # release message with delay
+  #   }
+  # 
   class Service < Cod::Service
     def one(&block)
       @channel.try_get { |(rq, answer_chan), control| 
@@ -21,6 +31,12 @@ module Cod::Beanstalk
         @channel_control = channel_control
       end
       
+      # Releases the request and instructs the beanstalkd server to hand it
+      # to us again in seconds seconds.
+      #
+      # @param [Fixnum] seconds 
+      # @return [void]
+      # 
       def retry_in(seconds)
         fail ArgumentError, 
           "#retry_in accepts only an integer number of seconds." \
@@ -28,16 +44,36 @@ module Cod::Beanstalk
             
         @channel_control.release_with_delay(seconds)
       end
+      
+      # Releases the request for immediate consumption by someone else.
+      # 
+      # @return [void]
+      #
       def retry
         @channel_control.release
       end
+      
+      # Buries the message for later inspection. (see beanstalkd manual)
+      # 
+      # @return [void]
+      #
       def bury
         @channel_control.bury
       end
+      
+      # Deletes the request. This is how you accept a request. 
+      #
+      # @return [void]
+      #
       def delete
         @channel_control.delete
       end
-      
+
+      # Returns true if a flow control command has already been given as answer
+      # to the current request. Multiple flow control commands are not allowed.
+      #
+      # @return [Boolean]
+      #
       def command_issued?
         @channel_control.command_given?
       end

data/lib/cod/channel.rb

@@ -1,33 +1,39 @@
 module Cod
-  # Channels transport ruby objects from one end to the other. The
+  # Channels transport Ruby objects from one end to the other. The
   # communication setup varies a bit depending on the transport used for the
   # channel, but the interface you interact with doesn't vary. You can #put
   # messages into a channel and you then #get them out of it. 
   #
-  # Synopsis: 
+  # = Synopsis
+  #
   #   channel.put [:a, :ruby, :object]
   #   channel.get # => [:a, :ruby, :object]
   #
   # By default, channels will serialize the messages you give them using
   # Marshal.dump and Marshal.load. You can change this by passing your own
-  # serializer to the channel upon construction; see SimpleSerializer for a
+  # serializer to the channel upon construction; see {SimpleSerializer} for a
   # description of the interface such a serializer needs to implement. 
   # 
-  # This class (Cod::Channel) is the abstract superclass of all Cod channels.
-  # It doesn't have a transport by its own, but implements the whole interface
-  # for documentation purposes.
+  # This class is the abstract superclass of all Cod channels. It doesn't have
+  # a transport by its own, but implements the whole interface for
+  # documentation purposes.
   #
   class Channel
     # Obtains one message from the channel. If the channel is empty, but
     # theoretically able to receive more messages, blocks forever. But if the
     # channel is somehow broken, an exception is raised. 
     #
+    # @return [Object] the next message waiting in the channel
+    #
     def get
       abstract_method_error
     end
     
     # Puts one message into a channel. 
     #
+    # @param msg [Object] any Ruby object that should be sent as message
+    # @return [void]
+    #
     def put(msg)
       abstract_method_error
     end
@@ -35,6 +41,9 @@ module Cod
     # Interact with a channel by first writing msg to it, then reading back 
     # the other ends answer. 
     #
+    # @param msg [Object] any Ruby object that should be sent as message
+    # @return [Object] the answer from the other end.
+    #
     def interact(msg)
       put msg
       get
@@ -42,6 +51,8 @@ module Cod
     
     # Produces a service that has this channel as communication point. 
     #
+    # @return [Cod::Service]
+    #
     def service
       abstract_method_error
     end
@@ -49,6 +60,9 @@ module Cod
     # Produces a service client that connects to this channel and receives
     # service answers to the channel indicated by answers_to.
     #
+    # @param answers_to [Cod::Channel] where to send the answers
+    # @return [Cod::Service::Client]
+    #
     def client(answers_to)
       abstract_method_error
     end

data/lib/cod/service.rb

@@ -6,11 +6,11 @@ module Cod
   # 
   # Synopsis: 
   #   # On the server end: 
-  #   service = Cod.service(central_location)
+  #   service = server_channel.service
   #   service.one { |request| :answer }
   #
   #   # On the client end: 
-  #   service = Cod.client(central_location, answer_here)
+  #   service = answer_channel.client(server_channel)
   #
   #   # asynchronous, no answer
   #   service.notify [:a, :request]   # => nil

data/lib/cod/simple_serializer.rb

@@ -4,10 +4,25 @@ module Cod
   # format serializers.
   #
   class SimpleSerializer
+    # Serializes obj into a format that can be transmitted via the wire. In
+    # this implementation, it will use Marshal.dump to turn the obj into a 
+    # string. 
+    #
+    # @param obj [Object] to dump
+    # @return [String] transmitted over the wire
+    # 
     def en(obj)
       Marshal.dump(obj)
     end
     
+    # Reads as many bytes as needed from io to reconstruct one message. Turns
+    # the message back into a Ruby object according to the rules of the serializer. 
+    # In this implementation, it will use Marshal.load to turn the object 
+    # from a String to a Ruby Object.
+    #
+    # @param io [IO] to read one message from
+    # @return [Object] that has been deserialized
+    #
     def de(io)
       if block_given?
         Marshal.load(io, Proc.new)

data/lib/cod/tcp_client.rb

@@ -4,7 +4,23 @@ module Cod
   # Acts as a channel that connects to a tcp listening socket on the other
   # end. 
   #
+  # Connection negotiation has three phases, as follows: 
+  # 1) Connection is establishing. Sent messages are buffered and really sent
+  #    down the wire once the connection stands. Reading from the channel
+  #    will block the client forever.
+  #
+  # 2) Connection is established: Sending and receiving are immediate and 
+  #    no buffering is done. 
+  #
+  # 3) Connection is down because of an interruption or exception. Sending and
+  #    receiving messages no longer works, instead a ConnectionLost error is
+  #    raised. 
+  #
   class TcpClient < Channel
+    # Constructs a tcp client channel. destination may either be a socket, 
+    # in which case phase 1) of connection negotiation is skipped, or a string
+    # that contains an 'address:port' part. 
+    #
     def initialize(destination, serializer)
       @serializer = serializer
       @destination = destination
@@ -23,10 +39,7 @@ module Cod
 
       # The predicate for allowing sends: Is the connection up?
       @work_queue.predicate {
-        # NOTE This will not be called unless we have some messages to send,
-        # so no useless connections are made
-        @connection.try_connect
-        @connection.established?
+        cached_connection_established?
       }
     end
     
@@ -35,12 +48,12 @@ module Cod
     # reconnection attempts. 
     #
     def close
-      @work_queue.shutdown
+      @work_queue.shutdown if @work_queue
       @connection.close
     end
 
-    # Sends an object to the other end of the channel, if it is connected. 
-    # If it is not connected, objects sent will queue up and once the internal
+    # Sends an object to the other end of the channel, if it is connected. If
+    # it is not connected, objects sent will queue up and once the internal
     # storage reaches the high watermark, they will be dropped silently. 
     #
     # Example: 
@@ -55,6 +68,12 @@ module Cod
         send(obj)
       }
       
+      @work_queue.exclusive {
+        # If we're connected, shut down the worker thread, do all the work
+        # here.
+        check_connection_state
+      }
+      
       @work_queue.try_work
     end
     
@@ -62,8 +81,16 @@ module Cod
     # Options include: 
     #
     def get(opts={})
-      @connection.try_connect
+      while @work_queue.size > 0
+        @work_queue.try_work
+      end
+                
+      check_connection_state
+
       @connection.read(@serializer)
+    rescue Errno::ECONNRESET, EOFError
+      # Connection reset by peer
+      raise ConnectionLost
     end
 
     # --------------------------------------------------------- service/client
@@ -100,9 +127,39 @@ module Cod
       OtherEnd.new(params)
     end
   private
+    # Checks to see in which of the three connection phases we're in. If we're
+    # past 1), shuts down the background worker thread.
+    #
+    def check_connection_state
+      # Has the connection been established in the meantime? If yes, shut
+      # down the work queues thread, all work will be done in this thread 
+      # from now on. 
+      if cached_connection_established?
+        @work_queue.shutdown
+      end
+    end
+  
+    # Returns false until the connection has been established once, at which
+    # point it always returns true. 
+    #
+    def cached_connection_established?
+      @cached_connection_established ||= begin
+        # NOTE This will not be called unless we have some messages to send,
+        # so no useless connections are made
+        @connection.try_connect
+        @connection.established?
+      end
+    end
+    
+    # Actual sending of messages. This is invoked from either the main thread 
+    # or the worker thread, but never both at the same time. 
+    #
     def send(msg)
       @connection.write(
         @serializer.en(msg))
+    rescue Exception => e
+      warn e
+      raise
     end
 
     # A connection that can be down. This allows elegant handling of

data/lib/cod/tcp_server.rb

@@ -29,12 +29,12 @@ module Cod
   # as part of the message you send. 
   # 
   class TcpServer
-    def initialize(bind_to)
+    def initialize(bind_to, serializer)
       @socket = TCPServer.new(*bind_to.split(':'))
       @client_sockets = []
       @round_robin_index = 0
       @messages = Array.new
-      @serializer = SimpleSerializer.new
+      @serializer = serializer
     end
     
     # Receives one object from the channel. 

data/lib/cod/work_queue.rb

@@ -27,6 +27,7 @@ module Cod
       @try_work_exclusive_section = ExclusiveSection.new
 
       @thread = Thread.start(&method(:thread_main))
+      @thread.priority = Thread.current.priority - 10
     end
     
     # The internal thread that is used to work on scheduled items in the
@@ -37,13 +38,26 @@ module Cod
       @try_work_exclusive_section.enter {
         # NOTE if predicate is nil or not set, no work will be accomplished. 
         # This is the way I need it. 
-        while !@queue.empty? && @predicate && @predicate.call
+        while !@queue.empty? && predicate?
           wi = @queue.shift
           wi.call
         end
       }
     end
     
+    # Allows to perform other work mutually exclusive with the work performed
+    # in the queue. (see ExclusiveSection)
+    #
+    def exclusive
+      @try_work_exclusive_section.enter { yield }
+    end
+    
+    # Evaluates the predicate. If the predicate is not set, this returns nil.
+    #
+    def predicate?
+      @predicate && @predicate.call
+    end
+    
     # Before any kind of work is attempted, this predicate must evaluate to 
     # true. It is tested repeatedly. 
     #
@@ -65,8 +79,11 @@ module Cod
     # Shuts down the queue properly, without waiting for work to be completed.
     #
     def shutdown
+      return unless @thread
+      
       @shutdown_requested = true
       @thread.join
+      @thread = nil
     end
     
     # Returns the size of the queue. 
@@ -86,8 +103,8 @@ module Cod
       Thread.current.abort_on_exception = true
       
       loop do
-        sleep 0.01
-        
+        Thread.pass
+
         try_work
 
         # Signal the outside world that we've been around this loop once.

data/lib/tcp_proxy.rb

@@ -1,3 +1,8 @@
+
+# Proxies tcp connections on a machine from one port to the next. This is used
+# for debugging and writing specifications for cod. This is not officially
+# part of cod's API. 
+#
 class TCPProxy
   attr_reader :connections
   
@@ -17,6 +22,8 @@ class TCPProxy
     @thread = Thread.start(&method(:thread_main))
   end
   
+  # Closes the proxy, disrupting every connection made to it. 
+  #
   def close
     @shutdown = true
     
@@ -28,16 +35,27 @@ class TCPProxy
     @connections.each do |connection|
       connection.close
     end
-    @ins.close
+    @ins.close if @ins
   end
   
+  # Disallows new connections. 
+  #
   def block
     @accept_new = false
+    @ins.close
+    @ins = nil
   end
+  
+  # Allows new connections to be made. This is the default, so you only need
+  # this to reenable connections after a {#block}. 
+  #
   def allow
+    @ins  = TCPServer.new(@host, @from_port)
     @accept_new = true
   end
   
+  # Drops all established connections. 
+  #
   def drop_all
     # Copy the connections and then empty the collection
     connections = @connections_m.synchronize {
@@ -51,6 +69,8 @@ class TCPProxy
   
   # Inside the background thread ----------------------------------------
   
+  # Internal thread that pumps messages from and to ports. 
+  # @private
   def thread_main
     loop do
       accept_connections if @accept_new
@@ -67,6 +87,7 @@ class TCPProxy
     raise
   end
 
+  # @private
   class Connection
     def initialize(in_sock, out_sock)
       @m = Mutex.new
@@ -96,10 +117,10 @@ class TCPProxy
           buf = socket.read_nonblock(16*1024)
           
           if socket == @in_sock
-            puts "--> #{buf.size}"
+            puts "--> #{buf.size}" if $DEBUG
             @out_sock.write(buf)
           else
-            puts "<-- #{buf.size}"
+            puts "<-- #{buf.size}" if $DEBUG
             @in_sock.write(buf)
           end
         end
@@ -111,6 +132,7 @@ class TCPProxy
     end
   end
 
+  # @private
   def accept_connections
     loop do
       in_sock = @ins.accept_nonblock
@@ -123,10 +145,21 @@ class TCPProxy
     # No more connections pending, stop accepting new connections
   end
   
+  # @private
   def forward_data
     connections = @connections_m.synchronize { @connections.dup }
+    remove_list = []
     connections.each do |conn|
-      conn.pump_synchronized
+      begin
+        conn.pump_synchronized
+      rescue EOFError
+        # Socket was closed, remove from the collection.
+        remove_list << conn
+      end
     end
+
+    @connections_m.synchronize {
+      @connections -= remove_list
+    }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cod
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-15 00:00:00.000000000 Z
+date: 2012-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70132592401200 !ruby/object:Gem::Requirement
+  requirement: &70357075424760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132592401200
+  version_requirements: *70357075424760
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70132592400460 !ruby/object:Gem::Requirement
+  requirement: &70357075424320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132592400460
+  version_requirements: *70357075424320
 - !ruby/object:Gem::Dependency
   name: flexmock
-  requirement: &70132592399720 !ruby/object:Gem::Requirement
+  requirement: &70357075423900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132592399720
+  version_requirements: *70357075423900
 - !ruby/object:Gem::Dependency
-  name: sdoc
-  requirement: &70132592399020 !ruby/object:Gem::Requirement
+  name: yard
+  requirement: &70357075423480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132592399020
+  version_requirements: *70357075423480
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &70132592398400 !ruby/object:Gem::Requirement
+  requirement: &70357075423060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132592398400
+  version_requirements: *70357075423060
 - !ruby/object:Gem::Dependency
   name: growl
-  requirement: &70132592397740 !ruby/object:Gem::Requirement
+  requirement: &70357075422640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132592397740
+  version_requirements: *70357075422640
 description: 
 email: kaspar.schiess@absurd.li
 executables: []
@@ -108,12 +108,12 @@ files:
 - lib/cod/work_queue.rb
 - lib/cod.rb
 - lib/tcp_proxy.rb
+- examples/bs_ping_pong/ping.rb
+- examples/bs_ping_pong/pong.rb
 - examples/example_scaffold.rb
 - examples/master_child.rb
 - examples/netcat/README
 - examples/netcat/server.rb
-- examples/ping_pong/ping.rb
-- examples/ping_pong/pong.rb
 - examples/presence/client.rb
 - examples/presence/server.rb
 - examples/protocol-buffers/master_child.rb
@@ -140,7 +140,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1652399252235665508
+      hash: -4089674409401429686
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -149,11 +149,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1652399252235665508
+      hash: -4089674409401429686
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
-summary: Really simple IPC.
+summary: Really simple IPC. Pipes, TCP sockets, beanstalkd, ...
 test_files: []

data/examples/ping_pong/ping.rb

@@ -1,9 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
-require 'cod'
-
-pipe = Cod.beanstalk('localhost:11300', 'pingpong')
-
-loop do
-  pipe.put Time.now
-  sleep 1
-end

data/examples/ping_pong/pong.rb

@@ -1,9 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
-require 'cod'
-
-pipe = Cod.beanstalk('localhost:11300', "pingpong")
-
-loop do
-  puts "Received: "+pipe.get.inspect
-end
-