caplets 1.0.0

data/CHANGELOG

@@ -0,0 +1,2 @@
+== 1.0.0
+  * Initial public release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Dean Strelau, Mint Digital
+
+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.

data/MODULES.md

@@ -0,0 +1,148 @@
+Caplets Modules
+===============
+
+caplets/deploy
+--------------
+
+#### Variables
+
+`:bin_cmd` - Command used to execute binaries within the context of the app.
+  For instance, `caplets/bundle` sets this to `gem exec`. (default: `nil`)
+
+`:environment` - The environment for this deployment, used as RAILS_ENV among
+  other things. (default: `production`)
+
+`:required_children` - Directories that need to exist in the project root.
+  These will be created during `deploy:setup`. This is the caplets replacement
+  of `:shared_children`. (default: `%w[config log public tmp/pids]`)
+
+`:server_processes` - Number of backend processes (ie, mongrels or unicorn
+  workers) to run. (default: `2`)
+
+`:server_port` - Port number on which to bind backend processes.
+  (default: `8000`)
+
+`:user` - UNIX user as which to login and run deploys. (default: `deploy`)
+
+### caplets/bundle
+
+Bundler 0.9+ support. By default, run after every code update, this `bundle
+install`s gems into the project (not into system gems to avoid using `sudo`).
+
+#### Variables
+
+`:bundle_exclude` - Bundler groups to exclude from installation. Passed to
+  bundler's `--without` switch. (default: `%w[development test]`)
+
+`:bundle_roles` - The server roles on which to bundle. (default: `[:app]`)
+
+`:bundle_to` - Subdirectory of the application in which to put installed gems.
+  Passed as an argument to `bundle install`. (default: `vendor/bundled_gems`)
+
+#### Tasks
+
+`deploy:bundle:install` - Runs a `bundle install` to install needed gems from
+  the application's Gemfile.
+
+#### Hooks
+
+`deploy:bundle:install` after `deploy:update_code`
+
+### caplets/db
+
+Tasks to support using ActiveRecord within your applications. This module
+adds functionality to write out your `database.yml` file and provides a
+`deploy:migrations` task.
+
+Differently from capistrano defaults, caplets does not expect your code to be
+deployed to your DB server. This means you don't even have to list it in your
+deploy file. Instead, it expects to run your migrations from your `:primary
+:app` server.
+
+#### Variables
+
+`:db_host` - default: `localhost`
+`:db_adapter` - default: `mysql`
+`:db_database` - default: `<application>_<environment>`
+`:db_username` - default: `<user>`
+`:db_password` - default: `<prompt for value>`
+`:db_encoding` - default: `utf8'
+
+These variables are used to set the corresponding values in your
+`database.yml` file. These values will be scoped appropriately under a key
+for your current `:environment`. If you'd rather, you can specify the entire
+`database.yml` yourself using `:db_confg`
+
+`:db_extra` - A hash of values merged into your :db_config, outside of any
+  environment key. Useful for adding access to slaves or other DBs.
+  (default: {})
+
+#### Tasks
+
+`deploy:db:config` - Write a generated `database.yml` to your project's config
+  directory.
+
+`deploy:migrate` - Run `rake db:migrate` on your primary app server.
+
+`deploy:migrations` - Do a deploy with migrations, including doing a
+  `web:disable` first and restarting (not reloading) the backends
+
+#### Hooks
+
+`deploy:db:config` after `deploy:setup`
+
+### caplets/git-tag
+
+Automatically tag a revision on deploy.
+
+#### Tasks
+
+`git:tag_current_release` - Tag the `:current_revision` with a tag like
+`deploy-<environment>-<timestamp>` and push it to the origin.
+
+#### Hooks
+
+`git:tag_current_release` after `deploy:migrations`
+`git:tag_current_release` after `deploy:quick`
+`git:tag_current_release` after `deploy:rebuild`
+
+### caplets/memcached
+
+Support for keeping track of memcached nodes and writing a `memcached.yml`
+config file based on the `:memcached` role.
+
+### Variables
+
+`:memcached_servers` - An array of 'host:port' strings of memcached servers.
+If any of your servers have the `:memcached` role, this is constructed
+dynamically based on those servers' `:private_ip`s. Otherwise:
+(default: `%w[localhost:11211]`)
+
+### Tasks
+
+`deploy:memcached:config` - Write a generated `memcached.yml` to your
+  projet's config directory.
+
+### Hooks
+
+`deploy:memcached:config` after `deploy:setup`
+
+### caplets/mongrel
+
+### caplets/networkfs
+
+## caplets/passenger
+
+## caplets/thinking-sphinx
+
+## caplets/unicorn
+
+## caplets/unicorn_rails
+
+## caplets/utils
+
+## caplets/web
+
+## caplets/whenever
+
+## caplets/yaml

data/README.md

@@ -0,0 +1,105 @@
+Caplets
+=======
+
+Capistrano is old and busted, right? Time to move on? WRONG! Caplets makes
+capistrano the new hotness once again. It bring capistrano into the future
+with all your favorite goodies: git, bundler, unicorn, and more.
+
+
+WARNING: Caplets has evolved out of Mint Digital's real-world deployments of
+many large Rails/Rack applications. Although we have tried to keep it as
+generic and customizable as possible, it is still very opinionated. That is
+to say, it is largely tailored to how we like to deploy applications. If
+caplets is missing something important to you, [submit an issue][issues] or
+[fork away][fork].
+
+[issues]: http://github.com/mintdigital/caplets/issues
+[fork]:   http://github.com/mintdigital/caplets/fork
+
+Quickstart
+----------
+
+
+    $ gem install caplets
+
+    # config/deploy.rb
+    require 'caplets'
+    load 'caplets/memcached'
+    load 'caplets/whenever'
+    # etc...
+
+Roles
+-----
+
+Caplets depends heavily on capistrano's concept of server roles to apply tasks
+only to the servers that require them. Most often, your sever definitions will
+look like this:
+
+    server 'app1.mintdigital.com',
+      :app, :memcached, :sphinx, :assets,
+      :primary => true
+
+Modules
+-------
+
+Caplets is a series of `load`able capistrano extensions. This given you
+maximum flexibility in your deployments without having to remember to
+set/unset loads of capistrano variables. Only the tasks you need get run.
+
+See the [MODULES][] file for descriptions of all the available modules, along
+with what tasks they add and what variables they use.
+
+[MODULES]: http://github.com/mintdigital/caplets/blob/master/MODULES.md
+
+caplets/deploy
+--------------
+
+The one module you will _always_ get, even if you just require
+`caplets/basic` is `caplets/deploy`. This file is the heart of caplets; it
+sets up the essentials of what caplets considers a modern deployment.
+
+The biggest change to the standard capistrano setup is that we use git to
+manage releases. Let me say that again as it's important:
+
+** Instead of using subdirectories and symlinks to manage releases, caplets
+uses git.**
+
+That means:
+
+  - You will not have `releases` or `shared` directories.
+  - Your code will be directly inside your `:deploy_to` directory.
+  - `:current_path`, `:current_release`, `:release_path`, `:latest_release`,
+    and `:shared_path` will all be the same.
+  - Rollbacks still work, through the power of `git reset`
+  - "shared" files are really just files written to your project root but not
+    under git version control -- no symlinks needed.
+
+Here are a few other changes that `caplets/deploy` makes:
+
+  - `:use_sudo` is false by default
+  - `:rails_env` is replaced with `:environment`, which caplets expects you to
+    set in your deploy file.
+  - `:user` and `:group` default to `deploy`
+  - `:shared_children` is not used. Use `:required_children` instead.
+  - The standard `deploy` task is disabled. Use `deploy:quick` to do an
+    `deploy:update` + `deploy:reload`. Load `caplets/db` for caplets'
+    replacement `deploy:migrations` task.
+  - Capistrano's built-in `deploy:web:enable` and `deploy:web:disable` are
+    disabled. Load `caplets/web` for caplets' replacements.
+
+require 'caplets'
+-----------------
+
+Requiring `caplets` gets you the most common modules in one go. If you don't
+want them all, you can always require `caplets/basic` instead.
+
+    # config/deploy.rb
+    require 'caplets'
+
+    # Equivalent to...
+    require 'caplets/basic'
+    load 'caplets/bundle'
+    load 'caplets/db'
+    load 'caplets/logs'
+    load 'caplets/web'
+    load 'caplets/yaml'

data/lib/caplets.rb

@@ -0,0 +1,8 @@
+require 'caplets/basic'
+
+config = Capistrano::Configuration.instance(:raise_on_error)
+config.load 'caplets/bundle'
+config.load 'caplets/db'
+config.load 'caplets/logs'
+config.load 'caplets/web'
+config.load 'caplets/yaml'

data/lib/caplets/basic.rb

@@ -0,0 +1,11 @@
+require 'caplets/version'
+require 'caplets/utils'
+
+config = Capistrano::Configuration.instance(:raise_on_error)
+
+# Apparently $: isn't good enough for Capistrano.
+config.instance_eval do
+  @load_paths.unshift File.expand_path('..',File.dirname(__FILE__))
+end
+
+config.load 'caplets/deploy'

data/lib/caplets/bundle.rb

@@ -0,0 +1,19 @@
+set :bundle_roles, [:app]
+set :bundle_exclude, %w[development test]
+set :bundle_to, 'vendor/bundled_gems'
+set :bin_cmd, 'bundle exec'
+
+## Tasks
+namespace :deploy do
+  namespace :bundle do
+    desc "Install gems from Gemfile"
+    task :install, :roles => lambda { fetch(:bundle_roles) },
+                   :except => {:no_release => true} do
+      without = fetch(:bundle_exclude).map{|g| "--without #{g}"}.join(' ')
+      run_current "bundle install #{fetch(:bundle_to)} #{without}"
+    end
+  end
+end
+
+## Hooks
+after 'deploy:update_code', 'deploy:bundle:install'

data/lib/caplets/cache.rb

@@ -0,0 +1,11 @@
+## Defaults
+_cset :cache_dir, 'cache'
+
+## Tasks
+namespace :deploy do
+  namespace :cache do
+    task :clear, :roles => :app, :only => { :primary => true } do
+      run "find #{fetch(:current_path)}/public/#{fetch(:cache_dir)} -type f -delete"
+    end
+  end
+end

data/lib/caplets/db.rb

@@ -0,0 +1,61 @@
+# In deploy:migrations, we use web.enable and web.disable
+# so we need to make sure this has been loaded.
+load 'caplets/web'
+
+## Defaults
+_cset :db_host, 'localhost'
+_cset :db_adapter, 'mysql'
+_cset(:db_database) { "#{fetch(:application)}_#{fetch(:environment)}" }
+_cset(:db_username) { user }
+_cset(:db_password) {
+  Capistrano::CLI.password_prompt(
+    "Please enter MySQL password for user #{fetch(:db_username)}: "
+  )
+}
+_cset :db_encoding, 'utf8'
+_cset(:db_config) {
+  fetch(:db_extra).merge({
+    fetch(:environment).to_s => {
+      'host'     => fetch(:db_host).to_s,
+      'adapter'  => fetch(:db_adapter).to_s,
+      'database' => fetch(:db_database).to_s,
+      'username' => fetch(:db_username).to_s,
+      'password' => fetch(:db_password).to_s,
+      'encoding' => fetch(:db_encoding).to_s
+    }
+  })
+}
+_cset :db_extra, {}
+
+## Tasks
+namespace :deploy do
+  namespace :db do
+    desc "write out database.yml"
+    task :config, :roles => :app do
+      put YAML.dump(fetch(:db_config)), "#{shared_path}/config/database.yml"
+    end
+  end
+
+  # migrate runs on the app server (no need for the code on the DB server)
+  task :migrate, :roles => :app, :only => { :primary => true } do
+    rake 'db:migrate'
+  end
+
+  desc <<-DESC
+  Do a deploy with migrations.
+
+  Use this when you need to completely disable the site and run migrations.
+  This will put up a maintenance page, run the migrations and completely
+  restart the app server processes.
+  DESC
+  task :migrations do
+    web.disable
+    update
+    migrate
+    restart
+    web.enable
+  end
+end
+
+## Hooks
+after 'deploy:setup', 'deploy:db:config'

data/lib/caplets/deploy.rb

@@ -0,0 +1,148 @@
+# A lot of this taken from GitHub's deployment:
+# http://github.com/blog/470-deployment-script-spring-cleaning
+
+# Overwrite cap defaults
+set :use_sudo, false
+set :deploy_via, :git # not used
+set :shared_children, %w[] # not relevant
+set(:rails_env) { environment } ## some built-in tasks use :rails_env
+default_run_options[:pty] = true
+
+# Setup basics
+_cset :user, 'deploy'
+_cset(:group) { user }
+_cset :environment, 'production'
+_cset :required_children, %w[config log public tmp/pids]
+
+# Server basics
+_cset :server_processes, 2
+_cset :server_port, 8000
+
+# Use one directory for everything
+set(:current_path)    { fetch(:deploy_to)    }
+set(:latest_release)  { fetch(:current_path) }
+set(:release_path)    { fetch(:current_path) }
+set(:current_release) { fetch(:current_path) }
+set(:shared_path)     { fetch(:current_path) }
+
+# Behold, the power of git
+set(:current_revision) {
+  capture("cd #{current_path}; git rev-parse --short HEAD").strip
+}
+set(:latest_revision)   {
+  capture("cd #{current_path}; git rev-parse --short HEAD").strip
+}
+set(:previous_revision) {
+  capture("cd #{current_path}; git rev-parse --short HEAD@{1}").strip
+}
+
+###########
+## Tasks ##
+###########
+
+namespace :deploy do
+  [:default, :cleanup, :symlink].each do |t|
+    task t do
+      abort "Task disabled by caplets."
+    end
+  end
+  [:enable, :disable].each do |t|
+    namespace :web do
+      task t do
+        abort "Task disabled by caplets. Load 'caplets/web' to re-enable."
+      end
+    end
+  end
+
+  desc "Setup a Git-based deploy"
+  task :setup, :except => {:no_release => true} do
+    run_multi(
+      "if [ -d #{fetch(:current_path)}/.git ]",
+      "then cd #{fetch(:current_path)}",
+      "#{try_sudo} git fetch",
+      "else #{try_sudo} git clone #{fetch(:repository)} #{fetch(:current_path)}",
+      "fi",
+      "mkdir -p " + fetch(:required_children,[]).
+                      map {|dir| "#{fetch(:current_path)}/#{dir}" }.
+                      join(' ')
+    )
+  end
+
+  desc <<-DESC
+  Do a zero-downtime deploy.
+
+  Use this when you have small code changes that you want to go out with
+  minimal impact. This does not put up the maintanance page nor run migrations,
+  and  will tell your app servers to 'reload' in-place instead of restarting
+  completely if they support it.
+  DESC
+  task :quick do
+    update
+    reload
+  end
+
+  task :update do
+    update_code
+  end
+
+  desc "Update the deployed code from git"
+  task :update_code, :except => { :no_release => true } do
+    run_multi "cd #{fetch(:current_path)}",
+      "git fetch origin",
+      "git reset --hard #{fetch(:branch)}"
+    finalize_update
+  end
+
+  # Just timestamps, please
+  task :finalize_update, :except => { :no_release => true } do
+  if fetch(:normalize_asset_timestamps, false)
+    stamp = Time.now.utc.strftime("%Y%m%d%H%M.%S")
+    asset_paths = %w(images stylesheets javascripts).map {|p|
+      "#{latest_release}/public/#{p}"
+    }.join(" ")
+    run "find #{asset_paths} -exec touch -t #{stamp} {} ';'; true",
+      :env => { "TZ" => "UTC" }
+  end
+end
+
+  %w[start stop restart reload].each do |taskname|
+    desc "#{taskname.capitalize} the application server(s)"
+    task taskname, :roles => :app, :except => {:no_release => true} do
+      deploy.send(fetch(:_server)).send(taskname)
+    end
+  end
+
+  namespace :rollback do
+    task :code do
+      abort "Task disabled by caplets"
+    end
+
+    desc <<-DESC
+    [internal] Rollback repo.
+
+    Moves the repo back one release by checking out HEAD@{1}
+    DESC
+    task :repo, :except => { :no_release => true } do
+      set :branch, "HEAD@{1}"
+      deploy.update_code
+    end
+
+    desc <<-DESC
+      [internal] Rewrite git reflog.
+      This makes HEAD@{1} continue to point at the next previous release.
+    DESC
+    task :cleanup, :except => { :no_release => true } do
+      run_multi "cd #{fetch(:current_path)}",
+        'git reflog delete --rewrite HEAD@{1}',
+        'git reflog delete --rewrite HEAD@{1}'
+    end
+
+    desc "Rolls back to the previously deployed version."
+    task :default do
+      rollback.repo
+      rollback.cleanup
+      deploy.reload
+    end
+  end
+
+end

data/lib/caplets/git-tag.rb

@@ -0,0 +1,16 @@
+## Tasks
+namespace :git do
+  desc 'Tag and push tag for current release'
+  task :tag_current_release, :roles => :app, :only => {:primary => true} do
+    if ENV['NO_TAG'].nil?
+      tag = "deploy-#{environment}-#{Time.now.to_i}"
+      `git tag #{tag} #{fetch(:current_revision)}`
+      `git push origin #{tag}`
+    end
+  end
+end
+
+## Hooks
+after 'deploy:migrations', 'git:tag_current_release'
+after 'deploy:quick', 'git:tag_current_release'
+after 'deploy:rebuild', 'git:tag_current_release'

