einhorn 0.7.4 → 1.0.0

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

data/lib/einhorn/event/timer.rb

@@ -2,7 +2,7 @@ module Einhorn::Event
   class Timer
     attr_reader :time
 
-    def initialize(time, start=nil, &blk)
+    def initialize(time, start = nil, &blk)
       @time = time
       @start = start || Time.now
       @blk = blk
@@ -10,7 +10,7 @@ module Einhorn::Event
 
     # TODO: abstract into some interface
     def self.open(*args, &blk)
-      instance = self.new(*args, &blk)
+      instance = new(*args, &blk)
       instance.register!
       instance
     end
@@ -27,12 +27,12 @@ module Einhorn::Event
     end
 
     def register!
-      Einhorn.log_debug("Scheduling a new #{self.time}s timer")
+      Einhorn.log_debug("Scheduling a new #{time}s timer")
       Einhorn::Event.register_timer(self)
     end
 
     def deregister!
-      Einhorn.log_debug("Nuking timer that expired #{Time.now - self.expires_at}s ago")
+      Einhorn.log_debug("Nuking timer that expired #{Time.now - expires_at}s ago")
       Einhorn::Event.deregister_timer(self)
     end
   end

data/lib/einhorn/event.rb

@@ -1,9 +1,10 @@
-require 'set'
+require "set"
 
 module Einhorn
   module Event
     @@loopbreak_reader = nil
     @@loopbreak_writer = nil
+    @@default_timeout = nil
     @@signal_actions = []
     @@readable = {}
     @@writeable = {}
@@ -36,8 +37,8 @@ module Einhorn
 
     def self.persistent_descriptors
       descriptor_sets = @@readable.values + @@writeable.values + @@timers.values
-      descriptors = descriptor_sets.inject {|a, b| a | b}
-      descriptors.select {|descriptor| Einhorn::Event::Persistent.persistent?(descriptor)}
+      descriptors = descriptor_sets.inject { |a, b| a | b }
+      descriptors.select { |descriptor| Einhorn::Event::Persistent.persistent?(descriptor) }
     end
 
     def self.restore_persistent_descriptors(persistent_descriptors)
@@ -80,8 +81,8 @@ module Einhorn
 
     def self.writeable_fds
       writers = @@writeable.select do |io, writers|
-        writers.any? {|writer| writer.write_pending?}
-      end.map {|io, writers| io}
+        writers.any? { |writer| writer.write_pending? }
+      end.map { |io, writers| io }
       Einhorn.log_debug("Writeable fds are #{writers.inspect}")
       writers
     end
@@ -117,10 +118,10 @@ module Einhorn
 
     def self.timeout
       # (expires_at of the next timer) - now
-      if expires_at = @@timers.keys.sort[0]
+      if (expires_at = @@timers.keys.min)
         expires_at - Time.now
       else
-        nil
+        @@default_timeout
       end
     end
 
@@ -129,7 +130,7 @@ module Einhorn
       # handlers. Since it's just an array we push to/shift from, we
       # can be sure there's no race (such as adding hash keys during
       # iteration.)
-      while blk = @@signal_actions.shift
+      while (blk = @@signal_actions.shift)
         blk.call
       end
     end
@@ -142,37 +143,45 @@ module Einhorn
 
       readable, writeable, _ = IO.select(readable_fds, writeable_fds, nil, time)
       (readable || []).each do |io|
-        @@readable[io].each {|reader| reader.notify_readable}
+        @@readable[io].each { |reader| reader.notify_readable }
       end
 
       (writeable || []).each do |io|
-        @@writeable[io].each {|writer| writer.notify_writeable}
+        @@writeable[io].each { |writer| writer.notify_writeable }
       end
     end
 
     def self.run_timers
-      @@timers.select {|expires_at, _| expires_at <= Time.now}.each do |expires_at, timers|
+      @@timers.select { |expires_at, _| expires_at <= Time.now }.each do |expires_at, timers|
         # Going to be modifying the set, so let's dup it.
-        timers.dup.each {|timer| timer.ring!}
+        timers.dup.each { |timer| timer.ring! }
       end
     end
 
     def self.break_loop
       Einhorn.log_debug("Breaking the loop")
       begin
-        @@loopbreak_writer.write_nonblock('a')
+        @@loopbreak_writer.write_nonblock("a")
       rescue Errno::EWOULDBLOCK, Errno::EAGAIN
         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
 
-require 'einhorn/event/persistent'
-require 'einhorn/event/timer'
+require "einhorn/event/persistent"
+require "einhorn/event/timer"
 
-require 'einhorn/event/abstract_text_descriptor'
-require 'einhorn/event/ack_timer'
-require 'einhorn/event/command_server'
-require 'einhorn/event/connection'
-require 'einhorn/event/loop_breaker'
+require "einhorn/event/abstract_text_descriptor"
+require "einhorn/event/ack_timer"
+require "einhorn/event/command_server"
+require "einhorn/event/connection"
+require "einhorn/event/loop_breaker"

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.match?(/linux/)
+    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,48 @@
+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
+        raise SystemCallError.new("get_pdeathsig", Fiddle.last_error)
+      end
+
+      signo = out.i
+      if signo == 0
+        return nil
+      end
+
+      Signal.signame(signo)
+    end
+
+    def self.set_pdeathsig(signal)
+      signo = if signal.nil?
+        0
+      elsif signal.instance_of?(String)
+        Signal.list.fetch(signal)
+      else
+        signal
+      end
+
+      if PrctlRaw.prctl(PrctlRaw::SET_PDEATHSIG, signo, 0, 0, 0) != 0
+        raise SystemCallError.new("set_pdeathsig(#{signal})", Fiddle.last_error)
+      end
+    end
+  end
+end

