einhorn 0.5.7 → 0.6.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTAzM2VhNjlkNDFhM2VlYzE4MjcwMjk3MmI3YzQwMzRkN2MxZmM0Ng==
+  data.tar.gz: !binary |-
+    NTdmZGE0ZDVjMjYyODdlODIyZWM0Y2ExYWE1MWViNmQ3MjEzNWFlMQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZjgzZGVlZmMwNzZmNGFjMDkzODZlNTJhZjdiNDdjY2I0MmRiOGE0NmQzYjkz
+    Mzc0NjY0MGQ1NWYxMzVkMjI4Nzg0MWNkZGI4MmEwMmIzZWI1MDk5ZDRkZmRh
+    YzBkYTAxMWU1MTVhZWU1ZTM1NDMzMGJlOTgyY2U0MTI5OTM3ZGI=
+  data.tar.gz: !binary |-
+    MjQyZTI4NjI0Njg4NDJmMDBlMWQwYTY4MDU3OWRiZTFhOGJlNDg1YmNkZGJl
+    Y2EzNWMzYjk5NTA3NzU1NzhiN2JmYzUwZjgzYjUxOWU2NTBhM2U0MDA4OTdm
+    Njc4NzQ1MDI0ZWY5Zjk4MDk1NzllODk2NWYzMDE3MTllODM5Njk=

data/README.md

@@ -211,7 +211,12 @@ pass `-c <name>`.
     -q, --quiet                      Make output quiet (can be reconfigured on the fly)
     -s, --seconds N                  Number of seconds to wait until respawning
     -v, --verbose                    Make output verbose (can be reconfigured on the fly)
+        --drop-env-var VAR_NAME      Delete VAR_NAME from the environment that is restored on upgrade
+        --reexec-as=CMDLINE          Substitute CMDLINE for \"einhorn\" when upgrading
+        --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.
         --with-state-fd STATE        [Internal option] With file descriptor containing state
+        --upgrade-check              [Internal option] Check if Einhorn can exec itself and exit with status 0 before loading code
         --version                    Show version
 
 

data/README.md.in

@@ -61,11 +61,8 @@ servers) to a wider array of applications.
 See https://stripe.com/blog/meet-einhorn for more background.
 
 Stripe currently uses Einhorn in production for a number of
