kapify 0.0.1

data/lib/kapify/logrotate/README.md

@@ -0,0 +1,83 @@
+# kapify/logrotate
+
+Capistrano task for enabling log rotation for your Rails application
+
+Provides capistrano tasks to:
+
+* creates logrotate record to rotate application logs
+
+For full customization, config can be copied to the application using generator.
+
+## Usage
+
+Add this line to your `deploy.rb`
+
+    require 'kapify/logrotate'
+
+Note, that following capistrano variables should be defined:
+
+    shared_path
+    user
+
+You can check that new tasks are available (`cap -T`):
+
+    # create logrotate record to rotate application logs
+    cap logrotate
+
+There is no need to execute any of these tasks manually.
+They will be called automatically on different deploy stages:
+
+* `logrotate` is hooked to `deploy:setup`
+
+This means that if you run `cap deploy:setup`,
+logrotate will be automatically set up.
+
+## Template Customization
+
+If you want to change default template, you can generate them using `rails generator`
+
+    rails g kapify:logrotate
+
+This will copy default templates to `config/deploy/templates` directory,
+so you can customize them as you like, and capistrano tasks will use this templates instead of default.
+
+You can also provide path, where to generate templates:
+
+    rails g kapify:logrotate config/templates
+
+In this case, don't forget to set `templates_path` varibale:
+
+```ruby
+# path to customized templates (see below for details)
+# default value: "config/deploy/templates"
+set :templates_path, "config/deploy/templates"
+```
+
+For example, if you also use nginx and unicorn, you want to notify them about rotation.
+In this case, your template file could look like this:
+
+```erb
+<%= shared_path %>/log/*.log {
+  daily
+  missingok
+  rotate 180
+  compress
+  dateext
+  delaycompress
+
+  lastaction
+    pid=<%= unicorn_pid %>
+    test -s $pid && kill -USR1 "$(cat $pid)"
+  endscript
+
+  prerotate
+    if [ -d /etc/logrotate.d/httpd-prerotate ]; then \
+      run-parts /etc/logrotate.d/httpd-prerotate; \
+    fi \
+  endscript
+
+  postrotate
+    [ ! -f /run/nginx.pid ] || kill -USR1 `cat /run/nginx.pid`
+  endscript
+}
+```

data/lib/kapify/logrotate/configuration.rb

@@ -0,0 +1,15 @@
+require 'capistrano'
+require 'kapify/base'
+
+Capistrano::Configuration.instance.load do
+  namespace :kapify do
+    desc "Setup logs rotation for application logs"
+    task :logrotate, roles: [:web, :app] do
+      kapify_template("logrotate", "logrotate.erb", "/tmp/#{application}_logrotate")
+      run "#{sudo} mv /tmp/#{application}_logrotate /etc/logrotate.d/#{application}"
+      run "#{sudo} chown root:root /etc/logrotate.d/#{application}"
+    end
+
+    after "deploy:setup", "kapify:logrotate"
+  end
+end

data/lib/kapify/logrotate.rb

@@ -0,0 +1 @@
+require 'kapify/logrotate/configuration'

data/lib/kapify/nginx/README.md

