capistrano 3.3.5 → 3.16.0

data/features/step_definitions/setup.rb

@@ -2,8 +2,16 @@ Given(/^a test app with the default configuration$/) do
   TestApp.install
 end
 
+Given(/^a test app without any configuration$/) do
+  TestApp.create_test_app
+end
+
 Given(/^servers with the roles app and web$/) do
-  vagrant_cli_command('up') rescue nil
+  begin
+    vagrant_cli_command("up")
+  rescue
+    nil
+  end
 end
 
 Given(/^a linked file "(.*?)"$/) do |file|
@@ -13,10 +21,16 @@ end
 
 Given(/^file "(.*?)" exists in shared path$/) do |file|
   file_shared_path = TestApp.shared_path.join(file)
-  run_vagrant_command("mkdir -p #{TestApp.shared_path}")
+  run_vagrant_command("mkdir -p #{file_shared_path.dirname}")
   run_vagrant_command("touch #{file_shared_path}")
 end
 
+Given(/^all linked files exists in shared path$/) do
+  TestApp.linked_files.each do |linked_file|
+    step %Q{file "#{linked_file}" exists in shared path}
+  end
+end
+
 Given(/^file "(.*?)" does not exist in shared path$/) do |file|
   file_shared_path = TestApp.shared_path.join(file)
   run_vagrant_command("mkdir -p #{TestApp.shared_path}")
@@ -24,7 +38,11 @@ Given(/^file "(.*?)" does not exist in shared path$/) do |file|
 end
 
 Given(/^a custom task to generate a file$/) do
-  TestApp.copy_task_to_test_app('spec/support/tasks/database.rake')
+  TestApp.copy_task_to_test_app("spec/support/tasks/database.rake")
+end
+
+Given(/^a task which executes as root$/) do
+  TestApp.copy_task_to_test_app("spec/support/tasks/root.rake")
 end
 
 Given(/config stage file has line "(.*?)"/) do |line|
@@ -32,15 +50,45 @@ Given(/config stage file has line "(.*?)"/) do |line|
 end
 
 Given(/^the configuration is in a custom location$/) do
-  TestApp.move_configuration_to_custom_location('app')
+  TestApp.move_configuration_to_custom_location("app")
 end
 
 Given(/^a custom task that will simulate a failure$/) do
-  safely_remove_file(TestApp.shared_path.join('failed'))
-  TestApp.copy_task_to_test_app('spec/support/tasks/fail.rake')
+  safely_remove_file(TestApp.shared_path.join("failed"))
+  TestApp.copy_task_to_test_app("spec/support/tasks/fail.rake")
 end
 
 Given(/^a custom task to run in the event of a failure$/) do
-  safely_remove_file(TestApp.shared_path.join('failed'))
-  TestApp.copy_task_to_test_app('spec/support/tasks/failed.rake')
+  safely_remove_file(TestApp.shared_path.join("failed"))
+  TestApp.copy_task_to_test_app("spec/support/tasks/failed.rake")
+end
+
+Given(/^a stage file named (.+)$/) do |filename|
+  TestApp.write_local_stage_file(filename)
+end
+
+Given(/^I make (\d+) deployments$/) do |count|
+  step "all linked files exists in shared path"
+
+  @release_paths = (1..count.to_i).map do
+    TestApp.cap("deploy")
+    stdout, _stderr = run_vagrant_command("readlink #{TestApp.current_path}")
+
+    stdout.strip
+  end
+end
+
+Given(/^(\d+) valid existing releases$/) do |num|
+  a_day = 86_400 # in seconds
+  (1...num).each_slice(100) do |num_batch|
+    dirs = num_batch.map do |i|
+      offset = -(a_day * i)
+      TestApp.release_path(TestApp.timestamp(offset))
+    end
+    run_vagrant_command("mkdir -p #{dirs.join(' ')}")
+  end
+end
+
+Given(/^an invalid release named "(.+)"$/) do |filename|
+  run_vagrant_command("mkdir -p #{TestApp.release_path(filename)}")
 end

data/features/subdirectory.feature

