einhorn 0.7.0 → 0.8.2

data/lib/einhorn/command/interface.rb

@@ -148,17 +148,17 @@ module Einhorn::Command
     ## Signals
     def self.install_handlers
       trap_async("INT") do
-        Einhorn::Command.signal_all("USR2", Einhorn::WorkerPool.workers)
+        Einhorn::Command.signal_all("USR2")
         Einhorn::Command.stop_respawning
       end
       trap_async("TERM") do
-        Einhorn::Command.signal_all("TERM", Einhorn::WorkerPool.workers)
+        Einhorn::Command.signal_all("TERM")
         Einhorn::Command.stop_respawning
       end
       # Note that quit is a bit different, in that it will actually
       # make Einhorn quit without waiting for children to exit.
       trap_async("QUIT") do
-        Einhorn::Command.signal_all("QUIT", Einhorn::WorkerPool.workers)
+        Einhorn::Command.signal_all("QUIT")
         Einhorn::Command.stop_respawning
         exit(1)
       end
@@ -169,12 +169,12 @@ module Einhorn::Command
       end
       trap_async("CHLD") {}
       trap_async("USR2") do
-        Einhorn::Command.signal_all("USR2", Einhorn::WorkerPool.workers)
+        Einhorn::Command.signal_all("USR2")
         Einhorn::Command.stop_respawning
       end
       at_exit do
         if Einhorn::State.kill_children_on_exit && Einhorn::TransientState.whatami == :master
-          Einhorn::Command.signal_all("USR2", Einhorn::WorkerPool.workers)
+          Einhorn::Command.signal_all("USR2")
           Einhorn::Command.stop_respawning
         end
       end
@@ -289,6 +289,17 @@ EOF
       nil
     end
 
+    command 'worker:ping' do |conn, request|
+      if pid = request['pid']
+        Einhorn::Command.register_ping(pid, request['request_id'])
+      else
+        conn.log_error("Invalid request (no pid): #{request.inspect}")
+      end
+      # Throw away this connection in case the application forgets to
+      conn.close
+      nil
+    end
+
     # Used by einhornsh
     command 'ehlo' do |conn, request|
       <<EOF
@@ -305,7 +316,7 @@ EOF
     end
 
     command 'state', "Get a dump of Einhorn's current state" do
-      YAML.dump(Einhorn::Command.dumpable_state)
+      YAML.dump({:state => Einhorn::State.dumpable_state})
     end
 
     command 'reload', 'Reload Einhorn' do |conn, request|
@@ -335,9 +346,9 @@ EOF
       end
 
       count = args[0].to_i
-      if count < 1 || count > 100
-        # sancheck. 100 is kinda arbitrary.
-        next "Invalid count: '#{args[0]}'. Must be an integer in [1,100)."
+      if count < 1 || count > 1000
+        # sancheck. 1000 is kinda arbitrary.
+        next "Invalid count: '#{args[0]}'. Must be an integer in [1,1000)."
       end
 
       Einhorn::Command.set_workers(count)
@@ -407,7 +418,7 @@ EOF
 
       signal = args[0] || "USR2"
 
-      response = Einhorn::Command.signal_all(signal, Einhorn::WorkerPool.workers)
+      response = Einhorn::Command.signal_all(signal)
       Einhorn::Command.stop_respawning
 
       "Einhorn is going down! #{response}"

data/lib/einhorn/event.rb

@@ -4,6 +4,7 @@ module Einhorn
   module Event
     @@loopbreak_reader = nil
     @@loopbreak_writer = nil
+    @@default_timeout = nil
     @@signal_actions = []
     @@readable = {}
     @@writeable = {}
@@ -120,7 +121,7 @@ module Einhorn
       if expires_at = @@timers.keys.sort[0]
         expires_at - Time.now
       else
-        nil
+        @@default_timeout
       end
     end
 
@@ -165,6 +166,14 @@ module Einhorn
         Einhorn.log_error("Loop break pipe is full -- probably means that we are quite backlogged")
       end
     end
+
+    def self.default_timeout=(val)
+      @@default_timeout = val.to_i == 0 ? nil : val.to_i
+    end
+
+    def self.default_timeout
+      @@default_timeout
+    end
   end
 end
 

data/lib/einhorn/event/connection.rb

@@ -57,13 +57,13 @@ module Einhorn::Event
     end
 
     def register!
-      log_info("client connected")
+      log_debug("client connected")
       Einhorn::Event.register_connection(self, @socket.fileno)
       super
     end
 
     def deregister!
-      log_info("client disconnected") if Einhorn::TransientState.whatami == :master
+      log_debug("client disconnected") if Einhorn::TransientState.whatami == :master
       Einhorn::Event.deregister_connection(@socket.fileno)
       super
     end

data/lib/einhorn/prctl.rb

