cod 0.5.0 → 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 849f13cc13d03934bdf098bc46697880be2380e7
+  data.tar.gz: e31877e11c7b73a9e725b3083b4e8508df3cecda
+SHA512:
+  metadata.gz: d37a103c94ccb8ce3f092a6b208809eac7b84ceaf560a4bd99f6958860f4f67c47991c33e9315d5d0197671fead58b92cfe949809aa821936786ba251a72bd72
+  data.tar.gz: d34fc64a7c8162855083775b99914987b6292d75db704f66b140e1c502b08839a714fd1a4b992663f305e5e479f0a5b5e2b2f688a2145ddf7c97c52c37daf1fd

data/HISTORY.txt

@@ -1,3 +1,15 @@
+= 0.6.0 / ???
+
+  + Cod.bidir is now based on UNIXSocket.pair (socketpair) and is called just
+    #bidir. Thanks to Yves Senn (senny) for the idea and the pairing sessions!
+  ! Eliminated some warnings for exceptions that were reraised anyway. Thanks 
+    to Chris Schmich (schmich). 
+  ! Updates project to work with modern rubies.
+
+= 0.5.1 / 30Aug2012
+
+  + Cod.bidir_pipe is now selectable.
+
 = 0.5.0 / 12Jun2012
 
   + Process#wait will not throw Errno::ECHILD anymore.

data/examples/master_child_bidir.rb

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'cod'
+
+pipe = Cod.bidir
+
+child_pid = fork do
+  pipe.swap!
+  pipe.put 'test'
+  pipe.put Process.pid
+  command = pipe.get 
+  p command
+end
+
+begin
+  p pipe.get
+  p pipe.get
+  pipe.put :foobar
+ensure
+  Process.wait(child_pid)
+end

data/lib/cod.rb

@@ -65,18 +65,32 @@ module Cod
   end
   module_function :pipe
   
-  # 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. 
+  # Creates a channel based on socketpair (UNIXSocket.pair). This is a
+  # IPC-kind of channel that can be used to exchange messages both ways. 
   #
-  # @overload bidir_pipe(serializer=nil)
+  # @overload bidir(serializer=nil)
   #   @param serializer [#en,#de] optional serializer to use
-  #   @return [Cod::BidirPipe]
+  #   @return [Cod::Bidir]
   #
-  def bidir_pipe(serializer=nil, pipe_pair=nil)
-    Cod::BidirPipe.new(serializer, pipe_pair)
+  def bidir(serializer=nil)
+    Cod::Bidir.pair(serializer)
   end
-  module_function :bidir_pipe
+  module_function :bidir
+  
+  # Creates a named bidirectional channel. Only one end of this will be 
+  # connected to the unix socket in the file system identified by path. 
+  #
+  def bidir_named(name, serializer=nil)
+    Cod::Bidir.named(name, serializer)
+  end
+  module_function :bidir_named
+  
+  # Creates the server side for a named unix socket connection. 
+  #
+  def bidir_server(name, serializer=nil)
+    Cod::BidirServer.new(name, serializer)
+  end
+  module_function :bidir_server
   
   # Creates a tcp connection to the destination and returns a channel for it.
   # 
@@ -169,9 +183,13 @@ module Cod
   end
 end
 
+require 'cod/callbacks'
+
 require 'cod/select_group'
 require 'cod/select'
 
+require 'cod/socket_server'
+
 require 'cod/iopair'
 
 require 'cod/channel'
@@ -180,7 +198,9 @@ require 'cod/simple_serializer'
 require 'cod/line_serializer'
 
 require 'cod/pipe'
-require 'cod/bidir_pipe'
+
+require 'cod/bidir'
+require 'cod/bidir_server'
 
 require 'cod/process'
 

data/lib/cod/bidir.rb

