einhorn 0.8.2 → 1.0.0

data/test/integration/upgrading.rb

@@ -1,204 +0,0 @@
-require(File.expand_path('_lib', File.dirname(__FILE__)))
-require 'socket'
-require 'einhorn/client'
-
-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 --keep-file-descriptors 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
-
-      it 'cleans up if a child dies during the reexec' do
-        # attempt to setup a scenario where a child exits in the
-        # interlude after old einhorn has execed the reexec-as
-        # command, but before the reexec-as command execs new einhorn
-
-        @dir = prepare_fixture_directory('exit_during_upgrade')
-        @server_program = File.join(@dir, "exiting_server.rb")
-        @socket_path = File.join(@dir, "einhorn.sock")
-
-        reexec_cmdline = File.join(@dir, 'upgrade_reexec.rb')
-
-        with_running_einhorn(%W{einhorn -m manual -b 127.0.0.1:#{@port} --reexec-as=#{reexec_cmdline} -d #{@socket_path} -- ruby #{@server_program}}) do |process|
-          wait_for_open_port
-
-          Process.kill('USR2', read_from_port.to_i)
-          einhornsh(%W{-d #{@socket_path} -e upgrade})
-
-          client = Einhorn::Client.for_path(@socket_path)
-          client.send_command('command' => 'state')
-          resp = client.receive_message
-
-          state = YAML.load(resp['message'])
-          assert_equal(1, state[:state][:children].count)
-
-          child = state[:state][:children].first.last
-          assert_in_delta(child[:pinged_at], Time.now, 60)
-          assert_equal("id-1", child[:pinged_request_id])
-
-          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 --keep-file-descriptors 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 --keep-file-descriptors 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 --keep-file-descriptors 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
-
-  describe "with --signal-timeout" do
-    before do
-      @dir = prepare_fixture_directory('signal_timeout')
-      @port = find_free_port
-      @server_program = File.join(@dir, "sleepy_server.rb")
-      @socket_path = File.join(@dir, "einhorn.sock")
-    end
-
-    after { cleanup_fixtured_directories }
-
-    it 'issues a SIGKILL to outdated children when signal-timeout has passed' do
-      signal_timeout = 2
-      sleep_for = 10
-      cmd = %W{
-        einhorn
-        -b 127.0.0.1:#{@port}
-        -d #{@socket_path}
-        --signal-timeout #{signal_timeout}
-        -- ruby #{@server_program}
-      }
-
-      with_running_einhorn(cmd, env: ENV.to_h.merge({'TRAP_SLEEP' => sleep_for.to_s})) do |process|
-        wait_for_open_port
-        client = Einhorn::Client.for_path(@socket_path)
-        einhornsh(%W{-d #{@socket_path} -e upgrade})
-
-        state = get_state(client)
-        assert_equal(2, state[:children].count)
-        signaled_children = state[:children].select{|_,c| c[:signaled].length > 0}
-        assert_equal(1, signaled_children.length)
-
-        sleep(signal_timeout * 2)
-
-        state = get_state(client)
-        assert_equal(1, state[:children].count)
-        signaled_children = state[:children].select{|_,c| c[:signaled].length > 0}
-        assert_equal(0, signaled_children.length)
-
-        process.terminate
-      end
-    end
-  end
-end

data/test/unit/_lib/bad_worker.rb

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-
-raise 'This worker has an error during preload'
-
-def einhorn_main
-
-end

data/test/unit/_lib/sleep_worker.rb

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-def einhorn_main
-  sleep 1
-end

data/test/unit/einhorn/client.rb

@@ -1,88 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../../_lib'))
-
-require 'einhorn'
-
-class ClientTest < EinhornTestCase
-  def unserialized_message
-    {:foo => ['%bar', '%baz']}
-  end
-
-  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
-
-  def serialized_2_0
-    "---%0A:foo:%0A- '%25bar'%0A- '%25baz'%0A\n"
-  end
-
-  def serialized_2_1
-    "---%0A:foo:%0A- \"%25bar\"%0A- \"%25baz\"%0A\n"
-  end
-
-  def serialized_options
-    [serialized_1_8, serialized_1_9, serialized_2_0, serialized_2_1]
-  end
-
-  describe "when sending a message" do
-    it "writes a serialized line" do
-      socket = mock
-      socket.expects(:write).with {|write| serialized_options.include?(write)}
-      Einhorn::Client::Transport.send_message(socket, unserialized_message)
-    end
-  end
-
-  describe "when receiving a message" do
-    it "deserializes 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
-
-    it "deserializes a single 1.9-style line" do
-      socket = mock
-      socket.expects(:readline).returns(serialized_1_9)
-      result = Einhorn::Client::Transport.receive_message(socket)
-      assert_equal(result, unserialized_message)
-    end
-  end
-
-  describe "when {de,}serializing a message" do
-    it "serializes and escape a message as expected" do
-      actual = Einhorn::Client::Transport.serialize_message(unserialized_message)
-      assert(serialized_options.include?(actual), "Actual message is #{actual.inspect}")
-    end
-
-    it "deserializes 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
-
-    it "deserializes 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
-
-    it "deserializes and unescapes a 2.0-style message as expected" do
-      actual = Einhorn::Client::Transport.deserialize_message(serialized_2_0)
-      assert_equal(unserialized_message, actual)
-    end
-
-    it "deserializes and unescapes a 2.1-style message as expected" do
-      actual = Einhorn::Client::Transport.deserialize_message(serialized_2_1)
-      assert_equal(unserialized_message, actual)
-    end
-
-    it "raises an error when deserializing invalid YAML" do
-      invalid_serialized = "-%0A\t-"
-      begin
-        Einhorn::Client::Transport.deserialize_message(invalid_serialized)
-      rescue Einhorn::Client::Transport::ParseError
-      end
-    end
-  end
-end

data/test/unit/einhorn/command/interface.rb

@@ -1,49 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../../../_lib'))
-
-require 'einhorn'
-
-class InterfaceTest < EinhornTestCase
-  include Einhorn::Command
-
-  describe "when a command is received" do
-    it "calls that command" do
-      conn = stub(:log_debug => nil)
-      conn.expects(:write).once.with do |message|
-        # Remove trailing newline
-        message = message[0...-1]
-        parsed = YAML.load(URI.unescape(message))
-        parsed['message'] =~ /Welcome, gdb/
-      end
-      request = {
-        'command' => 'ehlo',
-        'user' => 'gdb'
-      }
-      Interface.process_command(conn, YAML.dump(request))
-    end
-  end
-
-  describe "when an unrecognized command is received" do
-    it "calls the unrecognized_command method" do
-      conn = stub(:log_debug => nil)
-      Interface.expects(:unrecognized_command).once
-      request = {
-        'command' => 'made-up',
-      }
-      Interface.process_command(conn, YAML.dump(request))
-    end
-  end
-
-  describe "when a worker ack is received" do
-    it "registers ack and close the connection" do
-      conn = stub(:log_debug => nil)
-      conn.expects(:close).once
-      conn.expects(:write).never
-      request = {
-        'command' => 'worker:ack',
-        'pid' => 1234
-      }
-      Einhorn::Command.expects(:register_manual_ack).once.with(1234)
-      Interface.process_command(conn, YAML.dump(request))
-    end
-  end
-end

data/test/unit/einhorn/command.rb

@@ -1,135 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../../_lib'))
-
-require 'einhorn'
-
-class CommandTest < EinhornTestCase
-  include Einhorn
-
-  describe "when running quieter" do
-    it "increases the verbosity threshold" do
-      Einhorn::State.stubs(:verbosity => 1)
-      Einhorn::State.expects(:verbosity=).once.with(2).returns(2)
-      Command.quieter
-    end
-
-    it "maxes out at 2" do
-      Einhorn::State.stubs(:verbosity => 2)
-      Einhorn::State.expects(:verbosity=).never
-      Command.quieter
-    end
-  end
-
-  describe "resignal_timeout" do
-    it "does not kill any children" do
-      Einhorn::State.stubs(signal_timeout: 5 * 60)
-      Einhorn::State.stubs(children: {
-        12345 => {last_signaled_at: nil},
-        12346 => {signaled: Set.new(["USR1"]), last_signaled_at: Time.now - (2 * 60)},
-      })
-
-      Process.expects(:kill).never
-      Einhorn::Command.kill_expired_signaled_workers
-
-      refute(Einhorn::State.children[12346][:signaled].include?("KILL"), "Process was KILLed when it shouldn't have been")
-    end
-
-    it "KILLs stuck child processes" do
-      Time.stub :now, Time.at(0) do
-        Process.stub(:kill, true) do
-          Einhorn::State.stubs(signal_timeout: 60)
-          Einhorn::State.stubs(children: {
-            12346 => {signaled: Set.new(["USR2"]), last_signaled_at: Time.now - (2 * 60)},
-          })
-
-          Einhorn::Command.kill_expired_signaled_workers
-
-          child = Einhorn::State.children[12346]
-          assert(child[:signaled].include?("KILL"), "Process was not KILLed as expected")
-          assert(child[:last_signaled_at] == Time.now, "The last_processed_at was not updated as expected")
-        end
-      end
-    end
-  end
-
-  describe "trigger_spinup?" do
-    it "is true by default" do
-      assert(Einhorn::Command.trigger_spinup?(1))
-    end
-
-    it "is false if unacked >= max_unacked" do
-      Einhorn::State.stubs(children: {12346 => {type: :worker, acked: false, signaled: Set.new}})
-      assert(Einhorn::Command.trigger_spinup?(1))
-    end
-
-    it "is false if capacity is exceeded" do
-      Einhorn::State.stubs(config: {max_upgrade_additional: 1, number: 1})
-      Einhorn::State.stubs(
-        children: {
-          1 => {type: :worker, acked: true, signaled: Set.new},
-          2 => {type: :worker, acked: true, signaled: Set.new},
-          3 => {type: :worker, acked: true, signaled: Set.new},
-        }
-      )
-      refute(Einhorn::Command.trigger_spinup?(1))
-    end
-
-    it "is true if under capacity" do
-      Einhorn::State.stubs(config: {max_upgrade_additional: 2, number: 1})
-      Einhorn::State.stubs(children: {1 => {type: :worker, acked: true, signaled: Set.new}})
-      assert(Einhorn::Command.trigger_spinup?(1))
-    end
-  end
-
-  describe "replenish_gradually" do
-    it "does nothing if an outstanding spinup timer exists" do
-      Einhorn::TransientState.stubs(has_outstanding_spinup_timer: true)
-      Einhorn::Command.expects(:spinup).never
-      Einhorn::Command.replenish_gradually
-    end
-    it "does nothing if the worker pool is full" do
-      Einhorn::TransientState.stubs(has_outstanding_spinup_timer: false)
-      Einhorn::WorkerPool.stubs(missing_worker_count: 0)
-      Einhorn::Command.expects(:spinup).never
-      Einhorn::Command.replenish_gradually
-    end
-
-    it "does nothing if we have not reached the spinup interval" do
-      Einhorn::TransientState.stubs(has_outstanding_spinup_timer: false)
-      Einhorn::WorkerPool.stubs(missing_worker_count: 1)
-      Einhorn::State.stubs(last_spinup: Time.now)
-      Einhorn::Command.expects(:spinup).never
-      Einhorn::Command.replenish_gradually
-    end
-
-    it "calls trigger_spinup? if we have reached the spinup interval" do
-      Einhorn::TransientState.stubs(has_outstanding_spinup_timer: false)
-      Einhorn::State.stubs(config: {seconds: 1, max_unacked: 2, number: 1})
-      Einhorn::WorkerPool.stubs(missing_worker_count: 1)
-      Einhorn::State.stubs(last_spinup: Time.now - 2) # 2 seconds ago
-      Einhorn::Command.expects(:trigger_spinup?).with(2).returns(false)
-      Einhorn::Command.replenish_gradually
-    end
-
-    it "can handle sub-second spinup intervals" do
-      Einhorn::TransientState.stubs(has_outstanding_spinup_timer: false)
-      Einhorn::State.stubs(config: {seconds: 0.1, max_unacked: 2, number: 1})
-      Einhorn::WorkerPool.stubs(missing_worker_count: 1)
-      Einhorn::State.stubs(last_spinup: Time.now - 0.5) # Half a second ago
-      Einhorn::Command.stubs(trigger_spinup?: true)
-      Einhorn::Command.expects(:spinup)
-      Einhorn::Command.replenish_gradually
-    end
-
-    it "registers a timer to run again at spinup interval" do
-      Einhorn::TransientState.stubs(has_outstanding_spinup_timer: false)
-      Einhorn::State.stubs(config: {seconds: 0.1, max_unacked: 2, number: 1})
-      Einhorn::WorkerPool.stubs(missing_worker_count: 1)
-      Einhorn::State.stubs(last_spinup: Time.now - 1)
-      Einhorn::Command.stubs(trigger_spinup?: true)
-      Einhorn::Command.stubs(:spinup)
-      Einhorn::TransientState.expects(:has_outstanding_spinup_timer=).with(true)
-      Einhorn::Event::Timer.expects(:open).with(0.1)
-      Einhorn::Command.replenish_gradually
-    end
-  end
-end

data/test/unit/einhorn/event.rb

@@ -1,89 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../../_lib'))
-
-require 'set'
-require 'einhorn'
-
-module Einhorn::Event
-  def self.reset
-    @@loopbreak_reader = nil
-    @@loopbreak_writer = nil
-    @@readable = {}
-    @@writeable = {}
-    @@timers = {}
-  end
-end
-
-class EventTest < EinhornTestCase
-  describe "when running the event loop" do
-    before do
-      Einhorn::Event.reset
-    end
-
-    after do
-      Einhorn::Event.reset
-    end
-
-    it "selects on readable descriptors" do
-      sock1 = stub(:fileno => 4)
-      sock2 = stub(:fileno => 5)
-
-      conn1 = Einhorn::Event::Connection.open(sock1)
-      conn2 = Einhorn::Event::Connection.open(sock2)
-
-      IO.expects(:select).once.with do |readers, writers, errs, timeout|
-        Set.new(readers) == Set.new([sock1, sock2]) &&
-          writers == [] &&
-          errs == nil &&
-          timeout == nil
-      end.returns([[], [], []])
-
-      Einhorn::Event.loop_once
-    end
-
-    it "selects on writeable descriptors" do
-      sock1 = stub(:fileno => 4)
-      sock2 = stub(:fileno => 5)
-
-      conn1 = Einhorn::Event::Connection.open(sock1)
-      conn2 = Einhorn::Event::Connection.open(sock2)
-
-      sock2.expects(:write_nonblock).once.raises(Errno::EWOULDBLOCK.new)
-      conn2.write('Hello!')
-
-      IO.expects(:select).once.with do |readers, writers, errs, timeout|
-        Set.new(readers) == Set.new([sock1, sock2]) &&
-          writers == [sock2] &&
-          errs == nil &&
-          timeout == nil
-      end.returns([[], [], []])
-
-      Einhorn::Event.loop_once
-    end
-
-    it "runs callbacks for ready selectables" do
-      sock1 = stub(:fileno => 4)
-      sock2 = stub(:fileno => 5)
-
-      conn1 = Einhorn::Event::Connection.open(sock1)
-      conn2 = Einhorn::Event::Connection.open(sock2)
-
-      sock2.expects(:write_nonblock).once.raises(Errno::EWOULDBLOCK.new)
-      conn2.write('Hello!')
-
-      IO.expects(:select).once.with do |readers, writers, errs, timeout|
-        Set.new(readers) == Set.new([sock1, sock2]) &&
-          writers == [sock2] &&
-          errs == nil &&
-          timeout == nil
-      end.returns([[sock1], [sock2], []])
-
-      conn1.expects(:notify_readable).once
-      conn2.expects(:notify_writeable).never
-
-      conn1.expects(:notify_readable).never
-      conn2.expects(:notify_writeable).once
-
-      Einhorn::Event.loop_once
-    end
-  end
-end

data/test/unit/einhorn/worker_pool.rb

@@ -1,39 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../../_lib'))
-
-require 'einhorn'
-
-class WorkerPoolTest < EinhornTestCase
-  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
-
-  describe "#workers_with_state" do
-    before do
-      stub_children
-    end
-
-    it "selects 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
-
-  describe "#unsignaled_workers" do
-    before do
-      stub_children
-    end
-
-    it "selects unsignaled workers" do
-      unsignaled_workers = Einhorn::WorkerPool.unsignaled_workers
-      assert_equal([1236], unsignaled_workers)
-    end
-  end
-end