data/lib/caplets/logs.rb

@@ -0,0 +1,3 @@
+task :logs, :roles => :app do
+  stream "tail -n 0 -f #{shared_path}/log/*.log"
+end

data/lib/caplets/memcached.rb

@@ -0,0 +1,30 @@
+## Defaults
+_cset(:memcached_servers) do
+  if roles[:memcached].servers.any?
+    unless roles[:memcached].servers.all? {|s| s.options[:private_ip] }
+      abort "Set :private_ip for all :memcached servers or "+
+            "set :memcached_servers explicitly."
+    end
+    roles[:memcached].servers.map {|s| s.options[:private_ip] + ":11211" }
+  else
+    %w[localhost:11211]
+  end
+end
+
+## Tasks
+namespace :deploy do
+  namespace :memcached do
+    desc "Generate the memcached.yml in the shared directory"
+    task :config, :roles => :app do
+      config = {
+        environment => {
+          'servers' => fetch(:memcached_servers)
+        }
+      }
+      put YAML.dump(config), "#{shared_path}/config/memcached.yml"
+    end
+  end
+end
+
+## Hooks
+after 'deploy:setup', 'deploy:memcached:config'

data/lib/caplets/mongrel.rb

@@ -0,0 +1,46 @@
+set :_server, :mongrel
+
+namespace :deploy do
+  namespace :mongrel do
+    desc "Write the cluster config."
+    task :config, :roles => :app, :except => {:no_release => true} do
+      config = {
+        'user' => user,
+        'group' => group,
+        'cwd' => current_path,
+        'environment' => environment,
+        'port' => server_port,
+        'address' => '0.0.0.0',
+        'pid_file' => "#{shared_path}/tmp/pids/mongrel.pid",
+        'servers' => server_processes
+      }
+      put YAML.dump(config), "#{shared_path}/config/cluster.yml"
+    end
+
+    desc "Start the mongrel_cluster"
+    task :start, :roles => :app do
+      run "cd #{current_path} && " +
+        "mongrel_rails cluster::start -C #{shared_path}/config/cluster.yml --clean"
+    end
+
+    desc "Stop the mongrel_cluster"
+    task :stop, :roles => :app do
+      run "cd #{current_path} && " +
+        "mongrel_rails cluster::stop -C #{shared_path}/config/cluster.yml --clean"
+    end
+
+    desc "Restart the mongrel_cluster"
+    task :restart, :roles => :app do
+      run "cd #{current_path} && " +
+        "mongrel_rails cluster::restart -C #{shared_path}/config/cluster.yml --clean"
+    end
+
+    desc "Restart the mongrel_cluster, as mongrel does not support reloading"
+    task :reload, :roles => :app do
+      restart
+    end
+  end
+end
+
+## Hooks
+after 'deploy:setup', 'deploy:mongrel:config'

