einhorn 0.7.3 → 1.0.0

data/lib/einhorn/worker_pool.rb

@@ -7,13 +7,13 @@ module Einhorn
     end
 
     def self.workers
-      workers_with_state.map {|pid, _| pid}
+      workers_with_state.map { |pid, _| pid }
     end
 
     def self.unsignaled_workers
       workers_with_state.select do |pid, spec|
         spec[:signaled].length == 0
-      end.map {|pid, _| pid}
+      end.map { |pid, _| pid }
     end
 
     def self.modern_workers_with_state
@@ -23,15 +23,15 @@ module Einhorn
     end
 
     def self.acked_modern_workers_with_state
-      modern_workers_with_state.select {|pid, spec| spec[:acked]}
+      modern_workers_with_state.select { |pid, spec| spec[:acked] }
     end
 
     def self.modern_workers
-      modern_workers_with_state.map {|pid, _| pid}
+      modern_workers_with_state.map { |pid, _| pid }
     end
 
     def self.acked_modern_workers
-      acked_modern_workers_with_state.map {|pid, _| pid}
+      acked_modern_workers_with_state.map { |pid, _| pid }
     end
 
     def self.unsignaled_modern_workers_with_state
@@ -43,23 +43,23 @@ module Einhorn
     def self.acked_unsignaled_modern_workers
       acked_modern_workers_with_state.select do |_, spec|
         spec[:signaled].length == 0
-      end.map {|pid, _| pid}
+      end.map { |pid, _| pid }
     end
 
     def self.unsignaled_modern_workers_with_priority
       unsignaled_modern_workers_with_state.sort_by do |pid, spec|
         spec[:acked] ? 1 : 0
-      end.map {|pid, _| pid}
+      end.map { |pid, _| pid }
     end
 
     def self.unacked_unsignaled_modern_workers_with_state
