capper 0.8.3 → 0.9.0

data/README.rst

@@ -11,12 +11,12 @@ Capper is a collection of opinionated Capistrano recipes.
 Rationale
 =========
 
-Most Ruby (on Rails) applications are deployed the same way. While capistrano
-itself is already quite opinionated, maintaining a multitude of applications
-feels like copy&paste very fast.
+Most web applications are deployed the same way. While capistrano itself is
+already quite opinionated, maintaining a multitude of applications feels like
+copy&paste very fast.
 
 Capper provides sane defaults and many recipes for technologies typically used
-with Ruby (on Rails) deployments to make ``config/deploy.rb`` much more
+with Ruby and Python deployments to make ``config/deploy.rb`` much more
 declarative and terse.
 
 Usage
@@ -34,8 +34,8 @@ Capper recipes should be loaded via ``Capfile`` like this::
 
   load "capper/multistage"
 
-Note: capper takes care of loading capistranos default deploy recipe, no need
-to load it again in your ``Capfile``.
+Note: capper does not support capistranos default deploy recipe, instead an
+enhanced copy is shipped directly with capper and enabled by default.
 
 Multistage
 ----------
@@ -102,8 +102,9 @@ The following recipes are included in capper.
 base
 ----
 
-The base recipe is automatically loaded and provides the basic opinions capper
-has about deployment:
+The base is an enhanced version of capistranos default deploy recipe. It is
+loaded automatically and provides the basic opinions capper has about
+deployment:
 
 - The application is deployed to a dedicated user account with the same name as
   the application.
@@ -114,10 +115,12 @@ has about deployment:
 
 - Releases are cleaned up by default.
 
-Additionally a ``deploy:symlink`` task is provided to make symlinks declarative
-in ``config/deploy.rb``::
+- The application is deployed via ``remote_cache`` and ``git``.
 
