unicorn_relay 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb391afaecdf7ee75869e6d86ef3bcf590e60471
+  data.tar.gz: 76fe237036b5be4b6e2275217b59c8f415a3e270
+SHA512:
+  metadata.gz: 283caa1b2bda67e62c2158f9dbdbfab85c4877c71a62648c444ae06b2605fcdd278eb4026fcd753b60ef758f0dc7cb5860ddde996a9b8a64f49e2209929da931
+  data.tar.gz: 37dc59b4bd7be89f5f30b15b73e7cb7fdda487fab3b9299a4e1a5afd9b78e1443926ab652823f05d550da273cb07248b74b63c3872d4e5a9c9f0f626d9921aad

data/.gitignore

@@ -0,0 +1,10 @@
+.*.sw[pon]
+.AppleDouble
+.DS_Store
+.byebug_history
+.rvmrc
+Gemfile.lock
+coverage
+errors.lst
+pkg
+tags

data/.rspec

@@ -0,0 +1 @@
+--color

data/.utilsrc

@@ -0,0 +1,25 @@
+# vim: set ft=ruby:
+
+search do
+  prune_dirs /\A(\.svn|\.git|CVS|tmp|tags|coverage|pkg)\z/
+  skip_files /(\A\.|\.sw[pon]\z|\.(log|fnm|jpg|jpeg|png|pdf|svg)\z|tags|~\z)/i
+end
+
+discover do
+  prune_dirs /\A(\.svn|\.git|CVS|tmp|tags|coverage|pkg)\z/
+  skip_files /(\A\.|\.sw[pon]\z|\.log\z|~\z)/
+  binary false
+end
+
+strip_spaces do
+  prune_dirs /\A(\..*|CVS|pkg)\z/
+  skip_files /(\A\.|\.sw[pon]\z|\.log\z|~\z)/
+end
+
+probe do
+  test_framework :rspec
+end
+
+ssh_tunnel do
+  terminal_multiplexer :tmux
+end

data/Gemfile

@@ -0,0 +1,5 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,27 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+require 'gem_hadar'
+
+GemHadar do
+  name        'unicorn_relay'
+  author      'Florian Frank'
+  email       'flori@ping.de'
+  homepage    "http://flori.github.com/#{name}"
+  summary     'Allow controlling unicorn via supervise'
+  description 'Allow controlling unicorn via supervise by relaying signals to it'
+  test_dir    'spec'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', 'coverage', '.rvmrc',
+    '.AppleDouble', 'tags', '.byebug_history', '.DS_Store', 'errors.lst'
+  readme      'README.md'
+  title       "#{name.camelize} -- More Math in Ruby"
+  licenses    << 'Apache-2.0'
+  executables << 'unicorn_relay'
+
+  dependency  'tins', '~>1.0'
+  dependency  'mize'
+  development_dependency 'rake'
+  development_dependency 'simplecov'
+  development_dependency 'rspec'
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/unicorn_relay

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'unicorn_relay'
+
+# sv stop ...                    => service down/quit gracefully
+# sv stop ... ; sv interrupt ... => service down/terminate w/o grace
+UnicornRelay::Forker.new(
+  pid_file: ENV['PID_FILE']
+).start

data/bin/unocorn

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+STDOUT.sync = true
+
+STDOUT.puts "[#$$] #{File.basename($0)} started"
+
+signals = %i[ HUP USR1 USR2 TTIN TTOU WINCH INT QUIT TERM ]
+
+worker_pid = fork do
+
+  signals.each do |signal|
+    trap signal do
+      STDOUT.print "[#$$] signal #{signal.inspect} received by worker"
+      case signal
+      when :INT, :TERM
+        STDOUT.puts ", shutting down quickly."
+        exit
+      when :QUIT
+        STDOUT.puts ", shutting down gracefully."
+        exit
+      else
+        STDOUT.puts
+      end
+    end
+  end
+
+  sleep
+end
+
+signals = %i[ HUP USR1 USR2 TTIN TTOU WINCH INT QUIT TERM ]
+
+signals.each do |signal|
+  trap signal do
+    STDOUT.print "[#$$] signal #{signal.inspect} received by master"
+    case signal
+    when :INT, :TERM
+      STDOUT.puts ", shutting down quickly."
+      exit
+    when :QUIT
+      STDOUT.puts ", shutting down gracefully waiting for worker pid=#{worker_pid}."
+      Process.waitpid worker_pid
+      exit
+    else
+      STDOUT.puts
+    end
+  end
+end
+
+sleep