@@ -0,0 +1,102 @@
+module Cod
+  
+  # A bidirectional pipe, also called a socket pair. 
+  #
+  class Bidir < Channel
+    
+    include Callbacks
+    
+    # Serializer to use for messages on this transport. 
+    attr_reader :serializer
+    
+    # This process' end of the pipe, can be used for both reading and writing. 
+    attr_accessor :socket
+    
+    # The other side of the pipe. 
+    attr_reader :other
+    
+    # Path of the socket (.named), if based on a file system FIFO.
+    attr_reader :path
+    
+    def self.named(name, serializer=nil)
+      new(serializer || SimpleSerializer.new, 
+        name, 
+        UNIXSocket.new(name), nil)
+    end
+    def self.pair(serializer=nil)
+      new(serializer || SimpleSerializer.new, 
+        nil, 
+        *UNIXSocket.pair)
+    end
+    
+    # Initializes a Bidir channel given two or alternatively one end of a 
+    # bidirectional pipe. (socketpair)
+    # 
+    #   socket ---- other
+    #
+    def initialize(serializer, path, socket, other)
+      @serializer = serializer
+      @socket, @other = socket, other
+      @path = path
+    end
+    
+    def put(obj)
+      using_callbacks(socket) do
+        socket.write(
+          serializer.en(obj))
+      end
+    end
+    
+    def get
+      serializer.de(socket)
+    rescue EOFError, IOError
+      raise Cod::ConnectionLost, 
+        "All pipe ends seem to be closed. Reading from this pipe will not "+
+        "return any data."
+    end
+    
+    def close
+      socket.close; 
+      other.close if other
+    rescue IOError
+      # One code path through Cod::Process will close other prematurely. This
+      # is to avoid an error. 
+    end
+    
+    # Swaps the end of this pipe around. 
+    #
+    def swap!
+      @socket, @other = @other, @socket
+    end
+    
+    # ---------------------------------------------------------- serialization 
+    
+    # A small structure that is constructed for a serialized tcp client on 
+    # the other end (the deserializing end). What the deserializing code does
+    # with this is his problem. 
+    #
+    # @private
+    #
+    OtherEnd = Struct.new(:path) # :nodoc:
+    
+    def _dump(level) # :nodoc:
+      if !path && callbacks_enabled?
+        register_callback { |conn| conn.send_io(other) }
+      end
+      
+      Marshal.dump(path)
+    end
+    def self._load(params) # :nodoc:
+      # Instead of a tcp client (no way to construct one at this point), we'll
+      # insert a kind of marker in the object stream that will be replaced 
+      # with a valid client later on. (hopefully)
+      OtherEnd.new(Marshal.load(params))
+    end
+
+    # @private
+    #
+    def to_read_fds
+      [socket]
+    end
+  end
+end

data/lib/cod/bidir_server.rb

@@ -0,0 +1,34 @@
+module Cod
+  class BidirServer < SocketServer
+    include Callbacks
+    
+    attr_reader :path
+    
+    def initialize(path, serializer)
+      super serializer || SimpleSerializer.new, 
+        UNIXServer.new(path)
+
+      @path = path
+    end
+    
+    def deserialize_special(socket, obj)
+      case obj
+        when Bidir::OtherEnd
+          if obj.path == self.path
+            return back_channel(socket)
+          end
+          
+          channel = Bidir.new(serializer, nil, nil, nil)
+          register_callback { |conn| 
+            channel.socket= conn.recv_io(UNIXSocket) }
+          return channel
+      end
+      
+      obj
+    end
+    
+    def back_channel(socket)
+      Bidir.new(serializer, nil, socket, nil)
+    end
+  end
+end

data/lib/cod/callbacks.rb

@@ -0,0 +1,24 @@
+module Cod
+  module Callbacks
+    def using_callbacks(*args)
+      Thread.current[:callbacks] = []
+      
+      result = yield
+      
+      Thread.current[:callbacks].each do |cb|
+        cb.call(*args)
+      end
+      
+      return result
+    ensure
+      Thread.current[:callbacks] = nil
+    end
+    
+    def callbacks_enabled?
+      Thread.current[:callbacks]
+    end
+    def register_callback(&block)
+      Thread.current[:callbacks] << block
+    end
+  end
+end

data/lib/cod/iopair.rb

@@ -15,12 +15,10 @@ module Cod
       self.w = other.w.dup if other.w
     end
     def write(buf)
-      close_r
       raise Cod::ReadOnlyChannel unless w
       w.write(buf)
     end
     def read(serializer)
-      close_w
       raise Cod::WriteOnlyChannel unless r
       serializer.de(r)
     end

data/lib/cod/pipe.rb

@@ -104,6 +104,7 @@ module Cod
     #
     def put(obj)
       raise Cod::ReadOnlyChannel unless can_write?
+      pipe.close_r
       
       pipe.write(
         serializer.en(obj))
@@ -145,7 +146,7 @@ module Cod
     # @private
     #
     def to_read_fds
-      r
+      [r]
     end
     
     # Returns true if you can read from this pipe. 

data/lib/cod/process.rb

@@ -29,19 +29,24 @@ module Cod
     
     # @private
     def run(command)