data/lib/caplets/networkfs.rb

@@ -0,0 +1,30 @@
+# loading this file will modify your deploy for use with a networked filesystem
+# Mostly, this means you can define paths that will get symlinked to the FS
+
+## Defaults
+_cset :networkfs_path, '/srv/share'
+_cset :networkfs_resources, []
+
+## Tasks
+namespace :deploy do
+  namespace :networkfs do
+    desc "Create the application's directory on the network FS"
+    task :setup, :roles => :app, :only => {:primary => true} do
+      try_sudo "mkdir -p #{fetch(:networkfs_path)}/#{fetch(:application)}"
+    end
+
+    desc "Symlink networkfs_resources to the network FS"
+    task :symlink, :roles => [:app, :web] do
+      cmds = fetch(:networkfs_resources, []).map do |resource|
+        "ln -nfs" +
+          " #{fetch(:networkfs_path)}/#{fetch(:application)}/#{resource}" +
+          " #{fetch(:release_path)}/#{resource}"
+      end
+      try_sudo cmds.join(" && ")
+    end
+  end
+end
+
+## Hooks
+after 'deploy:setup', 'deploy:networkfs:setup'
+after 'deploy:setup', 'deploy:networkfs:symlink'

data/lib/caplets/passenger.rb

@@ -0,0 +1,19 @@
+set :_server, :passenger
+
+namespace :deploy do
+  namespace :passenger do
+    # These are no-ops for Passenger
+    task :start, :roles => :app, :except => {:no_release => true} do; end
+    task :stop, :roles => :app, :except => {:no_release => true} do; end
+
+    desc 'Restart the Passenger processes by touching tmp/restart.txt'
+    task :restart, :roles => :app, :except => {:no_release => true} do
+      run "touch #{current_path}/tmp/restart.txt"
+    end
+
+    desc 'Restart the Passenger process by touching tmp/restart.txt'
+    task :restart, :roles => :app, :except => {:no_release => true} do
+      run "touch #{current_path}/tmp/restart.txt"
+    end
+  end # namespace :passenger
+end # namespace :deploy