@@ -0,0 +1,26 @@
+module Einhorn
+  class PrctlAbstract
+    def self.get_pdeathsig
+      raise NotImplementedError
+    end
+
+    def self.set_pdeathsig(signal)
+      raise NotImplementedError
+    end
+  end
+
+  class PrctlUnimplemented < PrctlAbstract
+    # Deliberately empty; NotImplementedError is intended
+  end
+
+  if RUBY_PLATFORM =~ /linux/ then
+    begin
+      require 'einhorn/prctl_linux'
+      Prctl = PrctlLinux
+    rescue LoadError
+      Prctl = PrctlUnimplemented
+    end
+  else
+    Prctl = PrctlUnimplemented
+  end
+end

data/lib/einhorn/prctl_linux.rb

@@ -0,0 +1,49 @@
+require 'fiddle'
+require 'fiddle/import'
+
+module Einhorn
+  module PrctlRaw
+    extend Fiddle::Importer
+    dlload Fiddle.dlopen(nil) # libc
+    extern 'int prctl(int, unsigned long, unsigned long, unsigned long, unsigned long)'
+
+    # From linux/prctl.h
+    SET_PDEATHSIG = 1
+    GET_PDEATHSIG = 2
+  end
+
+  class PrctlLinux < PrctlAbstract
+    # Reading integers is hard with fiddle. :(
+    IntStruct = Fiddle::CStructBuilder.create(Fiddle::CStruct, [Fiddle::TYPE_INT], ['i'])
+
+    def self.get_pdeathsig
+      out = IntStruct.malloc
+      out.i = 0
+      if PrctlRaw.prctl(PrctlRaw::GET_PDEATHSIG, out.to_i, 0, 0, 0) != 0 then
+        raise SystemCallError.new("get_pdeathsig", Fiddle.last_error)
+      end
+
+      signo = out.i
+      if signo == 0 then
+        return nil
+      end
+
+      return Signal.signame(signo)
+    end
+
+    def self.set_pdeathsig(signal)
+      case
+      when signal == nil
+        signo = 0
+      when signal.instance_of?(String)
+        signo = Signal.list.fetch(signal)
+      else
+        signo = signal
+      end
+
+      if PrctlRaw.prctl(PrctlRaw::SET_PDEATHSIG, signo, 0, 0, 0) != 0 then
+        raise SystemCallError.new("set_pdeathsig(#{signal})", Fiddle.last_error)
+      end
+    end
+  end
+end

data/lib/einhorn/version.rb

@@ -1,3 +1,3 @@
 module Einhorn
-  VERSION = '0.7.0'
+  VERSION = '0.8.2'
 end

data/lib/einhorn/worker.rb

@@ -66,33 +66,28 @@ module Einhorn
     # be useful for anything. Maybe if it's always fd 3, because then
     # the user wouldn't have to provide an arg.
     def self.ack!(discovery=:env, arg=nil)
-      ensure_worker!
-      close_after_use = true
-
-      case discovery
-      when :env
-        socket = ENV['EINHORN_SOCK_PATH']
-        client = Einhorn::Client.for_path(socket)
-      when :fd
-        raise "No EINHORN_SOCK_FD provided in environment. Did you run einhorn with the -g flag?" unless fd_str = ENV['EINHORN_SOCK_FD']
-
-        fd = Integer(fd_str)
-        client = Einhorn::Client.for_fd(fd)
-        close_after_use = false if arg
-      when :direct
-        socket = arg
-        client = Einhorn::Client.for_path(socket)
-      else
-        raise "Unrecognized socket discovery mechanism: #{discovery.inspect}. Must be one of :filesystem, :argv, or :direct"
+      handle_command_socket(discovery, arg) do |client|
+        client.send_command('command' => 'worker:ack', 'pid' => $$)
       end
+    end
 
-      client.send_command({
-          'command' => 'worker:ack',
-          'pid' => $$
-        })
-
-      client.close if close_after_use
-      true
+    # Call this to indicate your child process is up and in a healthy state.
+    # Arguments:
+    #
+    # @request_id: Identifies the request ID of the worker, can be used to debug wedged workers.
+    #
+    # @discovery: How to discover the master process's command socket.
+    #   :env:        Discover the path from ENV['EINHORN_SOCK_PATH']
+    #   :fd:         Just use the file descriptor in ENV['EINHORN_SOCK_FD'].
+    #                Must run the master with the -g flag. This is mostly
+    #                useful if you don't have a nice library like Einhorn::Worker.
+    #                Then @arg being true causes the FD to be left open after ACK;
+    #                otherwise it is closed.
+    #   :direct:     Provide the path to the command socket in @arg.
+    def self.ping!(request_id, discovery=:env, arg=nil)
+      handle_command_socket(discovery, arg) do |client|
+        client.send_command('command' => 'worker:ping', 'pid' => $$, 'request_id' => request_id)
+      end
     end
 
     def self.socket(number=nil)
@@ -139,6 +134,33 @@ module Einhorn
 
     private
 