-      @pipe = Cod.bidir_pipe(@serializer)
+      @pipe = Cod.bidir(@serializer)
       
       @pid = ::Process.spawn(command, 
-        :in => @pipe.w.r, 
-        :out => @pipe.r.w)
+        :in => @pipe.other, 
+        :out => @pipe.other)
+        
+      # Close the end we just dedicated to the process we've spawned. 
+      # As a consequence, when the process exists, we'll get a read error
+      # on our side of the pipe (@pipe.socket, #put, #get)
+      @pipe.other.close
     end
     
     # Returns the cod channel associated with this process. The channel will
     # have the process' standard output bound to its #get (input), and the
     # process' standard input will be bound to #put (output).
     #
-    # Note that when the process exits and all communication has been read from
-    # the channel, it will probably raise a Cod::ConnectionLost error. 
+    # Note that when the process exits and all communication has been read
+    # from the channel, it will probably raise a Cod::ConnectionLost error. 
     #
     # @example
     #   process = Cod.process('uname', LineSerializer.new)
@@ -62,13 +67,13 @@ module Cod
       ::Process.kill :TERM, @pid
     end
     
-    # Asks the process to terminate by closing its stanard input. This normally
-    # closes down the process, but no guarantees are made. 
+    # Asks the process to terminate by closing its stanard input. This
+    # normally closes down the process, but no guarantees are made. 
     #
     # @return [void]
     #
     def terminate
-      @pipe.w.close
+      @pipe.socket.close_write
     end
     
     # Waits for the process to terminate and returns its exit value. May

data/lib/cod/select.rb

@@ -35,7 +35,7 @@ module Cod
     # @return [Hash,Array,Cod::Channel,IO]
     #
     def do
-      fds = groups.values { |e| to_read_fd(e) }.compact
+      fds = groups.values { |e| to_read_fds(e) }.compact
       
       # Perform select  
       r,w,e = IO.select(fds, nil, nil, timeout)
@@ -45,13 +45,14 @@ module Cod
       
       # Prepare a return value: The original hash, where the fds are ready.
       groups.
-        keep_if { |e| r.include?(to_read_fd(e)) }.
+        keep_if { |e| to_read_fds(e).
+          any? { |fd| r.include?(fd) } }.
         unpack
     end
   private
-    def to_read_fd(single)
-      return single.to_read_fds if single.respond_to?(:to_read_fds)
-      return single
+    def to_read_fds(channel)
+      return channel.to_read_fds if channel.respond_to?(:to_read_fds)
+      return [channel]
     end
   end
 end

data/lib/cod/socket_server.rb