@@ -0,0 +1,105 @@
+# kapify/nginx
+
+Capistrano tasks for configuration of nginx web server.
+
+Provides capistrano tasks to:
+
+* easily add application to nginx and reload it's configuration
+
+Provides several capistrano variables for easy customization.
+Also, for full customization, all configs can be copied to the application using generators.
+
+## Usage
+
+Add this line to your `deploy.rb`
+
+    require 'kapify/nginx'
+
+Note, that following capistrano variables should be defined:
+
+    application
+    current_path
+    shared_path
+    user
+
+You can check that new tasks are available (`cap -T`):
+
+    # add and enable application to nginx
+    cap kapify:nginx:setup
+
+    # reload nginx configuration
+    cap kapify:nginx:reload
+
+There is no need to execute any of these tasks manually.
+They will be called automatically on different deploy stages:
+
+* `kapify:nginx:setup` and `kapify:nginx:reload` are hooked to `deploy:setup`
+
+This means that if you run `cap deploy:setup`,
+nginx will be automatically configured.
+
+However, if you changed variables or customized templates,
+you can run any of these tasks to update configuration.
+
+## Customization
+
+### Using variables
+
+You can customize nginx config using capistrano variables:
+
+
+```ruby
+# path to customized templates (see below for details)
+# default value: "config/deploy/templates"
+set :templates_path, "config/deploy/templates"
+
+# server name for nginx, default value: no (will be prompted if not set)
+# set this to your site name as it is visible from outside
+# this will allow 1 nginx to serve several sites with different `server_name`
+set :nginx_server_name, "example.com"
+
+# if set, nginx will be configured to 443 port and port 80 will be auto rewritten to 443
+# also, on `nginx:setup`, paths to ssl certificate and key will be configured
+# and certificate file and key will be copied to `/etc/ssl/certs` and `/etc/ssl/private/` directories
+# default value: false
+set :nginx_use_ssl, false
+
+# remote file name of the certificate, only makes sense if `nginx_use_ssl` is set
+# default value: `nginx_server_name + ".crt"`
+set :nginx_ssl_certificate, "#{nginx_server_name}.crt"
+
+# remote file name of the certificate, only makes sense if `nginx_use_ssl` is set
+# default value: `nginx_server_name + ".key"`
+set :nginx_ssl_certificate_key, "#{nginx_server_name}.key"
+
+# local path to file with certificate, only makes sense if `nginx_use_ssl` is set
+# this file will be copied to remote server
+# default value: none (will be prompted if not set)
+set :nginx_ssl_certificate_local_path, "/home/ivalkeen/ssl/myssl.cert"
+
+# local path to file with certificate key, only makes sense if `nginx_use_ssl` is set
+# this file will be copied to remote server
+# default value: none (will be prompted if not set)
+set :nginx_ssl_certificate_key_local_path, "/home/ivalkeen/ssl/myssl.key"
+```
+
+For example, of you site name is `example.com`,
+your `deploy.rb` will look like this:
+
+```ruby
+set :server_name, "example.com"
+require 'kapify/nginx'
+```
+
+### Template Customization
+
+If you want to change default templates, you can generate them using `rails generator`
+
+    rails g kapify:nginx
+
+This will copy default templates to `config/deploy/templates` directory,
+so you can customize them as you like, and capistrano tasks will use this templates instead of default.
+
+You can also provide path, where to generate templates:
+
+    rails g kapify/nginx config/templates

data/lib/kapify/nginx/configuration.rb

@@ -0,0 +1,41 @@
+require 'capistrano'
+require 'kapify/base'
+
+Capistrano::Configuration.instance.load do
+  set_default(:nginx_server_name) { Capistrano::CLI.ui.ask "Nginx server name: " }
+  set_default(:nginx_use_ssl, false)
+  set_default(:nginx_ssl_certificate) { "#{nginx_server_name}.crt" }
+  set_default(:nginx_ssl_certificate_key) { "#{nginx_server_name}.key" }
+  set_default(:nginx_ssl_certificate_local_path) {Capistrano::CLI.ui.ask "Local path to ssl certificate: "}
+  set_default(:nginx_ssl_certificate_key_local_path) {Capistrano::CLI.ui.ask "Local path to ssl certificate key: "}
+
+  namespace :kapify do
+    namespace :nginx do
+      desc "Setup nginx configuration for this application"
+      task :setup, roles: :web do
+        kapify_template("nginx", "nginx_conf.erb", "/tmp/#{application}")
+        run "#{sudo} mv /tmp/#{application} /etc/nginx/sites-available/#{application}"
+        run "#{sudo} ln -fs /etc/nginx/sites-available/#{application} /etc/nginx/sites-enabled/#{application}"
+
+        if nginx_use_ssl
+          put File.read(nginx_ssl_certificate_local_path), "/tmp/#{nginx_ssl_certificate}"
+          put File.read(nginx_ssl_certificate_key_local_path), "/tmp/#{nginx_ssl_certificate_key}"
+
+          run "#{sudo} mv /tmp/#{nginx_ssl_certificate} /etc/ssl/certs/#{nginx_ssl_certificate}"
+          run "#{sudo} mv /tmp/#{nginx_ssl_certificate_key} /etc/ssl/private/#{nginx_ssl_certificate_key}"
+
+          run "#{sudo} chown root:root /etc/ssl/certs/#{nginx_ssl_certificate}"
+          run "#{sudo} chown root:root /etc/ssl/private/#{nginx_ssl_certificate_key}"
+        end
+      end
+
+      after "deploy:setup", "kapify:nginx:setup"
+      after "deploy:setup", "kapify:nginx:reload"
+
+      desc "Reload nginx configuration"
+      task :reload, roles: :web do
+        run "#{sudo} /etc/init.d/nginx reload"
+      end
+    end
+  end
+end

data/lib/kapify/nginx.rb

