worker_killer 1.0.4.189871 → 1.0.5.213977

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1481f9bea1f77d274c4155a94bd83c6527ab72eb53fe6958b8036985d714720c
-  data.tar.gz: 155090caa35e210c9e130f395b00d4b83eab0ec7dcc3aba1a4419e783410c442
+  metadata.gz: 2ac9af870733f50ff006c5a31d9c3030342d76ff3208b8e4193a2407ad8f264c
+  data.tar.gz: c222a1cada623f95f8668e61d15e4f32fa986fdf799572e1937365919bc651d4
 SHA512:
-  metadata.gz: 3b3d7dbef3dc17f218341dace5fca0a1f4c92263ef104b1c1d7f9d1a5f659650e21578f00844f55cd073228117b17744cb5526c388936e90a862e215d9c9f497
-  data.tar.gz: 7cd8957b9e57ee14f6ae13ff03dbec12369fc45e82f97d4f93b3f378606460254110c37209f7afb53cd2d053a81ccc2a021089386e15dd83bee7a174783e0683
+  metadata.gz: 88918e5de623c64691e96fbfc4f34b6eb19669e3f370be011eed996ef6e9a13aee61997b66adfae929e39cb685396557c3802d9a00dcb0ebef0d54e5cf1193fb
+  data.tar.gz: bdb4e2fafb1da70554c3b73284538695bfd918b1b516a9a24f477b02056d721b69745f4ecfe6bfde044fb90815fa55f7178c08c33d9cfd283420754d0175ee69

data/README.md

@@ -17,6 +17,7 @@ Features:
 
 - generic middleware implementation
 - Phusion Passenger support(through `passenger-config detach-process <PID>`)
+- Puma phased-restart support(through `pumactl phased-restart`)
 - DelayedJob support
 - custom reaction hook
 