@@ -0,0 +1,172 @@
+require 'socket'
+
+module Cod
+  
+  # Abstract base class for all kinds of socket based servers. Useful for all
+  # types of channels that know an #accept. 
+  #
+  class SocketServer
+    include Callbacks 
+    
+    attr_reader :socket
+    attr_reader :serializer
+    
+    def initialize(serializer, socket)
+      @socket = socket
+      @client_sockets = []
+      @round_robin_index = 0
+      @messages = Array.new
+      @serializer = serializer
+    end
+    
+    # Receives one object from the channel. This will receive one message from
+    # one of the connected clients in a round-robin fashion. 
+    #
+    # @example
+    #   channel.get # => object
+    #
+    # @param opts [Hash] 
+    # @return [Object] message sent by one of the clients
+    #   
+    def get(opts={})
+      msg, socket = _get(opts)
+      return msg
+    end
+    
+    # Receives one object from the channel. Returns a tuple of
+    # <message,channel> where channel is a tcp channel that links back to the
+    # client that sent message.
+    #
+    # Using this method, the server can communicate back to its clients
+    # individually instead of collectively. 
+    #
+    # @example Answering to the client that sent a specific message
+    #   msg, chan = server.get_ext
+    #   chan.put :answer
+    #
+    # @param opts [Hash]
+    # @return [Array<Object, TcpClient>] tuple of the message that was sent 
+    #   a channel back to the client that sent the message
+    def get_ext(opts={})
+      msg, socket = _get(opts)
+      return [
+        msg, 
+        back_channel(socket)]
+    end
+    
+    # Closes the channel. 
+    #
+    def close
+      @socket.close
+      @client_sockets.each { |io| io.close }
+    end
+
+    # Returns an array of IOs that Cod.select should select on. 
+    #
+    def to_read_fds
+      @client_sockets + [@socket]
+    end
+    
+    # Returns the number of clients that are connected to this server
+    # currently.
+    # 
+    def connections
+      @client_sockets.size
+    end
+
+    # ------------------------------------------------------- connection owner
+    
+    # Notifies the TcpServer that one of its connections needs to be closed.
+    # This can be triggered by using #get_ext to obtain a handle to
+    # connections and then calling #close on that connection. 
+    #
+    # @param socket [TCPSocket] the socket that needs to be closed @return
+    # [void]
+    #
+    def request_close(socket)
+      @client_sockets.delete(socket)
+      socket.close
+    end
+    
+  private
+    def _get(opts)
+      loop do
+        # Return a buffered message if there is one left.
+        return @messages.shift unless @messages.empty?
+
+        # Shuffle the socket list around, so we don't always read from the
+        # same client first.
+        socket_list = round_robin(@client_sockets)
+        
+        # Append the server socket to be able to react to new connections
+        # that are made.
+        socket_list << socket
+      
+        # Sleep until either a new connection is made or data is available on 
+        # one of the old connections. 
+        rr, _, _ = IO.select(socket_list, nil, nil)
+        next unless rr
+                
+        # Accept new connections
+        if rr.include?(@socket)
+          accept_new_connections
+          rr.delete(@socket)
+        end
+        
+        handle_socket_events(rr, opts)
+      end
+    end
+    
+    def handle_socket_events(sockets, opts)
+      sockets.each do |io|
+        if io.eof?
+          @client_sockets.delete(io)
+          io.close
+        else
+          consume_pending io, opts
+        end
+      end
+    end
+  
+    def consume_pending(io, opts)
+      until io.eof?
+        @messages << [
+          deserialize(io), 
+          io]
+          
+        # More messages from this socket? 
+        return unless IO.select([io], nil, nil, 0.0001)
+      end
+    end
+    
+    # Hooks deserialisation (if the programmer provided for this) and calls
+    # #deserialize_special for each object in the object stream. This allows
+    # construction of back channels from replacement tokens, for example.
+    #
+    def deserialize(io)
+      using_callbacks(io) do
+        @serializer.de(io) { |obj| deserialize_special(io, obj) }
+      end
+    end
+    
+    def round_robin(list)
+      @round_robin_index += 1
+      if @round_robin_index >= list.size
+        @round_robin_index = 0
+      end
+      
+      # Create a duplicate of list that has its elements rotated by
+      # @round_robin_index
+      list = list.dup
+      list = list + list.shift(@round_robin_index)
+    end
+    
+    def accept_new_connections
+      loop do
+        @client_sockets << @socket.accept_nonblock
+      end
+    rescue Errno::EAGAIN
+      # This means that there are no sockets to accept. Continue.
+    end
+  end
+end

data/lib/cod/tcp_client.rb

@@ -135,7 +135,11 @@ module Cod
     # @private
     #
     def to_read_fds
-      @connection.socket if @connection
+      if @connection
+        [@connection.socket] 
+      else
+        []
+      end
     end
   private
     # Checks to see in which of the three connection phases we're in. If we're
@@ -169,7 +173,6 @@ module Cod
       @connection.write(
         @serializer.en(msg))
     rescue Exception => e
-      warn e
       raise
     end
 
@@ -270,4 +273,4 @@ module Cod
       end
     end
   end
-end
+end

data/lib/cod/tcp_server.rb

@@ -26,70 +26,24 @@ module Cod
   # This means that you can transmit the client channel through the connection 
   # as part of the message you send. 
   # 
-  class TcpServer
+  class TcpServer < SocketServer
     def initialize(bind_to, serializer)
-      @socket = TCPServer.new(*bind_to.split(':'))
-      @client_sockets = []
-      @round_robin_index = 0
-      @messages = Array.new
-      @serializer = serializer
+      super(serializer, TCPServer.new(*bind_to.split(':')))
     end
     