data/lib/unicorn_relay.rb

@@ -0,0 +1,9 @@
+require 'tins/xt'
+require 'mize'
+
+module UnicornRelay
+end
+
+require 'unicorn_relay/version'
+require 'unicorn_relay/forker'
+require 'unicorn_relay/teardown'

data/lib/unicorn_relay/forker.rb

@@ -0,0 +1,192 @@
+class UnicornRelay::Forker
+  class StopException < StandardError; end
+
+  def initialize(script_path: $0, pid_file: nil, argv: ARGV, env: ENV)
+    @name             = File.basename(script_path)
+    @pid_file         = pid_file
+    @argv             = argv
+    @env              = env
+    @relay_signals    = %i[ HUP USR1 USR2 TTIN TTOU WINCH ]
+    @shutdown_signals = {
+      :INT  => :INT,
+      :QUIT => :QUIT,
+      :TERM => :QUIT,
+    }
+  end
+
+  def start
+    handle_old_pid_file
+    start_control_loop
+  end
+
+  def stop
+    stop_control_loop
+  end
+
+  private
+
+  def process
+    "#@name pid=#$$"
+  end
+
+  def output(message)
+    STDOUT.puts "#{process} #{message}"
+    STDOUT.flush
+    self
+  end
+
+  def error(message)
+    STDERR.puts "#{process} #{message}"
+    STDERR.flush
+    self
+  end
+
+  def read_pid
+    File.read(@pid_file).to_i
+  end
+
+  def handle_old_pid_file
+    unless @pid_file
+      output "no pid file was given"
+      return
+    end
+    if pid = read_pid.nonzero?
+      Process.kill :INT, pid
+      output "interrupts pid=#{pid} from pid file"
+    else
+      error "ignoring pid file without a pid"
+    end
+  rescue Errno::ENOENT, Errno::ENOTDIR
+    output "no pid file was found at #{@pid_file.inspect}"
+    self
+  rescue Errno::EPERM
+    error "found a pid file for pid=#{pid}, but no permission to signal"
+  rescue Errno::ESRCH
+    error "found a stale pid file for pid=#{pid}"
+  end
+
+  def setup_spawn_env(env)
+    if gc = env.delete('UNICORN_GC')
+      gc.split(/\s+/).each_with_object(env) do |l, h|
+        k, v = l.split('=', 2)
+        h[k] = v
+      end
+    end
+    env
+  end
+
+  def shutdown_process_group(signal:, shutdown_signal:)
+    Signal.trap signal do
+      unless @shutdown_signal
+        @shutdown_signal = shutdown_signal
+        output "received #{signal.inspect}, "\
+          "shutting down pgid=#@pgid with #{shutdown_signal.inspect}"
+      end
+    end
+  end
+
+  def relay_to_process_group(signal:)
+    # NOTE relaying USR1 signals this way might cause problems when using
+    # user/group switching in unicorn
+    Signal.trap signal do
+      output "relays signal #{signal.inspect} to process group pgid=#@pgid"
+      signal_process_group signal
+    end
+  end
+
+  def install_shutdown_signal_handlers
+    @shutdown_signals.each do |signal, shutdown_signal|
+      shutdown_process_group signal: signal, shutdown_signal: shutdown_signal
+    end
+    self
+  end
+
+  def install_relay_signal_handlers
+    @relay_signals.each do |signal|
+      relay_to_process_group signal: signal
+    end
+    self
+  end
+
+  def create_process_group(pid)
+    pgid = Process.getpgid(pid)
+    Process.detach pid
+    pgid
+  end
+
+  def fork_child_process_in_pgroup
+    # We're passing Ruby GC configuration environment variables through the
+    # UNICORN_GC variable indirectly to its spawn instead of defining them in
+    # the run script. We don't want to increase *this* process' memory
+    # footprint over ca. 22 MiB. Only the unicorn processes themselves should
+    # allocate a lot of memory for rails (= several hundred MiB) at startup.
+    setup_spawn_env(@env)
+    pid  = Process.spawn(@env, @argv.map(&:inspect) * ' ', pgroup: true)
+    pgid = create_process_group(pid)
+    output "forks child process with pid=#{pid} pgid=#{pgid}"
+    pgid
+  end
+
+  def signal_process_group(signal)
+    Process.kill signal, -@pgid
+  end
+
+  def shutdown_signal_pending?
+    @shutdown_signal && !@shutdown_signal_sent_at
+  end
+
+  # Send shutdown_signal to process group for the first time.
+  def send_shutdown_signal
+    @shutdown_signal_sent_at = Time.now
+    output "Sending #{@shutdown_signal.inspect} to process group pgid=#@pgid"
+    signal_process_group @shutdown_signal
+  end
+
+  def shutdown_signal_sent_before?
+    @shutdown_signal_sent_at && @shutdown_signal_sent_at - Time.now > 60
+  end
+
+  # Repeat relaying of all shutdown signals to process group approximately
+  # every minute after one was received until every process was shutdown.
+  def resend_shutdown_signal
+    @shutdown_signal_sent_at = Time.now
+    output "Resending #{@shutdown_signal.inspect} to process group pgid=#@pgid"
+    signal_process_group @shutdown_signal
+  end
+
+  # Exit loop via Errno::ESRCH expception, as soon as process group is
+  # empty.
+  def check_if_process_group_empty
+    signal_process_group 0
+  end
+
+  def stop_control_loop
+    raise StopException
+  end
+
+  def start_control_loop
+    @shutdown_signal         = nil
+    @shutdown_signal_sent_at = nil
+
+    @pgid = fork_child_process_in_pgroup
+
+    install_shutdown_signal_handlers
+    install_relay_signal_handlers
+
+    loop do
+      if shutdown_signal_pending?
+        send_shutdown_signal
+      elsif shutdown_signal_sent_before?
+        resend_shutdown_signal
+      else
+        check_if_process_group_empty
+      end
+      sleep 1
+    end
+  rescue Errno::ESRCH
+    output "process group pgid=#@pgid empty, exiting"
+    return
+  rescue StopException
+    return
+  end
+end

