einhorn 0.8.2 → 1.0.0

data/lib/einhorn/command.rb

@@ -1,27 +1,25 @@
-require 'pp'
-require 'set'
-require 'tmpdir'
+require "pp"
+require "set"
+require "tmpdir"
 
-require 'einhorn/command/interface'
-require 'einhorn/prctl'
+require "einhorn/command/interface"
+require "einhorn/prctl"
 
 module Einhorn
   module Command
     def self.reap
-      begin
-        while true
-          Einhorn.log_debug('Going to reap a child process')
-          pid = Process.wait(-1, Process::WNOHANG)
-          return unless pid
-          cleanup(pid)
-          Einhorn::Event.break_loop
-        end
-      rescue Errno::ECHILD
+      loop do
+        Einhorn.log_debug("Going to reap a child process")
+        pid = Process.wait(-1, Process::WNOHANG)
+        return unless pid
+        cleanup(pid)
+        Einhorn::Event.break_loop
       end
+    rescue Errno::ECHILD
     end
 
     def self.cleanup(pid)
-      unless spec = Einhorn::State.children[pid]
+      unless (spec = Einhorn::State.children[pid])
         Einhorn.log_error("Could not find any config for exited child #{pid.inspect}! This probably indicates a bug in Einhorn.")
         return
       end
@@ -31,7 +29,7 @@ module Einhorn
       # Unacked worker
       if spec[:type] == :worker && !spec[:acked]
         Einhorn::State.consecutive_deaths_before_ack += 1
-        extra = ' before it was ACKed'
+        extra = " before it was ACKed"
       else
         extra = nil
       end
@@ -47,7 +45,7 @@ module Einhorn
     end
 
     def self.register_ping(pid, request_id)
-      unless spec = Einhorn::State.children[pid]
+      unless (spec = Einhorn::State.children[pid])
         Einhorn.log_error("Could not find state for PID #{pid.inspect}; ignoring ACK.")
         return
       end
@@ -84,7 +82,7 @@ module Einhorn
     end
 
     def self.register_ack(pid)
-      unless spec = Einhorn::State.children[pid]
+      unless (spec = Einhorn::State.children[pid])
         Einhorn.log_error("Could not find state for PID #{pid.inspect}; ignoring ACK.")
         return
       end
@@ -94,10 +92,8 @@ module Einhorn
         return
       end
 
-      if Einhorn::State.consecutive_deaths_before_ack > 0
-        extra = ", breaking the streak of #{Einhorn::State.consecutive_deaths_before_ack} consecutive unacked workers dying"
-      else
-        extra = nil
+      extra = if Einhorn::State.consecutive_deaths_before_ack > 0
+        ", breaking the streak of #{Einhorn::State.consecutive_deaths_before_ack} consecutive unacked workers dying"
       end
       Einhorn::State.consecutive_deaths_before_ack = 0
 
@@ -107,14 +103,14 @@ module Einhorn
       Einhorn::Event.break_loop
     end
 
-    def self.signal_all(signal, children=nil, record=true)
+    def self.signal_all(signal, children = nil, record = true)
       children ||= Einhorn::WorkerPool.workers
       signaled = {}
 
       Einhorn.log_info("Sending #{signal} to #{children.inspect}", :upgrade)
 
       children.each do |child|
-        unless spec = Einhorn::State.children[child]
+        unless (spec = Einhorn::State.children[child])
           Einhorn.log_error("Trying to send #{signal} to dead child #{child.inspect}. The fact we tried this probably indicates a bug in Einhorn.", :upgrade)
           next
         end
@@ -150,10 +146,10 @@ module Einhorn
 
             Einhorn.log_info("Child #{child.inspect} is still active after #{Einhorn::State.signal_timeout}s. Sending SIGKILL.")
             begin
-              Process.kill('KILL', child)
+              Process.kill("KILL", child)
             rescue Errno::ESRCH
             end
-            spec[:signaled].add('KILL')
+            spec[:signaled].add("KILL")
           end
         end
 
@@ -161,20 +157,19 @@ module Einhorn
       end
     end
 
