capistrano 2.8.0 → 3.19.0

data/features/deploy_failure.feature

@@ -0,0 +1,17 @@
+Feature: Deploy failure
+
+  Background:
+    Given a test app with the default configuration
+    And a custom task that will simulate a failure
+    And a custom task to run in the event of a failure
+    And servers with the roles app and web
+
+  Scenario: Triggering the custom task
+    When I run cap "deploy:starting"
+    But an error is raised
+    Then the failure task will not run
+
+  Scenario: Triggering the custom task
+    When I run cap "deploy"
+    But an error is raised
+    Then the failure task will run

data/features/doctor.feature

@@ -0,0 +1,11 @@
+Feature: Doctor
+
+  Background:
+    Given a test app with the default configuration
+
+  Scenario: Running the doctor task
+    When I run cap "doctor"
+    Then the task is successful
+    And contains "Environment" in the output
+    And contains "Gems" in the output
+    And contains "Variables" in the output

data/features/installation.feature

@@ -0,0 +1,21 @@
+Feature: Installation
+
+  Background:
+    Given a test app without any configuration
+
+  Scenario: The "install" task documentation can be viewed
+    When I run "cap -T"
+    Then the task is successful
+    And contains "cap install" in the output
+
+  Scenario: With default stages
+    When I run "cap install"
+    Then the deploy.rb file is created
+    And the default stage files are created
+    And the tasks folder is created
+
+  Scenario: With specified stages
+    When I run "cap install STAGES=qa,production"
+    Then the deploy.rb file is created
+    And the specified stage files are created
+    And the tasks folder is created

data/features/sshconnect.feature

@@ -0,0 +1,11 @@
+Feature: SSH Connection
+
+  Background:
+    Given a test app with the default configuration
+    And servers with the roles app and web
+    And a task which executes as root
+
+  Scenario: Switching from default user to root and back again
+    When I run cap "am_i_root"
+    Then the task is successful
+    And the output matches "I am uid=0\(root\)" followed by "I am uid=\d+\(deployer\)"

data/features/stage_failure.feature

@@ -0,0 +1,9 @@
+Feature: Stage failure
+
+  Background:
+    Given a test app with the default configuration
+    And a stage file named deploy.rb
+
+  Scenario: Running a task
+    When I run cap "doctor"
+    Then the task fails

data/features/step_definitions/assertions.rb