data/lib/caplets/thinking-sphinx.rb

@@ -0,0 +1,72 @@
+# We require web:enable and web:disable for the rebuild task
+load 'caplets/web'
+
+## Defaults
+_cset(:sphinx_address) {
+  roles[:sphinx].servers.detect {|s| s.options[:primary] }.options[:private_ip] ||
+  '127.0.0.1'
+}
+_cset(:sphinx_max_matches) { 1000 }
+
+## Tasks
+namespace :deploy do
+  desc <<-DESC
+  Do a deploy with migrations and a sphinx rebuild.
+
+  Use this when you need to completely rebuild the sphinx index on deploy,
+  for instance if you have changed the index definitions. This task puts up
+  the maintenance page, runs migrations, rebuilds the sphinx index and restarts
+  the app server processes.
+  DESC
+  task :rebuild do
+    web.disable
+    update
+    migrate
+    ts.rebuild
+    restart
+    web.enable
+  end
+
+  namespace :sphinx do
+    desc "Generate the sphinx.yml file in the shared directory"
+    task :config, :roles => [:app, :sphinx] do
+      config = {
+        fetch(:environment) => {
+          'address' => fetch(:sphinx_address),
+          'max_matches' => fetch(:sphinx_max_matches)
+        }
+      }
+      put YAML.dump(config), "#{shared_path}/config/sphinx.yml"
+    end
+  end
+
+  namespace :ts do
+    desc "Generate the Thinking Sphinx config file"
+    task :config, :roles => [:app, :sphinx] do
+     rake 'ts:config'
+    end
+
+    desc "Rebuild Thinking Sphinx config and indexes and restart Sphinx"
+    task :rebuild, :roles => :sphinx do
+      rake 'ts:rebuild'
+    end
+
+    desc "Run a Sphinx index via Thinking Sphinx"
+    task :index, :roles => :sphinx do
+      rake 'ts:in'
+    end
+
+    desc "Start Sphinx searchd via Thinking Sphinx"
+    task :start, :roles => :sphinx do
+      rake 'ts:start'
+    end
+
+    desc "Stop Sphinx searchd via Thinking Sphinx"
+    task :stop, :roles => :sphinx do
+      rake 'ts:stop'
+    end
+  end
+end
+
+## Hooks
+after 'deploy:setup', 'deploy:sphinx:config'

