Initial commit

Author: rubydev

.gitignore

@@ -0,0 +1,16 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+doc
+.idea/
+

Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capistrano_recipes.gemspec
+gemspec

Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    capistrano_recipes (0.0.0)
+      capistrano (= 2.15.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    capistrano (2.15.4)
+      highline
+      net-scp (>= 1.0.0)
+      net-sftp (>= 2.0.0)
+      net-ssh (>= 2.0.14)
+      net-ssh-gateway (>= 1.1.0)
+    diff-lcs (1.2.5)
+    highline (1.6.20)
+    net-scp (1.1.2)
+      net-ssh (>= 2.6.5)
+    net-sftp (2.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.7.0)
+    net-ssh-gateway (1.2.0)
+      net-ssh (>= 2.6.5)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  capistrano_recipes!
+  rspec

LICENSE

@@ -0,0 +1,17 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the 'Software'), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,127 @@
+## capistrano_recipes
+
+Bunch of capistrano recipes
+
+GitHub: https://github.com/rubydev/capistrano_recipes
+
+## Installation
+
+Add `capistrano_recipes` to your application's Gemfile:
+
+    gem 'capistrano_recipes', :git => 'git://github.com/rubydev/capistrano_recipes.git'
+
+And then install the bundle:
+
+    $ bundle
+
+## Usage
+
+First, initialize capistrano:
+
+    capify .
+    
+This will create `./Capfile ` and `./config/deploy.rb`. Edit `./config/deploy.rb` and load recipes required
+for your application:
+
+    require "capistrano_recipes/nginx"
+    require "capistrano_recipes/mysql"
+    require "capistrano_recipes/host"
+
+Then run `cap host:setup deploy:initial` to make your first deploy. Use `cap deploy:migrations` for next deploys.
+
+### Example of rails app deployment
+
+`config/deploy.rb`:
+
+    default_run_options[:pty] = true     # Must be set for the password prompt to work
+    set :use_sudo, false                 # Don't use sudo (deploy user must have very limited permissions in system)
+
+    set :default_stage, "staging"        # Deploy on staging server by default
+
+    # Configure capistrano deploy strategy
+    set :repository, '.'
+    set :deploy_via, :copy
+    set :copy_exclude, [".git", "coverage", "results", "tmp", "public/system", "builder"]
+
+    set :root_user, "user"               # User with root privileges on server. You will need him only for host:setup
+                                         # and *:setup_host tasks. This will not be used during deploy,
+                                         # deploy:migrations and other common tasks.
+    set :user, "app_name"                # Deployer user
+    set :group, "app_name"               # Deployer group
+    set :user_home_path, "/home/www"     # Deployer home on target system (used in host:setup when creating new user)
+    set(:deploy_to) { "#{user_home_path}/#{application}" } # Path where to deploy your application
+
+    role(:web) { domain }                         # Your HTTP server, Apache/etc
+    role(:app) { domain }                         # This may be the same as your `Web` server
+    role(:db, :primary => true) { domain }        # This is where Rails migrations will run
+
+    require "capistrano_colors"                   # Colorized output in console (gem install capistrano_colors)
+    require "capistrano/ext/multistage"           # Enable multistage deployment
+    require "capistrano_recipes/nginx"            # Use nginx as web-server
+    require "capistrano_recipes/mysql"            # Use mysql as db-server
+    require "capistrano_recipes/host"             # Require host:setup task
+    require "capistrano_recipes/monit"            # Use monit as monitoring system
+    require "capistrano_recipes/ruby/thin"        # Use thing as app-server
+    require "capistrano_recipes/ruby/rails"       # Load rails-specific recipes
+    require "bundler/capistrano"                  # Use bundler on server
+    load "deploy/assets"                          # Use rails assets pipeline
+
+`config/deploy/production.rb`
+
+    set :application, "app_name"                  # Application name for production
+                                                  # (it's used in some configs and paths)
+    set :application_domain, "app_domain.com"     # Domain for production server
+    set :domain, "192.168.1.1"                    # Server address where to deploy production
+
+`config/deploy/staging.rb`
+
+    set :application, "app_name_test"             # Application name for staging server
+    set :application_domain, "qa.app_domain.com"  # Domain for staging server
+    set :domain, "192.168.1.1"                    # Server address where to deploy staging
+
+Then execute `cap host:setup deploy:initial nginx:enable` to create user and config files and perform initial deploy,
+then symlink `/etc/nginx/sites-available/app_name.conf` to `/etc/nginx/sites-enabled/app_name.conf`.
+On next deploy just run `cap deploy:migrations` to deploy new application version.
+
+`cap host:setup` will perform:
+
+ * `host:create_user` - creates `:user` on target system (if doesn't exist yet)
+ * `host:ssh_copy_id` - adds `~/.ssh/id_rsa.pub` from local machine to `authorized_keys` on target machine for `:user`
+ * Then it performs `*:setup_host` for all loaded recipes:
+   * `nginx:setup_host` - creates nginx config file in `/etc/nginx/sites-available/app_name.conf`, grants user
+     permissions to modify it. Creates `#{deploy_to}/shared/logs/nginx` directory and grants nginx permissions to
+     write there.
+   * `mysql:setup_host` - creates mysql user with random password grants him administrative permissions for application
+     database (`:database_name`). Then creates `:database_config_template` in `#{deploy_to}/shared/config/database.yml`,
+     grants it 440 permissions (only user and group can read it). It will be symlinked to
+     `#{deploy_to}/current/config/database.yml` on each deploy.
+   * `monit:setup_host` - creates monit config file for thin in `/etc/monit/conf.d/app_name-thin`, grants user
+     permissions to modify it.
+   * `thin:setup_host` - creates directory for thin sockets (if `:thin_socket` is set), creates thin config file in
+     `#{deploy_to}/shared/config/thin.yml`
+
+## Config templates
+
+Capistrano-scrip uses ERB to parse nginx/monit/thin/etc templates. You can see default config templates at github:
+https://github.com/rubydev/capistrano_recipes/tree/master/templates
+
+If you don't like any of this, you can replace it with you own:
+
+* Put your template in `config/deploy/templates/#{template_name}`
+* Or change `*_template` variable value to reflect your template path: `set :monit_config_template, 'deploy/monit.erb'`
+
+## Contributing
+
+1. Fork
+2. Create your feature branch (`git checkout -b my_branch`)
+3. Commit your changes (`git commit -am "my cool feature"`)
+4. Push to the branch (`git push origin my_branch`)
+5. Create new Pull Request
+
+### Editing documentation
+
+1. Install dependencies: `bundle install`
+2. Run yard server: `bundle exec yard server -r`
+3. Edit documentation
+4. Preview your changes at http://localhost:8808/
+5. Commit: `git commit -am "Updated documentation for ..."

Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

capistrano_recipes.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "capistrano_recipes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "capistrano_recipes"
+  s.version     = CapistranoRecipes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Marian Mrózek", "Jan Uhlář"]
+  s.email       = %w([email protected] [email protected])
+  s.homepage    = "https://github.com/rubydev/capistrano_recipes"
+  s.summary     = "Bunch of capistrano recipes"
+  s.description = "Some useful recipes for capistrano"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib)
+  s.extra_rdoc_files = %w(LICENSE)
+
+  s.add_dependency "capistrano", "2.15.4"
+  s.add_development_dependency 'rspec'
+
+end

lib/capistrano_recipes/host.rb

@@ -0,0 +1,91 @@
+require 'capistrano_recipes/utils'
+
+# System tasks (users/permissions management)
+#
+# Main task is +host:setup+ which will prepare servers for deploy - create config files
+# and directories required for deploy.
+Capistrano::Configuration.instance.load do
+  namespace :host do
+    # User with root privileges on server. +host:setup+ and all +*:setup_host+ tasks are performed
+    # on behalf of this user.
+    _cset(:root_user) {"root"}
+    # Home path for deployer
+    # (used in host:create_user task)
+    _cset(:user_home_path) { "/home/www/#{fetch(:deploy_user, user)}" }
+    # Path to public key (or public key itself as string)
+    _cset(:ssh_public_key) { "~/.ssh/id_rsa.pub" }
+
+    desc "Creates user, enables ssh authorization"
+    host_task :create_user do
+      script = <<-eos
+        set -e;
+        if #{sudo} id -u #{deploy_user} >/dev/null 2>&1 ; then
+          echo "User '#{deploy_user}' already exists";
+        else
+          #{sudo} useradd #{deploy_user} -d #{user_home_path};
+          #{sudo} mkdir -p #{user_home_path};
+          #{sudo} chown #{deploy_user}:#{group} #{user_home_path};
+          echo "Created user #{deploy_user} with home #{user_home_path}";
+        fi;
+      eos
+      if exists?(:rvm_ruby_string)
+        script << <<-eos
+          if #{sudo} getent group rvm >/dev/null 2>&1; then
+            #{sudo} usermod -a -G rvm #{deploy_user};
+          fi;
+        eos
+      end
+      run script
+    end
+
+    desc <<-EOF
+    Copy your public key to server. Path to key can be configured via {ssh_public_key}
+
+    You can also provide public key string itself as ssh_public_key:
+
+        set(:ssh_public_key) { "ssh-rsa AAAAB3N....2zQ== host@user" }
+
+    Also you can specify ssh_public_key via CLI:
+
+        !!!bash
+        cap host:ssh_copy_id -s ssh_public_key="AAAAB3N....2zQ== host@user"
+    EOF
+    host_task :ssh_copy_id do
+      key_path = File.expand_path(ssh_public_key)
+      if File.exist?(key_path)
+        key_string = IO.readlines(key_path)[0]
+      else
+        key_string = ssh_public_key
+      end
+      run <<-eos
+        set -e;
+        #{sudo :as => deploy_user} mkdir -p ~#{deploy_user}/.ssh;
+        if #{sudo} grep -q -s -F '#{key_string}' ~#{deploy_user}/.ssh/authorized_keys ; then
+          echo "Key already in authorized keys.";
+        else
+          #{sudo :as => deploy_user} touch ~#{deploy_user}/.ssh/authorized_keys;
+          echo '#{key_string}' | #{sudo :as => deploy_user} tee -a ~#{deploy_user}/.ssh/authorized_keys;
+          echo "Added #{key_path} to authorized_keys of #{deploy_user}";
+        fi;
+      eos
+    end
+
+    desc <<-EOF
+    Creates deploy user on target system, adds him to sudoers, etc.
+
+    Also performs deploy:setup and *:setup_host for all loaded recipes, so it will
+    create configs for monit / nginx / whatever you loaded via require "capistrano-script/.."
+
+    It is safe to run this task on servers that have already been set up;
+    it will not create extra users / destroy config files or data.
+    EOF
+    task :setup do
+      # It's not "host" task because inner tasks are host_tasks (not all of them)
+      create_user
+      ssh_copy_id
+
+      # We use `after` here to ensure that deploy:setup will latest of all `after "host:setup"` tasks
+      after "host:setup", "deploy:setup"
+    end
+  end
+end

lib/capistrano_recipes/monit.rb

@@ -0,0 +1,59 @@
+require 'capistrano_recipes/utils'
+
+# monit is a free, open source process supervision tool for Unix and Linux.
+Capistrano::Configuration.instance.load do
+  # Path to monit configuration template
+  _cset(:monit_config_template) { "monit/monit_#{app_server}.conf.erb" }
+  # The remote location of monit's config file
+  _cset(:monit_config_path) { "/etc/monit/conf.d/#{application}-#{app_server}" }
+  # Path to monit binary on server
+  _cset(:monit_command) { "monit" }
+
+  namespace :monit do
+    desc "Reloads monit"
+    task :reload, :roles => :app do
+      run "#{sudo} #{monit_command} reload"
+    end
+
+    namespace :status do
+      desc "Status summary"
+      task :default do
+        run "#{sudo} #{monit_command} summary"
+      end
+
+      desc "Full status"
+      task :full do
+        sudo "#{monit_command} status"
+      end
+    end
+
+    desc <<-EOF
+    Parses the configuration template file :{monit_config_template} through ERB to fetch our variables \
+    and uploads the result to :{monit_config_path}
+    EOF
+    task :setup, :roles => :app , :except => { :no_release => true } do
+      generate_config(monit_config_template, monit_config_path)
+    end
+
+    desc "Parses config file and outputs it to STDOUT (internal task) "
+    task :parse_config, :roles => :app , :except => { :no_release => true } do
+      puts parse_template(monit_config_template)
+    end
+
+    desc <<-EOF
+    Creates empty monit configuration file for this application, grants user permissions to modify it
+    EOF
+    host_task :setup_host do
+      run "#{sudo} touch #{monit_config_path} && " \
+          "#{sudo} chown #{deploy_user}:#{group} #{monit_config_path}"
+
+      with_user deploy_user do
+        monit.setup
+      end
+    end
+  end
+
+  after 'host:setup' do
+    monit.setup_host #if Capistrano::CLI.ui.agree("Create monit-related files? [y/n]")
+  end
+end