-      modern_workers_with_state.select {|pid, spec|
+      modern_workers_with_state.select { |pid, spec|
         !spec[:acked] && spec[:signaled].length == 0
       }
     end
 
     def self.unacked_unsignaled_modern_workers
-      unacked_unsignaled_modern_workers_with_state.map {|pid, _| pid}
+      unacked_unsignaled_modern_workers_with_state.map { |pid, _| pid }
     end
 
     # Use the number of modern workers, rather than unsignaled modern

data/lib/einhorn.rb

@@ -1,18 +1,36 @@
-require 'fcntl'
-require 'optparse'
-require 'pp'
-require 'set'
-require 'socket'
-require 'tmpdir'
-require 'yaml'
-require 'shellwords'
+require "fcntl"
+require "optparse"
+require "pp"
+require "set"
+require "socket"
+require "tmpdir"
+require "yaml"
+require "shellwords"
+require "einhorn/safe_yaml"
 
 module Einhorn
   module AbstractState
-    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 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 respond_to_missing?(name)
+      ((name.to_s =~ /(.*)=$/) && state.has_key?($1.to_sym)) ||
+        state.has_key?(name) ||
+        default_state.has_key?(name)
+    end
 
     def method_missing(name, *args)
       if (name.to_s =~ /(.*)=$/) && state.has_key?($1.to_sym)
@@ -37,66 +55,61 @@ module Einhorn
     # about backwards/forwards compatibility for upgrades/downgrades
     def self.default_state
       {
-        :children => {},
-        :config => {:number => 1, :backlog => 100, :seconds => 1},
-        :versions => {},
-        :version => 0,
-        :sockets => {},
-        :orig_cmd => nil,
-        :bind => [],
-        :bind_fds => [],
-        :cmd => nil,
-        :script_name => nil,
-        :respawn => true,
-        :upgrading => false,
-        :smooth_upgrade => false,
-        :reloading_for_upgrade => false,
-        :path => nil,
-        :cmd_name => nil,
-        :verbosity => 1,
-        :generation => 0,
-        :last_spinup => nil,
-        :ack_mode => {:type => :timer, :timeout => 1},
-        :kill_children_on_exit => false,
-        :command_socket_as_fd => false,
-        :socket_path => nil,
-        :pidfile => nil,
-        :lockfile => nil,
-        :consecutive_deaths_before_ack => 0,
-        :last_upgraded => nil,
-        :nice => {:master => nil, :worker => nil, :renice_cmd => '/usr/bin/renice'},
-        :reexec_commandline => nil,
-        :drop_environment_variables => [],
-        :signal_timeout => nil,
+        children: {},
+        config: {number: 1, backlog: 100, seconds: 1},
+        versions: {},
+        version: 0,
+        sockets: {},
+        orig_cmd: nil,
+        bind: [],
+        bind_fds: [],
+        bound_ports: [],
+        cmd: nil,
+        script_name: nil,
+        respawn: true,
+        upgrading: false,
+        smooth_upgrade: false,
+        reloading_for_upgrade: false,
+        path: nil,
+        cmd_name: nil,
+        verbosity: 1,
+        generation: 0,
+        last_spinup: nil,
+        ack_mode: {type: :timer, timeout: 1},
+        kill_children_on_exit: false,
+        command_socket_as_fd: false,
+        socket_path: nil,
+        pidfile: nil,
+        lockfile: nil,
+        consecutive_deaths_before_ack: 0,
+        last_upgraded: nil,
+        nice: {master: nil, worker: nil, renice_cmd: "/usr/bin/renice"},
+        reexec_commandline: nil,
+        drop_environment_variables: [],
+        signal_timeout: nil,
+        preloaded: false
       }
     end
-
-    def self.dumpable_state
-      dump = state
-      dump[:reloading_for_preload_upgrade] = dump[:reloading_for_upgrade]
-      dump
-    end
   end
 
   module TransientState
     extend AbstractState
     def self.default_state
       {
-        :whatami => :master,
-        :preloaded => false,
-        :script_name => nil,
-        :argv => [],
-        :environ => {},
-        :has_outstanding_spinup_timer => false,
-        :stateful => nil,
+        whatami: :master,
+        script_name: nil,
+        argv: [],
+        environ: {},
+        has_outstanding_spinup_timer: false,
+        stateful: nil,
         # Holds references so that the GC doesn't go and close your sockets.
-        :socket_handles => Set.new
+        socket_handles: Set.new
       }
     end
   end
 
   def self.restore_state(state)
-    parsed = YAML.load(state)
+    parsed = SafeYAML.load(state)
     updated_state, message = update_state(Einhorn::State, "einhorn", parsed[:state])
     Einhorn::State.state = updated_state
     Einhorn::Event.restore_persistent_descriptors(parsed[:persistent_descriptors])
@@ -110,37 +123,21 @@ module Einhorn
     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"
+    if store == Einhorn::State && updated_state[:children]
+      # Depending on what is passed for --reexec-as, it's possible
+      # that the process received a SIGCHLD while something other
+      # than einhorn was the active executable. If that happened,
+      # einhorn might not know about a dead child, so let's check
+      # them all
+      dead = []
+      updated_state[:children].each do |pid, v|
+        pid = Process.wait(pid, Process::WNOHANG)
+        dead << pid if pid
+      rescue Errno::ECHILD
+        dead << pid
       end
-
-      if updated_state[:children]
-        # For a period, we created children entries for state_passers,
-        # but we don't want that (in particular, it probably died
-        # before we could setup our SIGCHLD handler
-        updated_state[:children].delete_if {|k, v| v[:type] == :state_passer}
-
-        # Depending on what is passed for --reexec-as, it's possible
-        # that the process received a SIGCHLD while something other
-        # than einhorn was the active executable. If that happened,
-        # einhorn might not know about a dead child, so let's check
-        # them all
-        dead = []
-        updated_state[:children].each do |pid, v|
-          begin
-            pid = Process.wait(pid, Process::WNOHANG)
-            dead << pid if pid
-          rescue Errno::ECHILD
-            dead << pid
-          end
-        end
-        Einhorn::Event::Timer.open(0) do
-          dead.each {|pid| Einhorn::Command.mourn(pid)}
-        end
+      Einhorn::Event::Timer.open(0) do
+        dead.each { |pid| Einhorn::Command.cleanup(pid) }
       end
     end
 
@@ -149,12 +146,12 @@ module Einhorn
     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)}