-
     def self.increment
       Einhorn::Event.break_loop
       old = Einhorn::State.config[:number]
       new = (Einhorn::State.config[:number] += 1)
       output = "Incrementing number of workers from #{old} -> #{new}"
-      $stderr.puts(output)
+      warn(output)
       output
     end
 
     def self.decrement
       if Einhorn::State.config[:number] <= 1
         output = "Can't decrease number of workers (already at #{Einhorn::State.config[:number]}).  Run kill #{$$} if you really want to kill einhorn."
-        $stderr.puts(output)
+        warn(output)
         return output
       end
 
@@ -182,7 +177,7 @@ module Einhorn
       old = Einhorn::State.config[:number]
       new = (Einhorn::State.config[:number] -= 1)
       output = "Decrementing number of workers from #{old} -> #{new}"
-      $stderr.puts(output)
+      warn(output)
       output
     end
 
@@ -195,12 +190,12 @@ module Einhorn
       old = Einhorn::State.config[:number]
       Einhorn::State.config[:number] = new
       output = "Altering worker count, #{old} -> #{new}. Will "
-      if old < new
-        output << "spin up additional workers."
+      output << if old < new
+        "spin up additional workers."
       else
-        output << "gracefully terminate workers."
+        "gracefully terminate workers."
       end
-      $stderr.puts(output)
+      warn(output)
       output
     end
 
@@ -211,8 +206,8 @@ module Einhorn
       end
 
       {
-        :state => global_state,
-        :persistent_descriptors => descriptor_state,
+        state: global_state,
+        persistent_descriptors: descriptor_state
       }
     end
 
@@ -257,8 +252,8 @@ module Einhorn
 
       begin
         Einhorn.initialize_reload_environment
-        respawn_commandline = Einhorn.upgrade_commandline(['--with-state-fd', read.fileno.to_s])
-        respawn_commandline << { :close_others => false }
+        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
@@ -275,16 +270,16 @@ module Einhorn
       end
     end
 
-    def self.spinup(cmd=nil)
+    def self.spinup(cmd = nil)
       cmd ||= Einhorn::State.cmd
       index = next_index
       expected_ppid = Process.pid
-      if Einhorn::State.preloaded
-        pid = fork do
+      pid = if Einhorn::State.preloaded
+        fork do
           Einhorn::TransientState.whatami = :worker
           prepare_child_process
 
-          Einhorn.log_info('About to tear down Einhorn state and run einhorn_main')
+          Einhorn.log_info("About to tear down Einhorn state and run einhorn_main")
           Einhorn::Command::Interface.uninit
           Einhorn::Event.close_all_for_worker
           Einhorn.set_argv(cmd, true)
@@ -297,7 +292,7 @@ module Einhorn
           einhorn_main
         end
       else
-        pid = fork do
+        fork do
           Einhorn::TransientState.whatami = :worker
           prepare_child_process
 
@@ -314,20 +309,20 @@ module Einhorn
           setup_parent_watch(expected_ppid)
 
           prepare_child_environment(index)
-          Einhorn::Compat.exec(cmd[0], cmd[1..-1], :close_others => false)
+          Einhorn::Compat.exec(cmd[0], cmd[1..-1], close_others: false)
         end
       end
 
       Einhorn.log_info("===> Launched #{pid} (index: #{index})", :upgrade)
       Einhorn::State.last_spinup = Time.now
       Einhorn::State.children[pid] = {
-        :type => :worker,
-        :version => Einhorn::State.version,
-        :acked => false,
-        :signaled => Set.new,
-        :last_signaled_at => nil,
-        :index => index,
-        :spinup_time => Einhorn::State.last_spinup,
+        type: :worker,
+        version: Einhorn::State.version,
+        acked: false,
+        signaled: Set.new,
+        last_signaled_at: nil,
+        index: index,
+        spinup_time: Einhorn::State.last_spinup
       }
 
       # Set up whatever's needed for ACKing
@@ -336,6 +331,7 @@ module Einhorn
       when :timer
         Einhorn::Event::ACKTimer.open(ack_mode[:timeout], pid)
       when :manual
+        # nothing to do
       else
         Einhorn.log_error("Unrecognized ACK mode #{type.inspect}")
       end