+    def self.handle_command_socket(discovery, contextual_arg)
+      ensure_worker!
+      close_after_use = true
+
+      case discovery
+      when :env
+        socket = ENV['EINHORN_SOCK_PATH']
+        client = Einhorn::Client.for_path(socket)
+      when :fd
+        raise "No EINHORN_SOCK_FD provided in environment. Did you run einhorn with the -g flag?" unless fd_str = ENV['EINHORN_SOCK_FD']
+
+        fd = Integer(fd_str)
+        client = Einhorn::Client.for_fd(fd)
+        close_after_use = false if contextual_arg
+      when :direct
+        socket = contextual_arg
+        client = Einhorn::Client.for_path(socket)
+      else
+        raise "Unrecognized socket discovery mechanism: #{discovery.inspect}. Must be one of :filesystem, :argv, or :direct"
+      end
+
+      yield client
+      client.close if close_after_use
+
+      true
+    end
+
     def self.socket_from_filesystem(cmd_name)
       ppid = Process.ppid
       socket_path_file = Einhorn::Command::Interface.socket_path_file(ppid)

data/test/integration/_lib/fixtures/exit_during_upgrade/exiting_server.rb

@@ -5,6 +5,7 @@ require 'einhorn/worker'
 def einhorn_main
   serv = Socket.for_fd(Einhorn::Worker.socket!)
   Einhorn::Worker.ack!
+  Einhorn::Worker.ping!("id-1")
 
   Signal.trap('USR2') do
     sleep 3

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

@@ -0,0 +1,29 @@
+require 'bundler/setup'
+require 'socket'
+require 'einhorn/worker'
+require 'einhorn/prctl'
+
+def einhorn_main
+  serv = Socket.for_fd(Einhorn::Worker.socket!)
+
+  Signal.trap("USR2") { exit }
+
+  begin
+    output = Einhorn::Prctl.get_pdeathsig
+    if output == nil then
+      output = "nil"
+    end
+  rescue NotImplementedError
+    output = "not implemented"
+  end
+
+  Einhorn::Worker.ack!
+  while true
+    s, _ = serv.accept
+    s.write(output)
+    s.flush
+    s.close
+  end
+end
+
+einhorn_main if $0 == __FILE__

data/test/integration/_lib/fixtures/signal_timeout/sleepy_server.rb

@@ -0,0 +1,23 @@
+require 'bundler/setup'
+require 'socket'
+require 'einhorn/worker'
+
+def einhorn_main
+  serv = Socket.for_fd(Einhorn::Worker.socket!)
+  Einhorn::Worker.ack!
+  Einhorn::Worker.ping!("id-1")
+
+  Signal.trap('USR2') do
+    sleep ENV.fetch("TRAP_SLEEP").to_i
+    exit
+  end
+
+  while true
+    s, _ = serv.accept
+    s.write($$)
+    s.flush
+    s.close
+  end
+end
+
+einhorn_main if $0 == __FILE__

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

@@ -9,6 +9,8 @@ def einhorn_main
   $stderr.puts "Worker has a socket"
   Einhorn::Worker.ack!
   $stderr.puts "Worker sent ack to einhorn"
+  Einhorn::Worker.ping!("id-1")
+  $stderr.puts "Worker has sent a ping to einhorn"
   while true
     s, addrinfo = serv.accept
     $stderr.puts "Worker got a socket!"

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

@@ -40,28 +40,28 @@ module Helpers
           begin
             stdout, stderr = process.communicate
           rescue Errno::ECHILD
-            # It's dead, and we're not getting anything. This is
-            # peaceful.
+            # It's dead, and we're not getting anything. This is peaceful.
           end
         end
         yield(process) if block_given?
-      rescue Exception => e
+      rescue
         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
+          for i in 1..10 do
+            status = process.poll
+            if status && status.exited?
+              break
             end
-          rescue Timeout::Error
+            sleep(1)
+          end
+          unless status && status.exited?
             $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
@@ -106,6 +106,11 @@ module Helpers
       open_port.close
     end
 
+    def get_state(client)
+      client.send_command('command' => 'state')
+      YAML.load(client.receive_message['message'])[:state]
+    end
+
     def wait_for_open_port
       max_retries = 50
       begin

data/test/integration/pdeathsig.rb

@@ -0,0 +1,26 @@
+require(File.expand_path('_lib', File.dirname(__FILE__)))
+
+class PdeathsigTest < EinhornIntegrationTestCase
+  include Helpers::EinhornHelpers
+
+  describe 'when run with -k' do
+    before do
+      @dir = prepare_fixture_directory('pdeathsig_printer')
+      @port = find_free_port
+      @server_program = File.join(@dir, 'pdeathsig_printer.rb')
+      @socket_path = File.join(@dir, 'einhorn.sock')
+    end
+    after { cleanup_fixtured_directories }
+
+    it 'sets pdeathsig to USR2 in the child process' do
+      with_running_einhorn(%W{einhorn -m manual -b 127.0.0.1:#{@port} -d #{@socket_path} -k -- ruby #{@server_program}}) do |process|
+        wait_for_open_port
+        output = read_from_port
+        if output != "not implemented" then
+          assert_equal("USR2", output)
+        end
+        process.terminate
+      end
+    end
+  end
+end