+    added_keys.each { |key| updated_state[key] = default[key] }
+    deleted_keys.each { |key| updated_state.delete(key) }
 
     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(', ')}"
+    message = "State format for #{store_name} has changed: #{message.join(", ")}"
 
     # Can't print yet, since state hasn't been set, so we pass along the message.
     [updated_state, message]
@@ -169,42 +166,45 @@ module Einhorn
     sd = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
     Einhorn::Compat.cloexec!(sd, false)
 
-    if flags.include?('r') || flags.include?('so_reuseaddr')
+    if flags.include?("r") || flags.include?("so_reuseaddr")
       sd.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
     end
 
     sd.bind(Socket.pack_sockaddr_in(port, addr))
     sd.listen(Einhorn::State.config[:backlog])
 
-    if flags.include?('n') || flags.include?('o_nonblock')
+    if flags.include?("n") || flags.include?("o_nonblock")
       fl = sd.fcntl(Fcntl::F_GETFL)
       sd.fcntl(Fcntl::F_SETFL, fl | Fcntl::O_NONBLOCK)
     end
 
     Einhorn::TransientState.socket_handles << sd
-    sd.fileno
+    [sd.fileno, sd.local_address.ip_port]
   end
 
   # Implement these ourselves so it plays nicely with state persistence
-  def self.log_debug(msg, tag=nil)
-    $stderr.puts("#{log_tag} DEBUG: #{msg}\n") if Einhorn::State.verbosity <= 0
-    self.send_tagged_message(tag, msg) if tag
+  def self.log_debug(msg, tag = nil)
+    warn("#{log_tag} DEBUG: #{msg}\n") if Einhorn::State.verbosity <= 0
+    $stderr.flush
+    send_tagged_message(tag, msg) if tag
   end
-  def self.log_info(msg, tag=nil)
-    $stderr.puts("#{log_tag} INFO: #{msg}\n") if Einhorn::State.verbosity <= 1
-    self.send_tagged_message(tag, msg) if tag
+
+  def self.log_info(msg, tag = nil)
+    warn("#{log_tag} INFO: #{msg}\n") if Einhorn::State.verbosity <= 1
+    $stderr.flush
+    send_tagged_message(tag, msg) if tag
   end
-  def self.log_error(msg, tag=nil)
-    $stderr.puts("#{log_tag} ERROR: #{msg}\n") if Einhorn::State.verbosity <= 2
-    self.send_tagged_message(tag, "ERROR: #{msg}") if tag
+
+  def self.log_error(msg, tag = nil)
+    warn("#{log_tag} ERROR: #{msg}\n") if Einhorn::State.verbosity <= 2
+    $stderr.flush
+    send_tagged_message(tag, "ERROR: #{msg}") if tag
   end
 
-  def self.send_tagged_message(tag, message, last=false)
+  def self.send_tagged_message(tag, message, last = false)
     Einhorn::Command::Interface.send_tagged_message(tag, message, last)
   end
 
-  private
-
   def self.log_tag
     case whatami = Einhorn::TransientState.whatami
     when :master
@@ -217,17 +217,16 @@ module Einhorn
       "[UNKNOWN (#{whatami.inspect}) #{$$}]"
     end
   end
-
-  public
+  private_class_method :log_tag
 
   def self.which(cmd)
-    if cmd.include?('/')
-      return cmd if File.exists?(cmd)
+    if cmd.include?("/")
+      return cmd if File.exist?(cmd)
       raise "Could not find #{cmd}"
     else