@@ -0,0 +1,9 @@
+Feature: cap can be run from a subdirectory, and will still find the Capfile
+
+  Background:
+    Given a test app with the default configuration
+    And servers with the roles app and web
+
+  Scenario: Running cap from a subdirectory
+    When I run cap "git:check" within the "config" directory
+    Then the task is successful

data/features/support/env.rb

@@ -1,11 +1,11 @@
-PROJECT_ROOT = File.expand_path('../../../', __FILE__)
-VAGRANT_ROOT = File.join(PROJECT_ROOT, 'spec/support')
-VAGRANT_BIN = ENV['VAGRANT_BIN'] || "vagrant"
+PROJECT_ROOT = File.expand_path("../../../", __FILE__)
+VAGRANT_ROOT = File.join(PROJECT_ROOT, "spec/support")
+VAGRANT_BIN = ENV["VAGRANT_BIN"] || "vagrant"
 
 at_exit do
-  if ENV['KEEP_RUNNING']
+  if ENV["KEEP_RUNNING"]
     VagrantHelpers.run_vagrant_command("rm -rf /home/vagrant/var")
   end
 end
 
-require_relative '../../spec/support/test_app'
+require_relative "../../spec/support/test_app"

data/features/support/remote_command_helpers.rb

@@ -1,22 +1,28 @@
 module RemoteCommandHelpers
   def test_dir_exists(path)
-    exists?('d', path)
+    exists?("d", path)
   end
 
   def test_symlink_exists(path)
-    exists?('L', path)
+    exists?("L", path)
   end
 
   def test_file_exists(path)
-    exists?('f', path)
+    exists?("f", path)
   end
 
   def exists?(type, path)
