einhorn 0.4.2 → 0.4.3

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ree

data/README.md

@@ -80,12 +80,17 @@ Each address is specified as an ip/port pair, possibly accompanied by options:
     ADDR := (IP:PORT)[<,OPT>...]
 
 In the worker process, the opened file descriptors will be represented
-as a space-separated list of file descriptor numbers in the
-EINHORN_FDS environment variable (respecting the order that the `-b`
-options were provided in):
+as file descriptor numbers in a series of environment variables named
+EINHORN_FD_1, EINHORN_FD_2, etc. (respecting the order that the `-b`
+options were provided in), with the total number of file descriptors
+in the EINHORN_FD_COUNT environment variable:
 
-    EINHORN_FDS="6" # 127.0.0.1:1234
-    EINHORN_FDS="6 7" # 127.0.0.1:1234,r 127.0.0.1:1235
+    EINHORN_FD_1="6" # 127.0.0.1:1234
+    EINHORN_FD_COUNT="1"
+
+    EINHORN_FD_1="6" # 127.0.0.1:1234,r
+    EINHORN_FD_2="7" # 127.0.0.1:1235
+    EINHORN_FD_COUNT="2"
 
 Valid opts are:
 
@@ -98,7 +103,7 @@ You can for example run:
 
 Which will run 4 copies of
 
-    EINHORN_FDS=6 example/time_server
+    EINHORN_FD_1=6 EINHORN_FD_COUNT=1 example/time_server
 
 Where file descriptor 6 is a server socket bound to `127.0.0.1:2345`
 and with `SO_REUSEADDR` set. It is then your application's job to
@@ -191,7 +196,7 @@ pass `-c <name>`.
 
 ### Options
 
-    -b, --bind ADDR                  Bind an address and add the corresponding FD to EINHORN_FDS
+    -b, --bind ADDR                  Bind an address and add the corresponding FD via the environment
     -c, --command-name CMD_NAME      Set the command name in ps to this value
     -d, --socket-path PATH           Where to open the Einhorn command socket
     -e, --pidfile PIDFILE            Where to write out the Einhorn pidfile

data/Rakefile

@@ -17,3 +17,6 @@ Rake::TestTask.new do |t|
   t.verbose = true
   t.test_files = FileList['test/unit/**/*.rb']
 end
+
+task :default => :test do
+end

data/bin/einhorn

@@ -56,12 +56,17 @@ Each address is specified as an ip/port pair, possibly accompanied by options:
     ADDR := (IP:PORT)[<,OPT>...]
 
 In the worker process, the opened file descriptors will be represented
-as a space-separated list of file descriptor numbers in the
-EINHORN_FDS environment variable (respecting the order that the `-b`
-options were provided in):
+as file descriptor numbers in a series of environment variables named
+EINHORN_FD_1, EINHORN_FD_2, etc. (respecting the order that the `-b`
+options were provided in), with the total number of file descriptors
+in the EINHORN_FD_COUNT environment variable:
 
-    EINHORN_FDS="6" # 127.0.0.1:1234
-    EINHORN_FDS="6 7" # 127.0.0.1:1234,r 127.0.0.1:1235
+    EINHORN_FD_1="6" # 127.0.0.1:1234
+    EINHORN_FD_COUNT="1"
+
+    EINHORN_FD_1="6" # 127.0.0.1:1234,r
+    EINHORN_FD_2="7" # 127.0.0.1:1235
+    EINHORN_FD_COUNT="2"
 
 Valid opts are:
 
@@ -74,7 +79,7 @@ You can for example run:
 
 Which will run 4 copies of
 
-    EINHORN_FDS=6 example/time_server
+    EINHORN_FD_1=6 EINHORN_FD_COUNT=1 example/time_server
 
 Where file descriptor 6 is a server socket bound to `127.0.0.1:2345`
 and with `SO_REUSEADDR` set. It is then your application's job to
@@ -184,7 +189,7 @@ if true # $0 == __FILE__
   Einhorn::TransientState.environ = ENV.to_hash
 
   optparse = OptionParser.new do |opts|
