einhorn 0.7.4 → 1.0.0

data/test/integration/startup.rb

@@ -1,31 +0,0 @@
-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

@@ -1,157 +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)
-
-          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
-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,21 +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
-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

data/test/unit/einhorn.rb

@@ -1,58 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../_lib'))
-
-require 'einhorn'
-
-class EinhornTest < EinhornTestCase
-  describe "when sockifying" do
-    after do
-      Einhorn::State.sockets = {}
-    end
-
-    it "correctly parses srv: arguments" do
-      cmd = ['foo', 'srv:1.2.3.4:123,llama,test', 'bar']
-      Einhorn.expects(:bind).once.with('1.2.3.4', '123', ['llama', 'test']).returns(4)
-
-      Einhorn.socketify!(cmd)
-
-      assert_equal(['foo', '4', 'bar'], cmd)
-    end
-
-    it "correctly parses --opt=srv: arguments" do
-      cmd = ['foo', '--opt=srv:1.2.3.4:456', 'baz']
-      Einhorn.expects(:bind).once.with('1.2.3.4', '456', []).returns(5)
-
-      Einhorn.socketify!(cmd)
-
-      assert_equal(['foo', '--opt=5', 'baz'], cmd)
-    end
-
-    it "uses the same fd number for the same server spec" do
-      cmd = ['foo', '--opt=srv:1.2.3.4:8910', 'srv:1.2.3.4:8910']
-      Einhorn.expects(:bind).once.with('1.2.3.4', '8910', []).returns(10)
-
-      Einhorn.socketify!(cmd)
-
-      assert_equal(['foo', '--opt=10', '10'], cmd)
-    end
-  end
-
-  describe '.update_state' do
-    it 'correctly updates 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(Einhorn::State, 'einhorn', old_state)
-      assert_equal({:baz => 23, :foo => 2}, updated_state)
-      assert_match(/State format for einhorn has changed/, message)
-    end
-
-    it 'does 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(Einhorn::State, 'einhorn', old_state)
-      assert_equal({:baz => 14, :foo => 1234}, updated_state)
-      assert(message.nil?)
-    end
-  end
-end