magic_recipes_two 0.0.1

data/lib/capistrano/tasks/secrets.rake

@@ -0,0 +1,43 @@
+require 'capistrano/magic_recipes/base_helpers'
+include Capistrano::MagicRecipes::BaseHelpers
+
+namespace :load do
+  task :defaults do
+    set :secrets_roles,     -> { :app }
+    set :secrets_key_base,  -> { generate_secrect_key }
+    set :secrets_key_name,  -> { "#{ fetch(:application) }_#{ fetch(:stage) }_SECRET_KEY_BASE".gsub(/-/, "_").gsub(/[^a-zA-Z_]/, "").upcase }
+    set :secrets_user_path, -> { "/home/#{fetch(:user)}" }
+  end
+end
+
+namespace :secrets do
+  
+  
+  desc "upload secrets yaml"
+  task :upload do
+    on release_roles fetch(:secrets_roles) do
+      within shared_path do
+        magic_template("secrets_yml", '/tmp/secrets.yml')
+        execute :sudo, :mv, '/tmp/secrets.yml', "config/secrets.yml"
+      end
+    end
+  end
+  
+  
+  desc "set secret-key in .bashrc"
+  task :export do
+    on release_roles fetch(:secrets_roles) do
+      within fetch(:secrets_user_path) do
+        execute :sudo,  "echo 'export #{fetch(:secrets_key_name)}=#{fetch(:secrets_key_base)}' | cat >> .bashrc"
+        execute "export #{fetch(:secrets_key_name)}=#{fetch(:secrets_key_base)}"
+      end
+    end
+  end
+  
+  desc 'secrets setup task (upload and set)'
+  task :setup do
+    invoke "secrets:export"
+    invoke "secrets:upload"
+  end
+  
+end

data/lib/capistrano/tasks/sidekiq.rake