data/lib/caplets/unicorn.rb

@@ -0,0 +1,83 @@
+set :_server, :unicorn
+
+namespace :deploy do
+  namespace :unicorn do
+
+    def start_cmd
+      "#{fetch(:_unicorn_cmd,'unicorn')} -D" +
+      " -c config/unicorn.rb" +
+      " -E #{fetch(:environment)}"
+    end
+
+    def stop_cmd(signal='QUIT', pid='unicorn.pid')
+      pid = "tmp/pids/#{pid}"
+      "if [ -f #{pid} ] ; then kill -#{signal} $(cat #{pid}) ; fi"
+    end
+
+    def wait_for_pid(pid, to_disappear=false)
+     "while [ #{'!' unless to_disappear} -f tmp/pids/#{pid} ] ; do sleep 1; done"
+    end
+
+    desc "Write the unicorn config to the shared directory."
+    task :config, :roles => :app, :except => {:no_release => true} do
+      config = File.read(__FILE__).split(/^__END__$/, 2)[1]
+      put ERB.new(config,nil,'-').result(binding.dup),
+        fetch(:current_path) + '/config/unicorn.rb'
+    end
+
+    desc "Start the unicorn master and workers."
+    task :start, :roles => :app, :except => {:no_release => true} do
+      run_current start_cmd
+    end
+
+    desc "Stop the unicorn master and workers."
+    task :stop, :roles => :app, :except => {:no_release => true} do
+      run_current stop_cmd
+    end
+
+    desc "Restart the unicorn master and workers."
+    task :restart, :roles => :app, :except => {:no_release => true} do
+      run_current stop_cmd,
+                  wait_for_pid('unicorn.pid', :to_disappear),
+                  start_cmd,
+                  wait_for_pid('unicorn.pid'),
+                  'sleep 5' # app start-up
+    end
+
+    desc "Reload the unicorn master and workers with zero downtime."
+    task :reload, :roles => :app, :except => {:no_release => true} do
+      run_current stop_cmd('USR2'),
+                  wait_for_pid('unicorn.pid.oldbin'),
+                  wait_for_pid('unicorn.pid'),
+                  'sleep 5', # app start-up
+                  stop_cmd('QUIT', 'unicorn.pid.oldbin')
+    end
+  end
+end
+
+## Hooks
+after 'deploy:setup', 'deploy:unicorn:config'
+
+__END__
+pid '<%= fetch(:current_path) %>/tmp/pids/unicorn.pid'
+
+working_directory "<%= fetch(:current_path) %>"
+
+worker_processes <%= fetch(:server_processes, 4) %>
+
+# Pre-load for fast worker forks and COW-friendliness
+preload_app <%= fetch(:preload_app, true) %>
+
+timeout <%= fetch(:server_timeout, 60) %>
+
+listen '0.0.0.0:<%= fetch(:server_port, 8000) %>'
+
+stderr_path "<%= current_path %>/log/unicorn.log"
+stdout_path "<%= current_path %>/log/unicorn.log"
+
+# http://www.rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+GC.respond_to?(:copy_on_write_friendly=) and
+  GC.copy_on_write_friendly = true
+
+<%= fetch(:_unicorn_ar_config,'') %>
+<%= fetch(:unicorn_extra_config,'') %>

