capistrano 2.1.0 → 3.0.0

data/lib/capistrano/dsl/paths.rb

@@ -0,0 +1,94 @@
+require 'pathname'
+module Capistrano
+  module DSL
+    module Paths
+
+      def deploy_to
+        fetch(:deploy_to)
+      end
+
+      def deploy_path
+        Pathname.new(deploy_to)
+      end
+
+      def current_path
+        deploy_path.join('current')
+      end
+
+      def releases_path
+        deploy_path.join('releases')
+      end
+
+      def release_path
+        fetch(:release_path, current_path)
+      end
+
+      def set_release_path(timestamp=now)
+        set(:release_path, releases_path.join(timestamp))
+      end
+
+      def repo_url
+        require 'cgi'
+        require 'uri'
+        if fetch(:git_http_username) and fetch(:git_http_password)
+          URI.parse(fetch(:repo_url)).tap do |repo_uri|
+            repo_uri.user     = fetch(:git_http_username)
+            repo_uri.password = CGI.escape(fetch(:git_http_password))
+          end.to_s
+        elsif fetch(:git_http_username)
+          URI.parse(fetch(:repo_url)).tap do |repo_uri|
+            repo_uri.user = fetch(:git_http_username)
+          end.to_s
+        else
+          fetch(:repo_url)
+        end
+      end
+
+      def repo_path
+        deploy_path.join('repo')
+      end
+
+      def shared_path
+        deploy_path.join('shared')
+      end
+
+      def revision_log
+        deploy_path.join('revisions.log')
+      end
+
+      def now
+        env.timestamp.strftime("%Y%m%d%H%M%S")
+      end
+
+      def asset_timestamp
+        env.timestamp.strftime("%Y%m%d%H%M.%S")
+      end
+
+      def linked_dirs(parent)
+        paths = fetch(:linked_dirs)
+        join_paths(parent, paths)
+      end
+
+      def linked_files(parent)
+        paths = fetch(:linked_files)
+        join_paths(parent, paths)
+      end
+
+      def linked_file_dirs(parent)
+        map_dirnames(linked_files(parent))
+      end
+
+      def linked_dir_parents(parent)
+        map_dirnames(linked_dirs(parent))
+      end
+
+      def join_paths(parent, paths)
+        paths.map { |path| parent.join(path) }
+      end
+
+      def map_dirnames(paths)
+        paths.map { |path| path.dirname }
+      end
+    end
+  end
+end

data/lib/capistrano/dsl/stages.rb

@@ -0,0 +1,15 @@
+module Capistrano
+  module DSL
+    module Stages
+
+      def stages
+        Dir['config/deploy/*.rb'].map { |f| File.basename(f, '.rb') }
+      end
+
+      def stage_set?
+        !!fetch(:stage, false)
+      end
+
+    end
+  end
+end

data/lib/capistrano/dsl/task_enhancements.rb

@@ -0,0 +1,53 @@
+module Capistrano
+  module TaskEnhancements
+    def before(task, prerequisite, *args, &block)
+      prerequisite = Rake::Task.define_task(prerequisite, *args, &block) if block_given?
+      Rake::Task[task].enhance [prerequisite]
+    end
+
+    def after(task, post_task, *args, &block)
+      post_task = Rake::Task.define_task(post_task, *args, &block) if block_given?
+      Rake::Task[task].enhance do
+        invoke(post_task)
+      end
+    end
+
+    def remote_file(task)
+      target_roles = task.delete(:roles) { :all }
+      define_remote_file_task(task, target_roles)
+    end
+
+    def define_remote_file_task(task, target_roles)
+      Rake::Task.define_task(task) do |t|
+        prerequisite_file = t.prerequisites.first
+        file = shared_path.join(t.name)
+
+        on roles(target_roles) do
+          unless test "[ -f #{file} ]"
+            info "Uploading #{prerequisite_file} to #{file}"
+            upload! File.open(prerequisite_file), file
+          end
+        end
+
+      end
+    end
+
+    def ensure_stage
+      Rake::Task.define_task(:ensure_stage) do
+        unless stage_set?
+          puts t(:stage_not_set)
+          exit 1
+        end
+      end
+    end
+
+    def tasks_without_stage_dependency
+      stages + default_tasks
+    end
+
+    def default_tasks
+      %w{install}
+    end
+
+  end
+end

data/lib/capistrano/dsl.rb