-    opts.on('-b ADDR', '--bind ADDR', 'Bind an address and add the corresponding FD to EINHORN_FDS') do |addr|
+    opts.on('-b ADDR', '--bind ADDR', 'Bind an address and add the corresponding FD via the environment') do |addr|
       unless addr =~ /\A([^:]+):(\d+)((?:,\w+)*)\Z/
         raise "Invalid value for #{addr.inspect}: bind address must be of the form address:port[,flags...]"
       end
@@ -258,7 +263,7 @@ if true # $0 == __FILE__
     end
 
     opts.on('-q', '--quiet', 'Make output quiet (can be reconfigured on the fly)') do
-      Einhorn::Command.louder(false)
+      Einhorn::Command.quieter(false)
     end
 
     opts.on('-s', '--seconds N', 'Number of seconds to wait until respawning') do |b|
@@ -269,6 +274,16 @@ if true # $0 == __FILE__
       Einhorn::Command.louder(false)
     end
 
+    opts.on('--nice MASTER[:WORKER=0][:RENICE_CMD=/usr/bin/renice]', 'Unix nice level at which to run the einhorn processes. If not running as root, make sure to ulimit -e as appopriate.') do |nice|
+      master, worker, renice_cmd = nice.split(':')
+      master = Integer(master) if master
+      worker = Integer(worker) if worker
+
+      Einhorn::State.nice[:master] = master if master
+      Einhorn::State.nice[:worker] = worker if worker
+      Einhorn::State.nice[:renice_cmd] = renice_cmd if renice_cmd
+    end
+
     opts.on('--with-state-fd STATE', '[Internal option] With file descriptor containing state') do |fd|
       Einhorn::TransientState.stateful = true
       read = IO.for_fd(Integer(fd))

data/example/thin_example

@@ -27,10 +27,9 @@ end
 
 def einhorn_main
   puts "Called with #{ARGV.inspect}"
+  fd_count = Einhorn::Worker.einhorn_fd_count
 
-  einhorn_fds = Einhorn::Worker.einhorn_fds
-
-  unless einhorn_fds
+  unless fd_count > 0
     raise "Need to call with at least one bound socket. Try running 'einhorn -b 127.0.0.1:5000,r,n -b 127.0.0.1:5001,r,n #{$0}' and then running 'curl 127.0.0.1:5000' or 'curl 127.0.0.1:5001'"
   end
 
@@ -41,7 +40,8 @@ def einhorn_main
   Einhorn::Worker.ack!
 
   EventMachine.run do
-    einhorn_fds.each_with_index do |sock, i|
+    (0...fd_count).each do |i|
+      sock = Einhorn::Worker.socket!(i)
       srv = Thin::Server.new(sock, App.new(i), :reuse => true)
       srv.start
     end

data/example/time_server

@@ -2,7 +2,8 @@
 #
 # A simple example showing how to use Einhorn's shared-socket
 # features. Einhorn translates the (addr:port[,flags...]) bind spec in
-# into a file descriptor number in the EINHORN_FDS environment variable.
+# into a file descriptor number in the EINHORN_FD_# environment
+# variables.
 #
 # Invoke through Einhorn as
 #
@@ -15,7 +16,7 @@ require 'rubygems'
 require 'einhorn/worker'
 
 def einhorn_main
-  puts "Called with ENV['EINHORN_FDS']: #{ENV['EINHORN_FDS']}"
+  puts "Called with ENV['EINHORN_FD_1']: #{ENV['EINHORN_FD_1']}"
 
   fd_num = Einhorn::Worker.socket!
   socket = Socket.for_fd(fd_num)

data/lib/einhorn/command/interface.rb

@@ -292,9 +292,6 @@ EOF
       # buffer and lost upon reload.
       send_message(conn, 'Reloading, as commanded')
       Einhorn::Command.reload
-
-      # Reload should not return
-      raise "Not reachable"
     end
 
     command 'inc', 'Increment the number of Einhorn child processes' do
@@ -361,6 +358,32 @@ EOF
       "Einhorn is going down! #{response}"
     end
 