@@ -0,0 +1,217 @@
+# https://github.com/seuros/capistrano-sidekiq
+namespace :load do
+  task :defaults do
+    set :sidekiq_default_hooks, -> { true }
+
+    set :sidekiq_pid, -> { File.join(shared_path, 'tmp', 'pids', 'sidekiq.pid') }
+    set :sidekiq_env, -> { fetch(:rack_env, fetch(:rails_env, fetch(:stage))) }
+    set :sidekiq_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }
+    set :sidekiq_timeout, -> { 10 }
+    set :sidekiq_roles, -> { :app }
+    set :sidekiq_processes, -> { 1 }
+    # Rbenv and RVM integration
+    set :rbenv_map_bins, fetch(:rbenv_map_bins).to_a.concat(%w(sidekiq sidekiqctl))
+    set :rvm_map_bins, fetch(:rvm_map_bins).to_a.concat(%w(sidekiq sidekiqctl))
+  end
+end
+
+
+namespace :deploy do
+  before :starting, :check_sidekiq_hooks do
+    invoke 'sidekiq:add_default_hooks' if fetch(:sidekiq_default_hooks)
+  end
+  after :publishing, :restart_sidekiq do
+    invoke 'sidekiq:restart' if fetch(:sidekiq_default_hooks)
+  end
+end
+
+
+namespace :sidekiq do
+  def for_each_process(reverse = false, &block)
+    pids = processes_pids
+    pids.reverse! if reverse
+    pids.each_with_index do |pid_file, idx|
+      within current_path do
+        yield(pid_file, idx)
+      end
+    end
+  end
+
+  def processes_pids
+    pids = []
+    fetch(:sidekiq_processes).times do |idx|
+      pids.push (idx.zero? && fetch(:sidekiq_processes) <= 1) ?
+                    fetch(:sidekiq_pid) :
+                    fetch(:sidekiq_pid).gsub(/\.pid$/, "-#{idx}.pid")
+
+    end
+    pids
+  end
+
+  def pid_process_exists?(pid_file)
+    pid_file_exists?(pid_file) and test(*("kill -0 $( cat #{pid_file} )").split(' '))
+  end
+
+  def pid_file_exists?(pid_file)
+    test(*("[ -f #{pid_file} ]").split(' '))
+  end
+
+  def stop_sidekiq(pid_file)
+    if fetch(:stop_sidekiq_in_background, fetch(:sidekiq_run_in_background))
+      if fetch(:sidekiq_use_signals)
+        background "kill -TERM `cat #{pid_file}`"
+      else
+        background :bundle, :exec, :sidekiqctl, 'stop', "#{pid_file}", fetch(:sidekiq_timeout)
+      end
+    else
+      execute :bundle, :exec, :sidekiqctl, 'stop', "#{pid_file}", fetch(:sidekiq_timeout)
+    end
+  end
+
+  def quiet_sidekiq(pid_file)
+    if fetch(:sidekiq_use_signals)
+      background "kill -USR1 `cat #{pid_file}`"
+    else
+      begin
+        execute :bundle, :exec, :sidekiqctl, 'quiet', "#{pid_file}"
+      rescue SSHKit::Command::Failed
+        # If gems are not installed eq(first deploy) and sidekiq_default_hooks as active
+        warn 'sidekiqctl not found (ignore if this is the first deploy)'
+      end
+    end
+  end
+
+  def start_sidekiq(pid_file, idx = 0)
+    args = []
+    args.push "--index #{idx}"
+    args.push "--pidfile #{pid_file}"
+    args.push "--environment #{fetch(:sidekiq_env)}"
+    args.push "--logfile #{fetch(:sidekiq_log)}" if fetch(:sidekiq_log)
+    args.push "--require #{fetch(:sidekiq_require)}" if fetch(:sidekiq_require)
+    args.push "--tag #{fetch(:sidekiq_tag)}" if fetch(:sidekiq_tag)
+    Array(fetch(:sidekiq_queue)).each do |queue|
+      args.push "--queue #{queue}"
+    end
+    args.push "--config #{fetch(:sidekiq_config)}" if fetch(:sidekiq_config)
+    args.push "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency)
+    # use sidekiq_options for special options
+    args.push fetch(:sidekiq_options) if fetch(:sidekiq_options)
+
+    if defined?(JRUBY_VERSION)
+      args.push '>/dev/null 2>&1 &'
+      warn 'Since JRuby doesn\'t support Process.daemon, Sidekiq will not be running as a daemon.'
+    else
+      args.push '--daemon'
+    end
+
+    if fetch(:start_sidekiq_in_background, fetch(:sidekiq_run_in_background))
+      background :bundle, :exec, :sidekiq, args.compact.join(' ')
+    else
+      execute :bundle, :exec, :sidekiq, args.compact.join(' ')
+    end
+  end
+
+  task :add_default_hooks do
+    after 'deploy:starting', 'sidekiq:quiet'
+    after 'deploy:updated', 'sidekiq:stop'
+    after 'deploy:reverted', 'sidekiq:stop'
+    after 'deploy:published', 'sidekiq:start'
+  end
+
+  desc 'Quiet sidekiq (stop processing new tasks)'
+  task :quiet do
+    on roles fetch(:sidekiq_roles) do
+      if test("[ -d #{current_path} ]") # fixes #11
+        for_each_process(true) do |pid_file, idx|
+          if pid_process_exists?(pid_file)
+            quiet_sidekiq(pid_file)
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Stop sidekiq'
+  task :stop do
+    on roles fetch(:sidekiq_roles) do
+      if test("[ -d #{current_path} ]")
+        for_each_process(true) do |pid_file, idx|
+          if pid_process_exists?(pid_file)
+            stop_sidekiq(pid_file)
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Start sidekiq'
+  task :start do
+    on roles fetch(:sidekiq_roles) do
+      for_each_process do |pid_file, idx|
+        start_sidekiq(pid_file, idx) unless pid_process_exists?(pid_file)
+      end
+    end
+  end
+
+  desc 'Restart sidekiq'
+  task :restart do
+    invoke 'sidekiq:stop'
+    invoke 'sidekiq:start'
+  end
+
+  desc 'Rolling-restart sidekiq'
+  task :rolling_restart do
+    on roles fetch(:sidekiq_roles) do
+      for_each_process(true) do |pid_file, idx|
+        if pid_process_exists?(pid_file)
+          stop_sidekiq(pid_file)
+        end
+        start_sidekiq(pid_file, idx)
+      end
+    end
+  end
+
+  # Delete any pid file not in use
+  task :cleanup do
+    on roles fetch(:sidekiq_roles) do
+      for_each_process do |pid_file, idx|
+        if pid_file_exists?(pid_file)
+          execute "rm #{pid_file}" unless pid_process_exists?(pid_file)
+        end
+      end
+    end
+  end
+
+  # TODO : Don't start if all proccess are off, raise warning.
+  desc 'Respawn missing sidekiq proccesses'
+  task :respawn do
+    invoke 'sidekiq:cleanup'
+    on roles fetch(:sidekiq_roles) do
+      for_each_process do |pid_file, idx|
+        unless pid_file_exists?(pid_file)
+          start_sidekiq(pid_file, idx)
+        end
+      end
+    end
+  end
+
+  # => def template_sidekiq(from, to, role)
+  # =>   [
+  # =>       File.join('lib', 'capistrano', 'templates', "#{from}-#{role.hostname}-#{fetch(:stage)}.rb"),
+  # =>       File.join('lib', 'capistrano', 'templates', "#{from}-#{role.hostname}.rb"),
+  # =>       File.join('lib', 'capistrano', 'templates', "#{from}-#{fetch(:stage)}.rb"),
+  # =>       File.join('lib', 'capistrano', 'templates', "#{from}.rb.erb"),
+  # =>       File.join('lib', 'capistrano', 'templates', "#{from}.rb"),
+  # =>       File.join('lib', 'capistrano', 'templates', "#{from}.erb"),
+  # =>       File.expand_path("../../templates/#{from}.rb.erb", __FILE__),
+  # =>       File.expand_path("../../templates/#{from}.erb", __FILE__)
+  # =>   ].each do |path|
+  # =>     if File.file?(path)
+  # =>       erb = File.read(path)
+  # =>       upload! StringIO.new(ERB.new(erb).result(binding)), to
+  # =>       break
+  # =>     end
+  # =>   end
+  # => end
+
+end