@@ -343,24 +339,18 @@ module Einhorn
 
     def self.prepare_child_environment(index)
       # This is run from the child
-      ENV['EINHORN_MASTER_PID'] = Process.ppid.to_s
-      ENV['EINHORN_SOCK_PATH'] = Einhorn::Command::Interface.socket_path
+      ENV["EINHORN_MASTER_PID"] = Process.ppid.to_s
+      ENV["EINHORN_SOCK_PATH"] = Einhorn::Command::Interface.socket_path
       if Einhorn::State.command_socket_as_fd
         socket = UNIXSocket.open(Einhorn::Command::Interface.socket_path)
         Einhorn::TransientState.socket_handles << socket
-        ENV['EINHORN_SOCK_FD'] = socket.fileno.to_s
+        ENV["EINHORN_SOCK_FD"] = socket.fileno.to_s
       end
 
-      ENV['EINHORN_FD_COUNT'] = Einhorn::State.bind_fds.length.to_s
-      Einhorn::State.bind_fds.each_with_index {|fd, i| ENV["EINHORN_FD_#{i}"] = fd.to_s}
-
-      ENV['EINHORN_CHILD_INDEX'] = index.to_s
+      ENV["EINHORN_FD_COUNT"] = Einhorn::State.bind_fds.length.to_s
+      Einhorn::State.bind_fds.each_with_index { |fd, i| ENV["EINHORN_FD_#{i}"] = fd.to_s }
 
-      # EINHORN_FDS is deprecated. It was originally an attempt to
-      # match Upstart's nominal internal support for space-separated
-      # FD lists, but nobody uses that in practice, and it makes
-      # finding individual FDs more difficult
-      ENV['EINHORN_FDS'] = Einhorn::State.bind_fds.map(&:to_s).join(' ')
+      ENV["EINHORN_CHILD_INDEX"] = index.to_s
     end
 
     # Reseed common ruby random number generators.
@@ -383,11 +373,11 @@ module Einhorn
 
       # reseed OpenSSL::Random if it's loaded
       if defined?(OpenSSL::Random)
-        if defined?(Random)
-          seed = Random.new_seed
+        seed = if defined?(Random)
+          Random.new_seed
         else
           # Ruby 1.8
-          seed = rand
+          rand
         end
         OpenSSL::Random.seed(seed.to_s)
       end
@@ -399,14 +389,14 @@ module Einhorn
     end
 
     def self.setup_parent_watch(expected_ppid)
-      if Einhorn::State.kill_children_on_exit then
+      if Einhorn::State.kill_children_on_exit
         begin
           # NB: Having the USR2 signal handler set to terminate (the default) at
           # this point is required. If it's set to a ruby handler, there are
           # race conditions that could cause the worker to leak.
 
           Einhorn::Prctl.set_pdeathsig("USR2")
-          if Process.ppid != expected_ppid then
+          if Process.ppid != expected_ppid
             Einhorn.log_error("Parent process died before we set pdeathsig; cowardly refusing to exec child process.")
             exit(1)
           end
@@ -424,18 +414,19 @@ module Einhorn
     #   upgrade, bring up all the new workers and don't cull any old workers
     #   until they're all up.
     #
-    def self.full_upgrade(options={})
-      options = {:smooth => false}.merge(options)
+    def self.full_upgrade(options = {})
+      options = {smooth: false}.merge(options)
 
       Einhorn::State.smooth_upgrade = options.fetch(:smooth)
       reload_for_upgrade
     end
 
     def self.full_upgrade_smooth
-      full_upgrade(:smooth => true)
+      full_upgrade(smooth: true)
     end
+
     def self.full_upgrade_fleet
-      full_upgrade(:smooth => false)
+      full_upgrade(smooth: false)
     end
 
     def self.reload_for_upgrade
@@ -448,8 +439,8 @@ module Einhorn
         Einhorn.log_info("Currently upgrading (#{Einhorn::WorkerPool.ack_count} / #{Einhorn::WorkerPool.ack_target} ACKs; bumping version and starting over)...", :upgrade)
       else
         Einhorn::State.upgrading = true
