class CopyTunerClient::ProcessGuard

will not need to interact with this class directly.
processes and completing background jobs. Applications using the client
process (such as in Unicorn or Passenger). Also registers hooks for exiting
Starts the poller from a worker process, or register hooks for a spawner

def delayed_job_spawner?

def delayed_job_spawner?
  # delayed_job は二種類の起動の仕方がある。
  # - bin/delayed_job start
  # - bin/rake jobs:work
  # 前者の呼び出しでのみジョブ処理用の子プロセスが作られるため、　poller を作るフックを仕込む必要がある。
  defined?(Delayed::Worker) && $0.include?('delayed_job')
end

def good_job_spawner?

def good_job_spawner?
  $0.include?('good_job') && defined?(GoodJob) && ARGV.include?('--daemonize')
end

def initialize(cache, poller, options)

Options Hash: (**options)

:logger (Logger) -- where errors should be logged

Parameters:

options (Hash) --

def initialize(cache, poller, options)
  @cache  = cache
  @poller = poller
  @logger = options[:logger]
end

def passenger_spawner?

def passenger_spawner?
  defined?(PhusionPassenger) && ($0.include?("Passenger AppPreloader") || $0.include?("ApplicationSpawner") || $0.include?("rack-preloader"))
end

def puma_spawner?

def puma_spawner?
  defined?(Puma::Runner) && $0.include?('puma')
end

def register_delayed_hook

def register_delayed_hook
  @logger.info("Registered Delayed::Job start hook")
  poller = @poller
  Delayed::Worker.class_eval do
    alias_method :start_without_copy_tuner, :start
    define_method :start do
      poller.start
      start_without_copy_tuner
    end
  end
end

def register_exit_hooks

def register_exit_hooks
  at_exit do
    @cache.flush
  end
end

def register_good_job_hook

def register_good_job_hook
  @logger.info("Registered good_job start hook")
  poller = @poller
  hook_module = Module.new do
    define_method :daemon do
      super
      poller.start
    end
  end
  ::Process.singleton_class.prepend hook_module
end

def register_passenger_hook

def register_passenger_hook
  @logger.info("Registered Phusion Passenger fork hook")
  PhusionPassenger.on_event(:starting_worker_process) do |forked|
    start_polling
  end
end

def register_puma_hook

def register_puma_hook
  # If Puma is clustered mode without preload_app, this method is called on worker process.
  # Just start poller and return.
  if $0.include?('cluster worker')
    @logger.info('Puma would be clustered mode without preload_app')
    @poller.start
    return
  end
  @logger.info('Register Puma fork hook')
  # If Puma is clustered mode with preload_app, this method is called before fork.
  # Delay poller start until Puma::Runner#start_server which is called on worker process.
  poller = @poller
  hook_module = Module.new do
    define_method :start_server do
      poller.start
      super
    end
  end
  Puma::Runner.prepend hook_module
end

def register_spawn_hooks

def register_spawn_hooks
  if passenger_spawner?
    register_passenger_hook
  elsif unicorn_spawner?
    register_unicorn_hook
  elsif puma_spawner?
    register_puma_hook
  elsif delayed_job_spawner?
    register_delayed_hook
  elsif good_job_spawner?
    register_good_job_hook
  end
end

def register_unicorn_hook

def register_unicorn_hook
  @logger.info("Registered Unicorn fork hook")
  poller = @poller
  Unicorn::HttpServer.class_eval do
    alias_method :worker_loop_without_copy_tuner, :worker_loop
    define_method :worker_loop do |worker|
      poller.start
      worker_loop_without_copy_tuner(worker)
    end
  end
end

def spawner?

def spawner?
  passenger_spawner? || unicorn_spawner? || delayed_job_spawner? || puma_spawner? || good_job_spawner?
end

def start

Starts the poller or registers hooks

def start
  if spawner?
    register_spawn_hooks
  else
    register_exit_hooks
    start_polling
  end
end

def start_polling

def start_polling
  @poller.start
end

def unicorn_spawner?

def unicorn_spawner?
  defined?(Unicorn::HttpServer) && ($0.include?("unicorn") && !caller.any? { |line| line.include?("worker_loop") })
end

Modules

Classes