-    # Receives one object from the channel. This will receive one message from
-    # one of the connected clients in a round-robin fashion. 
-    #
-    # @example
-    #   channel.get # => object
-    #
-    # @param opts [Hash] 
-    # @return [Object] message sent by one of the clients
-    #   
-    def get(opts={})
-      msg, socket = _get(opts)
-      return msg
-    end
-    
-    # Receives one object from the channel. Returns a tuple of
-    # <message,channel> where channel is a tcp channel that links back to the
-    # client that sent message.
-    #
-    # Using this method, the server can communicate back to its clients
-    # individually instead of collectively. 
-    #
-    # @example Answering to the client that sent a specific message
-    #   msg, chan = server.get_ext
-    #   chan.put :answer
-    #
-    # @param opts [Hash]
-    # @return [Array<Object, TcpClient>] tuple of the message that was sent 
-    #   a channel back to the client that sent the message
-    def get_ext(opts={})
-      msg, socket = _get(opts)
-      return [
-        msg, 
-        produce_back_channel(socket)]
+    def deserialize_special(socket, obj)
+      if obj.kind_of?(TcpClient::OtherEnd)
+        return back_channel(socket)
+      end
+      return obj
     end
     
-    # Closes the channel. 
-    #
-    def close
-      @socket.close
-      @client_sockets.each { |io| io.close }
-    end
-
-    # Returns an array of IOs that Cod.select should select on. 
-    #
-    def to_read_fds
-      @client_sockets
+    def back_channel(socket)
+      TcpClient.new(
+        TcpClient::Connection.new(socket, self), 
+        serializer)    
     end
     
-    # Returns the number of clients that are connected to this server
-    # currently.
-    # 
-    def connections
-      @client_sockets.size
-    end
-
     # --------------------------------------------------------- service/client
     
     def service
@@ -102,104 +56,5 @@ module Cod
     def client(answers_to)
       Service::Client.new(answers_to, answers_to)
     end
-
-    # ------------------------------------------------------- connection owner
-    
-    # Notifies the TcpServer that one of its connections needs to be closed. 
-    # This can be triggered by using #get_ext to obtain a handle to connections
-    # and then calling #close on that connection. 
-    #
-    # @param socket [TCPSocket] the socket that needs to be closed
-    # @return [void]
-    #
-    def request_close(socket)
-      @client_sockets.delete(socket)
-      socket.close
-    end
-    
-  private
-    def _get(opts)
-      loop do
-        # Return a buffered message if there is one left.
-        return @messages.shift unless @messages.empty?
-
-        # Shuffle the socket list around, so we don't always read from the
-        # same client first.
-        socket_list = round_robin(@client_sockets)
-        
-        # Append the server socket to be able to react to new connections
-        # that are made.
-        socket_list << @socket
-      
-        # Sleep until either a new connection is made or data is available on 
-        # one of the old connections. 
-        rr, _, _ = IO.select(socket_list, nil, nil)
-        next unless rr
-        
-        # Accept new connections
-        if rr.include?(@socket)
-          accept_new_connections
-          rr.delete(@socket)
-        end
-        
-        handle_socket_events(rr, opts)
-      end
-    end
-    
-    def handle_socket_events(sockets, opts)
-      sockets.each do |io|
-        if io.eof?
-          @client_sockets.delete(io)
-          io.close
-        else
-          consume_pending io, opts
-        end
-      end
-    end
-  
-    def consume_pending(io, opts)
-      until io.eof?
-        @messages << [
-          deserialize(io), 
-          io]
-          
-        # More messages from this socket? 
-        return unless IO.select([io], nil, nil, 0.0001)
-      end
-    end
-    
-    def deserialize(io)
-      @serializer.de(io) { |obj|
-        obj.kind_of?(TcpClient::OtherEnd) ? 
-          produce_back_channel(io) : 
-          obj
-      }
-    end
-    
-    def round_robin(list)
-      @round_robin_index += 1
-      if @round_robin_index >= list.size
-        @round_robin_index = 0
-      end
-      
-      # Create a duplicate of list that has its elements rotated by
-      # @round_robin_index
-      list = list.dup
-      list = list + list.shift(@round_robin_index)
-    end
-    
-    def accept_new_connections
-      loop do
-        @client_sockets << @socket.accept_nonblock
-      end
-    rescue Errno::EAGAIN
-      # This means that there are no sockets to accept. Continue.
-    end
-
-    def produce_back_channel(socket)
-      TcpClient.new(
-        TcpClient::Connection.new(socket, self), 
-        @serializer)
-    end
   end
 end

data/lib/cod/work_queue.rb

@@ -35,7 +35,7 @@ module Cod
     attr_reader :thread
 
     def try_work
