capistrano-demonz 0.0.5

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Chinthaka Godawita
+
+MIT License
+
+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/README.md

@@ -0,0 +1,29 @@
+# Capistrano::Demonz
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'capistrano-demonz'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capistrano-demonz
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/capistrano-demonz.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'demonz/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "capistrano-demonz"
+  gem.version       = Capistrano::Demonz::VERSION
+  gem.authors       = ["Chinthaka Godawita"]
+  gem.email         = ["chinthaka.godawita@demonzmedia.com"]
+  gem.description   = "Demonz Media recipes for Capistrano"
+  gem.summary       = "Useful task libraries for Demonz Media recipes for Capistrano"
+  gem.homepage      = "https://github.com/demonz/capistrano-demonz"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency  "railsless-deploy", ">= 1.0.2"
+  gem.add_dependency  "capistrano", ">= 2.13.5"
+end

data/lib/capistrano-demonz.rb

@@ -0,0 +1,7 @@
+require "capistrano-demonz/version"
+
+module Capistrano
+  module Demonz
+    # Your code goes here...
+  end
+end

data/lib/demonz/base.rb

@@ -0,0 +1,541 @@
+# Capistrano2 differentiator
+load 'deploy' if respond_to?(:namespace)
+Dir['vendor/plugins/*/recipes/*.rb'].each { |plugin| load(plugin) }
+
+# Required gems/libraries
+require 'rubygems'
+require 'demonz/common'
+require 'capistrano/ext/multistage'
+
+# Bootstrap Capistrano instance
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+  Capistrano::Configuration.instance(:must_exist) :
+  Capistrano.configuration(:must_exist)
+
+configuration.load do
+
+  # Set default stages
+  set :stages, %w(staging production)
+  set :default_stage, "staging"
+
+  # Set shared path to be inside app directory
+  set :shared_path, File.join(deploy_to, 'shared')
+
+  # --------------------------------------------
+  # Task chains
+  # --------------------------------------------
+  after "multistage:ensure", "demonz:set_release_history"
+  before "deploy", "demonz:set_release_info"
+  before "deploy:finalize_update", "demonz:add_release_tracking"
+  after "deploy:setup", "deploy:setup_shared"
+  after "deploy:setup_shared", "deploy:setup_backup"
+  after "deploy:finalize_update", "demonz:htaccess"
+  after "deploy", "deploy:cleanup"
+  after "deploy:cleanup", "demonz:cleanup_release_tracking"
+  before "deploy:rollback", "demonz:set_rollback_release"
+  after "deploy:rollback", "demonz:update_release_tracking_for_rollback"
+
+  # --------------------------------------------
+  # Default variables
+  # --------------------------------------------
+  # SSH
+  set :user,              proc{text_prompt("SSH username: ")}
+  set :group,             :user
+  set :password,          proc{Capistrano::CLI.password_prompt("SSH password for '#{user}':")}
+
+  # Database
+  # set :dbuser,            proc{text_prompt("Database username: ")}
+  # set :dbpass,            proc{Capistrano::CLI.password_prompt("Database password for '#{dbuser}':")}
+  # set :dbname,            proc{text_prompt("Database name: ")}
+  _cset :mysqldump,       "mysqldump"
+  _cset :dump_options,    "--single-transaction --create-options --quick"
+
+  # Source Control
+  set :group_writable,    true
+  set :use_sudo,          false
+  set :scm,               :git
+  set :scm_verbose,       true
+  set :scm_username,      proc{text_prompt("Git username: ")}
+  set :scm_password,      proc{Capistrano::CLI.password_prompt("Git password for '#{scm_username}': ")}
+  set :deploy_via,        :remote_cache
+  set :copy_strategy,     :checkout
+  set :copy_compression,  :bz2
+  set :copy_exclude,      [".svn", ".DS_Store", "*.sample", "LICENSE*", "Capfile",
+    "RELEASE*", "*.rb", "*.sql", "nbproject", "_template", "*.sublime*"]
+
+  # Backups Path
+  _cset(:backups_path)      { File.join(deploy_to, "backups") }
+  _cset(:tmp_backups_path)  { File.join("#{backups_path}", "tmp") }
+  _cset(:backups)           { capture("ls -x #{backups_path}", :except => { :no_release => true }).split.sort }
+
+  # Define which files or directories you want to exclude from being backed up
+  _cset(:backup_exclude)  { [] }
+  set :exclude_string,    ''
+
+  # show password requests on windows
+  # (http://weblog.jamisbuck.org/2007/10/14/capistrano-2-1)
+  default_run_options[:pty] = true
+
+  # Release tracking
+  set :release_file,       File.join(shared_path, "RELEASES")
+
+  # SASS compilation support (via compass)
+  set :uses_sass,          false
+
+  # Add a dependency on compass and :themes if required
+  if uses_sass
+    depend :remote, :gem, "compass", ">=0.12"
+    _cset(:themes) { abort "Please specify themes on this site, set :themes, ['theme1', 'theme2']" }
+  end
+
+  # We need PHP and gzip
+  depend :remote, :command, "php"
+  depend :remote, :command, "gzip"
+
+  # --------------------------------------------
+  # Overloaded tasks
+  # --------------------------------------------
+  namespace :deploy do
+    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 \
+      make sure all of your servers have been prepared with `cap deploy:setup'. When \
+      you add a new server to your cluster, you can easily run the setup task \
+      on just that server by specifying the HOSTS environment variable:
+
+        $ cap HOSTS=new.server.com deploy:setup
+
+      It is safe to run this task on servers that have already been set up; it \
+      will not destroy any deployed revisions or data.
+    DESC
+    task :setup, :except => { :no_release => true } do
+      dirs = [deploy_to, releases_path, shared_path]
+      dirs += shared_children.map { |d| File.join(shared_path, d.split('/').last) }
+      run "#{try_sudo} mkdir -p #{dirs.join(' ')}"
+      run "#{try_sudo} chmod 775 #{dirs.join(' ')}" if fetch(:group_writable, true)
+      run "#{try_sudo} touch #{release_file}"
+      run "#{try_sudo} chmod g+w #{release_file}" if fetch(:group_writable, true)
+      run "#{try_sudo} chown -R #{user}:#{group} #{deploy_to}"
+    end
+
+    desc "Setup backup directory for database and web files"
+    task :setup_backup, :except => { :no_release => true } do
+      run "#{try_sudo} mkdir -p #{backups_path} #{tmp_backups_path} && #{try_sudo} chmod 775 #{backups_path} && #{try_sudo} chmod 775 #{tmp_backups_path}"
+    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. By default, this \
+      will use sudo to clean up the old releases, but if sudo is not available \
+      for your environment, set the :use_sudo variable to false instead. \
+
+      Overridden to set/reset file and directory permissions
+    DESC
+    task :cleanup, :except => { :no_release => true } do
+      count = fetch(:keep_releases, 5).to_i
+      local_releases = get_release_history(release_file).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"
+        set :cleanup_releases, (local_releases - local_releases.last(count))
+        directories = cleanup_releases.map { |release|
+          File.join(releases_path, release) }.join(" ")
+
+        directories.split(" ").each do |dir|
+          set_perms_dirs(dir)
+          set_perms_files(dir)
+        end
+
+        try_sudo "rm -rf #{directories}"
+      end
+    end
+
+    desc "Show deployment release history"
+    task :history do
+      logger.important "Previous deployments (in ascending order)"
+      history = get_release_history(release_file)
+
+      if history.empty?
+        logger.info "No previous deployments found"
+      else
+        logger.info history
+      end
+    end
+  end
+
+  # --------------------------------------------
+  # Demonz tasks
+  # --------------------------------------------
+  namespace :demonz do
+    desc "[internal] Set release history"
+    task :set_release_history, :roles => :web, :except => { :no_release => true } do
+      set :releases, get_release_history(release_file).split
+    end
+
+    desc "Set standard permissions for Demonz servers"
+    task :fixperms, :roles => :web, :except => { :no_release => true } do
+      # chmod the files and directories.
+      set_perms_dirs("#{latest_release}")
+      set_perms_files("#{latest_release}")
+    end
+
+    desc "Test: Task used to verify Capistrano is working. Prints operating system name."
+    task :uname do
+      run "uname -a"
+    end
+
+    desc "Test: Task used to verify Capistrano is working. Prints environment of Capistrano user."
+    task :getpath do
+      run "echo $PATH"
+    end
+
+    desc 'Copy distribution htaccess file'
+    task :htaccess, :roles => :web do
+      case true
+      when remote_file_exists?("#{latest_release}/htaccess.#{stage}.dist")
+        run "#{try_sudo} mv #{latest_release}/htaccess.#{stage}.dist #{latest_release}/.htaccess"
+      when remote_file_exists?("#{latest_release}/htaccess.#{stage}")
+        run "#{try_sudo} mv #{latest_release}/htaccess.#{stage} #{latest_release}/.htaccess"
+      when remote_file_exists?("#{latest_release}/htaccess.dist")
+        run "#{try_sudo} mv #{latest_release}/htaccess.dist #{latest_release}/.htaccess"
+      else
+        logger.important "Failed to move the .htaccess file in #{latest_release} because an unknown pattern was used"
+      end
+    end
+
+    # Modified from https://gist.github.com/2016396
+    desc "Push local changes to Git repository"
+    task :push do
+      # Check we are on the right branch, so we can't forget to merge before deploying
+      branch = %x(git branch --no-color 2>/dev/null | sed -e '/^[^*]/d' -e 's/* \\(.*\\)/\\1/').chomp
+      if branch != "#{branch}" && !ENV["IGNORE_BRANCH"]
+        raise Capistrano::Error, "Not on #{branch} branch (set IGNORE_BRANCH=1 to ignore)"
+      end
+
+      # Push the changes
+      if ! system "git push --tags #{fetch(:repository)} #{branch}"
+        raise Capistrano::Error, "Failed to push changes to #{fetch(:repository)}"
+      end
+    end
+
+    desc "[internal] Set release info (such as release name and git tag)"
+    task :set_release_info, :roles => :web, :except => { :no_release => true } do
+      # Get all Git tags from local repository
+      all_tags = %x[git for-each-ref --sort='*authordate' --format='%(refname:short)' refs/tags].split
+
+      # Error out if not tags
+      # if all_tags.empty?
+      #   raise Capistrano::Error, "No Git tags found, please define some before attempting deployment"
+      # end
+
+      # We're not using pure timestamps to track deployment anymore
+      set :deploy_timestamped, false
+
+      if variables.include?(:tag) && !all_tags.empty? && all_tags.include?(tag)
+        logger.info "deploying using Git tag '#{tag}'"
+
+        # Set revision to the commit that :tag points to
+        set :revision, run_locally("git rev-list #{tag} | head -n 1")
+
+        # Slashes are bad in directory names
+        clean_tag = tag.gsub("/", "-")
+      else
+        logger.important "no valid Git tag specified, continuing with HEAD instead"
+
+        # Get tag from user
+        tag = text_prompt("Please specify a tag name for this release (this will be created): ")
+        logger.info "setting release tag to #{tag}"
+
+        # Slashes are bad in directory names
+        clean_tag = tag.gsub("/", "-")
+
+        # Try to add tag to git
+        if ! system "git tag #{release_name}"
+          raise Capistrano::Error, "Failed to Git tag: #{release_name}"
+        end
+      end
+
+      # If the release directory already exists, append timestamp
+      if remote_file_exists?(File.join(releases_path, clean_tag, 'REVISION'))
+        clean_tag += '-' + Time.now.utc.strftime("%Y%m%d%H%M%S")
+        logger.important "previous deployment with this tag found, setting current release name to #{clean_tag}"
+      end
+
+      set :release_name, clean_tag
+      set :latest_release, release_path
+    end
+
+    desc "[internal] Keep track of the current release"
+    task :add_release_tracking, :roles => :web, :except => { :no_release => true } do
+      on_rollback { remove_release_from_history(release_name, release_file) }
+      run "#{try_sudo} echo #{release_name} >> #{release_file}"
+    end
+
+    desc "[internal] Cleanup release tracking"
+    task :cleanup_release_tracking, :roles => :web, :except => { :no_release => true } do
+      if variables.include?(:cleanup_releases)
+        cleanup_releases = fetch(:cleanup_releases, nil)
+
+        if !cleanup_releases.nil?
+          files_backups = cleanup_releases.map { |release|
+            remove_release_from_history(release, release_file) }
+        end
+      end
+    end
+
+    desc "[internal] Set last release name for rollback"
+    task :set_rollback_release, :except => { :no_release => true } do
+      set :release_name, releases.last
+    end
+
+    desc "[internal] Remove rollback release from release tracking"
+    task :update_release_tracking_for_rollback, :except => { :no_release => true } do
+      remove_release_from_history(release_name, release_file)
+    end
+  end
+
+  # --------------------------------------------
+  # PHP tasks
+  # --------------------------------------------
+  namespace :php do
+    namespace :apc do
+      desc "Disable the APC administrative panel"
+      task :disable, :roles => :web, :except => { :no_release => true } do
+        run "#{try_sudo} rm #{current_path}/apc.php"
+      end
+
+      desc "Enable the APC administrative panel"
+      task :enable, :roles => :web, :except => { :no_release => true } do
+        run "#{try_sudo} ln -s /usr/local/lib/php/apc.php #{current_path}/apc.php"
+      end
+    end
+  end
+
+  # --------------------------------------------
+  # Remote/Local database migration tasks
+  # --------------------------------------------
+  namespace :db do
+    desc "Migrate remote application database to local server"
+    task :to_local, :roles => :db, :except => { :no_release => true } do
+      remote_export
+      remote_download
+      local_import
+    end
+
+    desc "Migrate local application database to remote server"
+    task :to_remote, :roles => :db, :except => { :no_release => true } do
+      local_export
+      local_upload
+      remote_import
+    end
+
+    desc "Handles importing a MySQL database dump file. Uncompresses the file, does regex replacements, and imports."
+    task :local_import, :roles => :db do
+      # check for compressed file and decompress
+      if local_file_exists?("#{db_remote_name}.sql.gz")
+        system "gunzip -f #{db_remote_name}.sql.gz"
+      end
+
+      if local_file_exists?("#{db_remote_name}.sql")
+        # import into database
+        system "mysql -h#{db_local_host} -u#{db_local_user} -p#{db_local_pass} #{db_local_name} < #{db_remote_name}.sql"
+        # remove used file
+        run "#{try_sudo} rm -f #{deploy_to}/#{db_remote_name}.sql.gz"
+        system "#{try_sudo} rm -f #{db_remote_name}.sql"
+      end
+    end
+
+    task :local_export do
+      mysqldump     = fetch(:mysqldump, "mysqldump")
+      dump_options  = fetch(:dump_options, "--single-transaction --create-options --quick")
+
+      system "#{try_sudo} #{mysqldump} #{dump_options} --opt -h#{db_local_host} -u#{db_local_user} -p#{db_local_pass} #{db_local_name} | gzip -c --best > #{db_local_name}.sql.gz"
+    end
+
+    desc "Upload locally created MySQL dumpfile to remote server via SCP"
+    task :local_upload, :roles => :db do
+      upload "#{db_local_name}.sql.gz", "#{deploy_to}/#{db_local_name}.sql.gz", :via => :scp
+    end
+
+    desc "Handles importing a MySQL database dump file. Uncompresses the file, does regex replacements, and imports."
+    task :remote_import, :roles => :db do
+      # check for compressed file and decompress
+      if remote_file_exists?("#{deploy_to}/#{db_local_name}.sql.gz")
+        run "gunzip -f #{deploy_to}/#{db_local_name}.sql.gz"
+      end
+
+      if remote_file_exists?("#{deploy_to}/#{db_local_name}.sql")
+        # import into database
+        run "mysql -h#{db_remote_host} -u#{db_remote_user} -p#{db_remote_pass} #{db_remote_name} < #{deploy_to}/#{db_local_name}.sql"
+        # remove used file
+        run "#{try_sudo} rm -f #{deploy_to}/#{db_local_name}.sql"
+        system "#{try_sudo} rm -rf #{db_local_name}.sql.gz"
+      end
+    end
+
+    desc "Create a compressed MySQL dumpfile of the remote database"
+    task :remote_export, :roles => :db do
+      mysqldump     = fetch(:mysqldump, "mysqldump")
+      dump_options  = fetch(:dump_options, "--single-transaction --create-options --quick")
+
+      run "#{try_sudo} #{mysqldump} #{dump_options} --opt -h#{db_remote_host} -u#{db_remote_user} -p#{db_remote_pass} #{db_remote_name} | gzip -c --best > #{deploy_to}/#{db_remote_name}.sql.gz"
+    end
+
+    desc "Download remotely created MySQL dumpfile to local machine via SCP"
+    task :remote_download, :roles => :db do
+      download "#{deploy_to}/#{db_remote_name}.sql.gz", "#{db_remote_name}.sql.gz", :via => :scp
+    end
+  end
+
+  # --------------------------------------------
+  # Backup tasks
+  # --------------------------------------------
+  namespace :backup do
+    desc "Perform a backup of web and database files"
+    task :default do
+      deploy.setup_backup
+      db
+      web
+      cleanup
+    end
+
+    desc <<-DESC
+      Requires the rsync package to be installed.
+
+      Performs a file-level backup of the application and any assets \
+      from the shared directory that have been symlinked into the \
+      applications root or sub-directories.
+
+      You can specify which files or directories to exclude from being \
+      backed up (i.e., log files, sessions, cache) by setting the \
+      :backup_exclude variable
+          set(:backup_exclude) { [ "var/", "tmp/", logs/debug.log ] }
+    DESC
+    task :web, :roles => :web do
+      if previous_release
+        logger.info "Backing up web files (user uploaded content and previous release)"
+
+        if !backup_exclude.nil? && !backup_exclude.empty?
+          logger.debug "processing backup exclusions..."
+          backup_exclude.each do |pattern|
+            exclude_string << "--exclude '#{pattern}' "
+          end
+          logger.debug "Exclude string = #{exclude_string}"
+        end
+
+        # Copy the previous release to the /tmp directory
+        logger.debug "Copying previous release to the #{tmp_backups_path}/#{release_name} directory"
+        run "rsync -avzrtpL #{exclude_string} #{current_path}/ #{tmp_backups_path}/#{release_name}/"
+
+        # --------------------------
+        # SET/RESET PERMISSIONS
+        # --------------------------
+        set_perms_dirs("#{tmp_backups_path}/#{release_name}", 755)
+        set_perms_files("#{tmp_backups_path}/#{release_name}", 644)
+
+        # create the tarball of the previous release
+        set :archive_name, "release_B4_#{release_name}.tar.gz"
+        logger.debug "Creating a Tarball of the previous release in #{backups_path}/#{archive_name}"
+        run "cd #{tmp_backups_path} && tar -cvpf - ./#{release_name}/ | gzip -c --best > #{backups_path}/#{archive_name}"
+
+        # remove the the temporary copy
+        logger.debug "Removing the tempory copy"
+        run "rm -rf #{tmp_backups_path}/#{release_name}"
+      else
+        logger.important "no previous release to backup; backup of files skipped"
+      end
+    end
+
+    desc "Perform a backup of database files"
+    task :db, :roles => :db do
+      if previous_release
+        mysqldump     = fetch(:mysqldump, "mysqldump")
+        dump_options  = fetch(:dump_options, "--single-transaction --create-options --quick")
+
+        logger.info "Backing up the database now and putting dump file in the previous release directory"
+        # define the filename (include the current_path so the dump file will be within the directory)
+        filename = "#{current_path}/#{dbname}_dump-#{Time.now.to_s.gsub(/ /, "_")}.sql.gz"
+        # dump the database for the proper environment
+        run "#{mysqldump} #{dump_options} -u #{dbuser} -p #{dbname} | gzip -c --best > #{filename}" do |ch, stream, out|
+            ch.send_data "#{dbpass}\n" if out =~ /^Enter password:/
+        end
+      else
+        logger.important "no previous release to backup to; backup of database skipped"
+      end
+    end
+
+    desc <<-DESC
+      Clean up old backups. By default, the last 10 backups are kept on each \
+      server (though you can change this with the keep_backups variable). All \
+      other backups are removed from the servers. By default, this \
+      will use sudo to clean up the old backups, but if sudo is not available \
+      for your environment, set the :use_sudo variable to false instead.
+    DESC
+    task :cleanup, :except => { :no_release => true } do
+      count = fetch(:keep_backups, 10).to_i
+      if count >= backups.length
+        logger.important "no old backups to clean up"
+      else
+        logger.info "keeping #{count} of #{backups.length} backups"
+
+        archives = (backups - backups.last(count)).map { |backup|
+          File.join(backups_path, backup) }.join(" ")
+
+        # fix permissions on the the files and directories before removing them
+        archives.split(" ").each do |backup|
+          set_perms_dirs("#{backup}", 755)
+          set_perms_files("#{backup}", 644)
+        end
+
+        try_sudo "rm -rf #{archives}"
+      end
+    end
+  end
+
+  # --------------------------------------------
+  # Remote File/Directory test tasks
+  # --------------------------------------------
+  namespace :remote do
+    namespace :file do
+      desc "Test: Task to test existence of missing file"
+      task :missing do
+        if remote_file_exists?('/dev/mull')
+          logger.info "FAIL - Why does the '/dev/mull' path exist???"
+        else
+          logger.info "GOOD - Verified the '/dev/mull' path does not exist!"
+        end
+      end
+
+      desc "Test: Task used to test existence of a present file"
+      task :exists do
+        if remote_file_exists?('/dev/null')
+          logger.info "GOOD - Verified the '/dev/null' path exists!"
+        else
+          logger.info "FAIL - WHAT happened to the '/dev/null' path???"
+        end
+      end
+    end
+
+    namespace :dir do
+      desc "Test: Task to test existence of missing dir"
+      task :missing do
+        if remote_dir_exists?('/etc/fake_dir')
+          logger.info "FAIL - Why does the '/etc/fake_dir' dir exist???"
+        else
+          logger.info "GOOD - Verified the '/etc/fake_dir' dir does not exist!"
+        end
+      end
+
+      desc "Test: Task used to test existence of an existing directory"
+      task :exists do
+        if remote_dir_exists?('/etc')
+          logger.info "GOOD - Verified the '/etc' dir exists!"
+        else
+          logger.info "FAIL - WHAT happened to the '/etc' dir???"
+        end
+      end
+    end
+  end
+end

data/lib/demonz/common.rb

@@ -0,0 +1,128 @@
+# Prompts user entry
+# Params:
+# +prompt+
+def text_prompt(prompt="Value: ")
+  Capistrano::CLI.ui.ask(prompt) { |q| q.echo = true }
+end
+
+# Check if a local file exists
+def local_file_exists?(full_path)
+  File.exists?(full_path)
+end
+
+# Check if a local directory exists
+def local_dir_exists?(full_path)
+  File.directory?(full_path)
+end
+
+# From http://stackoverflow.com/a/1662001/356237
+# Needs full remote path
+def remote_file_exists?(full_path)
+  'true' ==  capture("if [ -e #{full_path} ]; then echo 'true'; fi").strip
+end
+
+# Sames as above but with directories
+def remote_dir_exists?(dir_path)
+  'true' == capture("if [[ -d #{dir_path} ]]; then echo 'true'; fi").strip
+end
+
+# Recursively set file permissions in a directory
+def set_perms_files(dir_path, perm = 644)
+  try_sudo "find #{dir_path} -type f -exec chmod #{perm} {} \\;"
+end
+def create_database
+    create_sql = <<-SQL
+      CREATE DATABASE #{db_name};
+    SQL
+
+    run "mysql --user=#{db_admin_user} --password=#{db_admin_password} --execute=\"#{create_sql}\""
+  end
+# Recursively set directory permissions in a directory
+def set_perms_dirs(dir_path, perm = 755)
+  try_sudo "find #{dir_path} -type d -exec chmod #{perm} {} \\;"
+end
+
+# Get release history from server as string
+def get_release_history(release_file)
+  release_history = capture("cat #{release_file}").strip
+  release_history
+end
+
+# Remove a particular release from history
+def remove_release_from_history(release, release_file)
+  release_history = capture("cat #{release_file}").split
+
+  # Remove release if it exists
+  release_history.delete_at release_history.index(release) unless release_history.index(release).nil?
+
+  # Save
+  release_history.join("\n")
+  try_sudo "echo #{release_history} > #{release_file}"
+end
+
+# Get the database name given an application and release name
+def get_db_name(application, release)
+  db_name = "#{application}__#{release_name}"
+  # Remove characters that may cause MySQL issues
+  db_name.downcase.gsub(/([\.\-\/])/, '_')
+end
+
+# Get the regex pattern to extract details from the mysql connection string
+def db_string_regex(type)
+  "--#{type}='?([a-zA-Z0-9!@\#$%^&*-=+]+)'?\s"
+end
+
+# Check if a MySQL database exists
+# Modified from http://www.grahambrooks.com/blog/create-mysql-database-with-capistrano/
+def database_exists?(connection_string, db_name)
+  exists = false
+
+  run "#{connection_string} --execute=\"show databases;\"" do |channel, stream, data|
+    exists = exists || data.include?(db_name)
+  end
+
+  exists
+end
+
+# Create a MySQL database
+# From http://www.grahambrooks.com/blog/create-mysql-database-with-capistrano/
+def create_database(connection_string, db_name)
+  create_sql = <<-SQL
+    CREATE DATABASE #{db_name};
+  SQL
+
+  run "#{connection_string} --execute=\"#{create_sql}\""
+end
+
+# Delete a MySQL database
+def delete_database(connection_string, db_name)
+  drop_sql = <<-SQL
+    DROP DATABASE #{db_name};
+  SQL
+
+  run "#{connection_string} --execute=\"#{drop_sql}\""
+end
+
+# Set permissions for a MySQL database
+# From http://www.grahambrooks.com/blog/create-mysql-database-with-capistrano/
+def setup_database_permissions(connection_string, db_name)
+  # We tack on a space at the end to help regex matches
+  connection_string += " "
+
+  db_admin_user = connection_string.match db_string_regex('user')
+  db_admin_user = db_admin_user[1]
+
+  db_admin_password = connection_string.match db_string_regex('password')
+  db_admin_password = db_admin_password[1]
+
+  grant_sql = <<-SQL
+    GRANT ALL PRIVILEGES ON #{db_name}.* TO #{db_admin_user}@localhost IDENTIFIED BY '#{db_admin_password}';
+  SQL
+
+  run "#{connection_string} --execute=\"#{grant_sql}\""
+end
+
+# Updates the Drupal settings file with the new database name
+def update_db_in_settings_file(settings_file, db_name)
+  run "sed -ri \"/^[ \\t]*(#|\\*|\\/)/! s/'database' => ''/'database' => '#{db_name}'/1\" #{settings_file}"
+end

data/lib/demonz/drupal.rb

@@ -0,0 +1,312 @@
+# Require our base library.
+require 'demonz/base'
+require 'railsless-deploy'
+
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+  Capistrano::Configuration.instance(:must_exist) :
+  Capistrano.configuration(:must_exist)
+
+configuration.load do
+
+  # --------------------------------------------
+  # Setting defaults
+  # --------------------------------------------
+  set :drush_bin, "drush"
+  _cset :dump_options,    "" # blank options b/c of MYISAM engine (unless anyone knows options that should be included)
+
+  # Boost module support (Drupal)
+  set :uses_boost, true
+
+  # --------------------------------------------
+  # Calling our Methods
+  # --------------------------------------------
+  after "deploy:setup", "deploy:setup_local"
+  after "deploy:finalize_update", "demonz:fixperms"
+  before "deploy:create_symlink", "drupal:symlink"
+  before "deploy:create_symlink", "drupal:protect"
+  before "deploy:create_symlink", "drupal:backup_files_dir"
+  before "deploy:create_symlink", "drupal:migrate"
+  before "deploy:create_symlink", "drupal:clearcache"
+
+  after "deploy:cleanup", "drupal:cleanup_files_backups"
+
+  # rollback the database and files directory during a rollback too
+  before "deploy:rollback:revision", "drupal:rollback_db"
+  after "drupal:rollback_db", "drupal:rollback_files_dir"
+
+  # --------------------------------------------
+  # Overloaded Methods
+  # --------------------------------------------
+  namespace :deploy do
+    desc "Setup local files necessary for deployment"
+    task :setup_local do
+      logger.important "make sure you copy over your files directory and settings files now"
+      # attempt to create files needed for proper deployment
+      if local_file_exists?('.htaccess')
+        system("cp .htaccess htaccess.dist")
+        system("git add htaccess.dist")
+        puts "Please commit htaccess.dist to your source control repository."
+      end
+    end
+
+    desc "Setup shared application directories and permissions after initial setup"
+    task :setup_shared do
+      uses_boost = fetch(:uses_boost, false)
+
+      # remove Capistrano specific directories
+      run "#{try_sudo} rm -Rf #{shared_path}/log"
+      run "#{try_sudo} rm -Rf #{shared_path}/pids"
+      run "#{try_sudo} rm -Rf #{shared_path}/system"
+
+      # create shared directories
+      run "#{try_sudo} mkdir -p #{shared_path}/default/files"
+      if uses_boost
+        run "#{try_sudo} mkdir -p #{shared_path}/boost/cache/normal"
+      end
+
+      # set correct permissions
+      run "#{try_sudo} chmod -R 777 #{shared_path}/*"
+    end
+
+    desc "[internal] Touches up the released code. This is called by update_code after the basic deploy finishes."
+    task :finalize_update, :roles => :web, :except => { :no_release => true } do
+      run "#{try_sudo} rm -Rf #{latest_release}/sites/default/files"
+    end
+
+    namespace :web do
+      desc "Disable the application and show a message screen"
+      task :disable, :roles => :web do
+        run "#{drush_bin} -r #{latest_release} vset --yes site_offline 1"
+      end
+
+      desc "Enable the application and remove the message screen"
+      task :enable, :roles => :web do
+        run "#{drush_bin} -r #{latest_release} vdel --yes site_offline"
+      end
+    end
+  end
+
+  # --------------------------------------------
+  # Remote/Local database migration tasks
+  # --------------------------------------------
+  namespace :db do
+    task :local_export do
+      mysqldump     = fetch(:mysqldump, "mysqldump")
+      dump_options  = fetch(:dump_options, "")
+
+      system "#{mysqldump} #{dump_options} --opt -h#{db_local_host} -u#{db_local_user} -p#{db_local_pass} #{db_local_name} | gzip -c --best > #{db_local_name}.sql.gz"
+    end
+
+    desc "Create a compressed MySQL dumpfile of the remote database"
+    task :remote_export, :roles => :db do
+      mysqldump     = fetch(:mysqldump, "mysqldump")
+      dump_options  = fetch(:dump_options, "")
+
+      run "#{mysqldump} #{dump_options} --opt -h#{db_remote_host} -u#{db_remote_user} -p#{db_remote_pass} #{db_remote_name} | gzip -c --best > #{deploy_to}/#{db_remote_name}.sql.gz"
+    end
+
+  end
+
+  namespace :backup do
+    desc "Perform a backup of database files"
+    task :db, :roles => :db do
+      if releases.last.nil?
+        logger.important "no previous release to backup; backup of database skipped"
+      else
+        logger.info "Backing up the database now and putting dump file in the previous release directory"
+        # define the filename (include the current_path so the dump file will be within the directory)
+        filename = "#{current_path}/default_dump-#{Time.now.to_s.gsub(/ /, "_")}.sql.gz"
+        # dump the database for the proper environment
+        run "#{drush_bin} -r #{current_path} sql-dump | gzip -c --best > #{filename}"
+      end
+    end
+  end
+
+  # --------------------------------------------
+  # Drupal-specific methods
+  # --------------------------------------------
+  namespace :drupal do
+    desc "Create database"
+    task :create_db, :roles => :web, :except => { :no_release => true } do
+      drupal_app_site_dir = File.join(latest_release, 'sites', 'default')
+      settings_file = File.join(drupal_app_site_dir, 'settings.php')
+
+      # Check if the base settings.php file exists first (we need this for db details)
+      if !remote_file_exists?(settings_file)
+        raise Capistrano::Error, "A settings.php file was not found, please create one before continuing. See previous errors for more info."
+      end
+
+      # Get database name
+      set :clean_db_name, get_db_name(application, release_name)
+
+      # Get MySQL connection string from drush (don't need a full bootstrap)
+      mysql_connection = capture("#{drush_bin} -r #{latest_release} sql-connect").chomp
+
+      # Only create if database doesn't exist
+      if !database_exists?(mysql_connection, clean_db_name)
+        # Remove DB on rollback
+        on_rollback { delete_database(mysql_connection, clean_db_name) }
+
+        create_database(mysql_connection, clean_db_name)
+        setup_database_permissions(mysql_connection, clean_db_name)
+      end
+
+      # Add the database name to the settings file.
+      update_db_in_settings_file(settings_file, clean_db_name)
+    end
+
+    desc "Copy old database to new one"
+    task :copy_old_to_new_db, :roles => :web, :except => { :no_release => true } do
+      if releases.last.nil?
+        # Ask user to upload a gzipped SQL file
+        logger.important "no previous release found, please specify a (gzipped) sql file I can use instead"
+        db_file_path = text_prompt("Full path to SQL file: ")
+
+        # Error out if file doesn't exist
+        raise Capistrano::Error, "File '#{db_file_path}' not found" unless local_file_exists?(db_file_path)
+
+        db_file_parts = File.split(db_file_path)
+        db_file = db_file_parts[1]
+
+        # Upload file to temp directory
+        remote_db_file = File.join(tmp_backups_path, db_file)
+        top.upload(db_file_path, remote_db_file)
+
+        # Just incase the command after fails, remove the upload file
+        on_rollback { run "#{try_sudo} rm #{remote_db_file}" }
+
+        run "gzip -fd #{remote_db_file} -c | #{drush_bin} -r #{latest_release} sqlc"
+
+        # We don't need the upload file anymore
+        run "#{try_sudo} rm #{remote_db_file}"
+      else
+        # Use current release as base
+        run "#{drush_bin} -r #{current_release} sql-dump | #{drush_bin} -r #{latest_release} sqlc"
+      end
+    end
+
+    desc "Run any update scripts for this release"
+    task :run_update_scripts, :roles => :web, :except => { :no_release => true } do
+      update_script_file = File.join(latest_release, 'sites', 'all', 'scripts', release_name, 'update.sh')
+
+      if remote_file_exists?(update_script_file)
+        run update_script_file
+      end
+    end
+
+    desc "Symlink shared directories"
+    task :symlink, :roles => :web, :except => { :no_release => true } do
+      uses_boost = fetch(:uses_boost, false)
+      # copies the appropriate environment's settings.php file
+      copy_config_file
+
+      run "#{try_sudo} ln -nfs #{shared_path}/default/files #{latest_release}/sites/default/files"
+      # run "#{drush_bin} -r #{latest_release} vset --yes file_directory_path sites/default/files"
+
+      # Symlink boost cache directory
+      if uses_boost
+        run "#{try_sudo} ln -nfs #{shared_path}/boost/cache #{latest_release}/cache"
+      end
+    end
+
+    desc <<-DESC
+      Copies the appropriate environment's settings file within the proper sites directory
+
+      Assumes the environment's settings file will be in the following format:
+        settings.<environment>.php
+    DESC
+    task :copy_config_file, :roles => :web, :except => { :no_release => true} do
+      drupal_app_site_dir = " #{latest_release}/sites/default"
+
+      case true
+        when remote_file_exists?("#{shared_path}/settings.#{stage}.php")
+          run "#{try_sudo} cp -fL #{shared_path}/settings.#{stage}.php #{drupal_app_site_dir}/settings.php"
+        when remote_file_exists?("#{drupal_app_site_dir}/settings.#{stage}.php")
+          run "#{try_sudo} cp -fL #{drupal_app_site_dir}/settings.#{stage}.php #{drupal_app_site_dir}/settings.php"
+        else
+          logger.important "Failed to symlink the settings.php file in #{drupal_app_site_dir} because an unknown pattern was used"
+      end
+    end
+
+    desc "Migrate old database to new release"
+    task :migrate, :roles => :web, :except => { :no_release => true } do
+      create_db
+      copy_old_to_new_db
+      run_update_scripts
+      # Run drush updb just incase
+      run "#{drush_bin} -r #{latest_release} updb"
+    end
+
+    desc "Backup the shared 'files' directory"
+    task :backup_files_dir, :roles => :web, :except => { :no_release => true } do
+      set :archive_name, "files_before_#{release_name}.tar.gz"
+      set :files_dir_location, File.join(shared_path, 'default')
+      logger.debug "Creating a Tarball of the files directory in #{backups_path}/#{archive_name}"
+      run "cd #{files_dir_location} && tar -cvpf - files | gzip -c --best > #{backups_path}/#{archive_name}"
+    end
+
+    desc "Clear all Drupal cache"
+    task :clearcache, :roles => :web, :except => { :no_release => true } do
+      run "#{drush_bin} -r #{latest_release} cache-clear all"
+      # Remove the 'styles' imagecache directory
+      image_styles_path = File.join(shared_path, 'default', 'files', 'styles')
+      run "#{try_sudo} rm -rf #{image_styles_path}" if remote_dir_exists?(image_styles_path)
+      # Also clear boost cache if set
+      boost_path = File.join(shared_path, 'boost', 'cache', 'normal', '*')
+      run "#{try_sudo} rm -rf #{boost_path}" if fetch(:uses_boost, false)
+    end
+
+    desc "Protect system files"
+    task :protect, :roles => :web, :except => { :no_release => true } do
+      run "#{try_sudo} chmod 644 #{latest_release}/sites/default/settings.php*"
+    end
+
+    desc "[internal] Delete latest version of DB"
+    task :rollback_db, :except => { :no_release => true } do
+      if previous_release
+        clean_db_name = get_db_name(application, releases.last)
+        mysql_connection = capture("#{drush_bin} -r #{latest_release} sql-connect").chomp
+        delete_database(mysql_connection, clean_db_name)
+      else
+        abort "could not rollback the code because there is no prior release"
+      end
+    end
+
+    desc "[internal] Rollback shared files directory"
+    task :rollback_files_dir, :except => { :no_release => true } do
+      if previous_release
+        old_release = releases.last
+        files_backup_file = File.join(backups_path, "files_before_#{old_release}.tar.gz")
+
+        if remote_file_exists?(files_backup_file)
+          files_dir_location = File.join(shared_path, 'default')
+          files_dir = File.join(files_dir_location, 'files')
+          files_dir_backup_archive = "files_after_#{old_release}_OLD"
+
+          on_rollback {
+            run "#{try_sudo} rm #{files_dir}" if remote_file_exists?(files_dir_backup_archive) && remote_dir_exists?(files_dir)
+            run "#{try_sudo} tar -xvzf #{files_dir_backup_archive} -C #{files_dir_location}" if remote_file_exists?(files_dir_backup_archive)
+          }
+
+          run "cd #{files_dir_location} && tar -cvpf - files | gzip -c --best > #{backups_path}/#{files_dir_backup_archive}"
+          run "#{try_sudo} tar -xvzf #{files_backup_file} -C #{files_dir_location}"
+        end
+      else
+        abort "could not rollback the code because there is no prior release"
+      end
+    end
+
+    desc "[internal] Remove old file directory backups"
+    task :cleanup_files_backups, :roles => :web, :except => { :no_release => true } do
+      if variables.include?(:cleanup_releases)
+        cleanup_releases = fetch(:cleanup_releases, nil)
+
+        if !cleanup_releases.nil?
+          files_backups = cleanup_releases.map { |release|
+            File.join(backups_path, "file_before_#{release}.tar.gz") }.join(" ")
+          try_sudo "rm -rf #{files_backups}"
+        end
+      end
+    end
+  end
+end

data/lib/demonz/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module Demonz
+    VERSION = "0.0.5"
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: capistrano-demonz
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Chinthaka Godawita
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: railsless-deploy
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 2
+        - 13
+        - 5
+        version: 2.13.5
+  type: :runtime
+  version_requirements: *id002
+description: Demonz Media recipes for Capistrano
+email: 
+- chinthaka.godawita@demonzmedia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- capistrano-demonz.gemspec
+- lib/capistrano-demonz.rb
+- lib/demonz/base.rb
+- lib/demonz/common.rb
+- lib/demonz/drupal.rb
+- lib/demonz/version.rb
+homepage: https://github.com/demonz/capistrano-demonz
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Useful task libraries for Demonz Media recipes for Capistrano
+test_files: []
+