einhorn 0.8.2 → 1.0.0

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,4 +1,4 @@
-require 'set'
+require "set"
 
 module Einhorn
   module Event
@@ -37,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)
@@ -81,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
@@ -118,7 +118,7 @@ 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
         @@default_timeout
@@ -130,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
@@ -143,25 +143,25 @@ 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
@@ -177,11 +177,11 @@ module Einhorn
   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

@@ -13,9 +13,9 @@ module Einhorn
     # Deliberately empty; NotImplementedError is intended
   end
 
-  if RUBY_PLATFORM =~ /linux/ then
+  if RUBY_PLATFORM.match?(/linux/)
     begin
-      require 'einhorn/prctl_linux'
+      require "einhorn/prctl_linux"
       Prctl = PrctlLinux
     rescue LoadError
       Prctl = PrctlUnimplemented

data/lib/einhorn/prctl_linux.rb

@@ -1,11 +1,11 @@
-require 'fiddle'
-require 'fiddle/import'
+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)'
+    extern "int prctl(int, unsigned long, unsigned long, unsigned long, unsigned long)"
 
     # From linux/prctl.h
     SET_PDEATHSIG = 1
@@ -14,34 +14,33 @@ module Einhorn
 
   class PrctlLinux < PrctlAbstract
     # Reading integers is hard with fiddle. :(
-    IntStruct = Fiddle::CStructBuilder.create(Fiddle::CStruct, [Fiddle::TYPE_INT], ['i'])
+    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
+      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 then
+      if signo == 0
         return nil
       end
 
-      return Signal.signame(signo)
+      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)
+      signo = if signal.nil?
+        0
+      elsif signal.instance_of?(String)
+        Signal.list.fetch(signal)
       else
-        signo = signal
+        signal
       end
 
-      if PrctlRaw.prctl(PrctlRaw::SET_PDEATHSIG, signo, 0, 0, 0) != 0 then
+      if PrctlRaw.prctl(PrctlRaw::SET_PDEATHSIG, signo, 0, 0, 0) != 0
         raise SystemCallError.new("set_pdeathsig(#{signal})", Fiddle.last_error)
       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.8.2'
+  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,9 +61,9 @@ 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)
+    def self.ack!(discovery = :env, arg = nil)
       handle_command_socket(discovery, arg) do |client|
-        client.send_command('command' => 'worker:ack', 'pid' => $$)
+        client.send_command("command" => "worker:ack", "pid" => $$)
       end
     end
 
@@ -84,21 +80,21 @@ module Einhorn
     #                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)
+    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)
+        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
 
@@ -106,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
 
@@ -114,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)
@@ -129,21 +125,19 @@ 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']
+        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']
+        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)
@@ -160,11 +154,13 @@ module Einhorn
 
       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