data/lib/caplets/unicorn_rails.rb

@@ -0,0 +1,17 @@
+set :_server, :unicorn
+set :_unicorn_cmd, 'unicorn_rails'
+set :_unicorn_ar_config, <<-CONF
+before_fork do |server, worker|
+  # master process doesn't need a connection
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.connection.disconnect!
+end
+
+after_fork do |server, worker|
+  # workers need to connect individually
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+end
+CONF
+
+load 'caplets/unicorn'

data/lib/caplets/utils.rb

@@ -0,0 +1,16 @@
+# This is just a collection of handy methods to use while writing tasks
+module Caplets::Utils
+  def rake(cmd)
+    run_current "RAILS_ENV=#{fetch(:environment)} rake #{cmd}"
+  end
+
+  def run_current(*cmds)
+    run ["cd #{fetch(:current_path)}"].concat(cmds).join(' && ')
+  end
+
+  def run_multi(*cmds)
+    run cmds.join(' ; ')
+  end
+end
+
+Capistrano::Configuration.send :include, Caplets::Utils

data/lib/caplets/version.rb

@@ -0,0 +1,10 @@
+module Caplets
+  module Version
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    BUILD = nil
+    STRING = [MAJOR,MINOR,TINY,BUILD].compact.join('.')
+  end
+  VERSION = Version::STRING
+end

