cod 0.4.4 → 0.5.0

data/HISTORY.txt

@@ -1,3 +1,7 @@
+= 0.5.0 / 12Jun2012
+
+  + Process#wait will not throw Errno::ECHILD anymore.
+
 = 0.4.4 / 7Mar2012
 
   + Uses IO.select in the server as well, not polling for accept. This should

data/README

@@ -34,7 +34,7 @@ Working transports include:
 * tcp (server and client)
 * beanstalk (connects to beanstalkd)
 
-At version 0.4.4
+At version 0.5.0
 
 (c) 2011 Kaspar Schiess
 

data/examples/forked_server/README

@@ -0,0 +1,15 @@
+Demonstrates a server that uses more than one worker process to handle a 
+single tcp port.
+
+This example forks one client that repeatedly makes connections to a tcp 
+server and then reads the servers pid from that connection. It counts what
+pid has answered how many times and prints that result in the end.
+
+The server accepts connections, writes its pid to it and then closes the
+connections. It will wait at most TIMEOUT seconds for a new connection to 
+be made, otherwise it will terminate. This is to ensure that the example exits
+cleanly and leaves no processes laying around.
+
+You can try (for kicks) to double/triple/n-uple the number of clients that
+does this counting. Server should keep up its even load distribution up to 
+a high number of clients.

data/examples/forked_server/forked.rb

@@ -0,0 +1,46 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__)) + "/../"
+require 'cod'
+require 'example_scaffold'
+require 'pp'
+require 'timeout'
+
+def timeout_no_exception(seconds)
+  timeout(seconds, &Proc.new)
+  false
+rescue Timeout::Error
+  true
+end
+
+client {
+  answer_map = Hash.new(0)
+
+  1000.times do
+    chan = Cod.tcp('localhost:32423')
+    chan.put :hei
+
+    pid = chan.get
+    answer_map[pid] += 1
+
+    chan.close
+  end
+  
+  pp answer_map
+}
+
+server {
+  server = Cod.tcp_server('localhost:32423')
+  8.times do 
+    fork {
+      loop do
+        break if timeout_no_exception(1) do
+          m, chan = server.get_ext
+          chan.put Process.pid
+          chan.close
+        end
+      end
+    }
+  end
+}
+
+run

data/lib/cod.rb

@@ -3,42 +3,64 @@ 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. 
+# Messages are retrieved in FIFO manner.
+# 
+#   channel.put :test1
+#   channel.put :test2
+#   channel.get # => :test1
 #
 # 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
 # simple one or two way RPC call. (one way = asynchronous) 
 #
+#   client = channel.client
+#   client.notify [:foo, :bar]
+#
 # Cod channels are serializable whereever possible. If you want to tell
 # somebody where to write his answers and/or questions to, send him the
 # channel! This is really powerful and used extensively in constructing the
 # higher order primitives. 
 #
+#   server.put [:some_request, my_channel]
+#   # Server will receive my_channel and be able to contact us there.
+#
 # 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.
+# wire formats, see {Cod::ProtocolBuffersSerializer} or {Cod::LineSerializer}
+# for an example of that.
+#
+#   line_protocol_channel = Cod.pipe(Cod::LineSerializer.new)
+#   line_protocol_channel.put 'some_string'
 #
 # 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
-# errors into plain text messages where it can't just handle them. This should
-# give you a clear place to look at if things go wrong. Note that this can
-# only be ever as good as the sum of situations Cod has been tested in.
-# Contribute your observations and we'll come up with a way of dealing with
-# most of the tricky stuff!
+# also translates cryptic OS errors into plain text messages where it can't
+# just handle them. This should give you a clear place to look at if things go
+# wrong. Note that this can only be ever as good as the sum of situations Cod
+# has been tested in. Contribute your observations and we'll come up with a
+# way of dealing with most of the tricky stuff!
 #
 # @see Cod::Channel