data/lib/unicorn_relay/teardown.rb

@@ -0,0 +1,38 @@
+# Before forking anew, kill the unicorn master process that belongs to the
+# .oldbin PID. This enables 0 downtime deploys.
+class UnicornRelay::Teardown
+  def initialize(server:, pid_file:)
+    @server   = server
+    @pid_file = pid_file
+  end
+
+  def perform
+    server_has_new_pid_file? && pid and kill_pid
+  end
+
+  private
+
+  def kill_pid
+    Process.kill(:QUIT, pid)
+  rescue Errno::ESRCH
+  end
+
+  def server_has_new_pid_file?
+    pid_file_exist? && @server.pid != @pid_file
+  end
+
+  def pid_file_exist?
+    File.exist?(@pid_file)
+  end
+
+  def pid_file_content
+    File.read(@pid_file)
+  rescue Errno::ENOENT, Errno::ENOTDIR
+  end
+
+  memoize method:
+  def pid
+    pid = pid_file_content.to_i
+    pid.nonzero?
+  end
+end

data/lib/unicorn_relay/version.rb

@@ -0,0 +1,8 @@
+module UnicornRelay
+  # UnicornRelay version
+  VERSION         = '0.0.0'
+  VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/spec/forker_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+
+describe UnicornRelay::Forker do
+  let :server do
+    double('Server')
+  end
+
+  let :pid_file do
+    'foo/bar.pid.oldbin'
+  end
+
+  let :forker do
+    described_class.new(
+      script_path: 'foo/bar/unicorn_relay',
+      pid_file:     pid_file
+    )
+  end
+
+  let :process do
+    forker.send(:process)
+  end
+
+  describe '#start' do
+    it 'calls two other methods' do
+      expect(forker).to receive(:handle_old_pid_file)
+      expect(forker).to receive(:start_control_loop)
+      forker.start
+    end
+  end
+
+  describe '#stop' do
+    it 'calls stop_control_loop' do
+      expect(forker).to receive(:stop_control_loop)
+      forker.stop
+    end
+  end
+
+  describe '#process' do
+    it 'returns process name and pid' do
+      expect(process).to eq "unicorn_relay pid=#$$"
+    end
+  end
+
+  describe '#output' do
+    it 'outputs message to STDOUT and returns self' do
+      expect(STDOUT).to receive(:puts).with("#{process} hello")
+      expect(forker.send(:output, "hello")).to eq forker
+    end
+  end
+
+  describe '#error' do
+    it 'outputs message to STDERR and returns self' do
+      expect(STDERR).to receive(:puts).with("#{process} hello")
+      expect(forker.send(:error, "hello")).to eq forker
+    end
+  end
+
+  describe '#read_pid' do
+    it 'returns pid as an Integer' do
+      allow(File).to receive(:read).with(pid_file).and_return '666'
+      expect(forker.send(:read_pid)).to eq 666
+    end
+  end
+
+  describe '#handle_old_pid_file' do
+    it 'does not have to handle a pid_file' do
+      forker = described_class.new
+      expect(forker).to receive(:output).with('no pid file was given')
+      forker.send(:handle_old_pid_file)
+    end
+
+    it 'ignores a pid file without a pid' do
+      allow(forker).to receive(:read_pid).and_return 0
+      expect(forker).to receive(:error).with('ignoring pid file without a pid')
+      forker.send(:handle_old_pid_file)
+    end
+
+    it 'ignores a pid file without a pid' do
+      allow(forker).to receive(:read_pid).and_return 666
+      expect(Process).to receive(:kill).with(:INT, 666)
+      expect(forker).to receive(:output).
+        with('interrupts pid=666 from pid file')
+      forker.send(:handle_old_pid_file)
+    end
+
+    it 'handles a missing pid file' do
+      allow(forker).to receive(:read_pid).and_raise Errno::ENOENT
+      expect(forker).to receive(:output).
+        with('no pid file was found at "foo/bar.pid.oldbin"')
+      expect(forker.send(:handle_old_pid_file)).to eq forker
+    end
+
+    it 'handles insufficient permissions' do
+      allow(forker).to receive(:read_pid).and_return 666
+      allow(Process).to receive(:kill).and_raise Errno::EPERM
+      expect(forker).to receive(:error).
+        with("found a pid file for pid=666, but no permission to signal")
+      forker.send(:handle_old_pid_file)
+    end
+
+    it 'handles stale pid files' do
+      allow(forker).to receive(:read_pid).and_return 666
+      allow(Process).to receive(:kill).and_raise Errno::ESRCH
+      expect(forker).to receive(:error).
+        with("found a stale pid file for pid=666")
+      forker.send(:handle_old_pid_file)
+    end
+  end
+
+  describe '#setup_spawn_env' do
+    let :env do
+      {
+        'FOO'        => 'BAR',
+        'UNICORN_GC' => 'BAZ=QUUX PI=3.141',
+      }
+    end
+
+    it 'handles UNICORN_GC env var' do
+      expect(forker.send(:setup_spawn_env, env)).to eq(
+        'FOO' => 'BAR',
+        'BAZ' => 'QUUX',
+        'PI'  => '3.141',
+      )
+    end
+
+    it 'just passes ENV on if UNICORN_GC is not defined' do
+      expect(forker.send(:setup_spawn_env, { 'FOO' => 'BAR' })).to eq(
+        'FOO' => 'BAR'
+      )
+    end
+  end
+
+
+  describe '#signal_process_group' do
+    it 'sends signal to process group' do
+      expect(Process).to receive(:kill).with(:USR1, -666)
+      forker.instance_eval do
+        @pgid = 666
+        signal_process_group(:USR1)
+      end
+    end
+  end
+
+  describe '#shutdown_process_group' do
+    it 'installs signal trap' do
+      expect(Signal).to receive(:trap).with(:USR1)
+      forker.send(:shutdown_process_group, signal: :USR1, shutdown_signal: :USR2)
+    end
+  end
+
+  describe '#relay_to_process_group' do
+    it 'installs signal trap' do
+      expect(Signal).to receive(:trap).with(:USR1)
+      forker.send(:relay_to_process_group, signal: :USR1)
+    end
+  end
+
+  describe '#install_shutdown_signal_handlers' do
+    it 'installs signal handlers' do
+      expect(forker).to receive(:shutdown_process_group).at_least(1)
+      forker.send(:install_shutdown_signal_handlers)
+    end
+  end
+
+  describe '#install_relay_signal_handlers' do
+    it 'installs signal handlers' do
+      expect(forker).to receive(:relay_to_process_group).at_least(1)
+      forker.send(:install_relay_signal_handlers)
+    end
+  end
+
+  describe '#create_process_group' do
+    it 'creates a process group for a pid' do
+      expect(Process).to receive(:getpgid).with(666).and_return 667
+      expect(Process).to receive(:detach).with(666)
+      expect(forker.send(:create_process_group, 666)).to eq 667
+    end
+  end
+
+  describe '#fork_child_process_in_pgroup' do
+    it 'forks and creates a process group' do
+      forker = described_class.new(env: {}, argv: [])
+      expect(Process).to receive(:spawn).with({}, "", pgroup: true).
+        and_return 123
+      expect(forker).to receive(:create_process_group).with(123).and_return 456
+      expect(forker).to receive(:output).
+        with('forks child process with pid=123 pgid=456')
+      forker.send(:fork_child_process_in_pgroup)
+    end
+  end
+
+  context 'shutdown_signal received' do
+    before do
+      forker.instance_eval do
+        @shutdown_signal = :QUIT
+        @pgid            = 666
+      end
+    end
+
+    describe '#send_shutdown_signal' do
+      it 'singals process group' do
+        expect(forker).to receive(:output).with('Sending :QUIT to process group pgid=666')
+        expect(forker).to receive(:signal_process_group).with(:QUIT)
+        expect {
+          forker.send(:send_shutdown_signal)
+        }.to change {
+          forker.instance_eval { @shutdown_signal_sent_at }
+        }.from(nil).to(instance_of(Time))
+      end
+    end
+
+    describe '#resend_shutdown_signal' do
+      it 'singals process group' do
+        forker.instance_eval { @shutdown_signal_sent_at = Time.now }
+        expect(forker).to receive(:output).with('Resending :QUIT to process group pgid=666')
+        expect(forker).to receive(:signal_process_group).with(:QUIT)
+        expect {
+          forker.send(:resend_shutdown_signal)
+        }.to change {
+          forker.instance_eval { @shutdown_signal_sent_at }
+        }
+      end
+    end
+  end
+
+  describe '#start_control_loop' do
+    it 'runs the control loop' do
+      expect(forker).to receive(:fork_child_process_in_pgroup).and_return 666
+      expect(forker).to receive(:install_shutdown_signal_handlers)
+      expect(forker).to receive(:install_relay_signal_handlers)
+      expect(forker).to receive(:loop)
+      forker.send(:start_control_loop)
+    end
+
+    context 'running the control loop' do
+      before do
+        allow(forker).to receive(:fork_child_process_in_pgroup).and_return 666
+        allow(forker).to receive(:install_shutdown_signal_handlers)
+        allow(forker).to receive(:install_relay_signal_handlers)
+      end
+
+      it 'sends a shutdown signal if pending' do
+        allow(forker).to receive(:output)
+        allow(forker).to receive(:shutdown_signal_pending?).and_return true
+        allow(forker).to receive(:shutdown_signal_sent_before?).and_return false
+        expect(forker).to receive(:send_shutdown_signal).and_raise UnicornRelay::Forker::StopException
+        forker.send(:start_control_loop)
+      end
+
+      it 'resends the shutdown signal after a while' do
+        allow(forker).to receive(:output)
+        allow(forker).to receive(:shutdown_signal_pending?).and_return false
+        allow(forker).to receive(:shutdown_signal_sent_before?).and_return true
+        expect(forker).to receive(:resend_shutdown_signal).and_raise UnicornRelay::Forker::StopException
+        forker.send(:start_control_loop)
+      end
+
+      it 'ends the control loop if the process group is empty' do
+        allow(forker).to receive(:signal_process_group).and_raise Errno::ESRCH
+        expect(forker).to receive(:check_if_process_group_empty).and_call_original
+        expect(forker).to receive(:output).with('process group pgid=666 empty, exiting')
+        forker.send(:start_control_loop)
+      end
+    end
+  end
+
+  describe '#stop_control_loop' do
+    it 'raises UnicornRelay::Forker::StopException' do
+      expect {
+        forker.send(:stop_control_loop)
+      }.to raise_error UnicornRelay::Forker::StopException
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+if ENV['START_SIMPLECOV'].to_i == 1
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "#{File.basename(File.dirname(__FILE__))}/"
+  end
+end
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+require 'rspec'
+begin
+  require 'byebug'
+rescue LoadError
+end
+require 'unicorn_relay'

