capistrano 2.0.0 → 2.15.2

data/lib/capistrano/errors.rb

@@ -1,15 +1,19 @@
 module Capistrano
-  class Error < RuntimeError; end
 
-  class CaptureError < Error; end
-  class NoSuchTaskError < Error; end
-  class NoMatchingServersError < Error; end
-  
+  Error = Class.new(RuntimeError)
+
+  CaptureError            = Class.new(Capistrano::Error)
+  NoSuchTaskError         = Class.new(Capistrano::Error)
+  NoMatchingServersError  = Class.new(Capistrano::Error)
+
   class RemoteError < Error
     attr_accessor :hosts
   end
 
-  class ConnectionError < RemoteError; end
-  class UploadError < RemoteError; end
-  class CommandError < RemoteError; end
+  ConnectionError     = Class.new(Capistrano::RemoteError)
+  TransferError       = Class.new(Capistrano::RemoteError)
+  CommandError        = Class.new(Capistrano::RemoteError)
+
+  LocalArgumentError  = Class.new(Capistrano::Error)
+
 end

data/lib/capistrano/ext/multistage.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+
+unless Capistrano::Configuration.respond_to?(:instance)
+  abort "capistrano/ext/multistage requires Capistrano 2"
+end
+
+Capistrano::Configuration.instance.load do
+  location = fetch(:stage_dir, "config/deploy")
+
+  unless exists?(:stages)
+    set :stages, Dir["#{location}/*.rb"].map { |f| File.basename(f, ".rb") }
+  end
+
+  stages.each do |name|
+    desc "Set the target stage to `#{name}'."
+    task(name) do
+      set :stage, name.to_sym
+      load "#{location}/#{stage}" if File.exist?(File.join(location, "#{stage}.rb"))
+    end
+  end
+
+  on :load do
+    if stages.include?(ARGV.first)
+      # Execute the specified stage so that recipes required in stage can contribute to task list
+      find_and_execute_task(ARGV.first) if ARGV.any?{ |option| option =~ /-T|--tasks|-e|--explain/ }
+    else
+      # Execute the default stage so that recipes required in stage can contribute tasks
+      find_and_execute_task(default_stage) if exists?(:default_stage)
+    end
+  end
+
+  namespace :multistage do
+    desc "[internal] Ensure that a stage has been selected."
+    task :ensure do
+      if !exists?(:stage)
+        if exists?(:default_stage)
+          logger.important "Defaulting to `#{default_stage}'"
+          find_and_execute_task(default_stage)
+        else
+          abort "No stage specified. Please specify one of: #{stages.join(', ')} (e.g. `cap #{stages.first} #{ARGV.last}')"
+        end
+      end
+    end
+
+    desc "Stub out the staging config files."
+    task :prepare do
+      FileUtils.mkdir_p(location)
+      stages.each do |name|
+        file = File.join(location, name + ".rb")
+        unless File.exists?(file)
+          File.open(file, "w") do |f|
+            f.puts "# #{name.upcase}-specific deployment configuration"
+            f.puts "# please put general deployment config in config/deploy.rb"
+          end
+        end
+      end
+    end
+  end
+
+  on :start, "multistage:ensure", :except => stages + ['multistage:prepare']
+
+end

data/lib/capistrano/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def compact
+    self.gsub(/\s+/, ' ')
+  end
+end

data/lib/capistrano/extensions.rb

@@ -25,7 +25,7 @@ module Capistrano
       Capistrano::Configuration.protected_instance_methods +
       Capistrano::Configuration.private_instance_methods
 
-    if methods.include?(name.to_s)
+    if methods.any? { |m| m.to_sym == name }
       raise Capistrano::Error, "registering a plugin named `#{name}' would shadow a method on Capistrano::Configuration with the same name"
     end
 

data/lib/capistrano/fix_rake_deprecated_dsl.rb

@@ -0,0 +1,8 @@
+#
+# See https://github.com/jimweirich/rake/issues/81
+#
+if defined?(Rake::DeprecatedObjectDSL)
+  Rake::DeprecatedObjectDSL.private_instance_methods.each do |m|
+    Rake::DeprecatedObjectDSL.send("undef_method", m)
+  end
+end

data/lib/capistrano/logger.rb

@@ -1,15 +1,80 @@
 module Capistrano
   class Logger #:nodoc:
-    attr_accessor :level
-    attr_reader   :device
+    attr_accessor :level, :device, :disable_formatters
 
     IMPORTANT = 0
     INFO      = 1
     DEBUG     = 2
     TRACE     = 3