data/lib/caplets/web.rb

@@ -0,0 +1,13 @@
+namespace :deploy do
+  namespace :web do
+    desc 'Enable maintenance mode'
+    task :disable, :roles => :web do
+      try_sudo "touch #{fetch(:current_release)}/public/SHOW_MAINTENANCE_PAGE"
+    end
+
+    desc 'Disable maintenance mode'
+    task :enable, :roles => :web do
+      try_sudo "rm -f #{fetch(:current_release)}/public/SHOW_MAINTENANCE_PAGE"
+    end
+  end
+end

data/lib/caplets/whenever.rb

@@ -0,0 +1,32 @@
+# Uses the whenever gem to update the server's crontab, using a combination
+# of role and environment to pick which crontab to use.
+#
+# Put per-server crontabs inside whenever/{environment}.{role}.rb
+#
+namespace :deploy do
+  namespace :whenever do
+    def update_cmd_for(role)
+      load_file = "config/whenever/#{fetch(:environment)}.#{role}.rb"
+      [ "cd #{fetch(:current_path)} &&",
+        "if [ -f #{load_file} ] ; then",
+          "#{fetch(:bin_cmd)} whenever",
+          "--update-crontab #{fetch(:application)}.#{fetch(:environment)}.#{role}",
+          "--load-file #{load_file}",
+          "--set environment=#{fetch(:environment)}",
+        "; fi"
+      ].join(' ')
+    end
+
+    desc "Update the crontab files by running 'whenever'"
+    task :update, :except => { :no_release => true } do
+      parallel do |session|
+        roles.keys.each do |role|
+          session.when "in?(#{role.inspect})", update_cmd_for(role)
+        end
+      end
+    end
+
+  end
+end
+
+after "deploy:update", "deploy:whenever:update"