@@ -0,0 +1 @@
+require 'kapify/nginx/configuration'

data/lib/kapify/pg/README.md

@@ -0,0 +1,118 @@
+# kapify/pg
+
+Capistrano tasks for basic configuration and management of PostgreSQL database.
+
+Provides capistrano tasks to:
+
+* create database.yml in `shared` folder and symlink into `config`
+* create user and database in postgres
+
+Provides several capistrano variables for easy customization.
+Also, for full customization, template of `database.yml` file can be copied to
+the application using generator.
+
+## Usage
+
+Add this line to your `deploy.rb`
+
+    require 'kapify/pg'
+
+Next, add role `pg` to the server which has running instance of PostgreSQL.
+Address of this server will be automatically used as `pg_host` (see below),
+`create_user` and `create_database` tasks will be executed on this server:
+
+```ruby
+# for dedicated database server it could look like this:
+server "192.168.33.12", :db, :pg, no_release: true
+
+# for all-in-one server it could look like this:
+server "192.168.33.11", :web, :app, :db, :pg, primary: true
+```
+
+Note, that following capistrano variables should be defined in the `deploy.rb` file:
+
+    application
+    current_path
+    shared_path
+    user
+
+You can check that new tasks are available (`cap -T`):
+
+    # create database user for the application
+    cap kapify:pg:create_user
+
+    # create database for the application
+    cap kapify:pg:create_database
+
+    # generates `database.yml` file in the `shared/config` folder
+    cap kapify:pg:setup
+
+    # symlinks `database.yml` from the `shared/config` folder to `current/config` folder
+    cap kapify:pg:symlink
+
+There is no need to execute any of these tasks manually.
+They will be called automatically on different deploy stages:
+
+* `kapify:pg:create_user`, `kapify:pg:create_database` and `kapify:pg:setup` are hooked to `deploy:setup`
+* `kapify:pg:symlink` is hooked to `deploy:finalize_update`
+
+This means that if you run `cap deploy:setup`,
+user and database will be created and `database.yml` file will be generated.
+And on each deploy, `database.yml` will be automatically linked to current version.
+
+However, if you changed variables or customized templates,
+you can run any of these tasks to update configuration.
+
+## Customization
+
+### Using variables
+
+You can customize `database.yml` using capistrano variables:
+
+```ruby
+# path to customized templates (see below for details)
+# default value: "config/deploy/templates"
+set :templates_path, "config/deploy/templates"
+
+# `host` value in `database.yml`
+# default value: address of the server, marked with `pg` role
+set :pg_host, "localhost"
+
+# `port` value in `database.yml`
+# default value: 5432
+set :pg_port, "5432"
+
+# `database` value in `database.yml`
+# default value: application variable value
+set :pg_database, "myapp_production"
+
+# `pool` value in `database.yml`
+# default value: 5
+set :pg_pool, "5"
+
+# `username` value in `database.yml`
+# default value: application variable value
+set :pg_user, application
+
+# `password` value in `database.yml`
+# default value: will be asked if not set
+# setting this value in config file is not recommended
+set :pg_password, application
+
+# indicates, it new database should be created on `deploy:setup` or not
+# default value: true
+set :pg_create_db, true
+```
+
+### Template Customization
+
+If you want to change default template, you can generate it using `rails generator`
+
+    rails g kapify:pg
+
+This will copy default template to `config/deploy/templates` directory,
+so you can customize them as you like, and capistrano tasks will use this templates instead of default.
+
+You can also provide path, where to generate template:
+
+    rails g kapify:pg config/templates

data/lib/kapify/pg/configuration.rb