data/lib/einhorn/safe_yaml.rb

@@ -0,0 +1,17 @@
+require "yaml"
+
+module Einhorn
+  module SafeYAML
+    begin
+      YAML.safe_load("---", permitted_classes: [])
+    rescue ArgumentError
+      def self.load(payload)
+        YAML.safe_load(payload, [Set, Symbol, Time], [], true)
+      end
+    else
+      def self.load(payload) # rubocop:disable Lint/DuplicateMethods
+        YAML.safe_load(payload, permitted_classes: [Set, Symbol, Time], aliases: true)
+      end
+    end
+  end
+end

data/lib/einhorn/version.rb

@@ -1,3 +1,3 @@
 module Einhorn
-  VERSION = '0.7.4'
+  VERSION = "1.0.0"
 end

data/lib/einhorn/worker.rb

@@ -1,23 +1,21 @@
-require 'einhorn/client'
-require 'einhorn/command/interface'
+require "einhorn/client"
+require "einhorn/command/interface"
 
 module Einhorn
   module Worker
     class WorkerError < RuntimeError; end
 
     def self.is_worker?
-      begin
-        ensure_worker!
-      rescue WorkerError
-        false
-      else
-        true
-      end
+      ensure_worker!
+    rescue WorkerError
+      false
+    else
+      true
     end
 
     def self.ensure_worker!
       # Make sure that EINHORN_MASTER_PID is my parent
-      if ppid_s = ENV['EINHORN_MASTER_PID']
+      if (ppid_s = ENV["EINHORN_MASTER_PID"])
         ppid = ppid_s.to_i
         raise WorkerError.new("EINHORN_MASTER_PID environment variable is #{ppid_s.inspect}, but my parent's pid is #{Process.ppid.inspect}. This probably means that I am a subprocess of an Einhorn worker, but am not one myself.") unless Process.ppid == ppid
         true
@@ -27,10 +25,8 @@ module Einhorn
     end
 
     def self.ack(*args)
-      begin
-        ack!(*args)
-      rescue WorkerError
-      end
+      ack!(*args)
+    rescue WorkerError
     end
 
     # Returns the index of this Einhorn child process.
@@ -42,7 +38,7 @@ module Einhorn
     # Returns nil if not running in Einhorn, or running on a version
     # of Einhorn that does not support indexing children.
     def self.einhorn_child_index
-      index = ENV['EINHORN_CHILD_INDEX']
+      index = ENV["EINHORN_CHILD_INDEX"]
       if index.nil? || index !~ /\A \d+ \z/x
         index
       else
@@ -65,45 +61,40 @@ module Einhorn
     # TODO: add a :fileno option? Easy to implement; not sure if it'd
     # 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"
+    def self.ack!(discovery = :env, arg = nil)
+      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)
+    def self.socket(number = nil)
       number ||= 0
       einhorn_fd(number)
     end
 
-    def self.socket!(number=nil)
+    def self.socket!(number = nil)
       number ||= 0
 
-      unless count = einhorn_fd_count
+      unless (count = einhorn_fd_count)
         raise "No EINHORN_FD_COUNT provided in environment. Are you running under Einhorn?"
       end
 
@@ -111,7 +102,7 @@ module Einhorn
         raise "Only #{count} FDs available, but FD #{number} was requested"
       end
 
-      unless fd = einhorn_fd(number)
+      unless (fd = einhorn_fd(number))
         raise "No EINHORN_FD_#{number} provided in environment. That's pretty weird"
       end
 
@@ -119,14 +110,14 @@ module Einhorn
     end
 
     def self.einhorn_fd(n)
-      unless raw_fd = ENV["EINHORN_FD_#{n}"]
+      unless (raw_fd = ENV["EINHORN_FD_#{n}"])
         return nil
       end
       Integer(raw_fd)
     end
 
     def self.einhorn_fd_count
-      unless raw_count = ENV['EINHORN_FD_COUNT']
+      unless (raw_count = ENV["EINHORN_FD_COUNT"])
         return 0
       end
       Integer(raw_count)
@@ -134,15 +125,42 @@ module Einhorn
 
     # Call this to handle graceful shutdown requests to your app.
     def self.graceful_shutdown(&blk)
-      Signal.trap('USR2', &blk)
+      Signal.trap("USR2", &blk)
     end
 
-    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
+    private_class_method :handle_command_socket
 
     def self.socket_from_filesystem(cmd_name)
       ppid = Process.ppid
       socket_path_file = Einhorn::Command::Interface.socket_path_file(ppid)
       File.read(socket_path_file)
     end
+    private_class_method :socket_from_filesystem
   end
 end

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