@@ -0,0 +1,48 @@
+require 'capistrano/dsl/task_enhancements'
+require 'capistrano/dsl/paths'
+require 'capistrano/dsl/stages'
+require 'capistrano/dsl/env'
+
+module Capistrano
+  module DSL
+    include TaskEnhancements
+    include Env
+    include Paths
+    include Stages
+
+    def invoke(task, *args)
+      Rake::Task[task].invoke(*args)
+    end
+
+    def t(key, options={})
+      I18n.t(key, options.merge(scope: :capistrano))
+    end
+
+    def scm
+      fetch(:scm)
+    end
+
+    def sudo(*args)
+      execute :sudo, *args
+    end
+
+    def revision_log_message
+      fetch(:revision_log_message,
+            t(:revision_log_message, branch: fetch(:branch), user: local_user, release: release_timestamp))
+    end
+
+    def rollback_log_message
+      t(:rollback_log_message, user: local_user, release: fetch(:rollback_timestamp))
+    end
+
+    def local_user
+      `whoami`
+    end
+
+    def lock(locked_version)
+      VersionValidator.new(locked_version).verify
+    end
+
+  end
+end
+self.extend Capistrano::DSL

data/lib/capistrano/git.rb

@@ -0,0 +1 @@
+load File.expand_path("../tasks/git.rake", __FILE__)

data/lib/capistrano/hg.rb

@@ -0,0 +1 @@
+load File.expand_path("../tasks/hg.rake", __FILE__)

data/lib/capistrano/i18n.rb

@@ -0,0 +1,34 @@
+require 'i18n'
+
+en = {
+  starting:                    'Starting',
+  capified:                    'Capified',
+  starting:                    'Starting',
+  start:                       'Start',
+  update:                      'Update',
+  finalize:                    'Finalise',
+  restart:                     'Restart',
+  finishing:                   'Finishing',
+  finished:                    'Finished',
+  stage_not_set:               'Stage not set, please call something such as `cap production deploy`, where production is a stage you have defined.',
+  written_file:                'create %{file}',
+  question:                    'Please enter %{key}: |%{default_value}|',
+  keeping_releases:            'Keeping %{keep_releases} of %{releases} deployed releases on %{host}',
+  no_old_releases:             'No old releases (keeping newest %{keep_releases}) on %{host}',
+  linked_file_does_not_exist:  'linked file %{file} does not exist on %{host}',
+  mirror_exists:               "The repository mirror is at %{at}",
+  revision_log_message:        'Branch %{branch} deployed as release %{release} by %{user}',
+  rollback_log_message:        '%{user} rolled back to release %{release}',
+  console: {
+    welcome:  'capistrano console - enter command to execute on %{stage}',
+    bye:      'bye'
+  },
+  error: {
+    user: {
+      does_not_exist:  'User %{user} does not exists',
+      cannot_switch:   'Cannot switch to user %{user}'
+    }
+  }
+}
+
+I18n.backend.store_translations(:en, { capistrano: en })

data/lib/capistrano/install.rb

@@ -0,0 +1 @@
+load File.expand_path(File.join(File.dirname(__FILE__),'tasks/install.rake'))

data/lib/capistrano/setup.rb

@@ -0,0 +1,21 @@
+include Capistrano::DSL
+
+namespace :load do
+  task :defaults do
+    load 'capistrano/defaults.rb'
+  end
+end
+
+stages.each do |stage|
+  Rake::Task.define_task(stage) do
+    invoke 'load:defaults'
+    load 'config/deploy.rb'
+    load "config/deploy/#{stage}.rb"
+    load "capistrano/#{fetch(:scm)}.rb"
+    set(:stage, stage.to_sym)
+    I18n.locale = fetch(:locale, :en)
+    configure_backend
+  end
+end
+
+require 'capistrano/dotfile'

data/lib/capistrano/tasks/console.rake

@@ -0,0 +1,21 @@
+desc 'Execute remote commands'
+task :console do
+  stage = fetch(:stage)
+  puts I18n.t('console.welcome', scope: :capistrano, stage: stage)
+  loop do
+    print "#{stage}> "
+    command = $stdin.gets.chomp
+    if %w{quit exit q}.include? command
+      puts t('console.bye')
+      break
+    else
+      begin
+        on roles :all do
+          execute command
+        end
+      rescue => e
+        puts e
+      end
+    end
+  end
+end

data/lib/capistrano/tasks/deploy.rake