@@ -0,0 +1,52 @@
+require 'capistrano'
+require 'kapify/base'
+
+Capistrano::Configuration.instance.load do
+  set_default(:pg_host) { find_servers(roles: :pg)[0] || "localhost" }
+  set_default(:pg_port, "5432")
+  set_default(:pg_database, application)
+  set_default(:pg_pool, 5)
+  set_default(:pg_user, application)
+  set_default(:pg_password) { Capistrano::CLI.password_prompt "PG password: " }
+  set_default(:pg_create_db, true)
+
+  namespace :kapify do
+    namespace :pg do
+      desc "Create user for application"
+      task :create_user, roles: :pg do
+        pg_params = "-p #{pg_port}"
+        check_user = %Q[#{sudo} -u postgres psql #{pg_params} postgres -c "select * from pg_user where usename='#{pg_user}'" | grep -c '#{pg_user}']
+        add_user = %Q[#{sudo} -u postgres psql #{pg_params} -c "create user #{pg_user}"]
+        run "#{check_user} || #{add_user}"
+        run %Q{#{sudo} -u postgres psql #{pg_params} -c "alter user #{pg_user} with password '#{pg_password}'" }
+      end
+
+      desc "Create database for application"
+      task :create_database, roles: :pg do
+        if pg_create_db
+          run %Q{#{sudo} -u postgres psql -c "create database #{pg_database} owner #{pg_user};"}
+        end
+      end
+
+      if find_servers(roles: :pg).size > 0
+        after "deploy:setup", "kapify:pg:create_user"
+        after "deploy:setup", "kapify:pg:create_database"
+      end
+
+      desc "Generate the database.yml configuration file."
+      task :setup, roles: :app do
+        run "mkdir -p #{shared_path}/config"
+        kapify_template("pg", "database.yml.erb", "#{shared_path}/config/database.yml")
+      end
+
+      after "deploy:setup", "kapify:pg:setup"
+
+      desc "Symlink the database.yml file into latest release"
+      task :symlink, roles: :app do
+        run "ln -nfs #{shared_path}/config/database.yml #{release_path}/config/database.yml"
+      end
+
+      after "deploy:finalize_update", "kapify:pg:symlink"
+    end
+  end
+end

data/lib/kapify/pg.rb

@@ -0,0 +1 @@
+require 'kapify/pg/configuration'

data/lib/kapify/resque/README.md

@@ -0,0 +1,104 @@
+# kapify/pg
+
+Capistrano tasks for basic configuration and management of Resque.
+
+Provides capistrano tasks to:
+
+* create resque init script for application, so it will be automatically started when OS restarts
+* start/stop resque (also can be done using `sudo service resque_<your_app> start/stop`)
+* gracefully restart resque on deployment
+
+Provides several capistrano variables for easy customization.
+Also, for full customization, init script's config can be copied to the application using generators.
+
+## Usage
+
+Add this line to your `deploy.rb`
+
+    require 'kapify/resque'
+
+Next, add role `resque_worker` to the server which you want resque workers to be started on.
+
+Note, that following capistrano variables should be defined:
+
+    application
+    current_path
+    shared_path
+    user
+
+You can check that new tasks are available (`cap -T`):
+
+    # create resque configuration and init script
+    cap kapify:resque:setup
+
+    # start resque
+    cap kapify:resque:start
+
+    # stop resque
+    cap kapify:resque:stop
+
+    # gracefully restart resque
+    cap kapify:resque:restart
+
+There is no need to execute any of these tasks manually.
+They will be called automatically on different deploy stages:
+
+* `kapify:resque:setup` is hooked to `deploy:setup`
+* `kapify:resque:restart` is hooked to `deploy:restart`
+
+This means that if you run `cap deploy:setup`,
+resque will be automatically configured.
+And after each deploy, resque will be automatically reloaded.
+
+However, if you changed variables or customized templates,
+you can run any of these tasks to update configuration.
+
+## Customization
+
+### Using variables
+
+You can customize resque configs using capistrano variables:
+
+```ruby
+# user name to run resque
+# default value: `user` (user varibale defined in your `deploy.rb`)
+set :resque_user, "user"
+
+# number of resque workers
+# default value: 2
+set :resque_workers, 4
+
+# name of resque workers queue
+# default value: *
+set :resque_queue, "*"
+
+# path to the bundle command
+# default value: /usr/local/rbenv/shims/bundle (for globally installed rbenv)
+set :resque_bundle, "/usr/bin/bundle"
+
+# name of rake task to run resque worker
+# default value: "environment resque:work"
+set :resque_task, "resque:work"
+
+```
+
+For example, if you don't want to load environment for your workers,
+your `deploy.rb` will look like this:
+
+```ruby
+set :resque_task, "resque:work"
+require 'kapify/resque'
+```
+
+### Template Customization
+
+If you want to change default templates, you can generate them using `rails generator`
+
+    rails g kapify:resque
+
+This will copy default templates to `config/deploy/templates` directory,
+so you can customize them as you like, and capistrano tasks will use this templates instead of default.
+
+You can also provide path, where to generate templates:
+
+    rails g kapify:resque config/templates

data/lib/kapify/resque/configuration.rb

@@ -0,0 +1,34 @@
+require 'capistrano'
+require 'kapify/base'
+
+Capistrano::Configuration.instance.load do
+  set_default(:resque_user, user)
+  set_default(:resque_workers, 2)
+  set_default(:resque_queue, "*")
+  set_default(:resque_bundle, "/usr/local/rbenv/shims/bundle")
+  set_default(:resque_task, "environment resque:work")
+
+  namespace :kapify do
+    namespace :resque do
+      desc "Setup Resque initializer and app configuration"
+      task :setup, roles: :resque_worker do
+        run "mkdir -p #{shared_path}/config"
+        kapify_template "resque", "resque_init.erb", "/tmp/resque_init"
+        run "chmod +x /tmp/resque_init"
+        run "#{sudo} mv /tmp/resque_init /etc/init.d/resque_#{application}"
+        run "#{sudo} update-rc.d -f resque_#{application} defaults"
+      end
+
+      after "deploy:setup", "kapify:resque:setup"
+
+      %w[start stop restart].each do |command|
+        desc "#{command} resque"
+        task command, roles: :resque_worker do
+          run "service resque_#{application} #{command}"
+        end
+
+        after "deploy:#{command}", "kapify:resque:#{command}"
+      end
+    end
+  end
+end

data/lib/kapify/resque.rb

@@ -0,0 +1 @@
+require 'kapify/resque/configuration'

data/lib/kapify/unicorn/README.md

@@ -0,0 +1,109 @@
+# kapify/unicorn
+
+Capistrano tasks for configuration and management unicorn for zero downtime deployments of Rails applications.
+
+Provides capistrano tasks to:
+
+* create unicorn init script for application, so it will be automatically started when OS restarts
+* start/stop unicorn (also can be done using `sudo service unicorn_<your_app> start/stop`)
+* restart unicorn using `USR2` signal to load new application version with zero downtime
+
+Provides several capistrano variables for easy customization.
+Also, for full customization, all configs can be copied to the application using generators.
+
+## Usage
+
+Add this line to your `deploy.rb`
+
+    require 'kapify/unicorn'
+
+Note, that following capistrano variables should be defined:
+
+    application
+    current_path
+    shared_path
+    user
+
+You can check that new tasks are available (`cap -T`):
+
+    # create unicorn configuration and init script
+    cap kapify:unicorn:setup
+
+    # start unicorn
+    cap kapify:unicorn:start
+
+    # stop unicorn
+    cap kapify:unicorn:stop
+
+    # restart unicorn with no downtime
+    # old workers will process new request until new master is fully loaded
+    # then old workers will be automatically killed and new workers will start processing requests
+    cap kapify:unicorn:restart
+
+There is no need to execute any of these tasks manually.
+They will be called automatically on different deploy stages:
+
+* `kapify:unicorn:setup` is hooked to `deploy:setup`
+* `kapify:unicorn:restart` is hooked to `deploy:restart`
+
+This means that if you run `cap deploy:setup`,
+unicorn will be automatically configured.
+And after each deploy, unicorn will be automatically restarted.
+
+However, if you changed variables or customized templates,
+you can run any of these tasks to update configuration.
+
+## Customization
+
+### Using variables
+
+You can customize unicorn configs using capistrano variables:
+
+
+```ruby
+# path to customized templates (see below for details)
+# default value: "config/deploy/templates"
+set :templates_path, "config/deploy/templates"
+
+# path, where unicorn pid file will be stored
+# default value: `"#{current_path}/tmp/pids/unicorn.pid"`
+set :unicorn_pid, "#{current_path}/tmp/pids/unicorn.pid"
+
+# path, where unicorn config file will be stored
+# default value: `"#{shared_path}/config/unicorn.rb"`
+set :unicorn_config, "#{shared_path}/config/unicorn.rb"
+
+# path, where unicorn log file will be stored
+# default value: `"#{shared_path}/config/unicorn.rb"`
+set :unicorn_log, "#{shared_path}/config/unicorn.rb"
+
+# user name to run unicorn
+# default value: `user` (user varibale defined in your `deploy.rb`)
+set :unicorn_user, "user"
+
+# number of unicorn workers
+# default value: no (will be prompted if not set)
+set :unicorn_workers, 4
+
+```
+
+For example, if you want to use 8 unicorn workers,
+your `deploy.rb` will look like this:
+
+```ruby
+set :unicorn_workers, 8
+require 'kapify/unicorn'
+```
+
+### Template Customization
+
+If you want to change default templates, you can generate them using `rails generator`
+
+    rails g kapify:unicorn
+
+This will copy default templates to `config/deploy/templates` directory,
+so you can customize them as you like, and capistrano tasks will use this templates instead of default.
+
+You can also provide path, where to generate templates:
+
+    rails g kapify:unicorn config/templates