-    %{[ -#{type} "#{path}" ]}
+    %Q{[ -#{type} "#{path}" ]}
   end
 
-  def safely_remove_file(path)
-    run_vagrant_command("rm #{test_file}") rescue VagrantHelpers::VagrantSSHCommandError
+  def symlinked?(symlink_path, target_path)
+    "[ #{symlink_path} -ef #{target_path} ]"
+  end
+
+  def safely_remove_file(_path)
+    run_vagrant_command("rm #{test_file}")
+  rescue
+    VagrantHelpers::VagrantSSHCommandError
   end
 end
 

data/features/support/vagrant_helpers.rb

@@ -1,10 +1,12 @@
+require "open3"
+
 module VagrantHelpers
   extend self
 
   class VagrantSSHCommandError < RuntimeError; end
 
   at_exit do
-    if ENV['KEEP_RUNNING']
+    if ENV["KEEP_RUNNING"]
       puts "Vagrant vm will be left up because KEEP_RUNNING is set."
       puts "Rerun without KEEP_RUNNING set to cleanup the vm."
     else
@@ -14,22 +16,26 @@ module VagrantHelpers
 
   def vagrant_cli_command(command)
     puts "[vagrant] #{command}"
-    Dir.chdir(VAGRANT_ROOT) do
-      `#{VAGRANT_BIN} #{command} 2>&1`.split("\n").each do |line|
-        puts "[vagrant] #{line}"
-      end
+    stdout, stderr, status = Dir.chdir(VAGRANT_ROOT) do
+      Open3.capture3("#{VAGRANT_BIN} #{command}")
     end
-    $?
+
+    (stdout + stderr).each_line { |line| puts "[vagrant] #{line}" }
+
+    [stdout, stderr, status]
   end
 
   def run_vagrant_command(command)
-    if (status = vagrant_cli_command("ssh -c #{command.inspect}")).success?
-      true
-    else
-      fail VagrantSSHCommandError, status
-    end
+    stdout, stderr, status = vagrant_cli_command("ssh -c #{command.inspect}")
+    return [stdout, stderr] if status.success?
+    raise VagrantSSHCommandError, status
   end
 
+  def puts(message)
+    # Attach log messages to the current cucumber feature (`log`),
+    # or simply puts to the console (`super`) if we are outside of cucumber.
+    respond_to?(:log) ? log(message) : super(message)
+  end
 end
 
 World(VagrantHelpers)

data/lib/Capfile

@@ -1,3 +1,3 @@
 #!/usr/bin/env cap
 include Capistrano::DSL
-require 'capistrano/install'
+require "capistrano/install"

data/lib/capistrano/all.rb

@@ -1,17 +1,17 @@
-require 'rake'
-require 'sshkit'
+require "rake"
+require "sshkit"
 
-require 'io/console'
+require "io/console"
 
 Rake.application.options.trace = true
 
-require 'capistrano/version'
-require 'capistrano/version_validator'
-require 'capistrano/i18n'
-require 'capistrano/dsl'
-require 'capistrano/application'
-require 'capistrano/configuration'
+require "capistrano/version"
+require "capistrano/version_validator"
+require "capistrano/i18n"
+require "capistrano/dsl"
+require "capistrano/application"
+require "capistrano/configuration"
+require "capistrano/configuration/scm_resolver"
 
 module Capistrano
-
 end

data/lib/capistrano/application.rb

@@ -1,9 +1,8 @@
 module Capistrano
   class Application < Rake::Application
-
     def initialize
       super
-      @rakefiles = %w{capfile Capfile capfile.rb Capfile.rb} << capfile
+      @rakefiles = %w{capfile Capfile capfile.rb Capfile.rb}
     end
 
     def name
@@ -21,11 +20,11 @@ module Capistrano
         switch =~ /--#{Regexp.union(not_applicable_to_capistrano)}/
       end
 
-      super.push(version, dry_run, roles, hostfilter)
+      super.push(version, dry_run, roles, hostfilter, print_config_variables)
     end
 
     def handle_options
-      options.rakelib = ['rakelib']
+      options.rakelib = ["rakelib"]
       options.trace_output = $stderr
 
       OptionParser.new do |opts|
@@ -48,11 +47,10 @@ module Capistrano
         end
 
         standard_rake_options.each { |args| opts.on(*args) }
-        opts.environment('RAKEOPT')
+        opts.environment("RAKEOPT")
       end.parse!
     end
 
-
     def top_level_tasks
       if tasks_without_stage_dependency.include?(@top_level_tasks.first)
         @top_level_tasks
@@ -63,13 +61,10 @@ module Capistrano
 
     def display_error_message(ex)
       unless options.backtrace
-        if loc = Rake.application.find_rakefile_location
-          whitelist = (@imported.dup << loc[0]).map{|f| File.absolute_path(f, loc[1])}
-          pattern = %r@^(?!#{whitelist.map{|p| Regexp.quote(p)}.join('|')})@
-          Rake.application.options.suppress_backtrace_pattern = pattern
-        end
+        Rake.application.options.suppress_backtrace_pattern = backtrace_pattern if backtrace_pattern
         trace "(Backtrace restricted to imported tasks)"
       end
+
       super
     end
 
@@ -81,60 +76,78 @@ module Capistrano
       end
     end
 
+    # allows the `cap install` task to load without a capfile
+    def find_rakefile_location
+      if (location = super).nil?
+        [capfile, Dir.pwd]
+      else
+        location
+      end
+    end
+
     private
 
+    def backtrace_pattern
+      loc = Rake.application.find_rakefile_location
+      return unless loc
+
+      whitelist = (@imported.dup << loc[0]).map { |f| File.absolute_path(f, loc[1]) }
+      /^(?!#{whitelist.map { |p| Regexp.quote(p) }.join('|')})/
+    end
+
     def load_imports
-      if options.show_tasks
-        invoke 'load:defaults'
-        set(:stage, '')
+      if options.show_tasks && Rake::Task.task_defined?("load:defaults")
+        invoke "load:defaults"
+        set(:stage, "")
         Dir[deploy_config_path].each { |f| add_import f }
       end
 
       super
     end
 
-    # allows the `cap install` task to load without a capfile
     def capfile
-      File.expand_path(File.join(File.dirname(__FILE__),'..','Capfile'))
+      File.expand_path(File.join(File.dirname(__FILE__), "..", "Capfile"))
     end
 
     def version
-      ['--version', '-V',
+      ["--version", "-V",
        "Display the program version.",
-       lambda { |value|
-         puts "Capistrano Version: #{Capistrano::VERSION} (Rake Version: #{RAKEVERSION})"
+       lambda do |_value|
+         puts "Capistrano Version: #{Capistrano::VERSION} (Rake Version: #{Rake::VERSION})"
          exit
-       }
-      ]
+       end]
     end
 
     def dry_run
-      ['--dry-run', '-n',
+      ["--dry-run", "-n",
        "Do a dry run without executing actions",
-       lambda { |value|
+       lambda do |_value|
          Configuration.env.set(:sshkit_backend, SSHKit::Backend::Printer)
-       }
-      ]
+       end]
     end
 
     def roles
-      ['--roles ROLES', '-r',
+      ["--roles ROLES", "-r",
        "Run SSH commands only on hosts matching these roles",
-       lambda { |value|
+       lambda do |value|
          Configuration.env.add_cmdline_filter(:role, value)
-       }
-      ]
+       end]
     end
 
     def hostfilter
-      ['--hosts HOSTS', '-z',
+      ["--hosts HOSTS", "-z",
        "Run SSH commands only on matching hosts",
-       lambda { |value|
+       lambda do |value|
          Configuration.env.add_cmdline_filter(:host, value)
-       }
-      ]
+       end]
     end
 
+    def print_config_variables
+      ["--print-config-variables", "-p",
+       "Display the defined config variables before starting the deployment tasks.",
+       lambda do |_value|
+         Configuration.env.set(:print_config_variables, true)
+       end]
+    end
   end
-
 end

data/lib/capistrano/configuration.rb

@@ -1,15 +1,15 @@
-require_relative 'configuration/filter'
-require_relative 'configuration/question'
-require_relative 'configuration/server'
-require_relative 'configuration/servers'
+require_relative "configuration/filter"
+require_relative "configuration/question"
+require_relative "configuration/plugin_installer"
+require_relative "configuration/server"
+require_relative "configuration/servers"
+require_relative "configuration/validated_variables"
+require_relative "configuration/variables"
 
 module Capistrano
-  class Configuration
-
-    def initialize(config = nil)
-      @config ||= config
-    end
+  class ValidationError < RuntimeError; end
 
+  class Configuration
     def self.env
       @env ||= new
     end
@@ -18,38 +18,53 @@ module Capistrano
       @env = new
     end
 
+    extend Forwardable
+    attr_reader :variables
+    def_delegators :variables,
+                   :set, :fetch, :fetch_for, :delete, :keys, :validate
+
+    def initialize(values={})
+      @variables = ValidatedVariables.new(Variables.new(values))
+    end
+
     def ask(key, default=nil, options={})
       question = Question.new(key, default, options)
       set(key, question)
     end
 
-    def set(key, value)
-      config[key] = value
+    def set_if_empty(key, value=nil, &block)
+      set(key, value, &block) unless keys.include?(key)
     end
 
-    def set_if_empty(key, value)
-      config[key] = value unless config.has_key? key
+    def append(key, *values)
+      set(key, Array(fetch(key)).concat(values))
     end
 
-    def delete(key)
-      config.delete(key)
+    def remove(key, *values)
+      set(key, Array(fetch(key)) - values)
     end
 
-    def fetch(key, default=nil, &block)
-      value = fetch_for(key, default, &block)
-      while callable_without_parameters?(value)
-        value = set(key, value.call)
+    def any?(key)
+      value = fetch(key)
+      if value && value.respond_to?(:any?)
+        begin
+          return value.any?
+        rescue ArgumentError # rubocop:disable Lint/HandleExceptions
+          # Gracefully ignore values whose `any?` method doesn't accept 0 args
+        end
       end
-      return value
+
+      !value.nil?
     end
 
-    def keys
-      config.keys
+    def is_question?(key)
+      value = fetch_for(key, nil)
+      !value.nil? && value.is_a?(Question)
     end
 
     def role(name, hosts, options={})
       if name == :all
-        raise ArgumentError.new("#{name} reserved name for role. Please choose another name")
+        raise ArgumentError, "#{name} reserved name for role. Please choose another name"
       end
 
       servers.add_role(name, hosts, options)
@@ -63,6 +78,10 @@ module Capistrano
       servers.roles_for(names)
     end
 
+    def role_properties_for(names, &block)
+      servers.role_properties_for(names, &block)
+    end
+
     def primary(role)
       servers.fetch_primary(role)
     end
@@ -75,27 +94,50 @@ module Capistrano
 
     def configure_backend
       backend.configure do |sshkit|
-        sshkit.format           = fetch(:format)
+        configure_sshkit_output(sshkit)
         sshkit.output_verbosity = fetch(:log_level)
         sshkit.default_env      = fetch(:default_env)
         sshkit.backend          = fetch(:sshkit_backend, SSHKit::Backend::Netssh)
         sshkit.backend.configure do |backend|
           backend.pty                = fetch(:pty)
           backend.connection_timeout = fetch(:connection_timeout)
-          backend.ssh_options        = fetch(:ssh_options) if fetch(:ssh_options)
+          backend.ssh_options        = (backend.ssh_options || {}).merge(fetch(:ssh_options, {}))
         end
       end
     end
 
+    def configure_scm
+      Capistrano::Configuration::SCMResolver.new.resolve
+    end
+
     def timestamp
       @timestamp ||= Time.now.utc
     end
 
+    def add_filter(filter=nil, &block)
+      if block
+        raise ArgumentError, "Both a block and an object were given" if filter
+
+        filter = Object.new
+        def filter.filter(servers)
+          block.call(servers)
+        end
+      elsif !filter.respond_to? :filter
+        raise TypeError, "Provided custom filter <#{filter.inspect}> does " \
+                         "not have a public 'filter' method"
+      end
+      @custom_filters ||= []
+      @custom_filters << filter
+    end
+
     def setup_filters
-      @filters = cmdline_filters.clone
-      @filters << Filter.new(:role, ENV['ROLES']) if ENV['ROLES']
-      @filters << Filter.new(:host, ENV['HOSTS']) if ENV['HOSTS']
-      fh = fetch_for(:filter,{})
+      @filters = cmdline_filters
+      @filters += @custom_filters if @custom_filters
+      @filters << Filter.new(:role, ENV["ROLES"]) if ENV["ROLES"]
+      @filters << Filter.new(:host, ENV["HOSTS"]) if ENV["HOSTS"]
+      fh = fetch_for(:filter, {}) || {}
+      @filters << Filter.new(:host, fh[:hosts]) if fh[:hosts]
+      @filters << Filter.new(:role, fh[:roles]) if fh[:roles]
       @filters << Filter.new(:host, fh[:host]) if fh[:host]
       @filters << Filter.new(:role, fh[:role]) if fh[:role]
     end
@@ -104,35 +146,44 @@ module Capistrano
       cmdline_filters << Filter.new(type, values)
     end
 
-    def filter list
+    def filter(list)
       setup_filters if @filters.nil?
-      @filters.reduce(list) { |l,f| f.filter l }
+      @filters.reduce(list) { |l, f| f.filter l }
     end
 
-    private
+    def dry_run?
+      fetch(:sshkit_backend) == SSHKit::Backend::Printer
+    end
 
-    def cmdline_filters
-      @cmdline_filters ||= []
+    def install_plugin(plugin, load_hooks: true, load_immediately: false)
+      installer.install(plugin,
+                        load_hooks: load_hooks,
+                        load_immediately: load_immediately)
+    end
+
+    def scm_plugin_installed?
+      installer.scm_installed?
     end
 
     def servers
       @servers ||= Servers.new
     end
 
-    def config
-      @config ||= Hash.new
+    private
+
+    def cmdline_filters
+      @cmdline_filters ||= []
     end
 
-    def fetch_for(key, default, &block)
-      if block_given?
-        config.fetch(key, &block)
-      else
-        config.fetch(key, default)
-      end
+    def installer
+      @installer ||= PluginInstaller.new
     end
 
-    def callable_without_parameters?(x)
-      x.respond_to?(:call) && ( !x.respond_to?(:arity) || x.arity == 0)
+    def configure_sshkit_output(sshkit)
+      format_args = [fetch(:format)]
+      format_args.push(fetch(:format_options)) if any?(:format_options)
+
+      sshkit.use_format(*format_args)
     end
   end
 end