+# 
+# == Types of channels in this version
+# 
+# {Cod.pipe} :: Transports via +IO.pipe+
+# {Cod.tcp}  :: Transports via TCP (client)
+# {Cod.tcp_server} :: Transports via TCP (as a server)
+# {Cod.stdio} :: Connects to +$stdin+ and +$stdout+ (+IO.pipe+)
+# {Cod.process} :: Spawn a child process and connects to that process' +$stdin+ and +$stdout+ (+IO.pipe+)
+# {Cod.beanstalk} :: Transports via a tube on beanstalkd
 #
 module Cod
   # Creates a pipe connection that is visible to this process and its
   # children. 
   #
-  # @see Cod::Pipe
+  # @param serializer [#en,#de] optional serializer to use
+  # @return [Cod::Pipe]
   #
-  def pipe(serializer=nil, pipe_pair=nil)
+  def pipe(serializer=nil)
     Cod::Pipe.new(serializer)
   end
   module_function :pipe
@@ -47,7 +69,9 @@ module Cod
   # things up so that you communication is bidirectional. Writes go to 
   # #out and reads come from #in. 
   #
-  # @see Cod::BidirPipe
+  # @overload bidir_pipe(serializer=nil)
+  #   @param serializer [#en,#de] optional serializer to use
+  #   @return [Cod::BidirPipe]
   #
   def bidir_pipe(serializer=nil, pipe_pair=nil)
     Cod::BidirPipe.new(serializer, pipe_pair)
@@ -56,7 +80,9 @@ module Cod
   
   # Creates a tcp connection to the destination and returns a channel for it.
   # 