-services. Our Thin + EventMachine servers currently require patches to
-both Thin and EventMachine (to support file-descriptor passing). You
-can obtain these patches from our public forks of the
-[respective](https://github.com/stripe/thin)
-[projects](https://github.com/stripe/eventmachine). Check out
+services. You can use Conrad Irwin's thin-attach_socket gem along with
+EventMachine-LE to support file-descriptor passing. Check out
 `example/thin_example` for an example of running Thin under Einhorn.
 
 ## Compatibility

data/Rakefile

@@ -11,13 +11,6 @@ task :readme do
   File.open('README.md', 'w') {|f| f.write(readme)}
 end
 
-Rake::TestTask.new do |t|
-  t.libs = ["lib"]
-  # t.warning = true
-  t.verbose = true
-  t.test_files = FileList['test/unit/**/*.rb']
-end
-
 task :default => :test do
 end
 require 'bundler/setup'

data/bin/einhorn

@@ -275,6 +275,14 @@ if true # $0 == __FILE__
       Einhorn::Command.louder(false)
     end
 
+    opts.on('--drop-env-var VAR_NAME', 'Delete VAR_NAME from the environment that is restored on upgrade') do |var|
+      Einhorn::State.drop_environment_variables << var
+    end
+
+    opts.on('--reexec-as=CMDLINE', 'Substitute CMDLINE for \"einhorn\" when upgrading') do |cmdline|
+      Einhorn::State.reexec_commandline = Shellwords.shellsplit(cmdline)
+    end
+
     Einhorn.plugins_send(:optparse, opts)
 
     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|
@@ -296,6 +304,11 @@ if true # $0 == __FILE__
       Einhorn.restore_state(state)
     end
 
+    opts.on('--upgrade-check', '[Internal option] Check if Einhorn can exec itself and exit with status 0 before loading code') do
+      Einhorn.dump_environment_info
+      exit 0
+    end
+
     opts.on('--version', 'Show version') do
       puts Einhorn::VERSION
       exit

data/einhorn.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'minitest', '< 5.0'
   gem.add_development_dependency 'mocha', '~> 0.13'
   gem.add_development_dependency 'chalk-rake'
+  gem.add_development_dependency 'subprocess'
 
   gem.version       = Einhorn::VERSION
 end

data/lib/einhorn/command/interface.rb

@@ -351,7 +351,7 @@ EOF
       Einhorn::Command.louder
     end
 
-    command 'upgrade', 'Upgrade all Einhorn workers smoothly. This may result in Einhorn reloading its own code as well.' do |conn, request|
+    command 'upgrade', 'Upgrade all Einhorn workers smoothly. This causes Einhorn to reload its own code as well.' do |conn, request|
       # send first message directly for old clients that don't support request
       # ids or subscriptions. Everything else is sent tagged with request id
       # for new clients.
@@ -362,7 +362,7 @@ EOF
       nil
     end
 
-    command 'upgrade_fleet', 'Upgrade all Einhorn workers a fleet at a time. This may result in Einhorn reloading its own code as well.' do |conn, request|
+    command 'upgrade_fleet', 'Upgrade all Einhorn workers a fleet at a time. This causes Einhorn to reload its own code as well.' do |conn, request|
       # send first message directly for old clients that don't support request
       # ids or subscriptions. Everything else is sent tagged with request id
       # for new clients.

data/lib/einhorn/command.rb

@@ -171,13 +171,13 @@ module Einhorn
     end
 
     def self.dumpable_state
-      global_state = Einhorn::State.state
+      global_state = Einhorn::State.dumpable_state
       descriptor_state = Einhorn::Event.persistent_descriptors.map do |descriptor|
         descriptor.to_state
       end
       plugin_state = {}
       Einhorn.plugins.each do |name, plugin|
-        plugin_state[name] = plugin::State.state if plugin.const_defined?(:State)
+        plugin_state[name] = plugin::State.dumpable_state if plugin.const_defined?(:State)
       end
 
       {
@@ -193,7 +193,7 @@ module Einhorn
         return
       end
 
-      Einhorn.log_info("Reloading einhorn (#{Einhorn::TransientState.script_name})...")
+      Einhorn.log_info("Reloading einhorn master (#{Einhorn::TransientState.script_name})...", :reload)
 
       # In case there's anything lurking
       $stdout.flush
@@ -221,19 +221,22 @@ module Einhorn
       end
       write.close
 
-      # Reload the original environment
-      ENV.clear
-      ENV.update(Einhorn::TransientState.environ)
+      unless Einhorn.can_safely_reload?
+        Einhorn.log_error("Can not initiate einhorn master reload safely, aborting", :reload)
+        Einhorn::State.reloading_for_upgrade = false
+        read.close
+        return
+      end
 
       begin
-        Einhorn::Compat.exec(
-          Einhorn::TransientState.script_name,
-          ['--with-state-fd', read.fileno.to_s, '--'] + Einhorn::State.cmd,
-          :close_others => false
-          )
+        Einhorn.initialize_reload_environment
+        respawn_commandline = Einhorn.upgrade_commandline(['--with-state-fd', read.fileno.to_s])
+        respawn_commandline << { :close_others => false }
+        Einhorn.log_info("About to re-exec einhorn master as #{respawn_commandline.inspect}", :reload)
+        Einhorn::Compat.exec(*respawn_commandline)
       rescue SystemCallError => e
-        Einhorn.log_error("Could not reload! Attempting to continue. Error was: #{e}")
-        Einhorn::State.reloading_for_preload_upgrade = false
+        Einhorn.log_error("Could not reload! Attempting to continue. Error was: #{e}", :reload)
+        Einhorn::State.reloading_for_upgrade = false
         read.close
       end
     end
@@ -371,12 +374,7 @@ module Einhorn
       options = {:smooth => false}.merge(options)
 
       Einhorn::State.smooth_upgrade = options.fetch(:smooth)
-
-      if Einhorn::State.path && !Einhorn::State.reloading_for_preload_upgrade
-        reload_for_preload_upgrade
-      else
-        upgrade_workers
-      end
+      reload_for_upgrade
     end
 
     def self.full_upgrade_smooth
@@ -386,8 +384,8 @@ module Einhorn
       full_upgrade(:smooth => false)
     end
 
-    def self.reload_for_preload_upgrade
-      Einhorn::State.reloading_for_preload_upgrade = true
+    def self.reload_for_upgrade
+      Einhorn::State.reloading_for_upgrade = true
       reload
     end
 
@@ -438,8 +436,8 @@ module Einhorn
         if excess > 0
           Einhorn.log_info("Smooth upgrade: killing off #{excess} old workers.", :upgrade)
           signal_all("USR2", old_workers.take(excess))
-        elsif excess < 0
-          Einhorn.log_error("Smooth upgrade: somehow excess is #{excess}!", :upgrade)
+        else
+          Einhorn.log_debug("Not killing old workers, as excess is #{excess}.")
         end
       end
 

data/lib/einhorn/version.rb

@@ -1,3 +1,3 @@
 module Einhorn
-  VERSION = '0.5.7'
+  VERSION = '0.6.0'
 end

data/lib/einhorn.rb

@@ -5,6 +5,7 @@ require 'set'
 require 'socket'
 require 'tmpdir'
 require 'yaml'
+require 'shellwords'
 
 require 'einhorn/third/little-plugger'
 
@@ -22,6 +23,7 @@ module Einhorn
     def default_state; raise NotImplementedError.new('Override in extended modules'); end
     def state; @state ||= default_state; end
     def state=(v); @state = v; end
+    def dumpable_state; state; end
 
     def method_missing(name, *args)
       if (name.to_s =~ /(.*)=$/) && state.has_key?($1.to_sym)
@@ -41,6 +43,9 @@ module Einhorn
 
   module State
     extend AbstractState
+
+    # WARNING: Don't change or remove these variables without thinking
+    # about backwards/forwards compatibility for upgrades/downgrades
     def self.default_state
       {
         :children => {},
@@ -56,7 +61,7 @@ module Einhorn
         :respawn => true,
         :upgrading => false,
         :smooth_upgrade => false,
-        :reloading_for_preload_upgrade => false,
+        :reloading_for_upgrade => false,
         :path => nil,
         :cmd_name => nil,
         :verbosity => 1,
@@ -70,9 +75,17 @@ module Einhorn
         :lockfile => nil,
         :consecutive_deaths_before_ack => 0,
         :last_upgraded => nil,
-        :nice => {:master => nil, :worker => nil, :renice_cmd => '/usr/bin/renice'}
+        :nice => {:master => nil, :worker => nil, :renice_cmd => '/usr/bin/renice'},
+        :reexec_commandline => nil,
+        :drop_environment_variables => [],
       }
     end
+
+    def self.dumpable_state
+      dump = state
+      dump[:reloading_for_preload_upgrade] = dump[:reloading_for_upgrade]
+      dump
+    end
   end
 
   module TransientState
@@ -105,18 +118,27 @@ module Einhorn
   end
 
   def self.update_state(store, store_name, old_state)
-    # TODO: handle format updates somehow? (probably need to write
-    # special-case code for each)
+    message = []
     updated_state = old_state.dup
+
+    # Handle changes in state format updates from previous einhorn versions
+    if store == Einhorn::State
+      # TODO: Drop this backwards compatibility hack when we hit 0.7
+      if updated_state.include?(:reloading_for_preload_upgrade) &&
+          !updated_state.include?(:reloading_for_upgrade)
+        updated_state[:reloading_for_upgrade] = updated_state.delete(:reloading_for_preload_upgrade)
+        message << "upgraded :reloading_for_preload_upgrade to :reloading_for_upgrade"
+      end
+    end
+
     default = store.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 = default.keys - updated_state.keys
+    deleted_keys = updated_state.keys - default.keys
+    return [updated_state, message.first] 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 for #{store_name} has changed: #{message.join(', ')}"
@@ -329,6 +351,61 @@ module Einhorn
     end
   end
 
+  # Construct and a command and args that can be used to re-exec
+  # Einhorn for upgrades.
+  def self.upgrade_commandline(einhorn_flags=[])
+    cmdline = []
+    if Einhorn::State.reexec_commandline
+      cmdline += Einhorn::State.reexec_commandline
+    else
+      cmdline << Einhorn::TransientState.script_name
+    end
+    cmdline += einhorn_flags
+    cmdline << '--'
+    cmdline += Einhorn::State.cmd
+    [cmdline[0], cmdline[1..-1]]
+  end
+
+  # Returns true if a reload of the einhorn master via re-execing is
+  # not likely to be completely unsafe (that is, the new process's
+  # environment won't prevent it from loading its code on exec).
+  def self.can_safely_reload?
+    upgrade_sentinel = fork do
+      Einhorn::TransientState.whatami = :upgrade_sentinel
+      Einhorn.initialize_reload_environment
+      Einhorn::Compat.exec(*Einhorn.upgrade_commandline(['--upgrade-check']))
+    end
+    Process.wait(upgrade_sentinel)
+    $?.exitstatus.zero?
+  end
+
+  # Set up the environment for reloading the einhorn master:
+  # 1. Clear the current process's environment,
+  # 2. Set it to the environmment at startup
+  # 3. Delete all variables marked to be dropped via `--drop-env-var`
+  #
+  # This method is safe to call in the master only before `exec`ing
+  # something.
+  def self.initialize_reload_environment
+    ENV.clear
+    ENV.update(Einhorn::TransientState.environ)
+    Einhorn::State.drop_environment_variables.each do |var|
+      ENV.delete(var)
+    end
+  end
+
+  # Log info about the environment as observed by ruby on
+  # startup. Currently, this means the bundler and rbenv versions.
+  def self.dump_environment_info
+    log_info("Running under Ruby #{RUBY_VERSION}", :environment)
+    log_info("Rbenv ruby version: #{ENV['RBENV_VERSION']}", :environment) if ENV['RBENV_VERSION']
+    begin
+      bundler_gem = Gem::Specification.find_by_name('bundler')
+      log_info("Using Bundler #{bundler_gem.version.to_s}", :environment)
+    rescue Gem::LoadError
+    end
+  end
+
   def self.run
     Einhorn::Command::Interface.init
     Einhorn::Event.init
@@ -353,9 +430,9 @@ module Einhorn
     preload
 
     # In the middle of upgrading
-    if Einhorn::State.reloading_for_preload_upgrade
+    if Einhorn::State.reloading_for_upgrade
       Einhorn::Command.upgrade_workers
-      Einhorn::State.reloading_for_preload_upgrade = false
+      Einhorn::State.reloading_for_upgrade = false
     end
 
     while Einhorn::State.respawn || Einhorn::State.children.size > 0

data/test/integration/_lib/fixtures/env_printer/env_printer.rb

@@ -0,0 +1,26 @@
+require 'bundler/setup'
+require 'socket'
+require 'einhorn/worker'
+
+def einhorn_main
+  $stderr.puts "Worker starting up!"
+  serv = Socket.for_fd(ENV['EINHORN_FD_0'].to_i)
+  $stderr.puts "Worker has a socket"
+  Einhorn::Worker.ack!
+  $stderr.puts "Worker sent ack to einhorn"
+  $stdout.puts "Environment from #{Process.pid} is: #{ENV.inspect}"
+  while true
+    s, addrinfo = serv.accept
+    $stderr.puts "Worker got a socket!"
+    output = ""
+    ARGV.each do |variable_to_write|
+      output += ENV[variable_to_write].to_s
+    end
+    s.write(output)
+    s.flush
+    s.close
+    $stderr.puts "Worker closed its socket"
+  end
+end
+
+einhorn_main if $0 == __FILE__

data/test/integration/_lib/fixtures/upgrade_project/upgrading_server.rb

@@ -0,0 +1,22 @@
+require 'bundler/setup'
+require 'socket'
+require 'einhorn/worker'
+
+def einhorn_main
+  version = File.read(File.join(File.dirname(__FILE__), "version"))
+  $stderr.puts "Worker starting up!"
+  serv = Socket.for_fd(ENV['EINHORN_FD_0'].to_i)
+  $stderr.puts "Worker has a socket"
+  Einhorn::Worker.ack!
+  $stderr.puts "Worker sent ack to einhorn"
+  while true
+    s, addrinfo = serv.accept
+    $stderr.puts "Worker got a socket!"
+    s.write(version)
+    s.flush
+    s.close
+    $stderr.puts "Worker closed its socket"
+  end
+end
+
+einhorn_main if $0 == __FILE__

data/test/integration/_lib/helpers/einhorn_helpers.rb

@@ -0,0 +1,139 @@
+require 'subprocess'
+require 'timeout'
+require 'tmpdir'
+
+module Helpers
+  module EinhornHelpers
+    def einhorn_code_dir
+      File.expand_path('../../../../', File.dirname(__FILE__))
+    end
+
+    def default_einhorn_command
+      ['bundle', 'exec', File.expand_path('bin/einhorn', einhorn_code_dir)]
+    end
+
+    def with_running_einhorn(cmdline, options = {})
+      options = options.dup
+      einhorn_command = options.delete(:einhorn_command) { default_einhorn_command }
+      expected_exit_code = options.delete(:expected_exit_code) { nil }
+      output_callback = options.delete(:output_callback) { nil }
+
+      stdout, stderr = "", ""
+      communicator = nil
+      process = Bundler.with_clean_env do
+        default_options = {
+          :stdout => Subprocess::PIPE,
+          :stderr => Subprocess::PIPE,
+          :stdin => '/dev/null',
+          :cwd => einhorn_code_dir
+        }
+        Subprocess::Process.new(Array(einhorn_command) + cmdline, default_options.merge(options))
+      end
+
+      status = nil
+      begin
+        communicator = Thread.new do
+          begin
+            stdout, stderr = process.communicate
+          rescue Errno::ECHILD
+            # It's dead, and we're not getting anything. This is
+            # peaceful.
+          end
+        end
+        yield(process) if block_given?
+      rescue Exception => e
+        unless (status = process.poll) && status.exited?
+          process.terminate
+        end
+        raise
+      ensure
+        unless (status = process.poll) && status.exited?
+          begin
+            Timeout.timeout(10) do  # (Argh, I'm so sorry)
+              status = process.wait
+            end
+          rescue Timeout::Error
+            $stderr.puts "Could not get Einhorn to quit within 10 seconds, killing it forcefully..."
+            process.send_signal("KILL")
+            status = process.wait
+          rescue Errno::ECHILD
+            # Process is dead!
+          end
+        end
+        communicator.join
+        output_callback.call(stdout, stderr) if output_callback
+      end
+    end
+
+    def einhornsh(commandline, options = {})
+      Subprocess.check_call(%W{bundle exec #{File.expand_path('bin/einhornsh')}} + commandline,
+                            {
+                              :stdin => '/dev/null',
+                              :stdout => '/dev/null',
+                              :stderr => '/dev/null'
+                            }.merge(options))
+    end
+
+    def fixture_path(name)
+      File.expand_path(File.join('../fixtures', name), File.dirname(__FILE__))
+    end
+
+    # Creates a new temporary directory with the initial contents from
+    # test/integration/_lib/fixtures/{name} and returns the path to
+    # it.  The contents of this directory are temporary and can be
+    # safely overwritten.
+    def prepare_fixture_directory(name)
+      @fixtured_dirs ||= Set.new
+      new_dir = Dir.mktmpdir(name)
+      @fixtured_dirs << new_dir
+      FileUtils.cp_r(File.join(fixture_path(name), '.'), new_dir)
+
+      new_dir
+    end
+
+    def cleanup_fixtured_directories
+      (@fixtured_dirs || []).each { |dir| FileUtils.rm_rf(dir) }
+    end
+
+    def find_free_port(host='127.0.0.1')
+      open_port = TCPServer.new(host, 0)
+      open_port.addr[1]
+    ensure
+      open_port.close
+    end
+
+    def wait_for_open_port
+      max_retries = 50
+      begin
+        read_from_port
+      rescue Errno::ECONNREFUSED
+        max_retries -= 1
+        if max_retries <= 0
+          raise
+        else
+          sleep 0.1
+          retry
+        end
+      end
+    end
+
+
+    def read_from_port
+      ewouldblock = RUBY_VERSION >= '1.9.0' ? IO::WaitWritable : Errno::EINPROGRESS
+      socket = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM, 0)
+      sockaddr = Socket.pack_sockaddr_in(@port, '127.0.0.1')
+      begin
+        socket.connect_nonblock(sockaddr)
+      rescue ewouldblock
+        IO.select(nil, [socket], [], 5)
+        begin
+          socket.connect_nonblock(sockaddr)
+        rescue Errno::EISCONN
+        end
+      end
+      socket.read.chomp
+    ensure
+      socket.close if socket
+    end
+  end
+end

data/test/integration/_lib/helpers.rb

@@ -0,0 +1,4 @@
+module Helpers
+end
+
+require(File.expand_path('helpers/einhorn_helpers', File.dirname(__FILE__)))

data/test/integration/_lib.rb

@@ -0,0 +1,6 @@
+require(File.expand_path('../_lib', File.dirname(__FILE__)))
+require(File.expand_path('_lib/helpers', File.dirname(__FILE__)))
+
+class EinhornIntegrationTestCase < EinhornTestCase
+
+end

data/test/integration/startup.rb

@@ -0,0 +1,31 @@
+require(File.expand_path('_lib', File.dirname(__FILE__)))
+
+class StartupTest < EinhornIntegrationTestCase
+  include Helpers::EinhornHelpers
+
+  describe 'when invoked without args' do
+    it 'prints usage and exits with 1' do
+      assert_raises(Subprocess::NonZeroExit) do
+        Subprocess.check_call(default_einhorn_command,
+                              :stdout => Subprocess::PIPE,
+                              :stderr => Subprocess::PIPE) do |einhorn|
+          stdout, stderr = einhorn.communicate
+          assert_match(/\A## Usage/, stdout)
+          assert_equal(1, einhorn.wait.exitstatus)
+        end
+      end
+    end
+  end
+
+  describe 'when invoked with --upgrade-check' do
+    it 'successfully exits' do
+      Subprocess.check_call(default_einhorn_command + %w[--upgrade-check],
+                            :stdout => Subprocess::PIPE,
+                            :stderr => Subprocess::PIPE) do |einhorn|
+        stdout, stderr = einhorn.communicate
+        status = einhorn.wait
+        assert_equal(0, status.exitstatus)
+      end
+    end
+  end
+end

data/test/integration/upgrading.rb

@@ -0,0 +1,128 @@
+require(File.expand_path('_lib', File.dirname(__FILE__)))
+require 'socket'
+
+class UpgradeTests < EinhornIntegrationTestCase
+  include Helpers::EinhornHelpers
+
+  describe 'when upgrading a running einhorn without preloading' do
+    before do
+      @dir = prepare_fixture_directory('upgrade_project')
+      @port = find_free_port
+      @server_program = File.join(@dir, "upgrading_server.rb")
+      @socket_path = File.join(@dir, "einhorn.sock")
+    end
+    after { cleanup_fixtured_directories }
+
+    it 'can restart' do
+      File.open(File.join(@dir, "version"), 'w') { |f| f.write("0") }
+      with_running_einhorn(%W{einhorn -m manual -b 127.0.0.1:#{@port} -d #{@socket_path} -- ruby #{@server_program}}) do |process|
+        wait_for_open_port
+        assert_equal("0", read_from_port, "Should report the initial version")
+
+        File.open(File.join(@dir, "version"), 'w') { |f| f.write("1") }
+        einhornsh(%W{-d #{@socket_path} -e upgrade})
+        assert_equal("1", read_from_port, "Should report the upgraded version")
+
+        process.terminate
+      end
+    end
+  end
+
+  describe 'handling environments on upgrade' do
+    before do
+      @dir = prepare_fixture_directory('env_printer')
+      @port = find_free_port
+      @server_program = File.join(@dir, "env_printer.rb")
+      @socket_path = File.join(@dir, "einhorn.sock")
+    end
+    after { cleanup_fixtured_directories }
+
+    describe 'when running with --reexec-as' do
+      it 'preserves environment variables across restarts' do
+        # exec the new einhorn with the same environment:
+        reexec_cmdline = 'env VAR=a bundle exec einhorn'
+
+        with_running_einhorn(%W{einhorn -m manual -b 127.0.0.1:#{@port} --reexec-as=#{reexec_cmdline} -d #{@socket_path} -- ruby #{@server_program} VAR},
+                             :env => ENV.to_hash.merge({'VAR' => 'a'})) do |process|
+
+          wait_for_open_port
+          einhornsh(%W{-d #{@socket_path} -e upgrade})
+          assert_equal("a", read_from_port, "Should report the upgraded version")
+
+          process.terminate
+        end
+      end
+
+      describe 'without preloading' do
+        it 'can update environment variables when the reexec command line says to' do
+          # exec the new einhorn with the same environment:
+          reexec_cmdline = 'env VAR=b OINK=b bundle exec einhorn'
+
+          with_running_einhorn(%W{einhorn -m manual -b 127.0.0.1:#{@port} --reexec-as=#{reexec_cmdline} -d #{@socket_path} -- ruby #{@server_program} VAR},
+                               :env => ENV.to_hash.merge({'VAR' => 'a'})) do |process|
+
+            wait_for_open_port
+            einhornsh(%W{-d #{@socket_path} -e upgrade})
+            assert_equal("b", read_from_port, "Should report the upgraded version")
+
+            process.terminate
+          end
+        end
+      end
+
+      describe 'with preloading' do
+        it 'can update environment variables on preloaded code when the reexec command line says to' do
+          # exec the new einhorn with the same environment:
+          reexec_cmdline = 'env VAR=b OINK=b bundle exec einhorn'
+
+          with_running_einhorn(%W{einhorn -m manual -p #{@server_program} -b 127.0.0.1:#{@port} --reexec-as=#{reexec_cmdline} -d #{@socket_path} -- ruby #{@server_program} VAR},
+                               :env => ENV.to_hash.merge({'VAR' => 'a'})) do |process|
+
+            wait_for_open_port
+            einhornsh(%W{-d #{@socket_path} -e upgrade})
+            assert_equal("b", read_from_port, "Should report the upgraded version")
+
+            process.terminate
+          end
+        end
+      end
+    end
+  end
+
+  describe 'when invoked with --drop-env-var' do
+    before do
+      @dir = prepare_fixture_directory('env_printer')
+      @port = find_free_port
+      @server_program = File.join(@dir, "env_printer.rb")
+      @socket_path = File.join(@dir, "einhorn.sock")
+    end
+    after { cleanup_fixtured_directories }
+
+    it %{removes the variable from its children's environment} do
+      with_running_einhorn(%W{einhorn -m manual -b 127.0.0.1:#{@port} --drop-env-var=VAR -d #{@socket_path} -- ruby #{@server_program} VAR},
+                           :env => ENV.to_hash.merge({'VAR' => 'a'})) do |process|
+        wait_for_open_port
+        assert_equal("a", read_from_port, "Should report $VAR initially")
+
+        einhornsh(%W{-d #{@socket_path} -e upgrade})
+        assert_equal("", read_from_port, "Should have dropped the variable post-upgrade")
+
+        process.terminate
+      end
+    end
+
+    it %{causes an upgrade with --reexec-as to not clobber the new environment} do
+      reexec_cmdline = 'env VAR2=b bundle exec einhorn'
+      with_running_einhorn(%W{einhorn -m manual -b 127.0.0.1:#{@port} --drop-env-var=VAR1 --drop-env-var=VAR2 -d #{@socket_path} --reexec-as=#{reexec_cmdline} -- ruby #{@server_program} VAR1 VAR2},
+                           :env => ENV.to_hash.merge({'VAR1' => 'a', 'VAR2' => 'a'})) do |process|
+        wait_for_open_port
+        assert_equal("aa", read_from_port, "Should report both $VAR1 and $VAR2 initially")
+
+        einhornsh(%W{-d #{@socket_path} -e upgrade})
+        assert_equal("b", read_from_port, "Should have dropped $VAR1 post-upgrade and re-set $VAR2")
+
+        process.terminate
+      end
+    end
+  end
+end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: einhorn
 version: !ruby/object:Gem::Version
-  version: 0.5.7
-  prerelease: 
+  version: 0.6.0
 platform: ruby
 authors:
 - Greg Brockman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-05 00:00:00.000000000 Z
+date: 2014-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -46,7 +41,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - <
       - !ruby/object:Gem::Version
@@ -54,7 +48,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - <
       - !ruby/object:Gem::Version
@@ -62,7 +55,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -70,7 +62,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -78,7 +69,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: chalk-rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -86,7 +76,20 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: subprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -145,6 +148,13 @@ files:
 - lib/einhorn/worker.rb
 - lib/einhorn/worker_pool.rb
 - test/_lib.rb
+- test/integration/_lib.rb
+- test/integration/_lib/fixtures/env_printer/env_printer.rb
+- test/integration/_lib/fixtures/upgrade_project/upgrading_server.rb
+- test/integration/_lib/helpers.rb
+- test/integration/_lib/helpers/einhorn_helpers.rb
+- test/integration/startup.rb
+- test/integration/upgrading.rb
 - test/unit/einhorn.rb
 - test/unit/einhorn/client.rb
 - test/unit/einhorn/command.rb
@@ -154,30 +164,36 @@ files:
 homepage: https://github.com/stripe/einhorn
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23.2
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ! 'Einhorn: the language-independent shared socket manager'
 test_files:
 - test/_lib.rb
+- test/integration/_lib.rb
+- test/integration/_lib/fixtures/env_printer/env_printer.rb
+- test/integration/_lib/fixtures/upgrade_project/upgrading_server.rb
+- test/integration/_lib/helpers.rb
+- test/integration/_lib/helpers/einhorn_helpers.rb
+- test/integration/startup.rb
+- test/integration/upgrading.rb
 - test/unit/einhorn.rb
 - test/unit/einhorn/client.rb
 - test/unit/einhorn/command.rb