-    
+
     MAX_LEVEL = 3
 
+    COLORS = {
+      :none     => "0",
+      :black    => "30",
+      :red      => "31",
+      :green    => "32",
+      :yellow   => "33",
+      :blue     => "34",
+      :magenta  => "35",
+      :cyan     => "36",
+      :white    => "37"
+    }
+
+    STYLES = {
+      :bright     => 1,
+      :dim        => 2,
+      :underscore => 4,
+      :blink      => 5,
+      :reverse    => 7,
+      :hidden     => 8
+    }
+
+    # Set up default formatters
+    @default_formatters = [
+      # TRACE
+      { :match => /command finished/,          :color => :white,   :style => :dim, :level => 3, :priority => -10 },
+      { :match => /executing locally/,         :color => :yellow,  :level => 3, :priority => -20 },
+
+      # DEBUG
+      { :match => /executing `.*/,             :color => :green,   :level => 2, :priority => -10, :timestamp => true },
+      { :match => /.*/,                        :color => :yellow,  :level => 2, :priority => -30 },
+
+      # INFO
+      { :match => /.*out\] (fatal:|ERROR:).*/, :color => :red,     :level => 1, :priority => -10 },
+      { :match => /Permission denied/,         :color => :red,     :level => 1, :priority => -20 },
+      { :match => /sh: .+: command not found/, :color => :magenta, :level => 1, :priority => -30 },
+
+      # IMPORTANT
+      { :match => /^err ::/,                   :color => :red,     :level => 0, :priority => -10 },
+      { :match => /.*/,                        :color => :blue,    :level => 0, :priority => -20 }
+    ]
+    @formatters = @default_formatters
+
+    class << self
+      def default_formatters
+        @default_formatters
+      end
+
+      def default_formatters=(defaults=nil)
+        @default_formatters = [defaults].flatten
+
+        # reset the formatters
+        @formatters = @default_formatters
+        @sorted_formatters = nil
+      end
+
+      def add_formatter(options) #:nodoc:
+        @formatters.push(options)
+        @sorted_formatters = nil
+      end
+
+      def sorted_formatters
+        # Sort matchers in reverse order so we can break if we found a match.
+        @sorted_formatters ||= @formatters.sort_by { |i| -(i[:priority] || i[:prio] || 0) }
+      end
+    end
+
     def initialize(options={})
       output = options[:output] || $stderr
       if output.respond_to?(:puts)
@@ -20,7 +85,8 @@ module Capistrano
       end
 
       @options = options
-      @level = 0
+      @level = options[:level] || 0
+      @disable_formatters = options[:disable_formatters]
     end
 
     def close
@@ -29,8 +95,44 @@ module Capistrano
 
     def log(level, message, line_prefix=nil)
       if level <= self.level
+        # Only format output if device is a TTY or formatters are not disabled
+        if device.tty? && !@disable_formatters
+          color = :none
+          style = nil
+
+          Logger.sorted_formatters.each do |formatter|
+            if (formatter[:level] == level || formatter[:level].nil?)
+              if message =~ formatter[:match] || line_prefix =~ formatter[:match]
+                color = formatter[:color] if formatter[:color]
+                style = formatter[:style] || formatter[:attribute] # (support original cap colors)
+                message.gsub!(formatter[:match], formatter[:replace]) if formatter[:replace]
+                message = formatter[:prepend] + message unless formatter[:prepend].nil?
+                message = message + formatter[:append] unless formatter[:append].nil?
+                message = Time.now.strftime('%Y-%m-%d %T') + ' ' + message if formatter[:timestamp]
+                break unless formatter[:replace]
+              end
+            end
+          end
+
+          if color == :hide
+            # Don't do anything if color is set to :hide
+            return false
+          end
+
+          term_color = COLORS[color]
+          term_style = STYLES[style]
+
+          # Don't format message if no color or style
+          unless color == :none and style.nil?
+            unless line_prefix.nil?
+              line_prefix = format(line_prefix, term_color, term_style, nil)
+            end
+            message = format(message, term_color, term_style)
+          end
+        end
+
         indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
-        message.each do |line|
+        (RUBY_VERSION >= "1.9" ? message.lines : message).each do |line|
           if line_prefix
             device.puts "#{indent} [#{line_prefix}] #{line.strip}\n"
           else
@@ -55,5 +157,10 @@ module Capistrano
     def trace(message, line_prefix=nil)
       log(TRACE, message, line_prefix)
     end
+
+    def format(message, color, style, nl = "\n")
+      style = "#{style};" if style
+      "\e[#{style}#{color}m" + message.to_s.strip + "\e[0m#{nl}"
+    end
   end
 end

data/lib/capistrano/processable.rb

@@ -0,0 +1,55 @@
+module Capistrano
+  module Processable
+    module SessionAssociation
+      def self.on(exception, session)
+        unless exception.respond_to?(:session)
+          exception.extend(self)
+          exception.session = session
+        end
+
+        return exception
+      end
+
+      attr_accessor :session
+    end
+
+    def process_iteration(wait=nil, &block)
+      ensure_each_session { |session| session.preprocess }
+
+      return false if block && !block.call(self)
+
+      readers = sessions.map { |session| session.listeners.keys }.flatten.reject { |io| io.closed? }
+      writers = readers.select { |io| io.respond_to?(:pending_write?) && io.pending_write? }
+
+      if readers.any? || writers.any?
+        readers, writers, = IO.select(readers, writers, nil, wait)
+      else
+        return false
+      end
+
+      if readers
+        ensure_each_session do |session|
+          ios = session.listeners.keys
+          session.postprocess(ios & readers, ios & writers)
+        end
+      end
+
+      true
+    end
+
+    def ensure_each_session
+      errors = []
+
+      sessions.each do |session|
+        begin
+          yield session
+        rescue Exception => error
+          errors << SessionAssociation.on(error, session)
+        end
+      end
+
+      raise errors.first if errors.any?
+      sessions
+    end
+  end
+end

data/lib/capistrano/recipes/compat.rb

@@ -7,7 +7,7 @@ load 'deploy'
 map = { "diff_from_last_deploy"  => "deploy:pending:diff",
         "update"                 => "deploy:update",
         "update_code"            => "deploy:update_code",
-        "symlink"                => "deploy:symlink",
+        "symlink"                => "deploy:create_symlink",
         "restart"                => "deploy:restart",
         "rollback"               => "deploy:rollback",
         "cleanup"                => "deploy:cleanup",
@@ -29,4 +29,4 @@ task :spinner do
   warn "[DEPRECATED] `spinner' is deprecated. Use `deploy:start' instead."
   set :runner, fetch(:spinner_user, "app")
   deploy.start
-end
+end

data/lib/capistrano/recipes/deploy/assets.rb

@@ -0,0 +1,185 @@
+require 'json'
+
+load 'deploy' unless defined?(_cset)
+
+_cset :asset_env, "RAILS_GROUPS=assets"
+_cset :assets_prefix, "assets"
+_cset :shared_assets_prefix, "assets"
+_cset :assets_role, [:web]
+_cset :expire_assets_after, (3600 * 24 * 7)
+
+_cset :normalize_asset_timestamps, false
+
+before 'deploy:finalize_update',   'deploy:assets:symlink'
+after  'deploy:update_code',       'deploy:assets:precompile'
+before 'deploy:assets:precompile', 'deploy:assets:update_asset_mtimes'
+after  'deploy:cleanup',           'deploy:assets:clean_expired'
+after  'deploy:rollback:revision', 'deploy:assets:rollback'
+
+def shared_manifest_path
+  @shared_manifest_path ||= capture("ls #{shared_path.shellescape}/#{shared_assets_prefix}/manifest*").strip
+end
+
+# Parses manifest and returns array of uncompressed and compressed asset filenames with and without digests
+# "Intelligently" determines format of string - supports YAML and JSON
+def parse_manifest(str)
+  assets_hash = str[0,1] == '{' ? JSON.parse(str)['assets'] : YAML.load(str)
+
+  assets_hash.to_a.flatten.map {|a| [a, "#{a}.gz"] }.flatten
+end
+
+namespace :deploy do
+  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 customize the assets path prefix, override the \
+      :assets_prefix variable to match. If you customize shared assets path \
+      prefix, override :shared_assets_prefix variable to match.
+    DESC
+    task :symlink, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run <<-CMD.compact
+        rm -rf #{latest_release}/public/#{assets_prefix} &&
+        mkdir -p #{latest_release}/public &&
+        mkdir -p #{shared_path}/#{shared_assets_prefix} &&
+        ln -s #{shared_path}/#{shared_assets_prefix} #{latest_release}/public/#{assets_prefix}
+      CMD
+    end
+
+    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 \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :precompile, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run <<-CMD.compact
+        cd -- #{latest_release} &&
+        #{rake} RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} assets:precompile
+      CMD
+
+      # Sync manifest filenames across servers if our manifest has a random filename
+      if shared_manifest_path =~ /manifest-.+\./
+        run <<-CMD.compact
+          [ -e #{shared_manifest_path.shellescape} ] || mv -- #{shared_path.shellescape}/#{shared_assets_prefix}/manifest* #{shared_manifest_path.shellescape}
+        CMD
+      end
+
+      # Copy manifest to release root (for clean_expired task)
+      run <<-CMD.compact
+        cp -- #{shared_manifest_path.shellescape} #{current_release.to_s.shellescape}/assets_manifest#{File.extname(shared_manifest_path)}
+      CMD
+    end
+
+    desc <<-DESC
+      [internal] Updates the mtimes for assets that are required by the current release.
+      This task runs before assets:precompile.
+    DESC
+    task :update_asset_mtimes, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      # Fetch assets/manifest contents.
+      manifest_content = capture("[ -e #{shared_path.shellescape}/#{shared_assets_prefix}/manifest* ] && cat #{shared_path.shellescape}/#{shared_assets_prefix}/manifest* || echo").strip
+
+      if manifest_content != ""
+        current_assets = parse_manifest(manifest_content)
+        logger.info "Updating mtimes for ~#{current_assets.count} assets..."
+        put current_assets.map{|a| "#{shared_path}/#{shared_assets_prefix}/#{a}" }.join("\n"), "#{deploy_to}/TOUCH_ASSETS", :via => :scp
+        run <<-CMD.compact
+          cat #{deploy_to.shellescape}/TOUCH_ASSETS | while read asset; do
+            touch -c -- "$asset";
+          done &&
+          rm -f -- #{deploy_to.shellescape}/TOUCH_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Run the asset clean rake task. Use with caution, this will delete \
+      all of your compiled assets. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :clean, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:clean"
+    end
+
+    desc <<-DESC
+      Clean up any assets that haven't been deployed for more than :expire_assets_after seconds.
+      Default time to keep old assets is one week. Set the :expire_assets_after variable
+      to change the assets expiry time. Assets will only be deleted if they are not required by
+      an existing release.
+    DESC
+    task :clean_expired, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      # Fetch all assets_manifest contents.
+      manifests_output = capture <<-CMD.compact
+        for manifest in #{releases_path.shellescape}/*/assets_manifest.*; do
+          cat -- "$manifest" 2> /dev/null && printf ':::' || true;
+        done
+      CMD
+      manifests = manifests_output.split(':::')
+
+      if manifests.empty?
+        logger.info "No manifests in #{releases_path}/*/assets_manifest.*"
+      else
+        logger.info "Fetched #{manifests.count} manifests from #{releases_path}/*/assets_manifest.*"
+        current_assets = Set.new
+        manifests.each do |content|
+          current_assets += parse_manifest(content)
+        end
+        current_assets += [File.basename(shared_manifest_path), "sources_manifest.yml"]
+
+        # Write the list of required assets to server.
+        logger.info "Writing required assets to #{deploy_to}/REQUIRED_ASSETS..."
+        escaped_assets = current_assets.sort.join("\n").gsub("\"", "\\\"") << "\n"
+        put escaped_assets, "#{deploy_to}/REQUIRED_ASSETS", :via => :scp
+
+        # Finds all files older than X minutes, then removes them if they are not referenced
+        # in REQUIRED_ASSETS.
+        expire_after_mins = (expire_assets_after.to_f / 60.0).to_i
+        logger.info "Removing assets that haven't been deployed for #{expire_after_mins} minutes..."
+        # LC_COLLATE=C tells the `sort` and `comm` commands to sort files in byte order.
+        run <<-CMD.compact
+          cd -- #{deploy_to.shellescape}/ &&
+          LC_COLLATE=C sort REQUIRED_ASSETS -o REQUIRED_ASSETS &&
+          cd -- #{shared_path.shellescape}/#{shared_assets_prefix}/ &&
+          for f in $(
+            find * -mmin +#{expire_after_mins.to_s.shellescape} -type f | LC_COLLATE=C sort |
+            LC_COLLATE=C comm -23 -- - #{deploy_to.shellescape}/REQUIRED_ASSETS
+          ); do
+            echo "Removing unneeded asset: $f";
+            rm -f -- "$f";
+          done;
+          rm -f -- #{deploy_to.shellescape}/REQUIRED_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Rolls back assets to the previous release by symlinking the release's manifest
+      to shared/assets/manifest, and finally recompiling or regenerating nondigest assets.
+    DESC
+    task :rollback, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      previous_manifest = capture("ls #{previous_release.shellescape}/assets_manifest.*").strip
+      if capture("[ -e #{previous_manifest.shellescape} ] && echo true || echo false").strip != 'true'
+        puts "#{previous_manifest} is missing! Cannot roll back assets. " <<
+             "Please run deploy:assets:precompile to update your assets when the rollback is finished."
+      else
+        run <<-CMD.compact
+          cd -- #{previous_release.shellescape} &&
+          cp -f -- #{previous_manifest.shellescape} #{shared_manifest_path.shellescape} &&
+          [ -z "$(#{rake} -P | grep assets:precompile:nondigest)" ] || #{rake} RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} assets:precompile:nondigest
+        CMD
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/dependencies.rb

@@ -18,7 +18,7 @@ module Capistrano
         yield self
         self
       end
-  
+
       def remote
         dep = RemoteDependency.new(configuration)
         @dependencies << dep
@@ -41,4 +41,4 @@ module Capistrano
       end
     end
   end
-end
+end

data/lib/capistrano/recipes/deploy/local_dependency.rb

@@ -30,7 +30,7 @@ module Capistrano
       # file is found that matches the parameter, this returns true.
       def find_in_path(utility)
         path = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
-        suffixes = RUBY_PLATFORM =~ /mswin/ ? %w(.bat .exe .com .cmd) : [""]
+        suffixes = self.class.on_windows? ? self.class.windows_executable_extensions : [""]
 
         path.each do |dir|
           suffixes.each do |sfx|
@@ -41,6 +41,14 @@ module Capistrano
 
         false
       end
+
+      def self.on_windows?
+        RUBY_PLATFORM =~ /mswin|mingw/
+      end
+
+      def self.windows_executable_extensions
+        %w(.exe .bat .com .cmd)
+      end
     end
   end
-end
+end

data/lib/capistrano/recipes/deploy/remote_dependency.rb

@@ -1,3 +1,5 @@
+require 'capistrano/errors'
+
 module Capistrano
   module Deploy
     class RemoteDependency
@@ -7,6 +9,7 @@ module Capistrano
       def initialize(configuration)
         @configuration = configuration
         @success = true
+        @hosts = nil
       end
 
       def directory(path, options={})
@@ -15,6 +18,12 @@ module Capistrano
         self
       end
 
+      def file(path, options={})
+        @message ||= "`#{path}' is not a file"
+        try("test -f #{path}", options)
+        self
+      end
+
       def writable(path, options={})
         @message ||= "`#{path}' is not writable"
         try("test -w #{path}", options)
@@ -34,6 +43,48 @@ module Capistrano
         self
       end
 
+      def deb(name, version, options={})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("dpkg -s #{name} | grep '^Version: #{version}'", options)
+        self
+      end
+
+      def rpm(name, version, options={})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("rpm -q #{name} | grep '#{version}'", options)
+        self
+      end
+
+      def match(command, expect, options={})
+        expect = Regexp.new(Regexp.escape(expect.to_s)) unless expect.is_a?(Regexp)
+
+        output_per_server = {}
+        try("#{command} ", options) do |ch, stream, out|
+          output_per_server[ch[:server]] ||= ''
+          output_per_server[ch[:server]] += out
+        end
+
+        # It is possible for some of these commands to return a status != 0
+        # (for example, rake --version exits with a 1). For this check we
+        # just care if the output matches, so we reset the success flag.
+        @success = true
+
+        errored_hosts = []
+        output_per_server.each_pair do |server, output|
+          next if output =~ expect
+          errored_hosts << server
+        end
+
+        if errored_hosts.any?
+          @hosts = errored_hosts.join(', ')
+          output = output_per_server[errored_hosts.first]
+          @message = "the output #{output.inspect} from #{command.inspect} did not match #{expect.inspect}"
+          @success = false
+        end
+
+        self
+      end
+
       def or(message)
         @message = message
         self
@@ -45,7 +96,7 @@ module Capistrano
 
       def message
         s = @message.dup
-        s << " (#{@hosts})" if @hosts && @hosts.any?
+        s << " (#{@hosts})" if @hosts
         s
       end
 
@@ -53,8 +104,9 @@ module Capistrano
 
       def try(command, options)
         return unless @success # short-circuit evaluation
-        configuration.run(command, options) do |ch,stream,out|
+        configuration.invoke_command(command, options) do |ch,stream,out|
           warn "#{ch[:server]}: #{out}" if stream == :err
+          yield ch, stream, out if block_given?
         end
       rescue Capistrano::CommandError => e
         @success = false