Demo unicorn and nginx config for workshop

my_app

# This needs to be zzz_amos because the default site must be loaded last otherwise
# We'll end up with the default site being highest priority in routing.
server {
	# Set as default fall back site.
	server_name _;
	listen 80 default_server;

	root /srv/my_app/my_app/public;

	index index.html;

	client_max_body_size 8m;

	keepalive_timeout 15;
	keepalive_requests 128;

	error_page 404 /404.html;
	error_page 422 /422.html;
	error_page 403 /403.html;
	error_page 500 /500.html;
	error_page 503 /maintenance.html;

	location ~ \.htaccess$ {
		return 404;
	}

	location ~ ^/(assets|images|javascripts|stylesheets|swfs|system)/ {
		location ~ \.(ttf|woff|eot|svg)$ {
			add_header Access-Control-Allow-Origin "*";
		}
		gzip_static on;
		add_header X-Server-Hostname amos1qa;
		expires     +30d;
		add_header  Cache-Control public;
		break;
	}

	location /apache.txt {
		access_log off;
		break;
	}

	# Nginx for some reason requires this be internal to work.
	location ~ ^/503.html {
		internal;
	}

	# Directly serve pages if they exist, otherwise send it to unicorn.
	location / {
		if ( -f $document_root/.maintenance ) {
			return 503;
		}
		try_files $uri @unicorn_my_app;
	}

	location /nginx_stub_status {
		stub_status on;
		allow 127.0.0.1;
		deny all;
		access_log off;
	}

	location @unicorn_my_app {
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		proxy_set_header Host $http_host;
		proxy_set_header X-Forwarded-Scheme $scheme;
		proxy_read_timeout 5m;
		proxy_redirect off;
		proxy_pass http://unix:/tmp/my_app-unicorn.socket;
	}
}

unicorn.rb

# Read about unicorn workers here:
# http://doc.gitlab.com/ee/install/requirements.html#unicorn-workers
#
worker_processes 2

# Help ensure your application will always spawn in the symlinked
# "current" directory that Capistrano sets up.
working_directory "/srv/my_app/my_app" # 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 "/tmp/my_app-unicorn.socket", :backlog => 1024

timeout 60

# feel free to point this anywhere accessible on the filesystem
pid '/var/run/my_app-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/my_app/unicorn.log'
stdout_path '/var/log/my_app/unicorn.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
GC.respond_to?(:copy_on_write_friendly=) and
  GC.copy_on_write_friendly = true

# 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

before_fork do |server, worker|
  # 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!

  # 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|
  # per-process listener ports for debugging/admin/migrations
  # addr = "127.0.0.1:#{9293 + worker.nr}"
  # server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)

  # the following is *required* for Rails + "preload_app true",
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.establish_connection

  # if preload_app is true, then you may also want to check and
  # restart any other shared sockets/descriptors such as Memcached,
  # and Redis.  TokyoCabinet file handles are safe to reuse
  # between any number of forked children (assuming your kernel
  # correctly implements pread()/pwrite() system calls)
end