diff options
author | Stefan Tatschner | 2015-06-09 22:58:50 +0200 |
---|---|---|
committer | Stefan Tatschner | 2015-06-09 22:58:50 +0200 |
commit | 147947e25d90ec49368a7d12a1fdf2ffaac3fe0a (patch) | |
tree | 617cfeedee0fb4bdc3fdcf5c96777a164bc74d28 /unicorn.conf.rb | |
download | aur-147947e25d90ec49368a7d12a1fdf2ffaac3fe0a.tar.gz |
Initial import
Diffstat (limited to 'unicorn.conf.rb')
-rw-r--r-- | unicorn.conf.rb | 114 |
1 files changed, 114 insertions, 0 deletions
diff --git a/unicorn.conf.rb b/unicorn.conf.rb new file mode 100644 index 000000000000..e3e605833f8e --- /dev/null +++ b/unicorn.conf.rb @@ -0,0 +1,114 @@ +# enable out of band gc out of the box, it is low risk and improves perf a lot +ENV['UNICORN_ENABLE_OOBGC'] ||= "1" + +# Use at least one worker per core if you're on a dedicated server, +# more will usually help for _short_ waits on databases/caches. +worker_processes 2 + +# Since Unicorn is never exposed to outside clients, it does not need to +# run on the standard HTTP port (80), there is no reason to start Unicorn +# as root unless it's from system init scripts. +# If running the master process as root and the workers as an unprivileged +# user, do this to switch euid/egid in the workers (also chowns logs): +# user "unprivileged_user", "unprivileged_group" + +# Help ensure your application will always spawn in the symlinked +# "current" directory that Capistrano sets up +working_directory '/usr/share/webapps/discourse' # available in 0.94.0+ + +# Listen on both a Unix domain socket and a TCP port. +# If you are load-balancing multiple Unicorn masters, lower the backlog +# setting to e.g. 64 for faster failover. +#listen "/var/run/discourse/discourse.socket", :backlog => 1024 +listen "127.0.0.1:9737", :tcp_nopush => true + +# nuke workers after 30 seconds instead of 60 seconds (the default) +timeout 30 + +# feel free to point this anywhere accessible on the filesystem +pid '/run/discourse/unicorn.pid' + +# By default, the Unicorn logger will write to stderr. +# Additionally, some applications/frameworks log to stderr or stdout, +# so prevent them from going to /dev/null when daemonized here: +stderr_path '/var/log/discourse/unicorn.stderr.log' +stdout_path '/var/log/discourse/unicorn.stdout.log' + +# combine Ruby 2.0.0dev or REE with "preload_app true" for memory savings +# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow +preload_app true + +# If 'UNICORN_ENABLE_OOBGC' is unset let's use GC.copy_on_write_friendly = true. +# http://unicorn.bogomips.org/Unicorn/Configurator.html +unless ENV['UNICORN_ENABLE_OOBGC'] + GC.respond_to?(:copy_on_write_friendly=) and + GC.copy_on_write_friendly = true +end + +# Enable this flag to have unicorn test client connections by writing the +# beginning of the HTTP headers before calling the application. This +# prevents calling the application for connections that have disconnected +# while queued. This is only guaranteed to detect clients on the same +# host unicorn runs on, and unlikely to detect disconnects even on a +# fast LAN. +check_client_connection false + +# local variable to guard against running a hook multiple times +run_once = true + +before_fork do |server, worker| + # Occasionally, it may be necessary to run non-idempotent code in the + # master before forking. Keep in mind the above disconnect! example + # is idempotent and does not need a guard. + if run_once + # load up the yaml for the localization bits, in master process + I18n.t(:posts) + + # load up all models and schema + (ActiveRecord::Base.connection.tables - %w[schema_migrations]).each do |table| + table.classify.constantize.first rescue nil + end + + # router warm up + Rails.application.routes.recognize_path('abc') rescue nil + + # get rid of rubbish so we don't share it + GC.start + + run_once = false # prevent from firing again + end + + # the following is highly recomended for Rails + "preload_app true" + # as there's no need for the master process to hold a connection + defined?(ActiveRecord::Base) and + ActiveRecord::Base.connection.disconnect! + $redis.client.disconnect + + # The following is only recommended for memory/DB-constrained + # installations. It is not needed if your system can house + # twice as many worker_processes as you have configured. + # + # This allows a new master process to incrementally + # phase out the old master process with SIGTTOU to avoid a + # thundering herd (especially in the "preload_app false" case) + # when doing a transparent upgrade. The last worker spawned + # will then kill off the old master process with a SIGQUIT. + old_pid = "#{server.config[:pid]}.oldbin" + if old_pid != server.pid + begin + sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU + Process.kill(sig, File.read(old_pid).to_i) + rescue Errno::ENOENT, Errno::ESRCH + end + end + + # Throttle the master from forking too quickly by sleeping. Due + # to the implementation of standard Unix signal handlers, this + # helps (but does not completely) prevent identical, repeated signals + # from being lost when the receiving process is busy. + sleep 1 +end + +after_fork do |server, worker| + Discourse.after_fork +end |