+    command 'config', 'Merge in a new set of config options. (Note: this will likely be subsumed by config file reloading at some point.)' do |conn, request|
+      args = request['args']
+      if message = validate_args(args)
+        next message
+      end
+
+      unless args.length > 0
+        next 'Must pass in a YAML-encoded hash'
+      end
+
+      begin
+        # We do the joining so people don't need to worry about quoting
+        parsed = YAML.load(args.join(' '))
+      rescue ArgumentError => e
+        next 'Could not parse argument. Must be a YAML-encoded hash'
+      end
+
+      unless parsed.kind_of?(Hash)
+        next "Parsed argument is a #{parsed.class}, not a hash"
+      end
+
+      Einhorn::State.state.merge!(parsed)
+
+      "Successfully merged in config: #{parsed.inspect}"
+    end
+
     def self.validate_args(args)
       return 'No args provided' unless args
       return 'Args must be an array' unless args.kind_of?(Array)

data/lib/einhorn/command.rb

@@ -192,13 +192,17 @@ module Einhorn
       end
       write.close
 
-      Einhorn::Event.uninit
-
       # Reload the original environment
       ENV.clear
       ENV.update(Einhorn::TransientState.environ)
 
-      exec [Einhorn::TransientState.script_name, Einhorn::TransientState.script_name], *(['--with-state-fd', read.fileno.to_s, '--'] + Einhorn::State.cmd)
+      begin
+        exec [Einhorn::TransientState.script_name, Einhorn::TransientState.script_name], *(['--with-state-fd', read.fileno.to_s, '--'] + Einhorn::State.cmd)
+      rescue SystemCallError => e
+        Einhorn.log_error("Could not reload! Attempting to continue. Error was: #{e}")
+        Einhorn::State.reloading_for_preload_upgrade = false
+        read.close
+      end
     end
 
     def self.spinup(cmd=nil)
@@ -206,6 +210,7 @@ module Einhorn
       if Einhorn::TransientState.preloaded
         pid = fork do
           Einhorn::TransientState.whatami = :worker
+          prepare_child_process
 
           Einhorn.log_info('About to tear down Einhorn state and run einhorn_main')
           Einhorn::Command::Interface.uninit
@@ -218,6 +223,7 @@ module Einhorn
       else
         pid = fork do
           Einhorn::TransientState.whatami = :worker
+          prepare_child_process
 
           Einhorn.log_info("About to exec #{cmd.inspect}")
           # Here's the only case where cloexec would help. Since we
@@ -260,12 +266,21 @@ module Einhorn
         Einhorn::TransientState.socket_handles << socket
         ENV['EINHORN_SOCK_FD'] = socket.fileno.to_s
       end
-      # Try to match Upstart's internal support for space-separated FD
-      # lists. (I don't think anyone actually uses that functionality,
-      # but seems reasonable enough.)
+
+      ENV['EINHORN_FD_COUNT'] = Einhorn::State.bind_fds.length.to_s
+      Einhorn::State.bind_fds.each_with_index {|fd, i| ENV["EINHORN_FD_#{i}"] = fd.to_s}
+
+      # EINHORN_FDS is deprecated. It was originally an attempt to
+      # match Upstart's nominal internal support for space-separated
+      # FD lists, but nobody uses that in practice, and it makes
+      # finding individual FDs more difficult
       ENV['EINHORN_FDS'] = Einhorn::State.bind_fds.map(&:to_s).join(' ')
     end
 
+    def self.prepare_child_process
+      Einhorn.renice_self
+    end
+
     def self.full_upgrade
       if Einhorn::State.path && !Einhorn::State.reloading_for_preload_upgrade
         reload_for_preload_upgrade

data/lib/einhorn/event.rb

@@ -8,20 +8,22 @@ module Einhorn
     @@writeable = {}
     @@timers = {}
 
+    def self.cloexec!(fd)
+      fd.fcntl(Fcntl::F_SETFD, fd.fcntl(Fcntl::F_GETFD) | Fcntl::FD_CLOEXEC)
+    end
+
     def self.init
       readable, writeable = IO.pipe
       @@loopbreak_reader = LoopBreaker.open(readable)
       @@loopbreak_writer = writeable
-    end
 
-    def self.uninit
-      # These don't need to persist across Einhorn reloads, so let's not keep.
-      @@loopbreak_reader.close
-      @@loopbreak_writer.close
+      cloexec!(readable)
+      cloexec!(writeable)
     end
 
     def self.close_all
-      uninit
+      @@loopbreak_reader.close
+      @@loopbreak_writer.close
       (@@readable.values + @@writeable.values).each do |descriptors|
         descriptors.each do |descriptor|
           descriptor.close