-  set :symlink, {
+The ``deploy:finalize_update`` task has been enhanced to make symlinks
+declarative in ``config/deploy.rb``::
+
+  set :symlinks, {
     "config/database.yml" => "config/database.yml",
     "shared/uploads" => "public/uploads"
   }
@@ -142,6 +145,7 @@ The bundler recipe is an extension of bundlers native capistrano integration:
   (``shared/bundle/#{gemset}``).
 
 - The option ``ruby_exec_prefix`` is set to ``bundle exec`` for convenience.
+  (see ``ruby`` recipe for details)
 
 config
 ------
@@ -169,14 +173,10 @@ automatically (re)started during deploy and can be specified via
     :worker2 => 2..10
   }
 
-git
----
-
-The git recipe will simply set capistrano to use the git strategy with
-remote_cache::
+django
+------
 
-  set(:scm, :git)
-  set(:deploy_via, :remote_cache)
+The django recipe provides setup and migrate tasks for Django.
 
 hoptoad
 -------
@@ -197,12 +197,19 @@ The monit recipe will collect all snippets declared via ``monit_config`` and
 render them into the file specified via ``monitrc`` (default:
 ``~/.monitrc.local``, this file should be included in your ``~/.monitrc``).
 
+python
+------
+
+The python recipe provides basic support for Python applications. It will
+create a symlink from ``#{current_path}/#{application}`` to ``#{current_path}``
+for Python namespace support.
+
 rails
 -----
 
 The rails recipe sets the default ``rails_env`` to production and includes
-tasks for deploying the asset pipeline for rails 3.1 applications. The recipe
-will automatically determine if your asset timestamps need to be normalized.
+tasks for deploying the asset pipeline for rails 3.1 applications. It also
+provdes a migrate task for Rails applications.
 
 resque
 ------
@@ -231,6 +238,12 @@ the ruby version and gemset via the projects ``.rvmrc``.
 A ``deploy:setup`` hook is provided to ensure the correct ruby and rubygems
 version is installed on all servers.
 
+ruby
+----
+
+The ruby recipe provides basic support for Ruby applications. It will setup a
+gemrc file and and variables for ``ruby_exec_prefix`` (such as bundler).
+
 unicorn
 -------
 
@@ -238,10 +251,6 @@ The unicorn recipe provides integration with Unicorn. A script to manage the
 unicorn process is uploaded to ``#{bin_path}/unicorn``. Additionally this
 recipe also manages the unicorn configuration file (in ``config/unicorn.rb``).
 
-If monit integration has been enabled via ``capper/monit`` unicorn is
-automatically (re)started during ``deploy:restart`` using unicorns in-place,
-no-downtime upgrade method.
-
 The following configuration options are provided:
 
 ``unicorn_worker_processes``
@@ -250,6 +259,25 @@ The following configuration options are provided:
 ``unicorn_timeout``
   Timeout after which workers are killed (default: 30)
 
+uwsgi
+-----
+
+The uwsgi recipe provides integration with uWSGI. A script to manage the uwsgi
+process is uploaded to ``#{bin_path}/uwsgi``. Additionally this recipe also
+manages the uwsgi configuration file (in ``config/uwsgi.xml``).
+
+The following configuration options are provided:
+
+``uwsgi_worker_processes``
+  Number of uwsgi workers (default: 4)
+
+virtualenv
+----------
+
+The virtualenv recipe provides ``deploy:setup`` hooks for virtualenv support.
+In addition required Python libraries are installed via pip into this
+environment.
+
 whenever
 --------
 
@@ -276,5 +304,5 @@ Contributing to capper
 Copyright
 =========
 
-Copyright (c) 2011 Benedikt Böhm. See LICENSE.txt for
+Copyright (c) 2011 Benedikt Böhm. See LICENSE for
 further details.

data/lib/capper.rb

@@ -13,6 +13,5 @@ include Capper::Utils::Monit
 # make sure capper recipes can be found by load() too
 Capistrano::Configuration.instance(true).load do
   load_paths << File.expand_path(File.dirname(__FILE__))
-  load 'deploy'
   load 'capper/base'
 end

data/lib/capper/base.rb

@@ -1,4 +1,92 @@
-# add custom color scheme
+require 'benchmark'
+require 'yaml'
+require 'capistrano/recipes/deploy/scm'
+require 'capistrano/recipes/deploy/strategy'
+
+def _cset(name, *args, &block)
+  unless exists?(name)
+    set(name, *args, &block)
+  end
+end
+
+# =========================================================================
+# These variables MUST be set in the client capfiles. If they are not set,
+# the deploy will fail with an error.
+# =========================================================================
+
+_cset(:application) { abort "Please specify the name of your application, set :application, 'foo'" }
+_cset(:repository)  { abort "Please specify the repository that houses your application's code, set :repository, 'foo'" }
+
+# =========================================================================
+# These variables may be set in the client capfile if their default values
+# are not sufficient.
+# =========================================================================
+
+_cset(:user) { application }
+
+_cset(:scm, :git)
+_cset(:deploy_via, :remote_cache)
+
+_cset(:deploy_to) { "/var/app/#{application}" }
+_cset(:revision)  { source.head }
+
+_cset(:ruby_exec_prefix, "")
+_cset(:rake) { "#{ruby_exec_prefix} rake" }
+
+_cset(:maintenance_basename, "maintenance")
+
+# =========================================================================
+# These variables should NOT be changed unless you are very confident in
+# what you are doing. Make sure you understand all the implications of your
+# changes if you do decide to muck with these!
+# =========================================================================
+
+_cset(:source)            { Capistrano::Deploy::SCM.new(scm, self) }
+_cset(:real_revision)     { source.local.query_revision(revision) { |cmd| with_env("LC_ALL", "C") { run_locally(cmd) } } }
+
+_cset(:strategy)          { Capistrano::Deploy::Strategy.new(deploy_via, self) }
+
+# If overriding release name, please also select an appropriate setting for :releases below.
+_cset(:release_name)      { set :deploy_timestamped, true; Time.now.utc.strftime("%Y%m%d%H%M%S") }
+
+_cset :releases_dir,      "releases"
+_cset :shared_dir,        "shared"
+_cset :current_dir,       "current"
+
+_cset(:releases_path)     { File.join(deploy_to, releases_dir) }
+_cset(:shared_path)       { File.join(deploy_to, shared_dir) }
+_cset(:current_path)      { File.join(deploy_to, current_dir) }
+_cset(:release_path)      { File.join(releases_path, release_name) }
+
+_cset(:bin_path)          { File.join(deploy_to, "bin") }
+_cset(:pid_path)          { File.join(shared_path, "pids") }
+_cset(:log_path)          { File.join(shared_path, "log") }
+_cset(:config_path)       { File.join(shared_path, "config") }
+
+_cset(:releases)          { capture("ls -x #{releases_path}", :except => { :no_release => true }).split.sort }
+_cset(:current_release)   { releases.length > 0 ? File.join(releases_path, releases.last) : nil }
+_cset(:previous_release)  { releases.length > 1 ? File.join(releases_path, releases[-2]) : nil }
+
+_cset(:current_revision)  { capture("cat #{current_path}/REVISION",     :except => { :no_release => true }).chomp }
+_cset(:latest_revision)   { capture("cat #{current_release}/REVISION",  :except => { :no_release => true }).chomp }
+_cset(:previous_revision) { capture("cat #{previous_release}/REVISION", :except => { :no_release => true }).chomp if previous_release }
+
+set(:internal_shared_children, fetch(:internal_shared_children, []) | %w(system log pids))
+
+# some tasks, like symlink, need to always point at the latest release, but
+# they can also (occassionally) be called standalone. In the standalone case,
+# the timestamped release_path will be inaccurate, since the directory won't
+# actually exist. This variable lets tasks like symlink work either in the
+# standalone case, or during deployment.
+_cset(:latest_release) { exists?(:deploy_timestamped) ? release_path : current_release }
+
+# set proper unicode locale, so gemspecs with unicode chars will not crash
+# bundler. see https://github.com/capistrano/capistrano/issues/70
+set(:default_environment, fetch(:default_environment).merge({
+  'LANG' => 'en_US.UTF-8'
+}))
+
+# add some colors and hide certain messages
 require 'capistrano_colors/configuration'
 require 'capistrano_colors/logger'
 
@@ -21,36 +109,53 @@ colorize([
 # do not trace by default
 logger.level = Capistrano::Logger::DEBUG
 
-# default app layout
-_cset(:user) { application }
-
-_cset(:base_path) { "/var/app" }
-set(:deploy_to) { "#{base_path}/#{application}" }
+# =========================================================================
+# These are helper methods that will be available to your recipes.
+# =========================================================================
 
-_cset(:bin_path) { File.join(deploy_to, "bin") }
-_cset(:pid_path) { File.join(shared_path, "pids") }
-_cset(:config_path) { File.join(shared_path, "config") }
-
-# apps should not require root access
-set(:use_sudo, false)
-set(:group_writable, false)
-
-# set proper unicode locale, so gemspecs with unicode chars will not crash
-# bundler. see https://github.com/capistrano/capistrano/issues/70
-_cset(:default_environment, { 'LANG' => 'en_US.UTF-8' })
+# Temporarily sets an environment variable, yields to a block, and restores
+# the value when it is done.
+def with_env(name, value)
+  saved, ENV[name] = ENV[name], value
+  yield
+ensure
+  ENV[name] = saved
+end
 
-# set a global (empty) prefix for ruby applications so that
-# other recipes (bundler) can override it (with bundle exec)
-_cset(:ruby_exec_prefix, "")
-set(:rake) { "#{ruby_exec_prefix} rake" }
+# logs the command then executes it locally.
+# returns the command output as a string
+def run_locally(cmd)
+  logger.trace "executing locally: #{cmd.inspect}" if logger
+  output_on_stdout = nil
+  elapsed = Benchmark.realtime do
+    output_on_stdout = `#{cmd}`
+  end
+  if $?.to_i > 0 # $? is command exit code (posix style)
+    raise Capistrano::LocalArgumentError, "Command #{cmd} returned status code #{$?}"
+  end
+  logger.trace "command finished in #{(elapsed * 1000).round}ms" if logger
+  output_on_stdout
+end
 
-# cleanup by default
-after "deploy:update", "deploy:cleanup"
-after "deploy:update_code", "deploy:symlink_shared"
+# =========================================================================
+# These are the tasks that are available to help with deploying web apps,
+# and specifically, Rails applications. You can have cap give you a summary
+# of them with `cap -T'.
+# =========================================================================
 
-# overwrite deploy:setup to get rid of the annoying chmod g+w which makes ssh
-# logins impossible
 namespace :deploy do
+  desc <<-DESC
+    Deploys your project. This calls `update', `cleanup' and `restart'. Note that \
+    this will generally only work for applications that have already been deployed \
+    once. For a "cold" deploy, you'll want to take a look at the `deploy:cold' \
+    task, which handles the cold start specifically.
+  DESC
+  task :default do
+    update
+    cleanup
+    restart
+  end
+
   desc <<-DESC
     Prepares one or more servers for deployment. Before you can use any \
     of the Capistrano deployment tasks with your project, you will need to \
@@ -64,16 +169,277 @@ namespace :deploy do
     will not destroy any deployed revisions or data.
   DESC
   task :setup, :except => { :no_release => true } do
-    shared = %w(system log pids) | shared_children
-    dirs = [releases_path, shared_path]
+    shared = fetch(:internal_shared_children, []) | fetch(:shared_children, [])
+    dirs = [deploy_to, releases_path, shared_path]
     dirs += shared.map { |d| File.join(shared_path, d) }
     run "mkdir -p #{dirs.join(' ')}"
   end
 
-  desc "Create symlinks from shared to current"
-  task :symlink_shared, :roles => :app, :except => { :no_release => true } do
-    fetch(:symlinks, {}).each do |source, dest|
-      run "rm -rf #{release_path}/#{dest} && ln -nfs #{shared_path}/#{source} #{release_path}/#{dest}"
+  desc <<-DESC
+    Copies your project and updates the symlink. It does this in a \
+    transaction, so that if either `update_code' or `symlink' fail, all \
+    changes made to the remote servers will be rolled back, leaving your \
+    system in the same state it was in before `update' was invoked. Usually, \
+    you will want to call `deploy' instead of `update', but `update' can be \
+    handy if you want to deploy, but not immediately restart your application.
+  DESC
+  task :update do
+    transaction do
+      update_code
+      symlink
+    end
+  end
+
+  desc <<-DESC
+    Copies your project to the remote servers. This is the first stage \
+    of any deployment; moving your updated code and assets to the deployment \
+    servers. You will rarely call this task directly, however; instead, you \
+    should call the `deploy' task (to do a complete deploy) or the `update' \
+    task (if you want to perform the `restart' task separately).
+
+    You will need to make sure you set the :scm variable to the source \
+    control software you are using (it defaults to :git), and the \
+    :deploy_via variable to the strategy you want to use to deploy (it \
+    defaults to :remote_cache).
+  DESC
+  task :update_code, :except => { :no_release => true } do
+    on_rollback { run "rm -rf #{release_path}; true" }
+    strategy.deploy!
+    finalize_update
+  end
+
+  desc <<-DESC
+    [internal] Touches up the released code. This is called by update_code \
+    after the basic deploy finishes.
+
+    This task will set up symlinks to the shared directory for the log, system, \
+    and tmp/pids directories as well as mappings specified in :symlinks.
+  DESC
+  task :finalize_update, :except => { :no_release => true } do
+    run(fetch(:internal_symlinks, {}).merge(fetch(:symlinks, {})).map do |source, dest|
+      "rm -rf #{latest_release}/#{dest} && " +
+      "mkdir -p #{File.dirname(File.join(latest_release, dest))} && " +
+      "ln -s #{shared_path}/#{source} #{latest_release}/#{dest}"
+    end.join(" && "))
+  end
+
+  desc <<-DESC
+    Updates the symlink to the most recently deployed version. Capistrano works \
+    by putting each new release of your application in its own directory. When \
+    you deploy a new version, this task's job is to update the `current' symlink \
+    to point at the new version. You will rarely need to call this task \
+    directly; instead, use the `deploy' task (which performs a complete \
+    deploy, including `restart') or the 'update' task (which does everything \
+    except `restart').
+  DESC
+  task :symlink, :except => { :no_release => true } do
+    on_rollback do
+      if previous_release
+        run "rm -f #{current_path}; ln -s #{previous_release} #{current_path}; true"
+      else
+        logger.important "no previous release to rollback to, rollback of symlink skipped"
+      end
+    end
+
+    run "rm -f #{current_path} && ln -s #{latest_release} #{current_path}"
+  end
+
+  desc <<-DESC
+    Blank task exists as a hook into which to install your own environment \
+    specific behaviour.
+  DESC
+  task :start, :roles => :app do
+    # Empty Task to overload with your platform specifics
+  end
+
+  desc <<-DESC
+    Blank task exists as a hook into which to install your own environment \
+    specific behaviour.
+  DESC
+  task :stop, :roles => :app do
+    # Empty Task to overload with your platform specifics
+  end
+
+  desc <<-DESC
+    Blank task exists as a hook into which to install your own environment \
+    specific behaviour.
+  DESC
+  task :restart, :roles => :app, :except => { :no_release => true } do
+    # Empty Task to overload with your platform specifics
+  end
+
+  desc <<-DESC
+    Blank task exists as a hook into which to install your own environment \
+    specific behaviour.
+  DESC
+  task :migrate, :roles => :db, :only => { :primary => true } do
+    # Empty Task to overload with your platform specifics
+  end
+
+  desc <<-DESC
+    Deploy and run pending migrations. This will work similarly to the \
+    `deploy' task, but will also run any pending migrations (via the \
+    `deploy:migrate' task) prior to updating the symlink. Note that the \
+    update in this case is not atomic, and transactions are not used, \
+    because migrations are not guaranteed to be reversible.
+  DESC
+  task :migrations do
+    update_code
+    migrate
+    symlink
+    restart
+  end
+
+  desc <<-DESC
+    Deploys and starts a `cold' application. This is useful if you have not \
+    deployed your application before, or if your application is (for some \
+    other reason) not currently running. It will deploy the code, run any \
+    pending migrations, and then instead of invoking `deploy:restart', it will \
+    invoke `deploy:start' to fire up the application servers.
+  DESC
+  task :cold do
+    update
+    migrate
+    start
+  end
+
+  namespace :rollback do
+    desc <<-DESC
+      [internal] Points the current symlink at the previous revision.
+      This is called by the rollback sequence, and should rarely (if
+      ever) need to be called directly.
+    DESC
+    task :revision, :except => { :no_release => true } do
+      if previous_release
+        run "rm #{current_path}; ln -s #{previous_release} #{current_path}"
+      else
+        abort "could not rollback the code because there is no prior release"
+      end
+    end
+
+    desc <<-DESC
+      [internal] Removes the most recently deployed release.
+      This is called by the rollback sequence, and should rarely
+      (if ever) need to be called directly.
+    DESC
+    task :cleanup, :except => { :no_release => true } do
+      run "if [ `readlink #{current_path}` != #{current_release} ]; then rm -rf #{current_release}; fi"
+    end
+
+    desc <<-DESC
+      Rolls back to the previously deployed version. The `current' symlink will \
+      be updated to point at the previously deployed version, and then the \
+      current release will be removed from the servers. You'll generally want \
+      to call `rollback' instead, as it performs a `restart' as well.
+    DESC
+    task :code, :except => { :no_release => true } do
+      revision
+      cleanup
+    end
+
+    desc <<-DESC
+      Rolls back to a previous version and restarts. This is handy if you ever \
+      discover that you've deployed a lemon; `cap rollback' and you're right \
+      back where you were, on the previously deployed version.
+    DESC
+    task :default do
+      revision
+      restart
+      cleanup
+    end
+  end
+
+  desc <<-DESC
+    Clean up old releases. By default, the last 5 releases are kept on each \
+    server (though you can change this with the keep_releases variable). All \
+    other deployed revisions are removed from the servers.
+  DESC
+  task :cleanup, :except => { :no_release => true } do
+    count = fetch(:keep_releases, 5).to_i
+    local_releases = capture("ls -xt #{releases_path}").split.reverse
+    if count >= local_releases.length
+      logger.important "no old releases to clean up"
+    else
+      logger.info "keeping #{count} of #{local_releases.length} deployed releases"
+      directories = (local_releases - local_releases.last(count)).map { |release|
+        File.join(releases_path, release) }.join(" ")
+
+      run "rm -rf #{directories}"
+    end
+  end
+
+  namespace :pending do
+    desc <<-DESC
+      Displays the `diff' since your last deploy. This is useful if you want \
+      to examine what changes are about to be deployed. Note that this might \
+      not be supported on all SCM's.
+    DESC
+    task :diff, :except => { :no_release => true } do
+      system(source.local.diff(current_revision))
+    end
+
+    desc <<-DESC
+      Displays the commits since your last deploy. This is good for a summary \
+      of the changes that have occurred since the last deploy. Note that this \
+      might not be supported on all SCM's.
+    DESC
+    task :default, :except => { :no_release => true } do
+      from = source.next_revision(current_revision)
+      system(source.local.log(from))
+    end
+  end
+
+  namespace :web do
+    desc <<-DESC
+      Present a maintenance page to visitors. Disables your application's web \
+      interface by writing a "#{maintenance_basename}.html" file to each web server. The \
+      servers must be configured to detect the presence of this file, and if \
+      it is present, always display it instead of performing the request.
+
+      By default, the maintenance page will just say the site is down for \
+      "maintenance", and will be back "shortly", but you can customize the \
+      page by specifying the REASON and UNTIL environment variables:
+
+        $ cap deploy:web:disable \\
+              REASON="hardware upgrade" \\
+              UNTIL="12pm Central Time"
+
+      Further customization will require that you write your own task.
+    DESC
+    task :disable, :roles => :web, :except => { :no_release => true } do
+      require 'erb'
+      on_rollback { run "rm #{shared_path}/system/#{maintenance_basename}.html" }
+
+      warn <<-EOHTACCESS
+
+        # Please add something like this to your site's htaccess to redirect users to the maintenance page.
+        # More Info: http://www.shiftcommathree.com/articles/make-your-rails-maintenance-page-respond-with-a-503
+
+        ErrorDocument 503 /system/#{maintenance_basename}.html
+        RewriteEngine On
+        RewriteCond %{REQUEST_URI} !\.(css|gif|jpg|png)$
+        RewriteCond %{DOCUMENT_ROOT}/system/#{maintenance_basename}.html -f
+        RewriteCond %{SCRIPT_FILENAME} !#{maintenance_basename}.html
+        RewriteRule ^.*$  -  [redirect=503,last]
+      EOHTACCESS
+
+      reason = ENV['REASON']
+      deadline = ENV['UNTIL']
+
+      template = File.read(File.join(File.dirname(__FILE__), "templates", "maintenance.rhtml"))
+      result = ERB.new(template).result(binding)
+
+      put result, "#{shared_path}/system/#{maintenance_basename}.html", :mode => 0644
+    end
+
+    desc <<-DESC
+      Makes the application web-accessible again. Removes the \
+      "#{maintenance_basename}.html" page generated by deploy:web:disable, which (if your \
+      web servers are configured correctly) will make your application \
+      web-accessible again.
+    DESC
+    task :enable, :roles => :web, :except => { :no_release => true } do
+      run "rm #{shared_path}/system/#{maintenance_basename}.html"
     end
   end
 end

data/lib/capper/bundler.rb

@@ -1,3 +1,5 @@
+load 'capper/ruby'
+
 require 'bundler/capistrano'
 
 # use bundle exec for all ruby programs

data/lib/capper/django.rb

@@ -0,0 +1,34 @@
+load "capper/python"
+
+after 'deploy:update_code', 'django:setup'
+
+before 'deploy:migrate', 'django:migrate'
+
+namespace :django do
+  desc "Generate rails configuration and helpers"
+  task :setup, :roles => :app, :except => { :no_release => true } do
+    upload_template_file("manage.py",
+                         File.join(bin_path, "manage.py"),
+                         :mode => "0755")
+  end
+
+  desc <<-DESC
+    Run the syncdb and migratedb task. By default, it runs this in most recently \
+    deployed version of the app. However, you can specify a different release \
+    via the migrate_target variable, which must be one of :latest (for the \
+    default behavior), or :current (for the release indicated by the \
+    `current' symlink). Strings will work for those values instead of symbols, \
+    too.
+  DESC
+  task :migrate, :roles => :db, :only => { :primary => true } do
+    migrate_target = fetch(:migrate_target, :latest)
+
+    directory = case migrate_target.to_sym
+      when :current then current_path
+      when :latest  then latest_release
+      else raise ArgumentError, "unknown migration target #{migrate_target.inspect}"
+      end
+
+    run "cd #{directory} && #{python} manage.py syncdb --migrate --noinput"
+  end
+end

data/lib/capper/python.rb

@@ -0,0 +1,5 @@
+_cset(:python, "python")
+
+after "deploy:finalize_update" do
+  run("ln -nfs #{latest_release} #{latest_release}/#{application}")
+end

data/lib/capper/rails.rb

@@ -1,20 +1,23 @@
+load "capper/ruby"
+
 _cset(:rails_env, "production")
 
 _cset(:asset_pipeline, true)
 _cset(:asset_env, "RAILS_GROUPS=assets")
-_cset(:assets_prefix, "assets")
 
-set(:normalize_asset_timestamps) do
-  if asset_pipeline
-    false
-  else
-    true
-  end
-end
+set(:internal_shared_children, fetch(:internal_shared_children, []) | %w(assets))
+
+set(:internal_symlinks, fetch(:internal_symlinks, {}).merge({
+  "assets" => "public/assets",
+  "log" => "log",
+  "pids" => "tmp/pids",
+  "system" => "public/system",
+}))
 
-before 'deploy:finalize_update', 'rails:assets:symlink'
-after 'deploy:update_code', 'rails:assets:precompile'
 after 'deploy:update_code', 'rails:setup'
+after 'deploy:update_code', 'rails:assets:precompile'
+
+before 'deploy:migrate', 'rails:migrate'
 
 namespace :rails do
   desc "Generate rails configuration and helpers"
@@ -24,26 +27,35 @@ namespace :rails do
                          :mode => "0755")
   end
 