-      ENV['PATH'].split(':').each do |f|
+      ENV["PATH"].split(":").each do |f|
         abs = File.join(f, cmd)
-        return abs if File.exists?(abs)
+        return abs if File.exist?(abs)
       end
       raise "Could not find #{cmd} in PATH"
     end
@@ -237,29 +236,33 @@ module Einhorn
   def self.is_script(file)
     File.open(file) do |f|
       bytes = f.read(2)
-      bytes == '#!'
+      bytes == "#!"
     end
   end
 
   def self.preload
-    if path = Einhorn::State.path
+    if (path = Einhorn::State.path)
       set_argv(Einhorn::State.cmd, false)
 
       begin
+        # Reset preloaded state to false - this allows us to monitor for failed preloads during reloads.
+        Einhorn::State.preloaded = false
         # If it's not going to be requireable, then load it.
-        if !path.end_with?('.rb') && File.exists?(path)
+        if !path.end_with?(".rb") && File.exist?(path)
           log_info("Loading #{path} (if this hangs, make sure your code can be properly loaded as a library)", :upgrade)
           load path
         else
           log_info("Requiring #{path} (if this hangs, make sure your code can be properly loaded as a library)", :upgrade)
           require path
+
+          force_move_to_oldgen if Einhorn::State.config[:gc_before_fork]
         end
-      rescue Exception => e
+      rescue StandardError, LoadError => e
         log_info("Proceeding with postload -- could not load #{path}: #{e} (#{e.class})\n  #{e.backtrace.join("\n  ")}", :upgrade)
       else
         if defined?(einhorn_main)
           log_info("Successfully loaded #{path}", :upgrade)
-          Einhorn::TransientState.preloaded = true
+          Einhorn::State.preloaded = true
         else
           log_info("Proceeding with postload -- loaded #{path}, but no einhorn_main method was defined", :upgrade)
         end
@@ -267,10 +270,26 @@ module Einhorn
     end
   end
 
+  # Make the GC more copy-on-write friendly by forcibly incrementing the generation
+  # counter on all objects to its maximum value. Learn more at: https://github.com/ko1/nakayoshi_fork
+  def self.force_move_to_oldgen
+    log_info("Starting GC to improve copy-on-write memory sharing", :upgrade)
+
+    GC.start
+    3.times do
+      GC.start(full_mark: false)
+    end
+
+    GC.compact if GC.respond_to?(:compact)
+
+    log_info("Finished GC after preloading", :upgrade)
+  end
+  private_class_method :force_move_to_oldgen
+
   def self.set_argv(cmd, set_ps_name)
     # TODO: clean up this hack
     idx = 0
-    if cmd[0] =~ /(^|\/)ruby$/
+    if /(^|\/)ruby$/.match?(cmd[0])
       idx = 1
     elsif !is_script(cmd[0])
       log_info("WARNING: Going to set $0 to #{cmd[idx]}, but it doesn't look like a script")
@@ -287,7 +306,7 @@ module Einhorn
       $0 = worker_ps_name
     end
 
-    ARGV[0..-1] = cmd[idx+1..-1]
+    ARGV[0..-1] = cmd[idx + 1..-1]
     log_info("Set#{set_ps_name ? " $0 = #{$0.inspect}, " : nil} ARGV = #{ARGV.inspect}")
   end
 
@@ -300,15 +319,15 @@ module Einhorn
   end
 
   def self.worker_ps_name
-    Einhorn::State.cmd_name ? "ruby #{Einhorn::State.cmd_name}" : Einhorn::State.orig_cmd.join(' ')
+    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]
+    return unless (nice = Einhorn::State.nice[whatami])
     pid = $$
 
-    unless nice.kind_of?(Fixnum)
+    unless nice.is_a?(Integer)
       raise "Nice must be a fixnum: #{nice.inspect}"
     end
 