data/lib/capistrano/tasks/thin.rake

@@ -0,0 +1,48 @@
+require 'capistrano/magic_recipes/base_helpers'
+include Capistrano::MagicRecipes::BaseHelpers
+
+namespace :load do
+  task :defaults do
+    set :thin_path, -> { '/etc/thin' }
+    set :thin_roles, -> { :web }
+  end
+end
+
+
+
+namespace :thin do
+  
+  
+  desc "rewrite thin-configurations"
+  task :reconf => ['nginx:load_vars'] do
+    on release_roles fetch(:thin_roles) do
+      within current_path do
+        magic_template("thin_app_yml", '/tmp/thin_app.yml')
+        execute :sudo, :mv, '/tmp/thin_app.yml', "config/thin_app_#{fetch(:stage)}.yml"
+        execute :sudo, :rm, ' -f', "#{fetch(:thin_path)}/thin_#{fetch(:application)}_#{fetch(:stage)}*"
+        execute :sudo, :ln, ' -sf', "#{current_path}/config/thin_app_#{fetch(:stage)}.yml", "#{fetch(:thin_path)}/thin_#{fetch(:application)}_#{fetch(:stage)}.yml"
+      end
+    end
+  end
+  
+  
+  %w[start stop restart].each do |command|
+    desc "#{command} thin"
+    task command => ['nginx:load_vars'] do
+      on release_roles fetch(:thin_roles) do
+        within current_path do
+          execute :bundle, :exec, :thin, "#{command} -C config/thin_app_#{fetch(:stage)}.yml"
+        end
+      end
+    end
+  end
+  
+  
+end
+
+after 'deploy:published', nil do
+  on release_roles fetch(:thin_roles) do
+    invoke "thin:reconf"
+    invoke "thin:restart"
+  end
+end

data/lib/generators/capistrano/magic_recipes/templates/capistrano3_nginx_conf.erb