data/lib/einhorn/version.rb

@@ -1,3 +1,3 @@
 module Einhorn
-  VERSION = '0.4.2'
+  VERSION = '0.4.3'
 end

data/lib/einhorn/worker.rb

@@ -80,30 +80,39 @@ module Einhorn
 
     def self.socket(number=nil)
       number ||= 0
-      fds = einhorn_fds
-      fds ? fds[number] : nil
+      einhorn_fd(number)
     end
 
     def self.socket!(number=nil)
       number ||= 0
 
-      unless fds = einhorn_fds
-        raise "No EINHORN_FDS provided in environment. Are you running under Einhorn?"
+      unless count = einhorn_fd_count
+        raise "No EINHORN_FD_COUNT provided in environment. Are you running under Einhorn?"
       end
 
-      unless number < fds.length
-        raise "Only #{fds.length} FDs available, but FD #{number} was requested"
+      unless number < count
+        raise "Only #{count} FDs available, but FD #{number} was requested"
       end
 
-      fds[number]
+      unless fd = einhorn_fd(number)
+        raise "No EINHORN_FD_#{number} provided in environment. That's pretty weird"
+      end
+
+      fd
     end
 
-    def self.einhorn_fds
-      unless raw_fds = ENV['EINHORN_FDS']
+    def self.einhorn_fd(n)
+      unless raw_fd = ENV["EINHORN_FD_#{n}"]
         return nil
       end
+      Integer(raw_fd)
+    end
 
-      raw_fds.split(' ').map {|fd| Integer(fd)}
+    def self.einhorn_fd_count
+      unless raw_count = ENV['EINHORN_FD_COUNT']
+        return 0
+      end
+      Integer(raw_count)
     end
 
     # Call this to handle graceful shutdown requests to your app.

data/lib/einhorn/worker_pool.rb

@@ -1,17 +1,23 @@
 module Einhorn
   module WorkerPool
+    def self.workers_with_state
+      Einhorn::State.children.select do |pid, spec|
+        spec[:type] == :worker
+      end
+    end
+
     def self.workers
-      Einhorn::State.children.keys
+      workers_with_state.map {|pid, _| pid}
     end
 
     def self.unsignaled_workers
-      Einhorn::State.children.select do |pid, spec|
+      workers_with_state.select do |pid, spec|
         spec[:signaled].length == 0
       end.map {|pid, _| pid}
     end
 
     def self.modern_workers_with_state
-      Einhorn::State.children.select do |pid, spec|
+      workers_with_state.select do |pid, spec|
         spec[:version] == Einhorn::State.version
       end
     end

data/lib/einhorn.rb

@@ -57,7 +57,8 @@ module Einhorn
         :pidfile => nil,
         :lockfile => nil,
         :consecutive_deaths_before_ack => 0,
-        :last_upgraded => nil
+        :last_upgraded => nil,
+        :nice => {:master => nil, :worker => nil, :renice_cmd => '/usr/bin/renice'}
       }
     end
   end
@@ -81,10 +82,33 @@ module Einhorn
 
   def self.restore_state(state)
     parsed = YAML.load(state)
-    Einhorn::State.state = parsed[:state]
+    updated_state, message = update_state(parsed[:state])
+    Einhorn::State.state = updated_state
     Einhorn::Event.restore_persistent_descriptors(parsed[:persistent_descriptors])
-    # Do this after setting state so verbosity is right9
+    # Do this after setting state so verbosity is right
     Einhorn.log_info("Using loaded state: #{parsed.inspect}")
+    Einhorn.log_info(message) if message
+  end
+
+  def self.update_state(old_state)
+    # TODO: handle format updates somehow? (probably need to write
+    # special-case code for each)
+    updated_state = old_state.dup
+    default = Einhorn::State.default_state
+    added_keys = default.keys - old_state.keys
+    deleted_keys = old_state.keys - default.keys
+    return [updated_state, nil] if added_keys.length == 0 && deleted_keys.length == 0
+
+    added_keys.each {|key| updated_state[key] = default[key]}
+    deleted_keys.each {|key| updated_state.delete(key)}
+
+    message = []
+    message << "adding default values for #{added_keys.inspect}"
+    message << "deleting values for #{deleted_keys.inspect}"
+    message = "State format has changed: #{message.join(', ')}"
+
+    # Can't print yet, since state hasn't been set, so we pass along the message.
+    [updated_state, message]
   end
 
   def self.print_state