@@ -0,0 +1,162 @@
+require "shellwords"
+
+Then(/^references in the remote repo are listed$/) do
+  expect(@output).to include("refs/heads/master")
+end
+
+Then(/^git wrapper permissions are 0700$/) do
+  permissions_test = %Q([ $(stat -c "%a" #{TestApp.git_wrapper_path_glob}) == "700" ])
+  expect { run_remote_ssh_command(permissions_test) }.not_to raise_error
+end
+
+Then(/^the shared path is created$/) do
+  run_remote_ssh_command(test_dir_exists(TestApp.shared_path))
+end
+
+Then(/^the releases path is created$/) do
+  run_remote_ssh_command(test_dir_exists(TestApp.releases_path))
+end
+
+Then(/^(\d+) valid releases are kept/) do |num|
+  test = %Q([ $(ls -g #{TestApp.releases_path} | grep -E '[0-9]{14}' | wc -l) == "#{num}" ])
+  expect { run_remote_ssh_command(test) }.not_to raise_error
+end
+
+Then(/^the invalid (.+) release is ignored$/) do |filename|
+  test = "ls -g #{TestApp.releases_path} | grep #{filename}"
+  expect { run_remote_ssh_command(test) }.not_to raise_error
+end
+
+Then(/^directories in :linked_dirs are created in shared$/) do
+  TestApp.linked_dirs.each do |dir|
+    run_remote_ssh_command(test_dir_exists(TestApp.shared_path.join(dir)))
+  end
+end
+
+Then(/^directories referenced in :linked_files are created in shared$/) do
+  dirs = TestApp.linked_files.map { |path| TestApp.shared_path.join(path).dirname }
+  dirs.each do |dir|
+    run_remote_ssh_command(test_dir_exists(dir))
+  end
+end
+
+Then(/^the repo is cloned$/) do
+  run_remote_ssh_command(test_dir_exists(TestApp.repo_path))
+end
+
+Then(/^the release is created$/) do
+  stdout, _stderr = run_remote_ssh_command("ls #{TestApp.releases_path}")
+
+  expect(stdout.strip).to match(/\A#{Time.now.utc.strftime("%Y%m%d")}\d{6}\Z/)
+end
+
+Then(/^the REVISION file is created in the release$/) do
+  stdout, _stderr = run_remote_ssh_command("cat #{@release_paths[0]}/REVISION")
+
+  expect(stdout.strip).to match(/\h{40}/)
+end
+
+Then(/^the REVISION_TIME file is created in the release$/) do
+  stdout, _stderr = run_remote_ssh_command("cat #{@release_paths[0]}/REVISION_TIME")
+
+  expect(stdout.strip).to match(/\d{10}/)
+end
+
+Then(/^file symlinks are created in the new release$/) do
+  TestApp.linked_files.each do |file|
+    run_remote_ssh_command(test_symlink_exists(TestApp.current_path.join(file)))
+  end
+end
+
+Then(/^directory symlinks are created in the new release$/) do
+  pending
+  TestApp.linked_dirs.each do |dir|
+    run_remote_ssh_command(test_symlink_exists(TestApp.release_path.join(dir)))
+  end
+end
+
+Then(/^the current directory will be a symlink to the release$/) do
+  run_remote_ssh_command(exists?("e", TestApp.current_path))
+end
+
+Then(/^the deploy\.rb file is created$/) do
+  file = TestApp.test_app_path.join("config/deploy.rb")
+  expect(File.exist?(file)).to be true
+end
+
+Then(/^the default stage files are created$/) do
+  staging = TestApp.test_app_path.join("config/deploy/staging.rb")
+  production = TestApp.test_app_path.join("config/deploy/production.rb")
+  expect(File.exist?(staging)).to be true
+  expect(File.exist?(production)).to be true
+end
+
+Then(/^the tasks folder is created$/) do
+  path = TestApp.test_app_path.join("lib/capistrano/tasks")
+  expect(Dir.exist?(path)).to be true
+end
+
+Then(/^the specified stage files are created$/) do
+  qa = TestApp.test_app_path.join("config/deploy/qa.rb")
+  production = TestApp.test_app_path.join("config/deploy/production.rb")
+  expect(File.exist?(qa)).to be true
+  expect(File.exist?(production)).to be true
+end
+
+Then(/^it creates the file with the remote_task prerequisite$/) do
+  TestApp.linked_files.each do |file|
+    run_remote_ssh_command(test_file_exists(TestApp.shared_path.join(file)))
+  end
+end
+
+Then(/^it will not recreate the file$/) do
+  #
+end
+
+Then(/^the task is successful$/) do
+  expect(@success).to be true
+end
+
+Then(/^the task fails$/) do
+  expect(@success).to be_falsey
+end
+
+Then(/^the failure task will run$/) do
+  failed = TestApp.shared_path.join("failed")
+  run_remote_ssh_command(test_file_exists(failed))
+end
+
+Then(/^the failure task will not run$/) do
+  failed = TestApp.shared_path.join("failed")
+  expect { run_remote_ssh_command(test_file_exists(failed)) }
+    .to raise_error(RemoteSSHHelpers::RemoteSSHCommandError)
+end
+
+When(/^an error is raised$/) do
+  error = TestApp.shared_path.join("fail")
+  run_remote_ssh_command(test_file_exists(error))
+end
+
+Then(/contains "([^"]*)" in the output/) do |expected|
+  expect(@output).to include(expected)
+end
+
+Then(/the output matches "([^"]*)" followed by "([^"]*)"/) do |expected, followedby|
+  expect(@output).to match(/#{expected}.*#{followedby}/m)
+end
+
+Then(/doesn't contain "([^"]*)" in the output/) do |expected|
+  expect(@output).not_to include(expected)
+end
+
+Then(/the current symlink points to the previous release/) do
+  previous_release_path = @release_paths[-2]
+
+  run_remote_ssh_command(symlinked?(TestApp.current_path, previous_release_path))
+end
+
+Then(/^the current symlink points to that specific release$/) do
+  specific_release_path = TestApp.releases_path.join(@rollback_release)
+
+  run_remote_ssh_command(symlinked?(TestApp.current_path, specific_release_path))
+end

data/features/step_definitions/cap_commands.rb

@@ -0,0 +1,21 @@
+When(/^I run cap "(.*?)"$/) do |task|
+  @success, @output = TestApp.cap(task)
+end
+
+When(/^I run cap "(.*?)" within the "(.*?)" directory$/) do |task, directory|
+  @success, @output = TestApp.cap(task, directory)
+end
+
+When(/^I run cap "(.*?)" as part of a release$/) do |task|
+  TestApp.cap("deploy:new_release_path #{task}")
+end
+
+When(/^I run "(.*?)"$/) do |command|
+  @success, @output = TestApp.run(command)
+end
+
+When(/^I rollback to a specific release$/) do
+  @rollback_release = @release_paths.first.split("/").last
+
+  step %Q{I run cap "deploy:rollback ROLLBACK_RELEASE=#{@rollback_release}"}
+end

data/features/step_definitions/setup.rb

@@ -0,0 +1,91 @@
+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
+  start_ssh_server
+  wait_for_ssh_server
+end
+
+Given(/^a linked file "(.*?)"$/) do |file|
+  # ignoring other linked files
+  TestApp.append_to_deploy_file("set :linked_files, ['#{file}']")
+end
+
+Given(/^file "(.*?)" exists in shared path$/) do |file|
+  file_shared_path = TestApp.shared_path.join(file)
+  run_remote_ssh_command("mkdir -p #{file_shared_path.dirname}")
+  run_remote_ssh_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_remote_ssh_command("mkdir -p #{TestApp.shared_path}")
+  run_remote_ssh_command("touch #{file_shared_path} && rm #{file_shared_path}")
+end
+
+Given(/^a custom task to generate a file$/) do
+  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|
+  TestApp.append_to_deploy_file(line)
+end
+
+Given(/^the configuration is in a custom location$/) do
+  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")
+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")
+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_remote_ssh_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_remote_ssh_command("mkdir -p #{dirs.join(' ')}")
+  end
+end
+
+Given(/^an invalid release named "(.+)"$/) do |filename|
+  run_remote_ssh_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/docker_gateway.rb

@@ -0,0 +1,53 @@
+# Ensure Docker container is completely stopped when Ruby exits.
+at_exit do
+  DockerGateway.new.stop
+end
+
+# Manages the Docker-based SSH server that is declared in docker-compose.yml.
+class DockerGateway
+  def initialize(log_proc=$stderr.method(:puts))
+    @log_proc = log_proc
+  end
+
+  def start
+    run_compose_command("up -d")
+  end
+
+  def stop
+    run_compose_command("down")
+  end
+
+  def run_shell_command(command)
+    run_compose_command("exec ssh_server /bin/bash -c #{command.shellescape}")
+  end
+
+  private
+
+  def run_compose_command(command)
+    log "[docker compose] #{command}"
+    stdout, stderr, status = Open3.popen3("docker compose #{command}") do |stdin, stdout, stderr, wait_threads|
+      stdin << ""
+      stdin.close
+      out = Thread.new { read_lines(stdout, &$stdout.method(:puts)) }
+      err = Thread.new { stderr.read }
+      [out.value, err.value.to_s, wait_threads.value]
+    end
+
+    (stdout + stderr).each_line { |line| log "[docker compose] #{line}" }
+
+    [stdout, stderr, status]
+  end
+
+  def read_lines(io)
+    buffer = + ""
+    while (line = io.gets)
+      buffer << line
+      yield line
+    end
+    buffer
+  end
+
+  def log(message)
+    @log_proc.call(message)
+  end
+end

data/features/support/env.rb

@@ -0,0 +1 @@
+require_relative "../../spec/support/test_app"

data/features/support/remote_command_helpers.rb

@@ -0,0 +1,29 @@
+module RemoteCommandHelpers
+  def test_dir_exists(path)
+    exists?("d", path)
+  end
+
+  def test_symlink_exists(path)
+    exists?("L", path)
+  end
+
+  def test_file_exists(path)
+    exists?("f", path)
+  end
+
+  def exists?(type, path)
+    %Q{[[ -#{type} "#{path}" ]]}
+  end
+
+  def symlinked?(symlink_path, target_path)
+    "[ #{symlink_path} -ef #{target_path} ]"
+  end
+
+  def safely_remove_file(_path)
+    run_remote_ssh_command("rm #{test_file}")
+  rescue
+    RemoteSSHHelpers::RemoteSSHCommandError
+  end
+end
+
+World(RemoteCommandHelpers)

data/features/support/remote_ssh_helpers.rb

@@ -0,0 +1,33 @@
+require "open3"
+require "socket"
+require_relative "docker_gateway"
+
+module RemoteSSHHelpers
+  extend self
+
+  class RemoteSSHCommandError < RuntimeError; end
+
+  def start_ssh_server
+    docker_gateway.start
+  end
+
+  def wait_for_ssh_server(retries=3)
+    Socket.tcp("localhost", 2022, connect_timeout: 1).close
+  rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT
+    retries -= 1
+    sleep(2) && retry if retries.positive?
+    raise
+  end
+
+  def run_remote_ssh_command(command)
+    stdout, stderr, status = docker_gateway.run_shell_command(command)
+    return [stdout, stderr] if status.success?
+    raise RemoteSSHCommandError, status
+  end
+
+  def docker_gateway
+    @docker_gateway ||= DockerGateway.new(method(:log))
+  end
+end
+
+World(RemoteSSHHelpers)

data/lib/Capfile

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

data/lib/capistrano/all.rb

@@ -0,0 +1,17 @@
+require "rake"
+require "sshkit"
+
+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/configuration/scm_resolver"
+
+module Capistrano
+end

data/lib/capistrano/application.rb

@@ -0,0 +1,153 @@
+module Capistrano
+  class Application < Rake::Application
+    def initialize
+      super
+      @rakefiles = %w{capfile Capfile capfile.rb Capfile.rb}
+    end
+
+    def name
+      "cap"
+    end
+
+    def run
+      Rake.application = self
+      super
+    end
+
+    def sort_options(options)
+      not_applicable_to_capistrano = %w(quiet silent verbose)
+      options.reject! do |(switch, *)|
+        switch =~ /--#{Regexp.union(not_applicable_to_capistrano)}/
+      end
+
+      super.push(version, dry_run, roles, hostfilter, print_config_variables)
+    end
+
+    def handle_options
+      options.rakelib = ["rakelib"]
+      options.trace_output = $stderr
+
+      OptionParser.new do |opts|
+        opts.banner = "See full documentation at http://capistranorb.com/."
+        opts.separator ""
+        opts.separator "Install capistrano in a project:"
+        opts.separator "    bundle exec cap install [STAGES=qa,staging,production,...]"
+        opts.separator ""
+        opts.separator "Show available tasks:"
+        opts.separator "    bundle exec cap -T"
+        opts.separator ""
+        opts.separator "Invoke (or simulate invoking) a task:"
+        opts.separator "    bundle exec cap [--dry-run] STAGE TASK"
+        opts.separator ""
+        opts.separator "Advanced options:"
+
+        opts.on_tail("-h", "--help", "-H", "Display this help message.") do
+          puts opts
+          exit
+        end
+
+        standard_rake_options.each { |args| opts.on(*args) }
+        opts.environment("RAKEOPT")
+      end.parse!
+    end
+
+    def top_level_tasks
+      if tasks_without_stage_dependency.include?(@top_level_tasks.first)
+        @top_level_tasks
+      else
+        @top_level_tasks.unshift(ensure_stage.to_s)
+      end
+    end
+
+    def display_error_message(ex)
+      unless options.backtrace
+        Rake.application.options.suppress_backtrace_pattern = backtrace_pattern if backtrace_pattern
+        trace "(Backtrace restricted to imported tasks)"
+      end
+
+      super
+    end
+
+    def exit_because_of_exception(ex)
+      if respond_to?(:deploying?) && deploying?
+        exit_deploy_because_of_exception(ex)
+      else
+        super
+      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 && Rake::Task.task_defined?("load:defaults")
+        invoke "load:defaults"
+        set(:stage, "")
+        Dir[deploy_config_path].each { |f| add_import f }
+      end
+
+      super
+    end
+
+    def capfile
+      File.expand_path(File.join(File.dirname(__FILE__), "..", "Capfile"))
+    end
+
+    def version
+      ["--version", "-V",
+       "Display the program version.",
+       lambda do |_value|
+         puts "Capistrano Version: #{Capistrano::VERSION} (Rake Version: #{Rake::VERSION})"
+         exit
+       end]
+    end
+
+    def dry_run
+      ["--dry-run", "-n",
+       "Do a dry run without executing actions",
+       lambda do |_value|
+         Configuration.env.set(:sshkit_backend, SSHKit::Backend::Printer)
+       end]
+    end
+
+    def roles
+      ["--roles ROLES", "-r",
+       "Run SSH commands only on hosts matching these roles",
+       lambda do |value|
+         Configuration.env.add_cmdline_filter(:role, value)
+       end]
+    end
+
+    def hostfilter
+      ["--hosts HOSTS", "-z",
+       "Run SSH commands only on matching hosts",
+       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/empty_filter.rb

@@ -0,0 +1,9 @@
+module Capistrano
+  class Configuration
+    class EmptyFilter
+      def filter(_servers)
+        []
+      end
+    end
+  end
+end