@@ -0,0 +1,68 @@
+<% if fetch(:app_server) && (fetch(:app_server_socket) || fetch(:app_server_port))%>
+# Define App Server Upstream
+upstream <%= fetch(:application) %>-app-server {
+<% if fetch(:app_server_socket) %>
+  server unix:<%= fetch(:app_server_socket) %> fail_timeout=0;
+<% elsif fetch(:app_server_port) %>
+  server <%= fetch(:app_server_host, '127.0.0.1') %>:<%= fetch(:app_server_port) %> fail_timeout=0;
+<% end %>
+}
+<% end %>
+
+# HTTP Server
+
+<% if fetch(:nginx_use_ssl) %>
+server {
+  listen 80;
+  rewrite ^(.*) https://$host$1 permanent;
+}
+<% end %>
+
+server {
+
+<% if fetch(:nginx_use_ssl) %>
+  listen 443;
+  ssl on;
+  ssl_certificate <%= fetch(:nginx_ssl_certificate_path) %>/<%= fetch(:nginx_ssl_certificate) %>;
+  ssl_certificate_key <%= fetch(:nginx_ssl_certificate_key_path) %>/<%= fetch(:nginx_ssl_certificate_key) %>;
+<% else %>
+  listen 80;
+<% end %>
+
+  server_name <%= fetch(:nginx_domains) %>;
+  root        <%= fetch(:deploy_to) %>/current/<%= fetch(:nginx_static_dir) %>;
+
+  access_log <%= fetch(:nginx_log_path) %>/nginx-access.log;
+  error_log  <%= fetch(:nginx_log_path) %>/nginx-error.log;
+
+  error_page 404 /404.html;
+  location /404.html { root <%= fetch(:deploy_to) %>/current/<%= fetch(:nginx_static_dir) %>; }
+
+  error_page 500 /500.html;
+  location /500.html { root <%= fetch  (:deploy_to) %>/current/<%= fetch(:nginx_static_dir) %>; }
+
+  client_max_body_size 4G;
+  keepalive_timeout 10;
+
+<% if fetch(:app_server) && (fetch(:app_server_socket) || fetch(:app_server_port))%>
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+
+  try_files $uri/index.html $uri @<%= fetch(:application) %>-app-server;
+
+  location @<%= fetch(:application) %>-app-server {
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-FORWARDED_PROTO http;
+    proxy_set_header Host $http_host;
+  <% if fetch(:nginx_use_ssl) %>
+    proxy_set_header X-Forwarded-Proto https;
+  <% end %>
+    proxy_redirect off;
+    proxy_pass http://<%= fetch(:application) %>-app-server;
+  }
+<% end %>
+}

data/lib/generators/capistrano/magic_recipes/templates/monit/monitrc.erb