data/spec/teardown_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe UnicornRelay::Teardown do
+  let :server do
+    double('Server')
+  end
+
+  let :teardown do
+    described_class.new(server: server, pid_file: 'foo/bar.pid.oldbin')
+  end
+
+  it 'does not perform without new pid_file' do
+    allow(teardown).to receive(:server_has_new_pid_file?).and_return false
+    allow(teardown).to receive(:pid).and_return 666
+    teardown.perform
+    expect(teardown).not_to receive(:kill_pid)
+  end
+
+  it 'does not perform without a pid in pid_file' do
+    allow(teardown).to receive(:server_has_new_pid_file?).and_return true
+    teardown.perform
+    expect(teardown).not_to receive(:kill_pid)
+  end
+
+  it 'performs killing otherwise' do
+    allow(teardown).to receive(:server_has_new_pid_file?).and_return true
+    allow(teardown).to receive(:pid).and_return 666
+    expect(Process).to receive(:kill).with(:QUIT, 666)
+    expect(teardown).to receive(:kill_pid).and_call_original
+    teardown.perform
+  end
+
+  describe '#kill_pid' do
+    it 'returns nil if process for pid is not found' do
+      allow(Process).to receive(:kill).and_raise Errno::ESRCH
+      expect(teardown.send(:kill_pid)).to be_nil
+    end
+
+  end
+
+  describe '#pid' do
+    it 'returns nil for missing pid file or non-numeric content' do
+      allow(teardown).to receive(:pid_file_content).and_return 'nix'
+      expect(teardown.send(:pid)).to be_nil
+    end
+  end
+
+  describe '#server_has_new_pid_file?' do
+    it 'returns true if server.pid is different from pid_file' do
+      allow(server).to receive(:pid).and_return 'something else'
+      allow(teardown).to receive(:pid_file_exist?).and_return true
+      expect(teardown.send(:server_has_new_pid_file?)).to eq true
+    end
+
+    it 'returns false if server.pid is the same as pid_file' do
+      allow(server).to receive(:pid).and_return 'foo/bar.pid.oldbin'
+      allow(teardown).to receive(:pid_file_exist?).and_return true
+      expect(teardown.send(:server_has_new_pid_file?)).to eq false
+    end
+
+    it 'returns false if pid_file does not exist' do
+      allow(teardown).to receive(:pid_file_exist?).and_return false
+      expect(teardown.send(:server_has_new_pid_file?)).to eq false
+    end
+  end
+
+  describe '#pid_file_exist?' do
+    it 'checks the existence of pid_file' do
+      expect(File).to receive(:exist?).with('foo/bar.pid.oldbin')
+      teardown.send(:pid_file_exist?)
+    end
+  end
+end