@@ -222,6 +246,25 @@ module Einhorn
     Einhorn::State.cmd_name ? "ruby #{Einhorn::State.cmd_name}" : Einhorn::State.orig_cmd.join(' ')
   end
 
+  def self.renice_self
+    whatami = Einhorn::TransientState.whatami
+    return unless nice = Einhorn::State.nice[whatami]
+    pid = $$
+
+    unless nice.kind_of?(Fixnum)
+      raise "Nice must be a fixnum: #{nice.inspect}"
+    end
+
+    # Explicitly don't shellescape the renice command
+    cmd = "#{Einhorn::State.nice[:renice_cmd]} #{nice} -p #{pid}"
+    log_info("Running #{cmd.inspect} to renice self to level #{nice}")
+    `#{cmd}`
+    unless $?.exitstatus == 0
+      # TODO: better error handling?
+      log_error("Renice command exited with status: #{$?.inspect}, but continuing on anyway.")
+    end
+  end
+
   def self.socketify_env!
     Einhorn::State.bind.each do |host, port, flags|
       fd = bind(host, port, flags)
@@ -267,6 +310,7 @@ module Einhorn
     end
 
     set_master_ps_name
+    renice_self
     preload
 
     # In the middle of upgrading

data/test/unit/einhorn/client.rb

@@ -3,46 +3,68 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../../test_helper'))
 require 'einhorn'
 
 class ClientTest < Test::Unit::TestCase
-  def message
+  def unserialized_message
     {:foo => ['%bar', '%baz']}
   end
 
-  def serialized
+  def serialized_1_8
     "--- %0A:foo: %0A- \"%25bar\"%0A- \"%25baz\"%0A\n"
   end
 
+  def serialized_1_9
+    "---%0A:foo:%0A- ! '%25bar'%0A- ! '%25baz'%0A\n"
+  end
+
   context "when sending a message" do
     should "write a serialized line" do
       socket = mock
-      socket.expects(:write).with(serialized)
-      Einhorn::Client::Transport.send_message(socket, message)
+      socket.expects(:write).with do |write|
+        write == serialized_1_8 || write == serialized_1_9
+      end
+      Einhorn::Client::Transport.send_message(socket, unserialized_message)
     end
   end
 
   context "when receiving a message" do
-    should "deserialize a single line" do
+    should "deserialize a single 1.8-style line" do
+      socket = mock
+      socket.expects(:readline).returns(serialized_1_8)
+      result = Einhorn::Client::Transport.receive_message(socket)
+      assert_equal(result, unserialized_message)
+    end
+
+    should "deserialize a single 1.9-style line" do
       socket = mock
-      socket.expects(:readline).returns(serialized)
+      socket.expects(:readline).returns(serialized_1_9)
       result = Einhorn::Client::Transport.receive_message(socket)
-      assert_equal(result, message)
+      assert_equal(result, unserialized_message)
     end
   end
 
   context "when {de,}serializing a message" do
     should "serialize and escape a message as expected" do
-      actual = Einhorn::Client::Transport.serialize_message(message)
-      assert_equal(serialized, actual)
+      actual = Einhorn::Client::Transport.serialize_message(unserialized_message)
+      assert(actual == serialized_1_8 || actual == serialized_1_9, "Actual message is #{actual.inspect}")
     end
 
-    should "deserialize and unescape a message as expected" do
-      actual = Einhorn::Client::Transport.deserialize_message(serialized)
-      assert_equal(message, actual)
+    should "deserialize and unescape a 1.8-style message as expected" do
+      actual = Einhorn::Client::Transport.deserialize_message(serialized_1_8)
+      assert_equal(unserialized_message, actual)
+    end
+
+    should "deserialize and unescape a 1.9-style message as expected" do
+      actual = Einhorn::Client::Transport.deserialize_message(serialized_1_9)
+      assert_equal(unserialized_message, actual)
     end
 
     should "raise an error when deserializing invalid YAML" do
       invalid_serialized = "-%0A\t-"