-  # @see Cod::TcpClient
+  # @param destination [String] an address to connect to, like 'localhost:1234'
+  # @param serializer [#en,#de] optional serializer to use
+  # @return [Cod::TcpClient]
   #
   def tcp(destination, serializer=nil)
     Cod::TcpClient.new(
@@ -67,7 +93,9 @@ module Cod
   
   # Creates a tcp listener on bind_to and returns a channel for it. 
   #
-  # @see Cod::TcpServer
+  # @param bind_to [String] an address and port to bind to, in the form "host:port"
+  # @param serializer [#en,#de] optional serializer to use
+  # @return [Cod::TcpServer]
   #
   def tcp_server(bind_to, serializer=nil)
     Cod::TcpServer.new(
@@ -78,7 +106,11 @@ module Cod
 
   # Creates a channel based on the beanstalkd messaging queue. 
   #
-  # @see Cod::Beanstalk::Channel
+  # @overload beanstalk(tube_name, server='localhost:11300')
+  #   @param tube_name [String] name of the tube to send messages to / 
+  #     receive messages from
+  #   @param server [String] address of the server to connect to
+  #   @return [Cod::Beanstalk::Channel]
   # 
   def beanstalk(tube_name, server=nil)
     Cod::Beanstalk::Channel.new(tube_name, server||'localhost:11300')
@@ -86,12 +118,12 @@ module Cod
   module_function :beanstalk
 
   # Runs a command via Process.spawn, then links a channel to the commands
-  # stdout and stdin. Returns the commands pid and the channel. 
+  # stdout and stdin. 
   #
-  # Example: 
-  #   pid, channel = Cod.process('cat')
-  #
-  # @see Cod::Process
+  # @param command [String] command to execute in a subprocess 
+  #   (using +Process.spawn+)
+  # @param serializer [#en,#de] serializer to use for all messages in channel
+  # @return [Cod::Process]
   #
   def process(command, serializer=nil)
     Cod::Process.new(command, serializer)
@@ -102,7 +134,8 @@ module Cod
   # pipes #put method will print to stdout, and the #get method will read from 
   # stdin.
   #
-  # @see Cod::Pipe
+  # @param serializer [#en,#de] optional serializer to use
+  # @return [Cod::Pipe]
   #
   def stdio(serializer=nil)
     Cod::Pipe.new(serializer, [$stdin, $stdout])
@@ -130,8 +163,8 @@ module Cod
   # Indicates that a standing connection was lost and must be reconnected. 
   # 
   class ConnectionLost < StandardError
-    def initialize
-      super "Connection lost."
+    def initialize(msg=nil)
+      super msg || "Connection lost."
     end
   end
 end
@@ -144,6 +177,7 @@ require 'cod/iopair'
 require 'cod/channel'
 
 require 'cod/simple_serializer'
+require 'cod/line_serializer'
 
 require 'cod/pipe'
 require 'cod/bidir_pipe'

data/lib/cod/beanstalk.rb

@@ -1,3 +1,4 @@
+# Implements communication via a beanstalkd server. See {Cod::Beanstalk::Channel}.
 module Cod::Beanstalk
 end
 

data/lib/cod/beanstalk/channel.rb

@@ -17,8 +17,10 @@ module Cod::Beanstalk
     JOB_PRIORITY = 0
     
     # Which tube this channel is connected to
+    # @return [String]
     attr_reader :tube_name
     # Beanstalkd server this channel is connected to
+    # @return [String]
     attr_reader :server_url
     
     def initialize(tube_name, server_url)
@@ -37,6 +39,11 @@ module Cod::Beanstalk
       initialize(other.tube_name, other.server_url)
     end
     
+    # Puts a job on the tube after serializing. 
+    #
+    # @param msg [Object] message to send
+    # @return [void]
+    #
     def put(msg)
       pri   = JOB_PRIORITY
       delay = 0
@@ -47,6 +54,10 @@ module Cod::Beanstalk
       fail "#put fails, #{answer.inspect}" unless answer == :inserted
     end
   
+    # Reads a job from the tube and decodes it as a message.
+    #
+    # @return [Object]
+    #
     def get
       id, msg = bs_reserve
       
@@ -67,6 +78,8 @@ module Cod::Beanstalk
     end
     
     # --------------------------------------------------------- service/client
+    
+    # 
     def service
       Service.new(self)
     end

data/lib/cod/line_serializer.rb

@@ -0,0 +1,29 @@
+module Cod
+  
+  # A serializer that implements a line by line wire protocol. Only strings
+  # can be sent. An instance of this class can be used when constructing
+  # any channel, turning it into a line oriented channel speaking a clear text
+  # protocol. 
+  #
+  class LineSerializer
+    # Turns a message into the wire format. 
+    #
+    # @param msg [#to_s] message to send
+    # @return [String] buffer to be written to the wire
+    #
+    def en(msg)
+      msg.to_s + "\n"
+    end
+    
+    # Deserializes a message from the wire. 
+    #
+    # @param io [IO] the wire
+    # @return [String]
+    #
+    def de(io)
+      msg = io.gets
+      return msg.chomp if msg
+      raise EOFError
+    end
+  end
+end

data/lib/cod/pipe.rb

@@ -2,10 +2,10 @@
 module Cod
   # A cod channel based on IO.pipe. 
   #
-  # NOTE: If you embed Cod::Pipe channels into your messages, Cod will insert
-  # the object id of that channel into the byte stream that is transmitted. On
-  # receiving such an object id (a machine pointer), Cod will try to
-  # reconstruct the channel that was at the origin of the id. This can
+  # Note that if you embed Cod::Pipe channels into your messages, Cod will
+  # insert the object id of that channel into the byte stream that is
+  # transmitted. On receiving such an object id (a machine pointer), Cod will
+  # try to reconstruct the channel that was at the origin of the id. This can
   # obviously only work if you have such an object in your address space.
   # There are multiple ways to construct such a situation. Say you want to
   # send a pipe channel to one of your (forked) childs: This will work if you
@@ -13,18 +13,26 @@ module Cod
   # share all objects that were available before the fork. 
   #
   class Pipe < Channel
+    # The underlying IOPair.
+    # @private 
     attr_reader :pipe
+    
+    # The serializer for this pipe.
     attr_reader :serializer
     
     # A few methods that a pipe split must answer to. The split itself is 
     # basically an array instance; these methods add some calling safety and
     # convenience. 
     #
+    # @private
+    #
     module SplitMethods # :nodoc:
       def read; first; end
       def write; last; end
     end
-
+    
+    # Creates a {Cod::Pipe}.
+    #
     def initialize(serializer=nil, pipe_pair=nil)
       super()
       @serializer = serializer || SimpleSerializer.new
@@ -35,6 +43,9 @@ module Cod
     # for the file descriptors stored in the pipe, so that a #close affects
     # only one copy. 
     #
+    # @example
+    #   pipe.dup  # => anotherpipe
+    #
     def initialize_copy(other)
       super
       @serializer = other.serializer
@@ -48,6 +59,8 @@ module Cod
     # Returns self so that you can write for example: 
     #   read_end = pipe.dup.readonly
     #
+    # @private
+    #
     def readonly
       pipe.close_w
       self
@@ -58,6 +71,8 @@ module Cod
     # Returns self so that you can write for example: 
     #   write_end = pipe.dup.writeonly
     #
+    # @private
+    #
     def writeonly
       pipe.close_r
       self
@@ -65,8 +80,10 @@ module Cod
     
     # Actively splits this pipe into two ends, a read end and a write end. The
     # original pipe is closed, leaving only the two ends to work with. The 
-    # read end can only be read from (#get) and the write end can only be 
-    # written to (#put).
+    # read end can only be read from ({#get}) and the write end can only be 
+    # written to ({#put}).
+    #
+    # @return [Array<Cod::Channel>]
     #
     def split
       [self.dup.readonly, self.dup.writeonly].tap { |split|
@@ -79,7 +96,10 @@ module Cod
     # Using #put on a pipe instance will close the other pipe end. Subsequent
     # #get will raise a Cod::InvalidOperation. 
     #
-    # Example: 
+    # @param obj [Object] message to send to the channel
+    # @return [void]
+    #
+    # @example 
     #   pipe.put [:a, :message]
     #
     def put(obj)
@@ -92,25 +112,25 @@ module Cod
     # Using #get on a pipe instance will close the other pipe end. Subsequent
     # #put will receive a Cod::InvalidOperation.
     #
-    # Example: 
+    # @example 
     #   pipe.get # => obj
     #
     def get(opts={})
       raise Cod::WriteOnlyChannel unless can_read?
       pipe.close_w
       
-      loop do
-        ready = Cod.select(nil, self)
-        return deserialize_one if ready
-      end
+      return deserialize_one
     rescue EOFError
-      fail "All pipe ends seem to be closed. Reading from this pipe will not "+
+      raise Cod::ConnectionLost, 
+        "All pipe ends seem to be closed. Reading from this pipe will not "+
         "return any data."
     end
     
     # Closes the pipe completely. All active ends are closed. Note that you
     # can call this function on a closed pipe without getting an error raised.
     #
+    # @return [void]
+    #
     def close
       pipe.close
     end
@@ -121,6 +141,9 @@ module Cod
       result = Cod.select(timeout, self)
       not result.nil?
     end
+    
+    # @private
+    #
     def to_read_fds
       r
     end
@@ -141,29 +164,49 @@ module Cod
 
     # Returns the read end of the pipe
     #
+    # @private
+    #
     def r
       pipe.r
     end
     
     # Returns the write end of the pipe
     #
+    # @private
+    #
     def w
       pipe.w
     end
 
     # --------------------------------------------------------- service/client
     
+    # Produces a service using this pipe as service channel. 
+    # @see Cod::Service 
+    #
+    # @return [Cod::Service]
+    #
     def service
       Service.new(self)
     end
+    
+    # Produces a service client. Requests are sent to this channel, and answers
+    # are routed back to +answers_to+.
+    #
+    # @param answers_to [Cod::Channel] Where answers should be addressed to.
+    # @return [Cod::Service::Client]
+    #
     def client(answers_to)
       Service::Client.new(self, answers_to)
     end
 
     # ---------------------------------------------------------- serialization
+    
+    # @private
     def _dump(depth) # :nodoc:
       object_id.to_s
     end
+
+    # @private
     def self._load(string) # :nodoc:
       ObjectSpace._id2ref(Integer(string))
     end

data/lib/cod/process.rb

@@ -1,13 +1,33 @@
 module Cod
+  
+  # A subprocess that is being run in server mode (think git-server). Use 
+  # {Cod}.process to obtain an instance of this. You can then call {#channel} to 
+  # obtain a Cod channel to communicate with the $stdio server you've spawned. 
+  #
+  # @example List the files in a directory
+  #   process = Cod.process('ls', Cod::LineSerializer.new)
+  #   process.wait
+  #   loop do
+  #     # Will list all entries of the current dir in turn, already chomped.
+  #     msg = process.get rescue nil
+  #     break unless msg
+  #   end
+  #
   class Process
+    # The pid of the process that was spawned.
+    # @return [Number]
     attr_reader :pid 
     
+    # Constructs a process object and runs the command. 
+    #
+    # @see Cod#process
     def initialize(command, serializer=nil)
       @serializer = serializer || SimpleSerializer.new
 
       run(command)
     end
     
+    # @private
     def run(command)
       @pipe = Cod.bidir_pipe(@serializer)
       
@@ -16,19 +36,49 @@ module Cod
         :out => @pipe.r.w)
     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. 
+    #
+    # @example
+    #   process = Cod.process('uname', LineSerializer.new)
+    #   process.channel.get # => {Darwin,Linux,...}
+    # 
+    # @return [Cod::Pipe]
+    #
     def channel
       @pipe
     end
     
+    # Stops the process unilaterally. 
+    # 
+    # @return [void]
+    #
     def kill
+      terminate
       ::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. 
+    #
+    # @return [void]
+    #
     def terminate
       @pipe.w.close
     end
     
+    # Waits for the process to terminate and returns its exit value. May
+    # return nil, in which case someone else already reaped the process.
+    #
+    # @return [Number,nil]
+    #
     def wait
       ::Process.wait(@pid)
+    rescue Errno::ECHILD
     end
   end
 end

data/lib/cod/select.rb

@@ -1,5 +1,13 @@
 module Cod
+  # A shortcurt for constructing a {Select}. See {Select#do} for more
+  # information.
+  #
+  # @param timeout [Number] seconds to block before giving up
+  # @param groups channels or io selectors to wait for
+  # @return [Hash,Array,Cod::Channel,IO]
+  # 
   def select(timeout, groups)
+    # TODO create an overload without the timeout
     Select.new(timeout, groups).do
   end
   module_function :select
@@ -24,8 +32,10 @@ module Cod
     # Performs the IO.select and returns a thinned out version of that initial
     # groups, containing only FDs and channels that are ready for reading. 
     #
+    # @return [Hash,Array,Cod::Channel,IO]
+    #
     def do
-      fds = groups.values { |e| to_read_fd(e) }
+      fds = groups.values { |e| to_read_fd(e) }.compact
       
       # Perform select  
       r,w,e = IO.select(fds, nil, nil, timeout)

data/lib/cod/tcp_client.rb

@@ -131,6 +131,12 @@ module Cod
       # with a valid client later on. (hopefully)
       OtherEnd.new(params)
     end
+
+    # @private
+    #
+    def to_read_fds
+      @connection.socket if @connection
+    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.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cod
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-07 00:00:00.000000000 Z
+date: 2012-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70125556634640 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70125556634640
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70125556634180 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70125556634180
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: flexmock
-  requirement: &70125556633740 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70125556633740
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70125556633260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +69,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70125556633260
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &70125556632740 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +85,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70125556632740
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: growl
-  requirement: &70125556632280 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +101,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70125556632280
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: kaspar.schiess@absurd.li
 executables: []
@@ -95,6 +125,7 @@ files:
 - lib/cod/bidir_pipe.rb
 - lib/cod/channel.rb
 - lib/cod/iopair.rb
+- lib/cod/line_serializer.rb
 - lib/cod/pipe.rb
 - lib/cod/process.rb
 - lib/cod/protocol_buffers_serializer.rb
@@ -110,6 +141,8 @@ files:
 - 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
@@ -134,7 +167,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -763744089584274604
+      hash: 4413858275826022328
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -143,10 +176,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -763744089584274604
+      hash: 4413858275826022328
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.16
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Really simple IPC. Pipes, TCP sockets, beanstalkd, ...