-  namespace :assets do
-    desc <<-DESC
-      [internal] This task will set up a symlink to the shared directory \
-      for the assets directory. Assets are shared across deploys to avoid \
-      mid-deploy mismatches between old application html asking for assets \
-      and getting a 404 file not found error. The assets cache is shared \
-      for efficiency. If you cutomize the assets path prefix, override the \
-      :assets_prefix variable to match.
-    DESC
-    task :symlink, :roles => [:web, :asset], :except => { :no_release => true } do
-      if asset_pipeline
-        run <<-CMD
-          rm -rf #{latest_release}/public/#{assets_prefix} &&
-          mkdir -p #{latest_release}/public &&
-          mkdir -p #{shared_path}/assets &&
-          ln -s #{shared_path}/assets #{latest_release}/public/#{assets_prefix}
-        CMD
+  desc <<-DESC
+    Run the migrate rake task. By default, it runs this in most recently \
+    deployed version of the app. However, you can specify a different release \
+    via the migrate_target variable, which must be one of :latest (for the \
+    default behavior), or :current (for the release indicated by the \
+    `current' symlink). Strings will work for those values instead of symbols, \
+    too. You can also specify additional environment variables to pass to rake \
+    via the migrate_env variable. Finally, you can specify the full path to the \
+    rake executable by setting the rake variable. The defaults are:
+
+      set :rake,           "rake"
+      set :rails_env,      "production"
+      set :migrate_env,    ""
+      set :migrate_target, :latest
+  DESC
+  task :migrate, :roles => :db, :only => { :primary => true } do
+    migrate_env = fetch(:migrate_env, "")
+    migrate_target = fetch(:migrate_target, :latest)
+
+    directory = case migrate_target.to_sym
+      when :current then current_path
+      when :latest  then latest_release
+      else raise ArgumentError, "unknown migration target #{migrate_target.inspect}"
       end
-    end
 
+    run "cd #{directory} && #{rake} RAILS_ENV=#{rails_env} #{migrate_env} db:migrate"
+  end
+
+  namespace :assets do
     desc <<-DESC
       Run the asset precompilation rake task. You can specify the full path \
       to the rake executable by setting the rake variable. You can also \

data/lib/capper/{gem.rb → ruby.rb}

@@ -1,3 +1,6 @@
+_cset(:ruby_exec_prefix, "")
+_cset(:rake) { "#{ruby_exec_prefix} rake" }
+
 before "deploy:setup", "gemrc:setup"
 
 namespace :gemrc do

data/lib/capper/rvm.rb

@@ -1,4 +1,4 @@
-load "capper/gem"
+load "capper/ruby"
 
 $:.unshift(File.expand_path('./lib', ENV['rvm_path']))
 require 'rvm/capistrano'

data/lib/capper/templates/manage.py.erb

@@ -0,0 +1,6 @@
+#!/bin/bash
+export HOME=<%= deploy_to %>
+
+cd <%= current_path %> >/dev/null
+
+exec <%= python %> manage.py "$@"

data/lib/capper/templates/unicorn.rb.erb

@@ -13,14 +13,14 @@ worker_processes <%= unicorn_worker_processes %>
 working_directory "<%= current_path %>"
 
 # listen on Unix domain socket and let nginx proxy
-listen "<%= shared_path %>/pids/unicorn.sock"
+listen "<%= pid_path %>/unicorn.sock"
 
 # nuke workers after 30 seconds instead of 60 seconds (the default)
 timeout <%= unicorn_timeout %>
 
 # Location of the pidfile. Should not be changed unless you
 # know what you are doing.
-pid "<%= shared_path %>/pids/unicorn.pid"
+pid "<%= unicorn_pidfile %>"
 
 # use syslogger if available
 begin
@@ -30,8 +30,8 @@ rescue
 end
 
 # these do not seem to support syslog
-stderr_path "<%= shared_path %>/log/unicorn.stderr.log"
-stdout_path "<%= shared_path %>/log/unicorn.stdout.log"
+stderr_path "<%= log_path %>/unicorn.stderr.log"
+stdout_path "<%= log_path %>/unicorn.stdout.log"
 
 # combine REE with "preload_app true" for memory savings
 # http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
@@ -66,7 +66,7 @@ before_fork do |server, worker|
   # thundering herd (especially in the "preload_app false" case)
   # when doing a transparent upgrade.  The last worker spawned
   # will then kill off the old master process with a SIGQUIT.
-  old_pid = "<%= shared_path %>/pids/unicorn.pid.oldbin"
+  old_pid = "<%= unicorn_pidfile %>.oldbin"
   if old_pid != server.pid
     begin
       sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU

data/lib/capper/templates/unicorn.sh.erb

@@ -6,8 +6,8 @@ if [[ -e "${HOME}"/.rvm/scripts/rvm ]]; then
   source "${HOME}"/.rvm/scripts/rvm
 fi
 
-PIDFILE=<%= shared_path %>/pids/unicorn.pid
-CONFIG=<%= shared_path %>/config/unicorn.rb
+PIDFILE=<%= unicorn_pidfile %>
+CONFIG=<%= unicorn_config %>
 CMD="<%= ruby_exec_prefix %> unicorn -c $CONFIG -E $RAILS_ENV -D config.ru"
 
 cd <%= current_path %> >/dev/null

data/lib/capper/templates/uwsgi.sh.erb

@@ -0,0 +1,33 @@
+#!/bin/bash
+export HOME=<%= deploy_to %>
+
+PIDFILE=<%= uwsgi_pidfile %>
+CONFIG=<%= uwsgi_config %>
+LOGFILE=<%= log_path %>/uwsgi.log
+CMD="uwsgi -x $CONFIG -d $LOGFILE"
+
+cd <%= current_path %> >/dev/null
+
+sig () {
+  test -s "$PIDFILE" && kill -$1 $(<$PIDFILE)
+}
+
+case $1 in
+start)
+  sig 0 && echo >&2 "Already running" && exit 0
+  $CMD
+  ;;
+stop)
+  sig QUIT && exit 0
+  echo >&2 "Not running"
+  ;;
+reload)
+  sig HUP && echo reloaded OK && exit 0
+  echo >&2 "Couldn't reload, starting '$CMD' instead"
+  $CMD
+  ;;
+*)
+  echo >&2 "Usage: $0 <start|stop|reload>"
+  exit 1
+  ;;
+esac

data/lib/capper/templates/uwsgi.xml.erb

@@ -0,0 +1,10 @@
+<uwsgi>
+  <master/>
+  <processes><%= uwsgi_worker_processes %></processes>
+  <home><%= deploy_to %></home>
+  <socket><%= pid_path %>/uwsgi.sock</socket>
+  <pidfile><%= uwsgi_pidfile %></pidfile>
+  <pythonpath><%= current_path %></pythonpath>
+  <env>DJANGO_SETTINGS_MODULE=<%= application %>.settings</env>
+  <module>django.core.handlers.wsgi:WSGIHandler()</module>
+</uwsgi>

data/lib/capper/uwsgi.rb

@@ -0,0 +1,44 @@
+# uwsgi configuration variables
+_cset(:uwsgi_worker_processes, 4)
+
+# these cannot be overriden
+set(:uwsgi_script) { File.join(bin_path, "uwsgi") }
+set(:uwsgi_config) { File.join(config_path, "uwsgi.xml") }
+set(:uwsgi_pidfile) { File.join(pid_path, "uwsgi.pid") }
+
+after "deploy:update_code", "uwsgi:setup"
+after "deploy:restart", "uwsgi:restart"
+
+monit_config "uwsgi", <<EOF, :roles => :app
+check process uwsgi
+with pidfile "<%= uwsgi_pidfile %>"
+start program = "<%= uwsgi_script %> start" with timeout 60 seconds
+stop program = "<%= uwsgi_script %> stop"
+EOF
+
+namespace :uwsgi do
+  desc "Generate uwsgi configuration files"
+  task :setup, :roles => :app, :except => { :no_release => true } do
+    upload_template_file("uwsgi.xml",
+                         uwsgi_config,
+                         :mode => "0644")
+    upload_template_file("uwsgi.sh",
+                         uwsgi_script,
+                         :mode => "0755")
+  end
+
+  desc "Start uwsgi"
+  task :start, :roles => :app, :except => { :no_release => true } do
+    run "#{uwsgi_script} start"
+  end
+
+  desc "Stop uwsgi"
+  task :stop, :roles => :app, :except => { :no_release => true } do
+    run "#{uwsgi_script} stop"
+  end
+
+  desc "Reload uwsgi"
+  task :restart, :roles => :app, :except => { :no_release => true } do
+    run "#{uwsgi_script} reload"
+  end
+end

data/lib/capper/version.rb

@@ -1,3 +1,3 @@
 module Capper
-  VERSION = "0.8.3"
+  VERSION = "0.9.0"
 end

data/lib/capper/virtualenv.rb

@@ -0,0 +1,21 @@
+load "capper/python"
+
+set(:python) { "#{bin_path}/python" }
+
+before "deploy:setup", "virtualenv:setup"
+
+after "deploy:finalize_update", "pip:install"
+
+namespace :virtualenv do
+  desc "Create virtualenv for Python packages"
+  task :setup, :except => {:no_release => true} do
+    run("if [ ! -e #{bin_path}/python ]; then " +
+        "virtualenv -q --no-site-packages #{deploy_to}; fi")
+  end
+end
+
+namespace :pip do
+  task :install do
+    run("#{bin_path}/pip install -q -E #{deploy_to} -r #{latest_release}/requirements.txt")
+  end
+end

data/lib/capper/whenever.rb

@@ -1,6 +1,8 @@
+load "capper/ruby"
+
 set(:whenever_command) { "#{ruby_exec_prefix} whenever" }
 set(:whenever_identifier) { application }
-set(:whenever_environment) { fetch(:rails_env, "production") }
+set(:whenever_environment) { rails_env }
 set(:whenever_update_flags) { "--update-crontab #{whenever_identifier} --set environment=#{whenever_environment}" }
 set(:whenever_clear_flags) { "--clear-crontab #{whenever_identifier}" }
 

metadata

@@ -2,7 +2,7 @@
 name: capper
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.8.3
+  version: 0.9.0
 platform: ruby
 authors: 
 - "Benedikt B\xC3\xB6hm"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-28 00:00:00 +02:00
+date: 2011-11-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,24 +70,30 @@ files:
 - lib/capper/bundler.rb
 - lib/capper/config.rb
 - lib/capper/delayed_job.rb
-- lib/capper/gem.rb
-- lib/capper/git.rb
+- lib/capper/django.rb
 - lib/capper/hoptoad.rb
 - lib/capper/monit.rb
 - lib/capper/multistage.rb
+- lib/capper/python.rb
 - lib/capper/rails.rb
 - lib/capper/resque.rb
+- lib/capper/ruby.rb
 - lib/capper/rvm.rb
 - lib/capper/templates/delayed_job.sh.erb
+- lib/capper/templates/manage.py.erb
 - lib/capper/templates/rails.console.sh.erb
 - lib/capper/templates/resque.sh.erb
 - lib/capper/templates/unicorn.rb.erb
 - lib/capper/templates/unicorn.sh.erb
+- lib/capper/templates/uwsgi.sh.erb
+- lib/capper/templates/uwsgi.xml.erb
 - lib/capper/unicorn.rb
 - lib/capper/utils/monit.rb
 - lib/capper/utils/multistage.rb
 - lib/capper/utils/templates.rb
+- lib/capper/uwsgi.rb
 - lib/capper/version.rb
+- lib/capper/virtualenv.rb
 - lib/capper/whenever.rb
 has_rdoc: true
 homepage: http://github.com/zenops/capper

data/lib/capper/git.rb

@@ -1,2 +0,0 @@
-set(:scm, :git)
-set(:deploy_via, :remote_cache)