piko-fast-tool 0.0.1

data/capistrano-3.20.1/features/deploy.feature

@@ -0,0 +1,92 @@
+Feature: Deploy
+
+  Background:
+    Given a test app with the default configuration
+    And servers with the roles app and web
+
+  Scenario: Creating the repo
+    When I run cap "git:check"
+    Then the task is successful
+    And git wrapper permissions are 0700
+
+  Scenario: Creating the directory structure
+    When I run cap "deploy:check:directories"
+    Then the shared path is created
+    And the releases path is created
+
+  Scenario: Creating linked directories
+    When I run cap "deploy:check:linked_dirs"
+    Then directories in :linked_dirs are created in shared
+
+  Scenario: Creating linked directories for linked files
+    When I run cap "deploy:check:make_linked_dirs"
+    Then directories referenced in :linked_files are created in shared
+
+  Scenario: Checking linked files - missing file
+    Given a linked file "missing_file.txt"
+    But file "missing_file.txt" does not exist in shared path
+    When I run cap "deploy:check:linked_files"
+    Then the task fails
+
+  Scenario: Checking linked files - file exists
+    Given a linked file "existing_file.txt"
+    And file "existing_file.txt" exists in shared path
+    When I run cap "deploy:check:linked_files"
+    Then the task is successful
+
+  Scenario: Creating a release
+    Given I run cap "deploy:check:directories"
+    When I run cap "git:create_release" as part of a release
+    Then the repo is cloned
+    And the release is created
+
+  Scenario: REVISION and REVISION_TIME files are present
+    When I make 1 deployment
+    Then the REVISION file is created in the release
+    Then the REVISION_TIME file is created in the release
+
+  Scenario: Symlink linked files
+    When I run cap "deploy:symlink:linked_files deploy:symlink:release" as part of a release
+    Then file symlinks are created in the new release
+
+  Scenario: Symlink linked dirs
+    When I run cap "deploy:symlink:linked_dirs" as part of a release
+    Then directory symlinks are created in the new release
+
+  Scenario: Publishing
+    When I run cap "deploy:symlink:release"
+    Then the current directory will be a symlink to the release
+
+  Scenario: Cleanup
+    Given config stage file has line "set :keep_releases, 3"
+    And 5 valid existing releases
+    And an invalid release named "new"
+    When I run cap "deploy:cleanup"
+    Then 3 valid releases are kept
+    And the invalid "new" release is ignored
+
+  Scenario: Cleanup after many failed releases doesn't remove last good release
+    Given config stage file has line "set :keep_releases, 2"
+    And I make 2 deployments
+    And an invalid release named "77777777777777"
+    And an invalid release named "88888888888888"
+    And an invalid release named "99999999999999"
+    When I run cap "deploy:cleanup"
+    Then 3 valid releases are kept
+    And the current directory will be a symlink to the release
+
+  Scenario: Cleanup when there are more releases than arguments can handle
+    Given config stage file has line "set :keep_releases, 3"
+    And 5000 valid existing releases
+    When I run cap "deploy:cleanup"
+    Then 3 valid releases are kept
+
+  Scenario: Rolling Back
+    Given I make 2 deployments
+    When I run cap "deploy:rollback"
+    Then the current symlink points to the previous release
+
+  Scenario: Rolling Back to a specific release
+    Given I make 3 deployments
+    When I rollback to a specific release
+    Then the current symlink points to that specific release

data/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/features/support/env.rb

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

data/capistrano-3.20.1/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/capistrano-3.20.1/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/capistrano-3.20.1/gemfiles/legacy.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in capistrano.gemspec
+gemspec path: ".."
+
+gem "mocha", "~> 2.8"
+gem "rspec", "~> 3.13"

data/capistrano-3.20.1/lib/Capfile

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

data/capistrano-3.20.1/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