data/unicorn_relay.gemspec

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+# stub: unicorn_relay 0.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "unicorn_relay".freeze
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Florian Frank".freeze]
+  s.date = "2016-10-11"
+  s.description = "Allow controlling unicorn via supervise by relaying signals to it".freeze
+  s.email = "flori@ping.de".freeze
+  s.executables = ["unicorn_relay".freeze]
+  s.extra_rdoc_files = ["README.md".freeze, "lib/unicorn_relay.rb".freeze, "lib/unicorn_relay/forker.rb".freeze, "lib/unicorn_relay/teardown.rb".freeze, "lib/unicorn_relay/version.rb".freeze]
+  s.files = [".gitignore".freeze, ".rspec".freeze, ".utilsrc".freeze, "Gemfile".freeze, "README.md".freeze, "Rakefile".freeze, "VERSION".freeze, "bin/unicorn_relay".freeze, "bin/unocorn".freeze, "lib/unicorn_relay.rb".freeze, "lib/unicorn_relay/forker.rb".freeze, "lib/unicorn_relay/teardown.rb".freeze, "lib/unicorn_relay/version.rb".freeze, "spec/forker_spec.rb".freeze, "spec/spec_helper.rb".freeze, "spec/teardown_spec.rb".freeze, "unicorn_relay.gemspec".freeze]
+  s.homepage = "http://flori.github.com/unicorn_relay".freeze
+  s.licenses = ["Apache-2.0".freeze]
+  s.rdoc_options = ["--title".freeze, "UnicornRelay -- More Math in Ruby".freeze, "--main".freeze, "README.md".freeze]
+  s.rubygems_version = "2.6.7".freeze
+  s.summary = "Allow controlling unicorn via supervise".freeze
+  s.test_files = ["spec/forker_spec.rb".freeze, "spec/spec_helper.rb".freeze, "spec/teardown_spec.rb".freeze]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<gem_hadar>.freeze, ["~> 1.8.0"])
+      s.add_development_dependency(%q<rake>.freeze, [">= 0"])
+      s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
+      s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
+      s.add_runtime_dependency(%q<tins>.freeze, ["~> 1.0"])
+      s.add_runtime_dependency(%q<mize>.freeze, [">= 0"])
+    else
+      s.add_dependency(%q<gem_hadar>.freeze, ["~> 1.8.0"])
+      s.add_dependency(%q<rake>.freeze, [">= 0"])
+      s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+      s.add_dependency(%q<rspec>.freeze, [">= 0"])
+      s.add_dependency(%q<tins>.freeze, ["~> 1.0"])
+      s.add_dependency(%q<mize>.freeze, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<gem_hadar>.freeze, ["~> 1.8.0"])
+    s.add_dependency(%q<rake>.freeze, [">= 0"])
+    s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+    s.add_dependency(%q<rspec>.freeze, [">= 0"])
+    s.add_dependency(%q<tins>.freeze, ["~> 1.0"])
+    s.add_dependency(%q<mize>.freeze, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: unicorn_relay
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Florian Frank
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gem_hadar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tins
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Allow controlling unicorn via supervise by relaying signals to it
+email: flori@ping.de
+executables:
+- unicorn_relay
+extensions: []
+extra_rdoc_files:
+- README.md
+- lib/unicorn_relay.rb
+- lib/unicorn_relay/forker.rb
+- lib/unicorn_relay/teardown.rb
+- lib/unicorn_relay/version.rb
+files:
+- ".gitignore"
+- ".rspec"
+- ".utilsrc"
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- bin/unicorn_relay
+- bin/unocorn
+- lib/unicorn_relay.rb
+- lib/unicorn_relay/forker.rb
+- lib/unicorn_relay/teardown.rb
+- lib/unicorn_relay/version.rb
+- spec/forker_spec.rb
+- spec/spec_helper.rb
+- spec/teardown_spec.rb
+- unicorn_relay.gemspec
+homepage: http://flori.github.com/unicorn_relay
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--title"
+- UnicornRelay -- More Math in Ruby
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Allow controlling unicorn via supervise
+test_files:
+- spec/forker_spec.rb
+- spec/spec_helper.rb
+- spec/teardown_spec.rb