@@ -0,0 +1,204 @@
+namespace :deploy do
+
+  task :starting do
+    invoke 'deploy:check'
+  end
+
+  task :updating => :new_release_path do
+    invoke "#{scm}:create_release"
+    invoke 'deploy:symlink:shared'
+  end
+
+  task :reverting do
+    invoke 'deploy:revert_release'
+  end
+
+  task :publishing do
+    invoke 'deploy:symlink:release'
+    invoke 'deploy:restart'
+  end
+
+  task :finishing do
+    invoke 'deploy:cleanup'
+  end
+
+  task :finishing_rollback do
+    invoke 'deploy:cleanup_rollback'
+  end
+
+  task :finished do
+    invoke 'deploy:log_revision'
+  end
+
+  desc 'Check required files and directories exist'
+  task :check do
+    invoke "#{scm}:check"
+    invoke 'deploy:check:directories'
+    invoke 'deploy:check:linked_dirs'
+    invoke 'deploy:check:make_linked_dirs'
+    invoke 'deploy:check:linked_files'
+  end
+
+  namespace :check do
+    desc 'Check shared and release directories exist'
+    task :directories do
+      on roles :all do
+        execute :mkdir, '-pv', shared_path, releases_path
+      end
+    end
+
+    desc 'Check directories to be linked exist in shared'
+    task :linked_dirs do
+      next unless any? :linked_dirs
+      on roles :app do
+        execute :mkdir, '-pv', linked_dirs(shared_path)
+      end
+    end
+    
+    desc 'Check directories of files to be linked exist in shared'
+    task :make_linked_dirs do
+      next unless any? :linked_files
+      on roles :app do |host|
+        execute :mkdir, '-pv', linked_file_dirs(shared_path)
+      end
+    end
+
+    desc 'Check files to be linked exist in shared'
+    task :linked_files do
+      next unless any? :linked_files
+      on roles :app do |host|
+        linked_files(shared_path).each do |file|
+          unless test "[ -f #{file} ]"
+            error t(:linked_file_does_not_exist, file: file, host: host)
+            exit 1
+          end
+        end
+      end
+    end
+  end
+
+  namespace :symlink do
+    desc 'Symlink release to current'
+    task :release do
+      on roles :all do
+        execute :rm, '-rf', current_path
+        execute :ln, '-s', release_path, current_path
+      end
+    end
+
+    desc 'Symlink files and directories from shared to release'
+    task :shared do
+      invoke 'deploy:symlink:linked_files'
+      invoke 'deploy:symlink:linked_dirs'
+    end
+
+    desc 'Symlink linked directories'
+    task :linked_dirs do
+      next unless any? :linked_dirs
+      on roles :app do
+        execute :mkdir, '-pv', linked_dir_parents(release_path)
+
+        fetch(:linked_dirs).each do |dir|
+          target = release_path.join(dir)
+          source = shared_path.join(dir)
+          unless test "[ -L #{target} ]"
+            if test "[ -d #{target} ]"
+              execute :rm, '-rf', target
+            end
+            execute :ln, '-s', source, target
+          end
+        end
+      end
+    end
+
+    desc 'Symlink linked files'
+    task :linked_files do
+      next unless any? :linked_files
+      on roles :app do
+        execute :mkdir, '-pv', linked_file_dirs(release_path)
+
+        fetch(:linked_files).each do |file|
+          target = release_path.join(file)
+          source = shared_path.join(file)
+          unless test "[ -L #{target} ]"
+            if test "[ -f #{target} ]"
+              execute :rm, target
+            end
+            execute :ln, '-s', source, target
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Clean up old releases'
+  task :cleanup do
+    on roles :all do |host|
+      releases = capture(:ls, '-x', releases_path).split
+      if releases.count >= fetch(:keep_releases)
+        info t(:keeping_releases, host: host.to_s, keep_releases: fetch(:keep_releases), releases: releases.count)
+        directories = (releases - releases.last(fetch(:keep_releases)))
+        if directories.any?
+          directories_str = directories.map do |release|
+            releases_path.join(release)
+          end.join(" ")
+          execute :rm, '-rf', directories_str
+        else
+          info t(:no_old_releases, host: host.to_s, keep_releases: fetch(:keep_releases))
+        end
+      end
+    end
+  end
+
+  desc 'Remove and archive rolled-back release.'
+  task :cleanup_rollback do
+    on roles(:all) do
+      last_release = capture(:ls, '-xr', releases_path).split.first
+      last_release_path = releases_path.join(last_release)
+      if test "[ `readlink #{current_path}` != #{last_release_path} ]"
+        execute :tar, '-czf',
+          deploy_path.join("rolled-back-release-#{last_release}.tar.gz"),
+        last_release_path
+        execute :rm, '-rf', last_release_path
+      else
+        debug 'Last release is the current release, skip cleanup_rollback.'
+      end
+    end
+  end
+
+  desc 'Log details of the deploy'
+  task :log_revision do
+    on roles(:all) do
+      within releases_path do
+        execute %{echo "#{revision_log_message}" >> #{revision_log}}
+      end
+    end
+  end
+
+  desc 'Revert to previous release timestamp'
+  task :revert_release => :rollback_release_path do
+    on roles(:all) do
+      set(:revision_log_message, rollback_log_message)
+    end
+  end
+
+  task :new_release_path do
+    set_release_path
+  end
+
+  task :last_release_path do
+    on roles(:all) do
+      last_release = capture(:ls, '-xr', releases_path).split[1]
+      set_release_path(last_release)
+    end
+  end
+
+  task :rollback_release_path do
+    on roles(:all) do
+      last_release = capture(:ls, '-xr', releases_path).split[1]
+      set_release_path(last_release)
+      set(:rollback_timestamp, last_release)
+    end
+  end
+
+end

data/lib/capistrano/tasks/framework.rake

@@ -0,0 +1,67 @@
+namespace :deploy do
+
+  desc 'Start a deployment, make sure server(s) ready.'
+  task :starting do
+  end
+
+  desc 'Started'
+  task :started do
+  end
+
+  desc 'Update server(s) by setting up a new release.'
+  task :updating do
+  end
+
+  desc 'Updated'
+  task :updated do
+  end
+
+  desc 'Revert server(s) to previous release.'
+  task :reverting do
+  end
+
+  desc 'Reverted'
+  task :reverted do
+  end
+
+  desc 'Publish the release.'
+  task :publishing do
+  end
+
+  desc 'Published'
+  task :published do
+  end
+
+  desc 'Finish the deployment, clean up server(s).'
+  task :finishing do
+  end
+
+  desc 'Finish the rollback, clean up server(s).'
+  task :finishing_rollback do
+  end
+
+  desc 'Finished'
+  task :finished do
+  end
+
+  desc 'Rollback to previous release.'
+  task :rollback do
+    %w{ starting started
+        reverting reverted
+        publishing published
+        finishing_rollback finished }.each do |task|
+      invoke "deploy:#{task}"
+    end
+  end
+end
+
+desc 'Deploy a new release.'
+task :deploy do
+  %w{ starting started
+      updating updated
+      publishing published
+      finishing finished }.each do |task|
+    invoke "deploy:#{task}"
+  end
+end
+task default: :deploy

data/lib/capistrano/tasks/git.rake

@@ -0,0 +1,62 @@
+namespace :git do
+
+  git_environmental_variables = {
+    git_askpass: "/bin/echo",
+    git_ssh:     "#{fetch(:tmp_dir)}/git-ssh.sh"
+  }
+
+  desc 'Upload the git wrapper script, this script guarantees that we can script git without getting an interactive prompt'
+  task :wrapper do
+    on roles :all do
+      upload! StringIO.new("#!/bin/sh -e\nexec /usr/bin/ssh -o PasswordAuthentication=no -o StrictHostKeyChecking=no \"$@\"\n"), "#{fetch(:tmp_dir)}/git-ssh.sh"
+      execute :chmod, "+x", "#{fetch(:tmp_dir)}/git-ssh.sh"
+    end
+  end
+
+  desc 'Check that the repository is reachable'
+  task check: :'git:wrapper' do
+    fetch(:branch)
+    on roles :all do
+      with git_environmental_variables do
+        exit 1 unless test :git, :'ls-remote', repo_url
+      end
+    end
+  end
+
+  desc 'Clone the repo to the cache'
+  task clone: :'git:wrapper' do
+    on roles :all do
+      if test " [ -f #{repo_path}/HEAD ] "
+        info t(:mirror_exists, at: repo_path)
+      else
+        within deploy_path do
+          with git_environmental_variables do
+            execute :git, :clone, '--mirror', repo_url, repo_path
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Update the repo mirror to reflect the origin state'
+  task update: :'git:clone' do
+    on roles :all do
+      within repo_path do
+        execute :git, :remote, :update
+      end
+    end
+  end
+
+  desc 'Copy repo to releases'
+  task create_release: :'git:update' do
+    on roles :all do
+      with git_environmental_variables do
+        within repo_path do
+          execute :mkdir, '-p', release_path
+          execute :git, :archive, fetch(:branch), '| tar -x -C', release_path
+        end
+      end
+    end
+  end
+end
+

data/lib/capistrano/tasks/hg.rake

@@ -0,0 +1,39 @@
+namespace :hg do
+  desc 'Check that the repo is reachable'
+  task :check do
+    on roles :all do
+      execute "hg", "id", repo_url
+    end
+  end
+
+  desc 'Clone the repo to the cache'
+  task :clone do
+    on roles :all do
+      if test " [ -d #{repo_path}/.hg ] "
+        info t(:mirror_exists, at: repo_path)
+      else
+        within deploy_path do
+          execute "hg", "clone", "--noupdate", repo_url, repo_path
+        end
+      end
+    end
+  end
+
+  desc 'Pull changes from the remote repo'
+  task :update => :'hg:clone' do
+    on roles :all do
+      within repo_path do
+        execute "hg", "pull"
+      end
+    end
+  end
+
+  desc 'Copy repo to releases'
+  task :create_release => :'hg:update' do
+    on roles :all do
+      within repo_path do
+        execute "hg", "archive", release_path, "--rev", fetch(:branch)
+      end
+    end
+  end
+end