@@ -42,14 +43,14 @@ Add these lines to your `config.ru` or `application.rb`. (These lines should be
 
   # Max requests per worker
   middleware.insert_before(
-    Rack::Sendfile,
+    Rack::Runtime,
     WorkerKiller::Middleware::RequestsLimiter, killer: killer, min: 3072, max: 4096
   )
 
   # Max memory size (RSS) per worker
   middleware.insert_before(
-    Rack::Sendfile,
-    WorkerKiller::Middleware::OOMLimiter, killer: killer, min: 500 * (1024**2), max: 600 * (1024**2)
+    Rack::Runtime,
+    WorkerKiller::Middleware::OOMLimiter, killer: killer, min: nil, max: 0.5, check_cycle: 16
   )
 ```
 
@@ -74,6 +75,39 @@ Add these lines to your `initializers/delayed_job.rb` or `application.rb`.
   end
 ```
 
+## Puma Web-server
+
+Add these lines to your `puma.rb` AND `application.rb`.
+
+```ruby
+  # puma.rb
+
+  on_worker_boot do |*args|
+    require 'worker_killer/killer'
+    require 'active_support/notifications'
+
+    ::ActiveSupport::Notifications.subscribe 'initialize.custom.rails' do |*eargs|
+      event = ActiveSupport::Notifications::Event.new(*eargs)
+      config = event.payload[:config]
+
+      killer = ::WorkerKiller::Killer::Puma.new
+      config.middleware.insert_before(
+        ::Rack::Runtime,
+        ::WorkerKiller::Middleware::RequestsLimiter, killer: killer, min: 3072, max: 4096
+      )
+
+      config.middleware.insert_before(
+        ::Rack::Runtime,
+        ::WorkerKiller::Middleware::OOMLimiter, killer: killer, min: nil, max: 0.5, verbose: true, check_cycle: 16
+      )
+    end
+  end
+
+  # application.rb
+
+  ActiveSupport::Notifications.instrument 'initialize.custom.rails', config: config
+```
+
 This gem provides two modules: WorkerKiller::CountLimiter and WorkerKiller::MemoryLimiter, some Rack integration and DelayedJob plugin.
 
 ### WorkerKiller::Middleware::RequestsLimiter and WorkerKiller::DelayedJobPlugin::JobsLimiter

data/lib/worker_killer/killer/puma.rb

@@ -0,0 +1,62 @@
+require 'socket'
+
+module ::WorkerKiller
+  module Killer
+    class Puma < ::WorkerKiller::Killer::Base
+
+      attr_accessor :type, :plugin_path, :num
+
+      def initialize(type: :phased, path: nil, num: nil, **kwargs)
+        super(**kwargs)
+        @type = type
+        @plugin_path = path
+        @num = num
+      end
+
+      def do_kill(sig, pid, alive_sec, **params)
+        if @type == :phased
+          do_phased_kill(sig, pid, alive_sec, **params)
+        elsif @type == :plugin
+          do_plugin_kill(sig, pid, alive_sec, **params)
+        end
+      end
+
+      def do_phased_kill(sig, pid, alive_sec, **_params)
+        cmd = 'pumactl phased-restart'
+
+        if sig == :KILL
+          logger.error "#{self} force to kill self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+          Process.kill sig, pid
+          return
+        end
+
+        return if @already_detached
+
+        logger.warn "#{self} run #{cmd.inspect} (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+        @already_detached = true
+
+        Thread.new(cmd) do |command|
+          unless Kernel.system(command)
+            logger.warn "#{self} run #{command.inspect} failed: #{$?.inspect}"
+          end
+        end
+      end
+
+      def do_plugin_kill(sig, pid, alive_sec, **_params)
+        if sig == :KILL
+          logger.error "#{self} force to kill self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+          Process.kill sig, pid
+          return
+        end
+
+        logger.warn "#{self} send #{num} to Puma Plugin (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+
+        Socket.unix(plugin_path) do |sock|
+          sock.puts num.to_s
+        end
+      end
+
+    end
+  end
+end
+

data/lib/worker_killer/killer.rb

@@ -38,5 +38,6 @@ end
 
 require_relative 'killer/signal'
 require_relative 'killer/passenger'
+require_relative 'killer/puma'
 require_relative 'killer/delayed_job'
 

data/lib/worker_killer/puma/plugin/worker_killer.rb

@@ -0,0 +1,104 @@
+require 'socket'
+require 'puma/plugin'
+require 'active_support/notifications'
+
+require 'worker_killer/killer'
+
+
+
+
+module WorkerKiller
+  module Puma
+    module Plugin
+      # Puma requires such plugin name and path :(
+      class WorkerKiller
+
+        def initialize(launcher, path)
+          @runner = launcher.instance_variable_get('@runner')
+
+          @thread = Thread.new do
+            Socket.unix_server_loop(path) do |sock, _client_addrinfo|
+              if (line = sock.gets)
+                worker_num = Integer(line.strip)
+                if (worker = find_worker(worker_num))
+                  log "Killing worker #{worker_num}"
+                  worker.term!
+                end
+              end
+            rescue StandardError => e
+              log("Exception: #{e.inspect}")
+            ensure
+              sock.close
+            end
+          end
+        end
+
+        def find_worker(worker_num)
+          worker = @runner.worker_at(worker_num)
+          unless worker
+            log "Unknown worker index: #{worker_num.inspect}. Skipping."
+            return nil
+          end
+
+          unless worker.booted?
+            log "Worker #{worker_num.inspect} is not booted yet. Skipping."
+            return nil
+          end
+
+          if worker.term?
+            log "Worker #{worker_num.inspect} already terminating. Skipping."
+            return nil
+          end
+
+          worker
+        end
+
+        def log(msg)
+          warn("#{self.class}: #{msg}")
+        end
+
+      end
+    end
+  end
+end
+
+Puma::Plugin.create do
+  attr_reader :path
+
+  def config(c)
+    c.on_worker_boot do |num|
+
+      if @killer
+        puts "ON OTHER WORKER BOOT: #{num}"
+        @killer.num = num
+      else
+        puts "ON MAIN WORKER BOOT: #{num}"
+        ::ActiveSupport::Notifications.subscribe 'worker_killer.initialize' do |*eargs|
+          @killer = ::WorkerKiller::Killer::Puma.new(num: num, path: path, type: :plugin)
+          puts "ON WORKER BOOT INIT:#{num}"
+          event = ActiveSupport::Notifications::Event.new(*eargs)
+          config = event.payload[:config]
+
+          @register_killer&.call(self, config, @killer)
+        end
+      end
+    end
+  end
+
+  def start(launcher)
+    @path = File.join('tmp', "puma_worker_killer_#{Process.pid}.socket")
+
+    launcher.events.on_booted do
+      @controller ||= WorkerKiller::Puma::Plugin::WorkerKiller.new(launcher, path)
+    end
+  end
+
+  def configure(&block)
+    self.instance_eval(&block)
+  end
+
+  def register_killer(&block)
+    @register_killer = block
+  end
+end
+

data/lib/worker_killer/puma_plugin.rb

@@ -0,0 +1,58 @@
+require 'worker_killer/memory_limiter'
+require 'worker_killer/count_limiter'
+require 'puma/plugin'
+
+Puma::Plugin.create do
+
+module WorkerKiller
+  class PumaPlugin
+
+    attr_reader :limiter, :killer, :reaction
+
+    def initialize(klass:, killer:, reaction: nil, **opts)
+      @killer = killer
+
+      @reaction = reaction || proc do |l, k, dj|
+        k.kill(l.started_at, dj: dj)
+      end
+
+      @limiter = klass.new(**opts)
+      @time_to_burn = false
+    end
+
+    def new(lifecycle = Delayed::Worker.lifecycle, *_args)
+      configure_lifecycle(lifecycle)
+    end
+
+    def configure_lifecycle(lifecycle)
+      # Count condition after every job
+      lifecycle.after(:perform) do |worker, *_args|
+        @time_to_burn ||= limiter.check
+      end
+      
+      # Stop execution only after whole loop completed
+      lifecycle.after(:loop) do |worker, *_args|
+        @time_to_burn ||= limiter.check
+        reaction.call(limiter, killer, worker) if @time_to_burn
+      end
+    end
+
+    class JobsLimiter < ::WorkerKiller::PumaPlugin
+
+      def initialize(**opts)
+        super(klass: ::WorkerKiller::CountLimiter, **opts)
+      end
+
+    end
+
+    class OOMLimiter < ::WorkerKiller::PumaPlugin
+
+      def initialize(**opts)
+        super(klass: ::WorkerKiller::MemoryLimiter, **opts)
+      end
+
+    end
+
+  end
+end
+

data/lib/worker_killer/version.rb

@@ -2,7 +2,7 @@
 
 module WorkerKiller
 
-  VERSION = '1.0.4'
+  VERSION = '1.0.5'
 
 end
 

data/spec/killer/puma_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe WorkerKiller::Killer::Puma do
+  let(:config) do
+    WorkerKiller::Configuration.new.tap do |c|
+      c.quit_attempts = 2
+      c.term_attempts = 2
+    end
+  end
+
+  let(:killer){ described_class.new }
+
+  describe '#kill' do
+    around do |example|
+      prev = WorkerKiller.configuration
+      WorkerKiller.configuration = config
+      example.run
+    ensure
+      WorkerKiller.configuration = prev
+    end
+
+    it 'expect right signal order' do
+      expect(Kernel).to receive(:system).with('pumactl phased-restart').and_return(true)
+      expect(Process).to receive(:kill).with(:KILL, anything).exactly(5).times
+
+      thread = killer.kill(Time.now)
+      thread.join
+
+      1.times { killer.kill(Time.now) } # 1 QUIT
+      2.times { killer.kill(Time.now) } # 1 TERM
+      5.times { killer.kill(Time.now) } # 5 KILL
+    end
+  end
+end
+

data/spec/killer_spec.rb

@@ -19,7 +19,7 @@ RSpec.describe WorkerKiller::Killer::Base do
       end
 
       it 'expect right signal order' do
-        if RUBY_VERSION >= "3.0.0"
+        if RUBY_VERSION >= "2.7.0"
           expect(killer).to receive(:do_kill).with(:QUIT, anything, anything).exactly(2).times
           expect(killer).to receive(:do_kill).with(:TERM, anything, anything).exactly(2).times
           expect(killer).to receive(:do_kill).with(:KILL, anything, anything).exactly(5).times

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_killer
 version: !ruby/object:Gem::Version
-  version: 1.0.4.189871
+  version: 1.0.5.213977
 platform: ruby
 authors:
 - Samoilenko Yuri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-05 00:00:00.000000000 Z
+date: 2024-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem
@@ -131,15 +131,19 @@ files:
 - lib/worker_killer/killer.rb
 - lib/worker_killer/killer/delayed_job.rb
 - lib/worker_killer/killer/passenger.rb
+- lib/worker_killer/killer/puma.rb
 - lib/worker_killer/killer/signal.rb
 - lib/worker_killer/memory_limiter.rb
 - lib/worker_killer/middleware.rb
+- lib/worker_killer/puma/plugin/worker_killer.rb
+- lib/worker_killer/puma_plugin.rb
 - lib/worker_killer/version.rb
 - spec/count_limiter_spec.rb
 - spec/delayed_job_plugin/jobs_limiter_spec.rb
 - spec/delayed_job_plugin/oom_limiter_spec.rb
 - spec/killer/delayed_job_spec.rb
 - spec/killer/passenger_spec.rb
+- spec/killer/puma_spec.rb
 - spec/killer/signal_spec.rb
 - spec/killer_spec.rb
 - spec/memory_limiter_spec.rb
@@ -177,6 +181,7 @@ test_files:
 - spec/delayed_job_plugin/oom_limiter_spec.rb
 - spec/delayed_job_plugin/jobs_limiter_spec.rb
 - spec/killer/passenger_spec.rb
+- spec/killer/puma_spec.rb
 - spec/killer/signal_spec.rb
 - spec/killer/delayed_job_spec.rb
 - spec/memory_limiter_spec.rb