data/lib/caplets/yaml.rb

@@ -0,0 +1,17 @@
+## Defaults
+_cset :config_files, {}
+
+## Tasks
+namespace :deploy do
+  namespace :yaml do
+    desc "Write any defined custom YAML config files."
+    task :config, :except => { :no_release => true } do
+      fetch(:config_files,{}).each do |name, data|
+        put YAML.dump(data), "#{fetch(:shared_path)}/config/#{name}.yml"
+      end
+    end
+  end
+end
+
+## Hooks
+after 'deploy:setup', 'deploy:yaml:config'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: caplets
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Dean Strelau
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :runtime
+  version_requirements: *id001
+description: " Caplets modernizes your capistrano deployments. At its most basic, it\n provides a fast, efficient git-based deployment without copying release\n trees or symlink tomfoolery. In addition, it includes modules for common\n tasks such as writing config files and crontabs, working with bundler,\n and using a networked filesystem.\n"
+email: dean@mintdigital.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/caplets/basic.rb
+- lib/caplets/bundle.rb
+- lib/caplets/cache.rb
+- lib/caplets/db.rb
+- lib/caplets/deploy.rb
+- lib/caplets/git-tag.rb
+- lib/caplets/logs.rb
+- lib/caplets/memcached.rb
+- lib/caplets/mongrel.rb
+- lib/caplets/networkfs.rb
+- lib/caplets/passenger.rb
+- lib/caplets/thinking-sphinx.rb
+- lib/caplets/unicorn.rb
+- lib/caplets/unicorn_rails.rb
+- lib/caplets/utils.rb
+- lib/caplets/version.rb
+- lib/caplets/web.rb
+- lib/caplets/whenever.rb
+- lib/caplets/yaml.rb
+- lib/caplets.rb
+- CHANGELOG
+- MIT-LICENSE
+- README.md
+- MODULES.md
+has_rdoc: true
+homepage: http://mintdigital.github.com/caplets
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Capistrano super powers
+test_files: []
+