-        u_type = Einhorn::State.smooth_upgrade ? 'smooth' : 'fleet'
-        Einhorn.log_info("Starting #{u_type} upgrade from version" +
+        u_type = Einhorn::State.smooth_upgrade ? "smooth" : "fleet"
+        Einhorn.log_info("Starting #{u_type} upgrade from version" \
                          " #{Einhorn::State.version}...", :upgrade)
       end
 
@@ -496,7 +487,7 @@ module Einhorn
       end
 
       if unsignaled > target
-        excess = Einhorn::WorkerPool.unsignaled_modern_workers_with_priority[0...(unsignaled-target)]
+        excess = Einhorn::WorkerPool.unsignaled_modern_workers_with_priority[0...(unsignaled - target)]
         Einhorn.log_info("Have too many workers at the current version, so killing off #{excess.length} of them.")
         signal_all("USR2", excess)
       end
@@ -507,13 +498,13 @@ module Einhorn
 
     def self.kill_expired_signaled_workers
       now = Time.now
-      children = Einhorn::State.children.select do |_,c|
+      children = Einhorn::State.children.select do |_, c|
         # Only interested in USR2 signaled workers
         next unless c[:signaled] && c[:signaled].length > 0
-        next unless c[:signaled].include?('USR2')
+        next unless c[:signaled].include?("USR2")
 
         # Ignore processes that have received KILL since it can't be trapped.
-        next if c[:signaled].include?('KILL')
+        next if c[:signaled].include?("KILL")
 
         # Filter out those children that have not reached signal_timeout yet.
         next unless c[:last_signaled_at]
@@ -527,12 +518,12 @@ module Einhorn
       children.each do |pid, child|
         Einhorn.log_info("Child #{pid.inspect} was signaled #{(child[:last_signaled_at] - now).abs.to_i}s ago. Sending SIGKILL as it is still active after #{Einhorn::State.signal_timeout}s timeout.", :upgrade)
         begin
-          Process.kill('KILL', pid)
+          Process.kill("KILL", pid)
         rescue Errno::ESRCH
           Einhorn.log_debug("Attempted to SIGKILL child #{pid.inspect} but the process does not exist.")
         end
 
-        child[:signaled].add('KILL')
+        child[:signaled].add("KILL")
         child[:last_signaled_at] = Time.now
       end
     end
@@ -559,7 +550,7 @@ module Einhorn
         return
       end
       Einhorn.log_info("Launching #{missing} new workers")
-      missing.times {spinup}
+      missing.times { spinup }
     end
 
     # Unbounded exponential backoff is not a thing: we run into problems if
@@ -568,7 +559,7 @@ module Einhorn
     # don't wait until the heat death of the universe to spin up new capacity.
     MAX_SPINUP_INTERVAL = 30.0
 
-    def self.replenish_gradually(max_unacked=nil)
+    def self.replenish_gradually(max_unacked = nil)
       return if Einhorn::TransientState.has_outstanding_spinup_timer
       return unless Einhorn::WorkerPool.missing_worker_count > 0
 
@@ -591,7 +582,7 @@ module Einhorn
 
       # Exponentially backoff automated spinup if we're just having
       # things die before ACKing
-      spinup_interval = Einhorn::State.config[:seconds] * (1.5 ** Einhorn::State.consecutive_deaths_before_ack)
+      spinup_interval = Einhorn::State.config[:seconds] * (1.5**Einhorn::State.consecutive_deaths_before_ack)
       spinup_interval = [spinup_interval, MAX_SPINUP_INTERVAL].min
       seconds_ago = (Time.now - Einhorn::State.last_spinup).to_f
 
@@ -618,14 +609,14 @@ module Einhorn
       end
     end
 
-    def self.quieter(log=true)
+    def self.quieter(log = true)
       Einhorn::State.verbosity += 1 if Einhorn::State.verbosity < 2
       output = "Verbosity set to #{Einhorn::State.verbosity}"
       Einhorn.log_info(output) if log
       output
     end
 
-    def self.louder(log=true)
+    def self.louder(log = true)
       Einhorn::State.verbosity -= 1 if Einhorn::State.verbosity > 0
       output = "Verbosity set to #{Einhorn::State.verbosity}"
       Einhorn.log_info(output) if log

data/lib/einhorn/compat.rb

@@ -11,10 +11,10 @@ module Einhorn
 
     def self.cloexec!(fd, enable)
       original = fd.fcntl(Fcntl::F_GETFD)
-      if enable
-        new = original | Fcntl::FD_CLOEXEC
+      new = if enable
+        original | Fcntl::FD_CLOEXEC
       else
-        new = original & (-Fcntl::FD_CLOEXEC-1)
+        original & (-Fcntl::FD_CLOEXEC - 1)
       end
       fd.fcntl(Fcntl::F_SETFD, new)
     end
@@ -24,7 +24,7 @@ module Einhorn
     end
 
     # Opts are ignored in Ruby 1.8
-    def self.exec(script, args, opts={})
+    def self.exec(script, args, opts = {})
       cmd = [script, script]
       begin
         Kernel.exec(cmd, *(args + [opts]))
@@ -53,18 +53,18 @@ module Einhorn
 
       # linux / friends
       begin
-        return File.read('/proc/cpuinfo').scan(/^processor\s*:/).count
+        return File.read("/proc/cpuinfo").scan(/^processor\s*:/).count
       rescue Errno::ENOENT
       end
 
       # OS X
-      if RUBY_PLATFORM =~ /darwin/
+      if RUBY_PLATFORM.match?(/darwin/)
         return Integer(`sysctl -n hw.logicalcpu`)
       end
 
       # windows / friends
       begin
-        require 'win32ole'
+        require "win32ole"
       rescue LoadError
       else
         wmi = WIN32OLE.connect("winmgmts://")

data/lib/einhorn/event/abstract_text_descriptor.rb

@@ -6,7 +6,7 @@ module Einhorn::Event
     @@instance_counter = 0
 
     def self.open(sock)
-      self.new(sock)
+      new(sock)
     end
 
     def initialize(sock)
@@ -40,24 +40,22 @@ module Einhorn::Event
     end
 
     def notify_readable
-      while true
-        begin
-          return if @closed
-          chunk = @socket.read_nonblock(1024)
-        rescue Errno::EAGAIN
-          break
-        rescue EOFError, Errno::EPIPE, Errno::ECONNRESET
-          close
-          break
-        rescue StandardError => e
-          log_error("Caught unrecognized error while reading from socket: #{e} (#{e.class})")
-          close
-          break
-        else
-          log_debug("read #{chunk.length} bytes (#{chunk.inspect[0..20]})")
-          @read_buffer << chunk
-          process_read_buffer
-        end
+      loop do
+        return if @closed
+        chunk = @socket.read_nonblock(1024)
+      rescue Errno::EAGAIN
+        break
+      rescue EOFError, Errno::EPIPE, Errno::ECONNRESET
+        close
+        break
+      rescue => e
+        log_error("Caught unrecognized error while reading from socket: #{e} (#{e.class})")
+        close
+        break
+      else
+        log_debug("read #{chunk.length} bytes (#{chunk.inspect[0..20]})")
+        @read_buffer << chunk
+        process_read_buffer
       end
     end
 
@@ -72,19 +70,17 @@ module Einhorn::Event
     end
 
     def notify_writeable
-      begin
-        return if @closed
-        written = @socket.write_nonblock(@write_buffer)
-      rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
-      rescue Errno::EPIPE, Errno::ECONNRESET
-        close
-      rescue StandardError => e
-        log_error("Caught unrecognized error while writing to socket: #{e} (#{e.class})")
-        close
-      else
-        log_debug("wrote #{written} bytes")
-        @write_buffer = @write_buffer[written..-1]
-      end
+      return if @closed
+      written = @socket.write_nonblock(@write_buffer)
+    rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
+    rescue Errno::EPIPE, Errno::ECONNRESET
+      close
+    rescue => e
+      log_error("Caught unrecognized error while writing to socket: #{e} (#{e.class})")
+      close
+    else
+      log_debug("wrote #{written} bytes")
+      @write_buffer = @write_buffer[written..-1]
     end
 
     def to_io
@@ -102,9 +98,9 @@ module Einhorn::Event
     end
 
     def process_read_buffer
-      while true
+      loop do
         if @read_buffer.length > 0
-          break unless split = parse_record
+          break unless (split = parse_record)
           record, remainder = split
           log_debug("Read a record of #{record.length} bytes.")
           @read_buffer = remainder
@@ -117,7 +113,7 @@ module Einhorn::Event
 
     # Override in subclass. This lets you do streaming reads.
     def parse_record
-      [@read_buffer, '']
+      [@read_buffer, ""]
     end
 
     def consume_record(record)

data/lib/einhorn/event/ack_timer.rb

@@ -2,7 +2,7 @@ module Einhorn::Event
   class ACKTimer < Timer
     include Persistent
 
-    def initialize(time, pid, start=nil)
+    def initialize(time, pid, start = nil)
       super(time, start) do
         Einhorn::Command.register_timer_ack(time, pid)
       end
@@ -10,7 +10,7 @@ module Einhorn::Event
     end
 
     def to_state
-      {:class => self.class.to_s, :time => @time, :start => @start, :pid => @pid}
+      {class: self.class.to_s, time: @time, start: @start, pid: @pid}
     end
 
     def self.from_state(state)

data/lib/einhorn/event/command_server.rb

@@ -3,7 +3,7 @@ module Einhorn::Event
     include Persistent
 
     def self.open(server)
-      self.new(server)
+      new(server)
     end
 
     def initialize(server)
@@ -15,14 +15,12 @@ module Einhorn::Event
     end
 
     def notify_readable
-      begin
-        while true
-          return if @closed
-          sock = Einhorn::Compat.accept_nonblock(@server)
-          Connection.open(sock)
-        end
-      rescue Errno::EAGAIN
+      loop do
+        return if @closed
+        sock = Einhorn::Compat.accept_nonblock(@server)
+        Connection.open(sock)
       end
+    rescue Errno::EAGAIN
     end
 
     def to_io
@@ -30,7 +28,7 @@ module Einhorn::Event
     end
 
     def to_state
-      {:class => self.class.to_s, :server => @server.fileno}
+      {class: self.class.to_s, server: @server.fileno}
     end
 
     def self.from_state(state)

data/lib/einhorn/event/connection.rb

@@ -11,8 +11,6 @@ module Einhorn::Event
       split = @read_buffer.split("\n", 2)
       if split.length > 1
         split
-      else
-        nil
       end
     end
 
@@ -21,7 +19,7 @@ module Einhorn::Event
     end
 
     def to_state
-      state = {:class => self.class.to_s, :socket => @socket.fileno}
+      state = {class: self.class.to_s, socket: @socket.fileno}
       # Don't include by default because it's not that pretty
       state[:read_buffer] = @read_buffer if @read_buffer.length > 0
       state[:write_buffer] = @write_buffer if @write_buffer.length > 0

data/lib/einhorn/event/loop_breaker.rb

@@ -1,6 +1,7 @@
 # TODO: set lots of cloexecs
 module Einhorn::Event
   class LoopBreaker < AbstractTextDescriptor
-    def consume_record(record); end
+    def consume_record(record)
+    end
   end
 end

data/lib/einhorn/event/persistent.rb

@@ -8,7 +8,7 @@ module Einhorn::Event
 
     def self.from_state(state)
       klass_name = state[:class]
-      if klass = @@persistent[klass_name]
+      if (klass = @@persistent[klass_name])
         klass.from_state(state)
       else
         Einhorn.log_error("Unrecognized persistent descriptor class #{klass_name.inspect}. Ignoring. This most likely indicates that your Einhorn version has upgraded. Everything should still be working, but it may be worth a restart.", :upgrade)
@@ -17,7 +17,7 @@ module Einhorn::Event
     end
 
     def self.persistent?(descriptor)
-      @@persistent.values.any? {|klass| descriptor.kind_of?(klass)}
+      @@persistent.values.any? { |klass| descriptor.is_a?(klass) }
     end
   end
 end