-      assert_raises(ArgumentError) do
+      expected = [ArgumentError]
+      expected << Psych::SyntaxError if defined?(Psych::SyntaxError) # 1.9
+
+      begin
         Einhorn::Client::Transport.deserialize_message(invalid_serialized)
+      rescue *expected
       end
     end
   end

data/test/unit/einhorn/worker_pool.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../test_helper'))
+
+require 'einhorn'
+
+class WorkerPoolTest < Test::Unit::TestCase
+  def stub_children
+    Einhorn::State.stubs(:children).returns(
+      1234 => {:type => :worker, :signaled => Set.new(['INT'])},
+      1235 => {:type => :state_passer},
+      1236 => {:type => :worker, :signaled => Set.new}
+      )
+  end
+
+  context "#workers_with_state" do
+    setup do
+      stub_children
+    end
+
+    should "select only the workers" do
+      workers_with_state = Einhorn::WorkerPool.workers_with_state
+      # Sort only needed for Ruby 1.8
+      assert_equal([
+          [1234, {:type => :worker, :signaled => Set.new(['INT'])}],
+          [1236, {:type => :worker, :signaled => Set.new}]
+        ], workers_with_state.sort)
+    end
+  end
+
+  context "#unsignaled_workers" do
+    setup do
+      stub_children
+    end
+
+    should "selects unsignaled workers" do
+      unsignaled_workers = Einhorn::WorkerPool.unsignaled_workers
+      assert_equal([1236], unsignaled_workers)
+    end
+  end
+end

data/test/unit/einhorn.rb

@@ -35,4 +35,24 @@ class EinhornTest < Test::Unit::TestCase
       assert_equal(['foo', '--opt=10', '10'], cmd)
     end
   end
+
+  context '.update_state' do
+    should 'correctly update keys to match new default state hash' do
+      Einhorn::State.stubs(:default_state).returns(:baz => 23, :foo => 1)
+      old_state = {:foo => 2, :bar => 2}
+
+      updated_state, message = Einhorn.update_state(old_state)
+      assert_equal({:baz => 23, :foo => 2}, updated_state)
+      assert_match(/State format has changed/, message)
+    end
+
+    should 'not change the state if the format has not changed' do
+      Einhorn::State.stubs(:default_state).returns(:baz => 23, :foo => 1)
+      old_state = {:baz => 14, :foo => 1234}
+
+      updated_state, message = Einhorn.update_state(old_state)
+      assert_equal({:baz => 14, :foo => 1234}, updated_state)
+      assert(message.nil?)
+    end
+  end
 end

metadata

@@ -1,76 +1,78 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: einhorn
-version: !ruby/object:Gem::Version 
-  hash: 11
+version: !ruby/object:Gem::Version
+  version: 0.4.3
   prerelease: 
-  segments: 
-  - 0
-  - 4
-  - 2
-  version: 0.4.2
 platform: ruby
-authors: 
+authors:
 - Greg Brockman
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-10-11 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: shoulda
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: mocha
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-description: Einhorn makes it easy to run multiple instances of an application server, all listening on the same port. You can also seamlessly restart your workers without dropping any requests. Einhorn requires minimal application-level support, making it easy to use with an existing project.
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Einhorn makes it easy to run multiple instances of an application server,
+  all listening on the same port. You can also seamlessly restart your workers without
+  dropping any requests. Einhorn requires minimal application-level support, making
+  it easy to use with an existing project.
+email:
 - gdb@stripe.com
-executables: 
+executables:
 - einhorn
 - einhornsh
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - History.txt
 - LICENSE
@@ -104,43 +106,37 @@ files:
 - test/unit/einhorn/command.rb
 - test/unit/einhorn/command/interface.rb
 - test/unit/einhorn/event.rb
+- test/unit/einhorn/worker_pool.rb
 homepage: https://github.com/stripe/einhorn
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: "Einhorn: the language-independent shared socket manager"
-test_files: 
+summary: ! 'Einhorn: the language-independent shared socket manager'
+test_files:
 - test/test_helper.rb
 - test/unit/einhorn.rb
 - test/unit/einhorn/client.rb
 - test/unit/einhorn/command.rb
 - test/unit/einhorn/command/interface.rb
 - test/unit/einhorn/event.rb
+- test/unit/einhorn/worker_pool.rb
+has_rdoc: