worker_killer 0.1.1.30345 → 0.1.1.39838

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6559ab7080c973e8a1410b166af0c1385054f5c8aa06af967525808c8319fe1
-  data.tar.gz: f163be90a2c2de875e85b8c4db2c543d28495a6a8a38cff2a093cac0d9a3b13a
+  metadata.gz: 92604c2f0b3b1fbd27a647f8c72556abbd2c6a38d3e57a120697118db1921b44
+  data.tar.gz: e22fb98b3d5dd0781e79eaba94213e7cca03c728f0f64ab0fe391b4f536de850
 SHA512:
-  metadata.gz: 851c5269665b10c65ee6838dbf4033f100a026c907b7d7fb72080df341851d3d8227eb192eecaa9b1417226ca9a3349dbd7e1ca54a45feea850f9fc932926990
-  data.tar.gz: b5fd359caeddabdea93b5beaff3fcf8887ef467cbda2732a141082c9c4244573329137fac8273e7565e6cbeee2562fa4b0b8496fdf64ab53d84d4a97f688d825
+  metadata.gz: acabb632791e185856f983c44b3f7ae151e5798508e846c669b8699ec6bf06bd435c6a4a9fe551e94033e5a577ab252a8a3aaaffb09733ee52a27422faf0de0a
+  data.tar.gz: 253ae056f4b4d107458a85a897c3ad16a6ec532282bf7e9781fed06cfde943f177b23c6c3f96c3c513fe6f4a01ed92604c84eaca31bc64dca05ccfe2ba9c902e

data/lib/worker_killer.rb

@@ -3,6 +3,7 @@ require 'worker_killer/configuration'
 require 'worker_killer/count_limiter'
 require 'worker_killer/memory_limiter'
 require 'worker_killer/middleware'
+require 'worker_killer/killer'
 
 module WorkerKiller
 
@@ -27,45 +28,45 @@ module WorkerKiller
   # the process isn't killed after `configuration.quit_attempts` QUIT signals,
   # send TERM signals until `configuration.kill_attempts`. Finally, send a KILL
   # signal. A single signal is sent per request.
-  def self.kill_self(logger, start_time)
-    alive_sec = (Time.now - start_time).round
-
-    @kill_attempts ||= 0
-    @kill_attempts += 1
-
-    if configuration.use_quit
-      sig = :QUIT
-      sig = :TERM if @kill_attempts > configuration.quit_attempts
-      sig = :KILL if @kill_attempts > (configuration.quit_attempts + configuration.kill_attempts)
-    else
-      sig = :TERM
-      sig = :KILL if @kill_attempts > configuration.kill_attempts
-    end
-
-    if sig == :QUIT && configuration.passenger?
-      kill_by_passenger(logger, alive_sec, configuration.passenger_config, Process.pid)
-    else
-      kill_by_signal(logger, alive_sec, sig, Process.pid)
-    end
-  end
-
-  def self.kill_by_signal(logger, alive_sec, signal, pid)
-    logger.warn "#{self} send SIG#{signal} (pid: #{pid}) alive: #{alive_sec} sec (trial #{@kill_attempts})"
-    Process.kill signal, pid
-  end
-
-  def self.kill_by_passenger(logger, alive_sec, passenger, pid)
-    return if @already_detached
-    @already_detached = true
-
-    cmd = "#{passenger} detach-process #{pid}"
-    logger.warn "#{self} run #{cmd.inspect} (pid: #{pid}) alive: #{alive_sec} sec (trial #{@kill_attempts})"
-    Thread.new(cmd) do |command|
-      unless Kernel.system(command)
-        logger.warn "#{self} run #{cmd.inspect} failed: #{$?.inspect}"
-      end
-    end
-  end
+  # def self.kill_self(logger, start_time)
+  #   alive_sec = (Time.now - start_time).round
+
+  #   @kill_attempts ||= 0
+  #   @kill_attempts += 1
+
+  #   if configuration.use_quit
+  #     sig = :QUIT
+  #     sig = :TERM if @kill_attempts > configuration.quit_attempts
+  #     sig = :KILL if @kill_attempts > (configuration.quit_attempts + configuration.term_attempts)
+  #   else
+  #     sig = :TERM
+  #     sig = :KILL if @kill_attempts > configuration.term_attempts
+  #   end
+
+  #   if sig == :QUIT && configuration.passenger?
+  #     kill_by_passenger(logger, alive_sec, configuration.passenger_config, Process.pid)
+  #   else
+  #     kill_by_signal(logger, alive_sec, sig, Process.pid)
+  #   end
+  # end
+
+  # def self.kill_by_signal(logger, alive_sec, signal, pid)
+  #   logger.warn "#{self} send SIG#{signal} (pid: #{pid}) alive: #{alive_sec} sec (trial #{@kill_attempts})"
+  #   Process.kill signal, pid
+  # end
+
+  # def self.kill_by_passenger(logger, alive_sec, passenger, pid)
+  #   return if @already_detached
+  #   @already_detached = true
+
+  #   cmd = "#{passenger} detach-process #{pid}"
+  #   logger.warn "#{self} run #{cmd.inspect} (pid: #{pid}) alive: #{alive_sec} sec (trial #{@kill_attempts})"
+  #   Thread.new(cmd) do |command|
+  #     unless Kernel.system(command)
+  #       logger.warn "#{self} run #{cmd.inspect} failed: #{$?.inspect}"
+  #     end
+  #   end
+  # end
 
 end
 

data/lib/worker_killer/configuration.rb

@@ -4,47 +4,15 @@ module WorkerKiller
   # Methods for configuring WorkerKiller
   class Configuration
 
-    attr_accessor :logger, :quit_attempts, :kill_attempts, :use_quit, :passenger_config
+    attr_accessor :logger, :quit_attempts, :term_attempts
 
     # Override defaults for configuration
-    def initialize(quit_attempts: 5, kill_attempts: 10, use_quit: true, passenger_config: nil)
+    def initialize(quit_attempts: 10, term_attempts: 50)
       @quit_attempts = quit_attempts
-      @kill_attempts = kill_attempts
-      @use_quit = use_quit
-      @passenger_config = check_passenger(passenger_config)
+      @term_attempts = term_attempts
       @logger = Logger.new(STDOUT, level: Logger::INFO, progname: 'WorkerKiller')
     end
 
-    def passenger?
-      !@passenger_config.nil?
-    end
-
-    def check_passenger provided_path
-      if provided_path.nil? || provided_path.empty?
-        return check_passenger_config(`which passenger-config`)
-      else
-        return check_passenger_config!(provided_path)
-      end
-    end
-
-    def check_passenger_config path
-      path.strip!
-      help = `#{path} detach-process --help 2> /dev/null`
-      if help['Remove an application process from the Phusion Passenger process pool']
-        return path
-      end
-    rescue StandardError => e
-      return nil
-    end
-
-    def check_passenger_config! path
-      if path = check_passenger_config(path)
-        return path
-      else
-        raise "Can't find passenger config at #{path.inspect}"
-      end
-    end
-
   end
 end
 

data/lib/worker_killer/count_limiter.rb

@@ -2,15 +2,13 @@ module WorkerKiller
   class CountLimiter
 
     attr_reader :min, :max, :left, :limit, :started_at
-    attr_accessor :reaction
 
-    def initialize(min: 3072, max: 4096, verbose: false, &block)
+    def initialize(min: 3072, max: 4096, verbose: false)
       @min = min
       @max = max
       @limit = @min + WorkerKiller.randomize(@max - @min + 1)
       @left = @limit
       @verbose = verbose
-      @reaction = block
     end
 
     def check
@@ -25,7 +23,6 @@ module WorkerKiller
       return false if (@left -= 1) > 0
 
       logger.warn "#{self}: worker (pid: #{Process.pid}) exceeds max number of requests (limit: #{@limit})"
-      @reaction.call(self)
 
       true
     end

data/lib/worker_killer/delayed_job_plugin.rb

@@ -0,0 +1,31 @@
+require 'worker_killer/memory_limiter'
+require 'worker_killer/count_limiter'
+
+module WorkerKiller
+  class DelayedJobPlugin
+
+    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)
+    end
+
+    def new(*_args)
+      configure_lifecycle(Delayed::Worker.lifecycle)
+    end
+
+    def configure_lifecycle(lifecycle)
+      lifecycle.after(:perform) do |worker, *_args|
+        reaction.call(limiter, killer, worker) if limiter.check
+      end
+    end
+
+  end
+end
+

data/lib/worker_killer/killer.rb

@@ -0,0 +1,38 @@
+module WorkerKiller
+  module Killer
+    class Base
+
+      attr_accessor :config, :kill_attempts, :logger
+
+      def initialize(logger: WorkerKiller.configuration.logger, **_kwargs)
+        @logger = logger
+        @config = WorkerKiller.configuration
+        @kill_attempts = 0
+      end
+
+      def kill(start_time, **params)
+        alive_sec = (Time.now - start_time).round
+
+        @kill_attempts += 1
+
+        sig = :QUIT
+        sig = :TERM if kill_attempts > config.quit_attempts
+        sig = :KILL if kill_attempts > (config.quit_attempts + config.term_attempts)
+
+        do_kill(sig, Process.pid, alive_sec, **params)
+      end
+
+      # :nocov:
+      def do_kill(*_args)
+        raise 'Not Implemented'
+      end
+      # :nocov:
+
+    end
+  end
+end
+
+require_relative 'killer/signal'
+require_relative 'killer/passenger'
+require_relative 'killer/delayed_job'
+

data/lib/worker_killer/killer/delayed_job.rb

@@ -0,0 +1,27 @@
+module WorkerKiller
+  module Killer
+    class DelayedJob < ::WorkerKiller::Killer::Base
+
+      def do_kill(sig, pid, alive_sec, dj:, **_params)
+        if sig == :KILL
+          logger.error "#{self} force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+          Process.kill sig, pid
+          return
+        end
+
+        dj.stop
+
+        return if sig != :TERM
+
+        if @termination
+          logger.warn "#{self} force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+          Process.kill sig, pid
+        else
+          @termination = true
+        end
+      end
+
+    end
+  end
+end
+

data/lib/worker_killer/killer/passenger.rb

@@ -0,0 +1,55 @@
+module WorkerKiller
+  module Killer
+    class Passenger < ::WorkerKiller::Killer::Base
+
+      attr_reader :passenger_config
+
+      def initialize path: nil, **kwrags
+        super
+        @passenger_config = if path.nil? || path.empty?
+          self.class.check_passenger_config(`which passenger-config`)
+        else
+          self.class.check_passenger_config!(path)
+        end
+      end
+
+      def do_kill(sig, pid, alive_sec, **params)
+        cmd = "#{passenger_config} detach-process #{pid}"
+        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 self.check_passenger_config path
+        path.strip!
+        help = `#{path} detach-process --help 2> /dev/null`
+        return path if help['Remove an application process from the Phusion Passenger process pool']
+      rescue StandardError => e
+        nil
+      end
+
+      def self.check_passenger_config! path
+        if path = check_passenger_config(path)
+          path
+        else
+          raise "Can't find passenger config at #{path.inspect}"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/worker_killer/killer/signal.rb

@@ -0,0 +1,16 @@
+module WorkerKiller
+  module Killer
+    class Signal < ::WorkerKiller::Killer::Base
+
+      def do_kill(sig, pid, alive_sec, **params)
+        return if sig == @last_signal
+
+        @last_signal = sig
+        logger.warn "#{self} send SIG#{sig} (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+        Process.kill sig, pid
+      end
+
+    end
+  end
+end
+

data/lib/worker_killer/memory_limiter.rb

@@ -4,16 +4,14 @@ module WorkerKiller
   class MemoryLimiter
 
     attr_reader :min, :max, :limit, :started_at, :check_cycle
-    attr_accessor :reaction
 
-    def initialize(min: (1024**3), max: (2 * (1024**3)), check_cycle: 16, verbose: false, &block)
+    def initialize(min: (1024**3), max: (2 * (1024**3)), check_cycle: 16, verbose: false)
       @min = min
       @max = max
       @limit = @min + WorkerKiller.randomize(@max - @min + 1)
       @check_cycle = check_cycle
       @check_count = 0
       @verbose = verbose
-      @reaction = block
     end
 
     def check
@@ -33,7 +31,6 @@ module WorkerKiller
       return false if rss <= @limit
 
       logger.warn "#{self}: worker (pid: #{Process.pid}) exceeds memory limit (#{rss} bytes > #{@limit} bytes)"
-      @reaction.call(self)
 
       true
     end

data/lib/worker_killer/middleware.rb

@@ -4,23 +4,22 @@ require 'worker_killer/count_limiter'
 module WorkerKiller
   class Middleware
 
-    attr_reader :limiter
+    attr_reader :limiter, :killer, :reaction
 
-    def initialize(app, klass:, reaction: nil, **opts)
+    def initialize(app, killer:, klass:, reaction: nil, **opts)
       @app = app
+      @killer = killer
 
-      @passenger = system('which passenger')
-
-      reaction ||= proc do |limiter|
-        WorkerKiller.kill_self(limiter.logger, limiter.started_at)
+      @reaction = reaction || proc do |l, k|
+        k.kill(l.started_at)
       end
 
-      @limiter = klass.new(opts, &reaction)
+      @limiter = klass.new(opts)
     end
 
     def call(env)
       response = @app.call(env)
-      @limiter.check
+      reaction.call(limiter, killer) if limiter.check
       response
     end
 

data/spec/count_limiter_spec.rb

@@ -1,20 +1,15 @@
 RSpec.describe WorkerKiller::CountLimiter do
-  let(:logger){ Logger.new(nil) }
-
   subject{ described_class.new(options) }
   let(:min){ rand(50..100) }
   let(:max){ min + rand(100) }
-  let(:options){ { min: min, max: max } }
+  let(:options){ { min: min, max: max, verbose: true } }
 
   it { is_expected.to have_attributes(min: min, max: max, limit: a_value_between(min, max), left: subject.limit) }
 
   it 'expect not to react while less than limit' do
-    expect do |b|
-      subject.reaction = b.to_proc
-      (subject.limit - 1).times do
-        expect(subject.check).to be_falsey
-      end
-    end.not_to yield_control
+    (subject.limit - 1).times do
+      expect(subject.check).to be_falsey
+    end
   end
 
   it 'expect call reaction when check succeded' do
@@ -22,11 +17,8 @@ RSpec.describe WorkerKiller::CountLimiter do
       expect(subject.check).to be_falsey
     end
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      expect(subject.check).to be_truthy
-      expect(subject.check).to be_truthy
-    end.to yield_control.exactly(2).times
+    expect(subject.check).to be_truthy
+    expect(subject.check).to be_truthy
   end
 end
 

data/spec/killer/delayed_job_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe WorkerKiller::Killer::DelayedJob 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() }
+  let(:dj){ double }
+
+  describe '#kill' do
+    context 'with use_quit TRUE' do
+      around do |example|
+        prev = WorkerKiller.configuration
+        WorkerKiller.configuration = config
+        example.run
+      ensure
+        WorkerKiller.configuration = prev
+      end
+
+      it 'expect right signal order' do
+        expect(dj).to receive(:stop).exactly(4)
+        expect(Process).to receive(:kill).with(:TERM, anything).exactly(1).times
+        expect(Process).to receive(:kill).with(:KILL, anything).exactly(5).times
+
+        2.times { killer.kill(Time.now, dj: dj) } # 1 QUIT
+        2.times { killer.kill(Time.now, dj: dj) } # 1 TERM
+        5.times { killer.kill(Time.now, dj: dj) } # 5 KILL
+      end
+    end
+  end
+end
+

data/spec/killer/passenger_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe WorkerKiller::Killer::Passenger 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
+    before do
+      allow(described_class).to receive(:check_passenger_config).and_return('custompath')
+    end
+
+    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("custompath detach-process #{Process.pid}").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
+
+  describe '#check_passenger_config!' do
+    it do
+      expect{ described_class.check_passenger_config!('nonenone') }.to raise_error(/Can't find passenger/)
+    end
+  end
+end
+

data/spec/killer/signal_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe WorkerKiller::Killer::Signal 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
+    context 'with use_quit TRUE' do
+      around do |example|
+        prev = WorkerKiller.configuration
+        WorkerKiller.configuration = config
+        example.run
+      ensure
+        WorkerKiller.configuration = prev
+      end
+
+      it 'expect right signal order' do
+        expect(Process).to receive(:kill).with(:QUIT, anything).exactly(1).times
+        expect(Process).to receive(:kill).with(:TERM, anything).exactly(1).times
+        expect(Process).to receive(:kill).with(:KILL, anything).exactly(1).times
+
+        2.times { killer.kill(Time.now) } # 1 QUIT
+        2.times { killer.kill(Time.now) } # 1 TERM
+        5.times { killer.kill(Time.now) } # 1 KILL
+      end
+    end
+  end
+end
+

data/spec/killer_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe WorkerKiller::Killer::Base 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
+    context 'with use_quit TRUE' do
+      around do |example|
+        prev = WorkerKiller.configuration
+        WorkerKiller.configuration = config
+        example.run
+      ensure
+        WorkerKiller.configuration = prev
+      end
+
+      it 'expect right signal order' do
+        expect(killer).to receive(:do_kill).with(:QUIT, anything, anything, anything).exactly(2).times
+        expect(killer).to receive(:do_kill).with(:TERM, anything, anything, anything).exactly(2).times
+        expect(killer).to receive(:do_kill).with(:KILL, anything, anything, anything).exactly(5).times
+
+        2.times { killer.kill(Time.now) } # 2 QUIT
+        2.times { killer.kill(Time.now) } # 2 TERM
+        5.times { killer.kill(Time.now) } # other - KILL
+      end
+    end
+
+  end
+end
+

data/spec/memory_limiter_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe WorkerKiller::MemoryLimiter do
   let(:min){ rand(50..100) * mb }
   let(:max){ min + rand(100) * mb }
   let(:check_cycle){ 5 }
-  let(:options){ { min: min, max: max, check_cycle: check_cycle } }
+  let(:options){ { min: min, max: max, check_cycle: check_cycle, verbose: true} }
 
   it { is_expected.to have_attributes(min: min, max: max, limit: a_value_between(min, max)) }
 
@@ -19,10 +19,7 @@ RSpec.describe WorkerKiller::MemoryLimiter do
   it 'expect to skip check while less than cycle count' do
     expect(GetProcessMem).not_to receive(:new)
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      skip_cycles(subject, check_cycle)
-    end.not_to yield_control
+    skip_cycles(subject, check_cycle)
   end
 
   it 'expect to skip check after cycle count reached' do
@@ -30,11 +27,8 @@ RSpec.describe WorkerKiller::MemoryLimiter do
     expect(memory).to receive(:bytes).and_return(min - 1)
     expect(GetProcessMem).to receive(:new).and_return(memory)
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      skip_cycles(subject, check_cycle)
-      expect(subject.check).to be_falsey
-    end.not_to yield_control
+    skip_cycles(subject, check_cycle)
+    expect(subject.check).to be_falsey
   end
 
   it 'expect call reaction when check succeded' do
@@ -42,11 +36,8 @@ RSpec.describe WorkerKiller::MemoryLimiter do
     expect(memory).to receive(:bytes).and_return(subject.limit + 1)
     expect(GetProcessMem).to receive(:new).and_return(memory)
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      skip_cycles(subject, check_cycle)
-      expect(subject.check).to be_truthy
-    end.to yield_control.exactly(1).times
+    skip_cycles(subject, check_cycle)
+    expect(subject.check).to be_truthy
   end
 end
 

data/spec/middleware_spec.rb

@@ -1,44 +1,79 @@
 require 'securerandom'
 
 RSpec.describe WorkerKiller::Middleware do
-  let(:logger){ Logger.new(nil) }
-
-  let(:app){ double }
-  let(:reaction){ ->{} }
+  let(:app){ double(call: {}) }
+  let(:killer) { double }
+  let(:reaction){ double }
   let(:anykey){ SecureRandom.hex(8) }
 
   describe 'Custom class' do
     let(:klass){ double }
-    let(:options){ { klass: klass, reaction: reaction, anykey: anykey } }
+    let(:options){ { killer: killer, klass: klass, reaction: reaction, anykey: anykey } }
     subject{ described_class.new(app, options) }
 
     it 'is expected to be initialized' do
       expect(klass).to receive(:new).with(anykey: anykey).and_return(99)
       expect(subject.limiter).to eq(99)
+      expect(subject.killer).to eq(killer)
     end
   end
 
   describe WorkerKiller::Middleware::RequestsLimiter do
-    let(:options){ { reaction: reaction, min: 1111 } }
+    let(:options){ { killer: killer, min: 3, max: 3 } }
     subject{ described_class.new(app, options) }
 
+    it 'is expected to be initialized without reaction' do
+      expect(WorkerKiller::CountLimiter).to receive(:new).with(min: 3, max: 3).and_call_original
+      expect(subject.limiter).to be_an(WorkerKiller::CountLimiter)
+      expect(subject.limiter.min).to eq(3)
+      expect(subject.limiter.max).to eq(3)
+      expect(killer).to receive(:kill).with(Time).twice
+
+      4.times do
+        subject.call({})
+      end
+    end
+
     it 'is expected to be initialized with reaction' do
-      expect(WorkerKiller::CountLimiter).to receive(:new).with(min: 1111).and_call_original
+      options[:reaction] = reaction
+
+      expect(WorkerKiller::CountLimiter).to receive(:new).with(min: 3, max: 3).and_call_original
       expect(subject.limiter).to be_an(WorkerKiller::CountLimiter)
-      expect(subject.limiter.min).to eq(1111)
-      expect(subject.limiter.reaction).to eq(reaction)
+      expect(subject.limiter.min).to eq(3)
+      expect(subject.limiter.max).to eq(3)
+      expect(reaction).to receive(:call).with(subject.limiter, killer).twice
+
+      4.times do
+        subject.call({})
+      end
     end
   end
 
   describe WorkerKiller::Middleware::OOMLimiter do
-    let(:options){ { reaction: reaction, min: 2222 } }
+    let(:options){ { killer: killer, min: 2222, max: 2223 } }
     subject{ described_class.new(app, options) }
 
+    it 'is expected to be initialized without reaction' do
+      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222, max: 2223).and_call_original
+      expect(subject.limiter).to be_an(WorkerKiller::MemoryLimiter)
+      expect(subject.limiter.min).to eq(2222)
+      expect(subject.limiter.max).to eq(2223)
+      expect(killer).to receive(:kill).with(subject.limiter.started_at).once
+      expect(subject.limiter).to receive(:check).and_return(true)
+
+      subject.call({})
+    end
+
     it 'is expected to be initialized with reaction' do
-      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222).and_call_original
+      options[:reaction] = reaction
+      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222, max: 2223).and_call_original
       expect(subject.limiter).to be_an(WorkerKiller::MemoryLimiter)
       expect(subject.limiter.min).to eq(2222)
-      expect(subject.limiter.reaction).to eq(reaction)
+      expect(subject.limiter.max).to eq(2223)
+      expect(reaction).to receive(:call).with(subject.limiter, killer)
+      expect(subject.limiter).to receive(:check).and_return(true)
+
+      subject.call({})
     end
   end
 end

data/spec/spec_helper.rb

@@ -29,6 +29,7 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
 SimpleCov.start
 
 require 'worker_killer'
+require 'worker_killer/delayed_job_plugin'
 
 $root = File.join(File.dirname(__dir__), 'spec')
 Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each {|f| require f }

data/spec/support/logger.rb

@@ -0,0 +1,12 @@
+RSpec.configure do |config|
+  config.before(:suite) do
+    $logger = Logger.new(STDOUT).tap do |logger|
+      logger.progname = "WorkerKille"
+      logger.level = "ERROR"
+    end
+    WorkerKiller.configure do |cfg|
+      cfg.logger = $logger
+    end
+  end
+end
+

data/spec/worker_killer_spec.rb

@@ -1,15 +1,5 @@
 RSpec.describe WorkerKiller do
   let(:logger){ Logger.new(nil) }
-  let(:config) do
-    WorkerKiller::Configuration.new.tap do |c|
-      c.quit_attempts = 2
-      c.kill_attempts = 2
-    end
-  end
-
-  before do
-    WorkerKiller.instance_variable_set('@kill_attempts', nil)
-  end
 
   describe '#randomize' do
     [1, 5, 25, 125, 5000, 10_000].each do |max|
@@ -22,68 +12,5 @@ RSpec.describe WorkerKiller do
       end
     end
   end
-
-  describe '#kill_by_signal' do
-    [:QUIT, :TERM, :KILL].each do |sig|
-      it "must send #{sig} signal" do
-        pid = rand(1000)
-        expect(Process).to receive(:kill).with(sig, pid)
-        WorkerKiller.kill_by_signal(logger, 11111, sig, pid)
-      end
-    end
-  end
-
-  describe '#kill_by_passenger' do
-    it "must run passenger-config" do
-      pid = rand(1000)
-      path = "passenger-config-#{rand(1000)}"
-      expect(Kernel).to receive(:system).with("#{path} detach-process #{pid}").and_return(true)
-
-      thread = WorkerKiller.kill_by_passenger(logger, 11111, path, pid)
-      thread.join
-    end
-  end
-
-  describe '#kill_self' do
-    context 'with use_quit TRUE' do
-      around do |example|
-        prev = WorkerKiller.configuration
-        config.use_quit = true
-        WorkerKiller.configuration = config
-        example.run
-      ensure
-        WorkerKiller.configuration = prev
-      end
-
-      it 'expect right signal order' do
-        expect(WorkerKiller).to receive(:kill_by_signal).with(logger, anything, :QUIT, anything).exactly(2).times
-        expect(WorkerKiller).to receive(:kill_by_signal).with(logger, anything, :TERM, anything).exactly(2).times
-        expect(WorkerKiller).to receive(:kill_by_signal).with(logger, anything, :KILL, anything).exactly(5).times
-
-        2.times { WorkerKiller.kill_self(logger, Time.now) } # 2 QUIT
-        2.times { WorkerKiller.kill_self(logger, Time.now) } # 2 TERM
-        5.times { WorkerKiller.kill_self(logger, Time.now) } # other - KILL
-      end
-    end
-
-    context 'with use_quit FALSE' do
-      around do |example|
-        prev = WorkerKiller.configuration
-        config.use_quit = false
-        WorkerKiller.configuration = config
-        example.run
-      ensure
-        WorkerKiller.configuration = prev
-      end
-
-      it 'expect right signal order' do
-        expect(WorkerKiller).to receive(:kill_by_signal).with(logger, anything, :TERM, anything).exactly(2).times
-        expect(WorkerKiller).to receive(:kill_by_signal).with(logger, anything, :KILL, anything).exactly(5).times
-
-        2.times { WorkerKiller.kill_self(logger, Time.now) } # 2 TERM
-        5.times { WorkerKiller.kill_self(logger, Time.now) } # other - KILL
-      end
-    end
-  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_killer
 version: !ruby/object:Gem::Version
-  version: 0.1.1.30345
+  version: 0.1.1.39838
 platform: ruby
 authors:
 - Samoilenko Yuri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-20 00:00:00.000000000 Z
+date: 2020-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem
@@ -127,13 +127,23 @@ files:
 - lib/worker_killer.rb
 - lib/worker_killer/configuration.rb
 - lib/worker_killer/count_limiter.rb
+- lib/worker_killer/delayed_job_plugin.rb
+- lib/worker_killer/killer.rb
+- lib/worker_killer/killer/delayed_job.rb
+- lib/worker_killer/killer/passenger.rb
+- lib/worker_killer/killer/signal.rb
 - lib/worker_killer/memory_limiter.rb
 - lib/worker_killer/middleware.rb
 - lib/worker_killer/version.rb
 - spec/count_limiter_spec.rb
+- spec/killer/delayed_job_spec.rb
+- spec/killer/passenger_spec.rb
+- spec/killer/signal_spec.rb
+- spec/killer_spec.rb
 - spec/memory_limiter_spec.rb
 - spec/middleware_spec.rb
 - spec/spec_helper.rb
+- spec/support/logger.rb
 - spec/worker_killer_spec.rb
 homepage: https://github.com/RnD-Soft/worker_killer
 licenses:
@@ -160,7 +170,12 @@ specification_version: 4
 summary: Kill any workers by memory and request counts or take custom reaction
 test_files:
 - spec/middleware_spec.rb
+- spec/killer_spec.rb
 - spec/spec_helper.rb
+- spec/killer/passenger_spec.rb
+- spec/killer/signal_spec.rb
+- spec/killer/delayed_job_spec.rb
 - spec/memory_limiter_spec.rb
+- spec/support/logger.rb
 - spec/worker_killer_spec.rb
 - spec/count_limiter_spec.rb