-      @try_work_exclusive_section.enter {
+      exclusive {
         # NOTE if predicate is nil or not set, no work will be accomplished. 
         # This is the way I need it. 
         while !@queue.empty? && predicate?
@@ -73,7 +73,9 @@ module Cod
     #   work_queue.schedule { a_piece_of_work }
     #
     def schedule(&work)
-      @queue << work
+      exclusive {
+        @queue << work
+      }
     end
 
     # Shuts down the queue properly, without waiting for work to be completed.
@@ -89,7 +91,9 @@ module Cod
     # Returns the size of the queue. 
     #
     def size
-      @queue.size
+      exclusive {
+        @queue.size
+      }
     end
 
     def clear_thread_semaphore

metadata

@@ -1,110 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: cod
 version: !ruby/object:Gem::Version
-  version: 0.5.0
-  prerelease: 
+  version: 0.6.0
 platform: ruby
 authors:
 - Kaspar Schiess
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-12 00:00:00.000000000 Z
+date: 2014-09-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: flexmock
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: growl
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -116,13 +89,29 @@ extra_rdoc_files:
 files:
 - HISTORY.txt
 - LICENSE
-- Rakefile
 - README
+- examples/bs_ping_pong/ping.rb
+- examples/bs_ping_pong/pong.rb
+- examples/example_scaffold.rb
+- examples/forked_server/README
+- examples/forked_server/forked.rb
+- examples/master_child.rb
+- examples/master_child_bidir.rb
+- examples/netcat/README
+- examples/netcat/server.rb
+- examples/protocol-buffers/README
+- examples/protocol-buffers/master_child.rb
+- examples/service.rb
+- examples/tcp.rb
+- examples/tcp_get_ext.rb
+- lib/cod.rb
+- lib/cod/beanstalk.rb
 - lib/cod/beanstalk/channel.rb
 - lib/cod/beanstalk/serializer.rb
 - lib/cod/beanstalk/service.rb
-- lib/cod/beanstalk.rb
-- lib/cod/bidir_pipe.rb
+- lib/cod/bidir.rb
+- lib/cod/bidir_server.rb
+- lib/cod/callbacks.rb
 - lib/cod/channel.rb
 - lib/cod/iopair.rb
 - lib/cod/line_serializer.rb
@@ -133,54 +122,34 @@ files:
 - lib/cod/select_group.rb
 - lib/cod/service.rb
 - lib/cod/simple_serializer.rb
+- lib/cod/socket_server.rb
 - lib/cod/tcp_client.rb
 - lib/cod/tcp_server.rb
 - 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/forked_server/forked.rb
-- examples/forked_server/README
-- examples/master_child.rb
-- examples/netcat/README
-- examples/netcat/server.rb
-- examples/protocol-buffers/master_child.rb
-- examples/protocol-buffers/README
-- examples/service.rb
-- examples/tcp.rb
-- examples/tcp_get_ext.rb
 homepage: http://kschiess.github.com/cod
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 4413858275826022328
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 4413858275826022328
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Really simple IPC. Pipes, TCP sockets, beanstalkd, ...
 test_files: []

data/Rakefile

@@ -1,35 +0,0 @@
-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
-
-task :default => :spec
-
-task :stats do
-  %w(lib spec).each do |path|
-    printf "%10s:", path
-    system %Q(find #{path} -name "*.rb" | xargs wc -l | grep total)
-  end
-end
-
-require 'yard'
-YARD::Rake::YardocTask.new do |t|
-  # t.files   = ['lib/**/*.rb']
-  # t.options = ['--any', '--extra', '--opts'] # optional
-end
-
-# This task actually builds the gem. 
-task :gem => :spec
-spec = eval(File.read('cod.gemspec'))
-
-desc "Generate the gem package."
-Gem::PackageTask.new(spec) do |pkg|
-  # pkg.need_tar = true
-end
-
-CLEAN << 'pkg'
-CLEAN << 'doc'

data/lib/cod/bidir_pipe.rb

@@ -1,32 +0,0 @@
-module Cod
-  class BidirPipe < Channel
-    # The Cod::Pipe instance we're currently #put'ting to. 
-    attr_reader :w
-    # The Cod::Pipe instance we're currently #get'ting from. 
-    attr_reader :r
-    
-    def initialize(serializer=nil, pipe_pair=nil)
-      @serializer = serializer || SimpleSerializer.new
-      @r, @w = pipe_pair || [Cod.pipe(@serializer), Cod.pipe(@serializer)]
-    end
-    
-    def put(msg)
-      w.put(msg)
-    end
-    
-    def get
-      r.get
-    end
-    
-    def close
-      r.close
-      w.close
-    end
-    
-    # Swaps the end of this pipe around. 
-    #
-    def swap!
-      @r, @w = w, r
-    end
-  end
-end