@@ -324,32 +343,15 @@ module Einhorn
 
   def self.socketify_env!
     Einhorn::State.bind.each do |host, port, flags|
-      fd = bind(host, port, flags)
+      fd, actual_port = bind(host, port, flags)
       Einhorn::State.bind_fds << fd
-    end
-  end
-
-  # This duplicates some code from the environment path, but is
-  # deprecated so that's ok.
-  def self.socketify!(cmd)
-    cmd.map! do |arg|
-      if arg =~ /^(.*=|)srv:([^:]+):(\d+)((?:,\w+)*)$/
-        log_error("Using deprecated command-line configuration for Einhorn; should upgrade to the environment variable interface.")
-        opt = $1
-        host = $2
-        port = $3
-        flags = $4.split(',').select {|flag| flag.length > 0}.map {|flag| flag.downcase}
-        fd = (Einhorn::State.sockets[[host, port]] ||= bind(host, port, flags))
-        "#{opt}#{fd}"
-      else
-        arg
-      end
+      Einhorn::State.bound_ports << actual_port
     end
   end
 
   # Construct and a command and args that can be used to re-exec
   # Einhorn for upgrades.
-  def self.upgrade_commandline(einhorn_flags=[])
+  def self.upgrade_commandline(einhorn_flags = [])
     cmdline = []
     if Einhorn::State.reexec_commandline
       cmdline += Einhorn::State.reexec_commandline
@@ -357,7 +359,7 @@ module Einhorn
       cmdline << Einhorn::TransientState.script_name
     end
     cmdline += einhorn_flags
-    cmdline << '--'
+    cmdline << "--"
     cmdline += Einhorn::State.cmd
     [cmdline[0], cmdline[1..-1]]
   end
@@ -369,7 +371,7 @@ module Einhorn
     upgrade_sentinel = fork do
       Einhorn::TransientState.whatami = :upgrade_sentinel
       Einhorn.initialize_reload_environment
-      Einhorn::Compat.exec(*Einhorn.upgrade_commandline(['--upgrade-check']))
+      Einhorn::Compat.exec(*Einhorn.upgrade_commandline(["--upgrade-check"]))
     end
     Process.wait(upgrade_sentinel)
     $?.exitstatus.zero?
@@ -394,10 +396,10 @@ module Einhorn
   # 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']
+    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)
+      bundler_gem = Gem::Specification.find_by_name("bundler")
+      log_info("Using Bundler #{bundler_gem.version}", :environment)
     rescue Gem::LoadError
     end
   end
@@ -418,7 +420,6 @@ module Einhorn
       # TODO: don't actually alter ARGV[0]?
       Einhorn::State.cmd[0] = which(Einhorn::State.cmd[0])
       socketify_env!
-      socketify!(Einhorn::State.cmd)
     end
 
     set_master_ps_name
@@ -431,6 +432,14 @@ module Einhorn
       Einhorn::State.reloading_for_upgrade = false
     end
 
+    # If setting a signal-timeout, timeout the event loop
+    # in the same timeframe, ensuring processes are culled
+    # on a regular basis.
+    if Einhorn::State.signal_timeout
+      Einhorn::Event.default_timeout = Einhorn::Event.default_timeout.nil? ?
+        Einhorn::State.signal_timeout : [Einhorn::State.signal_timeout, Einhorn::Event.default_timeout].min
+    end
+
     while Einhorn::State.respawn || Einhorn::State.children.size > 0
       log_debug("Entering event loop")
 
@@ -445,10 +454,10 @@ module Einhorn
   end
 end
 
-require 'einhorn/command'
-require 'einhorn/compat'
-require 'einhorn/client'
-require 'einhorn/event'
-require 'einhorn/worker'
-require 'einhorn/worker_pool'
-require 'einhorn/version'
+require "einhorn/command"
+require "einhorn/compat"
+require "einhorn/client"
+require "einhorn/event"
+require "einhorn/worker"
+require "einhorn/worker_pool"
+require "einhorn/version"