@@ -0,0 +1,67 @@
+set daemon <%= fetch(:monit_interval) %>
+
+set logfile /var/log/monit.log
+set idfile /var/lib/monit/id
+set statefile /var/lib/monit/state
+
+set eventqueue
+    basedir /var/lib/monit/events
+    slots 100
+
+set mail-format {
+        from: <%= fetch(:monit_mail_from) %>
+    reply-to: <%= fetch(:monit_mail_reply_to) %>
+     subject: !!! $EVENT on $SERVICE !!!
+     message: $EVENT on $SERVICE - $DESCRIPTION.
+              
+              - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+              When:     $DATE
+              What:     $EVENT   [$ACTION]
+              Where:    $SERVICE
+              More:     $DESCRIPTION
+              Server:   $HOST
+              - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+              
+              Your faithful employee,
+              M O N I T
+              
+              <% if fetch(:monit_http_client) %><% if fetch(:monit_http_domain) %>
+              Web:      <%= fetch(:monit_http_use_ssl) ? "https" : "http" %>://<%= fetch(:monit_http_domain) %>:2812/
+              <% else %>
+              Web:      <%= fetch(:monit_http_use_ssl) ? "https" : "http" %>://<%= fetch(:app_server_ip) %>:2812/
+              <% end %><% end %>
+}
+
+set mailserver <%= fetch(:monit_mail_server) %> port <%= fetch(:monit_mail_port) %>
+    username "<%= fetch(:monit_mail_username) %>" password "<%= fetch(:monit_mail_password) %>"
+    <% if fetch(:monit_mail_authentication) %>
+    using <%= fetch(:monit_mail_authentication) %>
+    <% end %>
+    with timeout 30 seconds
+
+set alert <%= fetch(:monit_mail_to) %>
+
+<% if fetch(:monit_http_client) %>
+set httpd port <%= fetch(:monit_http_port) %>
+    <% if fetch(:monit_http_domain) %>
+    use address <%= fetch(:monit_http_domain) %>
+    <% end %>
+    # allow careagents.cloudapp.net
+    # allow 191.233.74.184
+    # allow 127.0.0.1
+    <% if fetch(:monit_http_use_ssl) %>
+    ssl enable
+    pemfile <%= fetch(:monit_http_pemfile) %>
+    <% end %>
+    allow <%= fetch(:monit_http_username) %>:<%= fetch(:monit_http_password) %>
+<% end %>
+
+check system <%= fetch(:application) %>_server
+    if loadavg(5min) > 2 for 2 cycles then alert
+    if memory > 75% for 2 cycles then alert
+    if cpu(user) > 75% for 2 cycles then alert
+
+check device HardDrive with path /
+    if SPACE usage > 75% then alert
+
+include /etc/monit/conf.d/*

data/lib/generators/capistrano/magic_recipes/templates/monit/nginx.erb

@@ -0,0 +1,9 @@
+# Monit configuration for NGINX :  <%= fetch(:application) %>
+check process nginx with pidfile /var/run/nginx.pid
+  start program = "/etc/init.d/nginx start"
+  stop program = "/etc/init.d/nginx stop"
+  if children > 250 then restart
+  if failed host 127.0.0.1 port 80 then restart
+  if cpu is greater than 40% for 2 cycles then alert
+  if cpu > 60% for 5 cycles then restart 
+  if 10 restarts within 10 cycles then timeout

data/lib/generators/capistrano/magic_recipes/templates/monit/postgresql.erb

@@ -0,0 +1,6 @@
+# Monit configuration for POSTGRESQL :  <%= fetch(:application) %>
+check process postgresql with pidfile <%= fetch(:postgresql_pid) %>
+  start program = "/etc/init.d/postgresql start"
+  stop program = "/etc/init.d/postgresql stop"
+  if failed host localhost port 5432 protocol pgsql then restart
+  if 5 restarts within 5 cycles then timeout

data/lib/generators/capistrano/magic_recipes/templates/monit/redis.erb

@@ -0,0 +1,10 @@
+# Monit configuration for REDIS :  <%= fetch(:application) %>
+check process redis with pidfile <%= fetch(:redis_pid) %>
+    start program = "/etc/init.d/redis-server start"
+    stop program = "/etc/init.d/redis-server stop"
+    if 2 restarts within 3 cycles then timeout
+    if totalmem > 100 Mb then alert
+    if children > 255 for 5 cycles then stop
+    if cpu usage > 95% for 3 cycles then restart
+    if failed host 127.0.0.1 port 6379 then restart
+    if 5 restarts within 5 cycles then timeout

data/lib/generators/capistrano/magic_recipes/templates/monit/sidekiq.erb

@@ -0,0 +1,30 @@
+# Monit configuration for SIDEKIQ :  <%= fetch(:application) %>  (<%= fetch(:stage) %>)
+<% processes_pids.each_with_index do |pid_file, idx| %>
+<% 
+  args = []                                                                               
+  args.push "--index #{idx}"                                                              
+  args.push "--pidfile #{pid_file}"                                                       
+  args.push "--environment #{fetch(:sidekiq_env)}"                                        
+  args.push "--logfile #{fetch(:sidekiq_log)}" if fetch(:sidekiq_log)                     
+  args.push "--require #{fetch(:sidekiq_require)}" if fetch(:sidekiq_require)             
+  args.push "--tag #{fetch(:sidekiq_tag)}" if fetch(:sidekiq_tag)                         
+  Array(fetch(:sidekiq_queue)).each do |queue|                                            
+    args.push "--queue #{queue}"                                                          
+  end                                                                                     
+  args.push "--config #{fetch(:sidekiq_config)}" if fetch(:sidekiq_config)                
+  args.push "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency) 
+  # use sidekiq_options for special options                                               
+  args.push fetch(:sidekiq_options) if fetch(:sidekiq_options)                            
+  args.push '--daemon'                                                                    
+%>
+check process <%= sidekiq_service_name(idx) %>
+  with pidfile "<%= pid_file %>"
+  start program = "/bin/su - <%= @role.user %> -c 'cd <%= current_path %> ; bundle exec sidekiq <%= args.join(" ") %>'" with timeout 30 seconds
+  stop program = "/bin/su - <%= @role.user %> -c 'cd <%= current_path %> ; bundle exec sidekiqctl stop <%= pid_file %>' " with timeout <%= fetch(:sidekiq_timeout).to_i + 10  %> seconds
+  group <%= fetch(:sidekiq_monit_group, fetch(:application)) %>-sidekiq
+  if totalmem is greater than 200 MB for 2 cycles then restart
+  if 3 restarts within 5 cycles then timeout
+  alert <%= fetch(:monit_mail_to) %> only on { pid }
+  if 2 restarts within 3 cycles then alert
+  if changed pid 2 times within 10 cycles then alert
+<% end %>

data/lib/generators/capistrano/magic_recipes/templates/monit/thin.erb

@@ -0,0 +1,13 @@
+# Monit configuration for THIN :  <%= fetch(:application) %>  (<%= fetch(:stage) %>)
+<%  fetch(:app_instances, 1).times do |n| %>
+  check process <%= fetch(:application) %>_<%= fetch(:stage) %>_thin_<%= n %> with pidfile <%= deploy_to %>/shared/pids/thin_<%= fetch(:application) %>_<%= fetch(:stage) %>.<%= n %>.pid
+    group thin-<%= fetch(:application) %>
+    group thin-<%= fetch(:stage) %>
+    start program = "/bin/su - <%= fetch(:user) %> -c 'cd <%= current_path %> ; bundle exec thin start -C config/thin_app_<%= fetch(:stage) %>.yml -o <%= n %>' "
+    stop program = "/bin/su - <%= fetch(:user) %> -c 'cd <%= current_path %> ; bundle exec thin stop -C config/thin_app_<%= fetch(:stage) %>.yml -o <%= n %>' " 
+    if mem > 200.0 MB for 1 cycles then restart
+    if cpu > 50% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+    alert <%= fetch(:monit_mail_to) %> only on { pid }
+    if changed pid 2 times within 20 cycles then alert
+<% end %>

data/lib/generators/capistrano/magic_recipes/templates/monit/website.erb

@@ -0,0 +1,9 @@
+# Check domains on port 80 <%= "(and 443 if ssl is on)" if fetch(:nginx_use_ssl) %> for <%= fetch(:application) %> [<%= fetch(:stage) %>]
+<% Array(fetch(:nginx_domains)).each do |domain| %>
+<% domain = domain.gsub(/^\*?\./, "") %>
+check host <%= domain %> with address <%= fetch(:app_server_ip) %>
+  if failed port 80 protocol http then alert
+  # <% if fetch(:nginx_use_ssl) %>if failed port 443 type TCPSSL protocol http then alert<% end %>
+
+
+<% end %>

data/lib/generators/capistrano/magic_recipes/templates/nginx.conf.erb

@@ -0,0 +1,139 @@
+upstream thin_<%= fetch(:application) %>_<%= fetch(:stage) %>_cluster {
+  <% fetch(:app_instances).to_i.times do |i| %>
+  server unix:/tmp/thin.<%= fetch(:application) %>.<%= fetch(:stage) %>.<%= i %>.sock  max_fails=1 fail_timeout=15s;
+  <% end %>
+}
+
+# HTTP Server
+<% if fetch(:nginx_use_ssl) %>
+<% if fetch(:nginx_major_domain) %>
+server {
+  listen 80<%= ' default_server' if fetch(:default_site) %>;
+  server_name <%= Array(fetch(:nginx_domains)).map{ |d| d.gsub(/^\*?\./, "") }.join("\n              ") %>
+              <%= ".#{fetch(:nginx_major_domain).gsub(/^\*?\./, "")}" %>;
+  
+  # return 301 https://<%= fetch(:nginx_major_domain).gsub(/^\*?\./, "") %>$request_uri;
+  
+  location ^~ /assets/ico/ {
+    root        <%= current_path %>/public;
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+  location / {
+    return 301 https://<%= fetch(:nginx_major_domain).gsub(/^\*?\./, "") %>$request_uri;
+  }
+  
+}
+server {
+  listen 80;
+  server_name <%= Array(fetch(:nginx_domains)).map{ |d| "~^(?<sub>\w+)#{ Regexp.escape( ".#{d.gsub(/^\*?\./, "")}" ) }" }.join("\n              ") %>
+              <%= "~^#{Regexp.escape("www.")}(?<sub>\w+)#{ Regexp.escape( ".#{fetch(:nginx_major_domain).gsub(/^\*?\./, "")}" ) }" %>
+              <%= "~^(?<sub>\w+)#{ Regexp.escape( ".#{fetch(:nginx_major_domain).gsub(/^\*?\./, "")}" ) }" %>;
+  
+  # return 301 https://$sub.<%= fetch(:nginx_major_domain).gsub(/^\*?\./, "") %>$request_uri;
+  
+  location ^~ /assets/ico/ {
+    root        <%= current_path %>/public;
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+  location / {
+    return 301 https://$sub.<%= fetch(:nginx_major_domain).gsub(/^\*?\./, "") %>$request_uri;
+  }
+  
+}
+<% else %>
+server {
+  listen 80;
+  server_name <%= Array(fetch(:nginx_domains)).map{ |d| d[0] == "." ? d : ".#{d}"}.join("\n              ") %>;
+  # return 301 https://$host$request_uri;
+  
+  location ^~ /assets/ico/ {
+    root        <%= current_path %>/public;
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+  location / {
+    return 301 https://$host$request_uri;
+  }
+  
+}
+<% end %>
+<% end %>
+
+<% if fetch(:nginx_major_domain) %>
+server {
+  listen 443;
+  server_name <%= Array(fetch(:nginx_domains)).map{ |d| d.gsub(/^\*?\./, "") }.join("\n              ") %>;
+  return 301 https://<%= fetch(:nginx_major_domain).gsub(/^\*?\./, "") %>$request_uri;
+  ssl on;
+  ssl_certificate <%= fetch(:nginx_ssl_certificate_path) %>/<%= fetch(:nginx_old_ssl_certificate) %>;
+  ssl_certificate_key <%= fetch(:nginx_ssl_certificate_key_path) %>/<%= fetch(:nginx_old_ssl_certificate_key) %>;
+}
+server {
+  listen 443;
+  server_name <%= Array(fetch(:nginx_domains)).map{ |d| "~^(?<sub>\w+)\.#{ Regexp.escape( d.gsub(/^\*?\./, "") ) }" }.join("\n              ") %>;
+  return 301 https://$sub.<%= fetch(:nginx_major_domain).gsub(/^\*?\./, "") %>$request_uri;
+  ssl on;
+  ssl_certificate <%= fetch(:nginx_ssl_certificate_path) %>/<%= fetch(:nginx_old_ssl_certificate) %>;
+  ssl_certificate_key <%= fetch(:nginx_ssl_certificate_key_path) %>/<%= fetch(:nginx_old_ssl_certificate_key) %>;
+}
+<% end %>
+
+server {
+<% if fetch(:nginx_use_ssl) %>
+  listen 443<%= ' default_server ssl' if fetch(:default_site) %>;
+  ssl on;
+  ssl_certificate <%= fetch(:nginx_ssl_certificate_path) %>/<%= fetch(:nginx_ssl_certificate) %>;
+  ssl_certificate_key <%= fetch(:nginx_ssl_certificate_key_path) %>/<%= fetch(:nginx_ssl_certificate_key) %>;
+<% else %>
+  listen 80<%= ' default deferred' if fetch(:default_site) %>;
+<% end %>
+  <% if fetch(:nginx_major_domain) %>
+  server_name <%= ".#{fetch(:nginx_major_domain).gsub(/^\*?\./, "")}" %>;
+  <% else %>
+  server_name <%= Array( fetch(:nginx_domains) ).join("\n              ") %>;
+  <% end %>
+  
+  if ($host ~* ^www\.(.*)) {
+    set $host_without_www $1;
+    rewrite ^(.*) http://$host_without_www$1 permanent;
+  }
+
+  root        <%= current_path %>/public;
+
+  access_log <%= fetch(:nginx_log_path) %>/nginx-access.log;
+  error_log  <%= fetch(:nginx_log_path) %>/nginx-error.log;
+
+  error_page 404 /404.html;
+  location /404.html { root <%= fetch(:deploy_to) %>/current/<%= fetch(:nginx_static_dir) %>; }
+
+  error_page 500 502 503 504 /500.html;
+  location /500.html { root <%= fetch  (:deploy_to) %>/current/<%= fetch(:nginx_static_dir) %>; }
+
+  client_max_body_size 4G;
+  keepalive_timeout 10;
+
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+
+  try_files $uri/index.html $uri @thin_<%= fetch(:application) %>_<%= fetch(:stage) %>;
+
+  location @thin_<%= fetch(:application) %>_<%= fetch(:stage) %> {
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-FORWARDED_PROTO http;
+    proxy_set_header Host $host:$server_port;
+  <% if fetch(:nginx_use_ssl) %>
+    proxy_set_header X-Forwarded-Proto https;
+  <% end %>
+    proxy_redirect off;
+    proxy_pass http://thin_<%= fetch(:application) %>_<%= fetch(:stage) %>_cluster;
+  }
+}

data/lib/generators/capistrano/magic_recipes/templates/postgresql.yml.erb

@@ -0,0 +1,8 @@
+<%= fetch :stage %>:
+  adapter: postgresql
+  encoding: <%= fetch :pg_encoding %>
+  database: <%= fetch :pg_database %>
+  pool: <%= fetch :pg_pool %>
+  username: <%= fetch :pg_user %>
+  password: '<%= fetch :pg_password %>'
+  host: <%= fetch :pg_host %>