unicorn.conf.rb.erb

RailsRoot = "<%= @site.code_path %>"
PidsDir = "#{RailsRoot}/tmp/pids"
OldPidFile = "#{PidsDir}/unicorn.pid.oldbin"

ListenAddress = "127.0.0.1"
ListenPort = <%= @site.server.port %>
UnixListen = "run/unicorn.sock"
Backlog = <%= @site.server.backlog %>

Workers = <%= @site.server.workers %>
Timeout = <%= @site.server.timeout %>

WarmUp = true
WarmUpTime = <%= @site.server.warmup_time %>
# caution use non cacheable urls
WarmUpUrl = <%= @site.server.warmup_urls %>

CurrentPrio = Process.getpriority Process::PRIO_PROCESS, 0
# put "* - nice 0" on /etc/security/limits.conf to enable
WarmUpRenice = `bash -c 'ulimit -e'`.to_i-20 >= CurrentPrio rescue false
WarmUpRenicePrio = 19

WorkerKiller = <%= @site.server.worker_killer %>
if WorkerKiller
  begin
    require 'unicorn/worker_killer'
    WorkerKillByRequests = <%= @site.server.restart_on_requests.first %>..<%= @site.server.restart_on_requests.last %>
    WorkerKillByMemory = <%= @site.server.restart_on_memory.first %>..<%= @site.server.restart_on_memory.last %>
  rescue LoadError
    WorkerKiller = false
  end
end

# FIXME: this makes the worker too big and activate Unicorn::WorkerKiller::Oom
WorkerOutOfBandGcFrequency = nil

WorkerListen = true
WorkerPidFile = true

WorkerDaemons = {
  0 => {
    :name => 'delayed_job',
    :run => proc{
      require 'delayed/command'
      Thread.new{ sleep 30.minutes; Process.kill :SIGTERM, Process.pid }

    <% if @site.version >= '1.0' %>
      Delayed::Worker.before_fork
    <% end %>
      Delayed::Command.new([]).run 'delayed_job'
    },
  },
<% if @site.server.feed_updater_enabled %>
  1 => {
    :name => 'feed-updater',
    :run => proc{
      Thread.new{ sleep 2.hours; Process.kill :SIGTERM, Process.pid }

      FeedUpdater.new.start
    },
  },
<% end %>
}

working_directory RailsRoot

worker_processes (if Workers < WorkerDaemons.count+1 then WorkerDaemons.count+1 else Workers end)
timeout Timeout

stderr_path "#{RailsRoot}/log/unicorn.stderr.log"
stdout_path "#{RailsRoot}/log/unicorn.stdout.log"
pid "#{PidsDir}/unicorn.pid"

listen "#{RailsRoot}/#{UnixListen}", :backlog => Backlog
listen "#{ListenAddress}:#{ListenPort}", :tcp_nopush => true

# combine Ruby 2 or REE with "preload_app true" for memory savings
# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
preload_app true
GC.copy_on_write_friendly = true if GC.respond_to? :copy_on_write_friendly=

# this is loaded on first run or restart conditions (URS2, HUP). Unset on first before_fork call
master_run = true

before_fork do |server, worker|
  if master_run
    if WarmUp
      Process.setpriority Process::PRIO_PROCESS, 0, WarmUpRenicePrio if WarmUpRenice

      require 'rack/test'
      client = Rack::MockRequest.new server.app
      Array(WarmUpUrl).each do |url|
        client.get url
      end

      Process.setpriority Process::PRIO_PROCESS, 0, CurrentPrio if WarmUpRenice
    end

    # Disconnect since the database connection will not carry over
    ActiveRecord::Base.connection.disconnect! if defined? ActiveRecord::Base

    if File.exists? OldPidFile
      Thread.new do
        # wait a little for the new master
        sleep WarmUpTime

        # a .oldbin file exists if unicorn was gracefully restarted with a USR2 signal
        # we should terminate the old process now that we're up and running
        old_pid = File.read(OldPidFile).to_i
        begin
          Process.kill "QUIT", old_pid
          File.delete OldPidFile
        rescue Errno::ENOENT, Errno::ESRCH
          # someone else did our job for us
        end
      end
    end

    master_run = false
  end
end

after_fork do |server, worker|
  daemon = WorkerDaemons[worker.nr]

  MessageBus.after_fork if defined? MessageBus
  # Start up the database connection again in the worker
  ActiveRecord::Base.establish_connection if defined? ActiveRecord::Base
  # reset memcache connection (if using memcache-client)
  Rails.cache.instance_variable_get(:@data).reset if Rails.cache.class.to_s == 'ActiveSupport::Cache::MemCacheStore'

  if WorkerKiller
    Unicorn::WorkerKiller::MaxRequests.new nil, WorkerKillByRequests.begin, WorkerKillByRequests.end if WorkerKillByRequests
    Unicorn::WorkerKiller::Oom.new nil, WorkerKillByMemory.begin * (1024**2), WorkerKillByMemory.end * (1024**2) if WorkerKillByMemory
  end unless daemon

  # say to the kernel to kill very big workers first than other processes
  # Not very secure
  #File.open("/proc/#{Process.pid}/oom_adj", "w"){ |f| f << '12' }

  if WorkerListen
    # per-process listener ports for debugging/admin/migrations
    server.listen "#{ListenAddress}:#{ListenPort + worker.nr}", :tries => -1, :delay => 5
  end unless daemon
  if WorkerPidFile
    child_pid_file = server.config[:pid].sub '.pid', ".#{worker.nr}.pid"
    system "echo #{Process.pid} > #{child_pid_file}"
  end
end

# daemons support
require 'active_support/all'
class Unicorn::HttpServer

  def worker_loop_with_daemons worker
    daemon = WorkerDaemons[worker.nr]
    if daemon
      ctx = START_CTX.dup #save for later use with proc_name
      init_worker_process worker
      START_CTX.merge! ctx

      name = "#{worker.nr}:#{daemon[:name]}"
      proc_name "worker[#{name}]"
      @logger.info "worker=#{name} ready as a daemon"

      daemon[:run].call
    else
      worker_loop_without_daemons worker
    end
  end
  alias_method_chain :worker_loop, :daemons

  def awaken_master_with_daemons
    if SIG_QUEUE.include? :QUIT
      WORKERS.each do |pid, worker|
        daemon = WorkerDaemons[worker.nr]
        next unless daemon
        Process.kill 'TERM', pid
      end
    end
    awaken_master_without_daemons
  end
  alias_method_chain :awaken_master, :daemons

end