engineyard-serverside 2.8.0.pre4 → 3.0.4

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA256:
-  metadata.gz: ae5f22352514fece09ff9eb57f642aa6d3cd5b8503c397aef41ffd45e11de6c0
-  data.tar.gz: 9e2732d61febae63336b3ea57805a8ab8736cfa332e52a7bf666e738d766e95e
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjVjNTU5ZjVkOGJmODg2ZmQxOTlkNWJmNTMzNDczZTMzYmU1ZGQwZg==
+  data.tar.gz: !binary |-
+    NWNmNmU2YTFjNWM3OTZhM2IzYzFmOWMwNWQzZGY2YTZmOTdkMWVhZA==
 SHA512:
-  metadata.gz: 160b8f26f18d7aa68badd7e5bd55883c0630f77a8f3b62eb9e643e69ca639d4a55d983806b85b3495d37d8fcfc9aaf801b587a6314ef6c74222e9a5f5ca21f96
-  data.tar.gz: e2e81cbef5a4ed51780c9c7ade4d39598bd2eabbc9e0ae6afe81539484c9c8a598807b07180589e9af8a884ffc50fa1e122b4c7187c579ea70fb8f0c0a8d6651
+  metadata.gz: !binary |-
+    MTVmYjBhMjYyM2QwM2U0YjIzMDdhZjIyY2EzNGNhZWQ5ZDJlZThjOTY4NzQw
+    MjU5M2JmYjhjOGRhYTg5Y2M4NTI3ZTlkMGQ4OGIwOTg2MjY5NzQzM2UxYzI5
+    NTkxM2Y4ZWU1ZTAxMzUxZjY2MDIzZDg0OGVlMzk0MWVlYzczODQ=
+  data.tar.gz: !binary |-
+    ZWZmNmI5ZTY0NjJjOGVkNjAyNWJjZDc3NjY5MTA3MDZlNDA4ZDlmNTdhZjJm
+    NmUyZjA3MjhjNmE4ZGViZWM1ZTVlNTgzZDBlYzNlYmNlZGNkYThmM2ZjMjFk
+    MTdiYTc0MjMxYWFkNjQyZTQzZTkwN2Q4NWI3Mzc3YTgzOGFmMzI=

data/features/hook/running-a-deploy-hook.feature

@@ -0,0 +1,277 @@
+Feature: Running A Deploy Hook
+  In order to inject needed extra steps into the deploy process, I want to be able
+  to provide hooks for various pre-defined callbacks. Meanwhile, serverside needs
+  to know how to execute such hooks.
+
+  Background:
+    Given my account name is TestAccount
+    And my app's name is george
+    And my app lives in an environment named george_fliggerbop
+    And the framework env for my environment is staging
+
+  Scenario Outline: Running a callback
+    When I run `engineyard-serverside hook <Callback Name> --app=george --environment-name=george_fliggerbop --account-name=TestAccount --framework-env=staging`
+    Then I see output indicating that the <Callback Name> hooks were processed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with no hooks present
+    Given my app has no deploy hooks
+    And my app has no service hooks
+    When I run the <Callback Name> callback
+    Then I see a notice that the <Callback Name> callback was skipped
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with a Ruby deploy hook
+    Given my app has a <Callback Name> ruby deploy hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> ruby deploy hook is executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with an Executable deploy hook
+    Given my app has a <Callback Name> executable deploy hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> executable deploy hook is executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with both Ruby and Executable deploy hooks
+    Given my app has a <Callback Name> executable deploy hook
+    Given my app has a <Callback Name> ruby deploy hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> ruby deploy hook is executed
+    But the <Callback Name> executable deploy hook is not executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with a Ruby service hook
+    Given I have a service named selective
+    And my service has a <Callback Name> ruby hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> ruby hook for my service is executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with an executable service hook
+    Given I have a service named selective
+    And my service has a <Callback Name> executable hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> executable hook for my service is executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with both Ruby and Executable service hooks
+    Given I have a service named selective
+    Given my service has a <Callback Name> executable hook
+    Given my service has a <Callback Name> ruby hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> ruby hook for my service is executed
+    But the <Callback Name> executable hook for my service is not executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+  Scenario Outline: Running a callback with botth service hooks and deploy hooks
+    Given my app has a <Callback Name> executable deploy hook
+    And I have a service named selective
+    Given my service has a <Callback Name> ruby hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> ruby hook for my service is executed
+    And the <Callback Name> executable deploy hook is executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+
+  Scenario Outline: Executable hooks without the executable bit get skipped
+    Given my app has a <Callback Name> executable deploy hook
+    But my app's <Callback Name> executable deploy hook is not actually executable
+    And I have a service named selective
+    Given my service has a <Callback Name> executable hook
+    When I run the <Callback Name> callback
+    Then the <Callback Name> executable hook for my service is executed
+    But the <Callback Name> executable deploy hook is not executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+    @error
+  Scenario Outline: Ruby hooks with syntax errors cause an error
+    Given my app has a <Callback Name> ruby deploy hook
+    And I have a service named selective
+    And my service has a <Callback Name> ruby hook
+    But my service's <Callback Name> ruby hook contains syntax errors
+    When I run the <Callback Name> callback
+    Then I see a notice about the <Callback Name> syntax error
+    But my service's <Callback Name> ruby hook is not executed
+    And the <Callback Name> ruby deploy hook is not executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |
+
+    @failure
+  Scenario Outline: Ruby hooks with syntax errors cause an error
+    Given my app has a <Callback Name> ruby deploy hook
+    And I have a service named selective
+    And my service has a <Callback Name> ruby hook
+    But my service's <Callback Name> ruby hook is prone to errors
+    When I run the <Callback Name> callback
+    Then the <Callback Name> ruby hook for my service is executed
+    But I see a notice about the <Callback Name> exception
+    And the <Callback Name> ruby deploy hook is not executed
+
+    Examples:
+      | Callback Name         |
+      | before_deploy         |
+      | before_bundle         |
+      | after_bundle          |
+      | before_compile_assets |
+      | after_compile_assets  |
+      | before_migrate        |
+      | after_migrate         |
+      | before_symlink        |
+      | after_symlink         |
+      | before_restart        |
+      | after_restart         |
+      | after_deploy          |

data/features/hook/step_definitions/running-a-deploy-hook-steps.rb

@@ -0,0 +1,200 @@
+require 'fileutils'
+
+def account_name
+  recall_fact(:account_name)
+end
+
+def app_name
+  recall_fact(:app_name)
+end
+
+def env_name
+  recall_fact(:env_name)
+end
+
+def framework_env
+  recall_fact(:framework_env)
+end
+
+def service_name
+  recall_fact(:service_name)
+end
+
+Given %r{^my account name is (.+)$} do |account_name|
+  memorize_fact(:account_name, account_name)
+end
+
+Given %r{^my app's name is (.+)$} do |app_name|
+  memorize_fact(:app_name, app_name)
+  setup_release_path
+end
+
+Given %r{^my app lives in an environment named (.+)$} do |env_name|
+  memorize_fact(:env_name, env_name)
+end
+
+Given %r{^the framework env for my environment is (.+)$} do |framework_env|
+  memorize_fact(:framework_env, framework_env)
+end
+
+Then %r{^I see output indicating that the (.+) hooks were processed$} do |hook_name|
+  expect(output_text).to include(hook_name)
+end
+
+Given %{my app has no deploy hooks} do
+  cleanup_deploy_hooks_path
+  true
+end
+
+Given %{my app has no service hooks} do
+  cleanup_shared_hooks_path
+  true
+end
+
+When %r{^I run the (.+) callback$} do |callback_name|
+  #puts "Data: '#{Dir["#{data_path}/**/*"]}'"
+
+  config = {:deploy_to => app_path.to_s}
+
+  command = [
+    'engineyard-serverside',
+    'hook',
+    callback_name,
+    "--app=#{app_name}",
+    "--environment-name=#{env_name}",
+    "--account-name=#{account_name}",
+    "--framework-env=#{framework_env}",
+    "--release-path=#{release_path}",
+    "--config='#{config.to_json}'"
+  ].join(' ')
+
+  step %(I run `#{command}`)
+end
+
+Then %r{^I see a notice that the (.+) callback was skipped$} do |callback_name|
+  expect(output_text).to include("#{callback_name}. Skipping.")
+end
+
+def write_ruby_deploy_hook(callback_name, content)
+  setup_deploy_hooks_path
+
+  hook = deploy_hooks_path.join("#{callback_name}.rb")
+
+  f = File.open(hook.to_s, 'w')
+  f.write(content.to_s)
+  f.close
+end
+
+def write_ruby_service_hook(callback_name, content)
+  setup_service_path(service_name)
+
+  hook = service_path(service_name).join("#{callback_name}.rb")
+
+  f = File.open(hook.to_s, 'w')
+  f.write(content.to_s)
+  f.close
+end
+
+Given %r{^my app has a (.+) ruby deploy hook$} do |callback_name|
+  write_ruby_deploy_hook(callback_name, 'true')
+end
+
+Then %r{^the (.+) ruby deploy hook is executed$} do |callback_name|
+  expect(output_text).
+    to include("Executing #{deploy_hooks_path.join("#{callback_name}.rb")}")
+end
+
+Given %r{^my app has a (.+) executable deploy hook$} do |callback_name|
+  setup_deploy_hooks_path
+
+  hook = deploy_hooks_path.join(callback_name)
+  f = File.open(hook.to_s, 'w')
+  f.write("#!/bin/bash\n\necho #{hook.to_s}")
+  f.close
+
+  hook.chmod(0755)
+end
+
+Then %r{^the (.+) executable deploy hook is executed$} do |callback_name|
+  expect(ExecutedCommands.deploy_hook_executed?(callback_name)).to eql(true)
+end
+
+Then %r{^the (.+) executable deploy hook is not executed$} do |callback_name|
+  expect(ExecutedCommands.deploy_hook_executed?(callback_name)).to eql(false)
+end
+
+Given %r{^I have a service named (.+)$} do |service_name|
+  memorize_fact(:service_name, service_name)
+end
+
+Given %r{^my service has a (.+) ruby hook$} do |callback_name|
+  write_ruby_service_hook(callback_name, 'true')
+end
+
+Then %r{^the (.+) ruby hook for my service is executed$} do |callback_name|
+  hook = service_path(service_name).join("#{callback_name}.rb")
+
+  expect(output_text).to include("Executing #{hook}")
+end
+
+Given %r{^my service has a (.+) executable hook$} do |callback_name|
+  setup_service_path(service_name)
+
+  hook = service_path(service_name).join(callback_name)
+  f = File.open(hook.to_s, 'w')
+  f.write("#!/bin/bash\n\necho #{hook.to_s}")
+  f.close
+
+  hook.chmod(0755)
+end
+
+Then %r{^the (.+) executable hook for my service is executed$} do |callback_name|
+  expect(ExecutedCommands.service_hook_executed?(service_name, callback_name)).
+    to eql(true)
+end
+
+Then %r{^the (.+) executable hook for my service is not executed$} do |callback_name|
+  expect(ExecutedCommands.service_hook_executed?(service_name, callback_name)).
+    to eql(false)
+end
+
+Given %r{^my app's (.+) executable deploy hook is not actually executable$} do |callback_name|
+  hook = deploy_hooks_path.join(callback_name)
+
+  hook.chmod(0644)
+end
+
+Given %r{^my service's (.+) ruby hook contains syntax errors$} do |callback_name|
+  write_ruby_service_hook(callback_name, "# encoding: UTF-8\n\n)")
+end
+
+Then %r{^I see a notice about the (.+) syntax error$} do |callback_name|
+  hook = service_path(service_name).join("#{callback_name}.rb")
+  expect(output_text).to include("*** [Error] Invalid Ruby syntax in hook: #{hook}")
+end
+
+Then %r(^my service's (.+) ruby hook is not executed$) do |callback_name|
+  hook = service_path(service_name).join("#{callback_name}.rb")
+
+  expect(output_text).not_to include("Executing #{hook}")
+end
+
+Given %r{^my service's (.+) ruby hook is prone to errors$} do |callback_name|
+  write_ruby_service_hook(callback_name, "raise 'a ruckus'")
+end
+
+Then %r{^I see a notice about the (.+) exception$} do |callback_name|
+  hook = service_path(service_name).join("#{callback_name}.rb")
+
+  expect(output_text).
+    to include("Exception raised in hook #{hook.to_s}")
+end
+
+Then %r{^the (.+) ruby deploy hook is not executed$} do |callback_name|
+  expect(output_text).
+    not_to include("Executing #{deploy_hooks_path.join("#{callback_name}.rb")}")
+end
+
+Then %{I see the output} do
+  puts "OUTPUT START\n\n#{output_text}\n\nOUTPUT END"
+end

data/features/step_definitions/command_steps.rb

@@ -0,0 +1,8 @@
+Then %(the command has an unsuccessful exit status) do
+  step %{the exit status should not be 0}
+  step %{the exit status should not be 255}
+end
+
+Then %(the command suffers a critical failure) do
+  step %{the exit status should be 255}
+end

data/features/step_definitions/version_steps.rb

@@ -0,0 +1,5 @@
+require 'engineyard-serverside/version'
+
+Then %{the current version is displayed} do
+  expect(output_text).to include(EY::Serverside::VERSION)
+end

data/features/support/env.rb

@@ -0,0 +1,63 @@
+unless RUBY_VERSION =~ /^1\.8\./
+  require 'simplecov'
+  SimpleCov.coverage_dir 'coverage/outside'
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/features/'
+    add_filter '/mock/'
+    add_filter '/lib/vendor/'
+    add_group 'CLI Workflows', 'lib/engineyard-serverside/cli/workflows/'
+    add_group 'Callbacks', 'lib/engineyard-serverside/callbacks/'
+  end
+end
+
+require 'cucumber/rspec/doubles'
+require 'aruba/cucumber'
+require 'factis/cucumber'
+require 'devnull'
+require 'engineyard-serverside'
+
+# This is a fun bit of glue to allow us to use Aruba's in-process runner
+class Runatron
+  include RSpec::Mocks::ExampleMethods
+
+  def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+    @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+  end
+
+  def execute!
+    exit_code = begin
+                  $stderr = @stderr
+                  $stdin = @stdin
+                  $stdout = @stdout
+                  $logger = Logger.new(DevNull.new)
+                  allow(Logger).to receive(:new).and_return($logger)
+
+                  EY::Serverside::CLI::App.start(@argv)
+                  0
+                rescue StandardError => e
+                  b = e.backtrace
+                  @stderr.puts("#{b.shift}: #{e.message} (#{e.class})")
+                  @stderr.puts(b.map {|s| "\tfrom #{s}"}.join("\n"))
+                  255
+                rescue SystemExit => e
+                  e.status
+                ensure
+                  $stderr = STDERR
+                  $stdin = STDIN
+                  $stdout = STDOUT
+                end
+
+    @kernel.exit(exit_code)
+  end
+end
+
+Aruba.configure do |config|
+  config.command_launcher = :in_process
+  config.main_class = Runatron
+end
+
+After do
+  ExecutedCommands.reset
+  cleanup_fs
+end

data/features/support/error_codes.rb

@@ -0,0 +1,17 @@
+Before('@error') do
+  memorize_fact(:exit_status, 1)
+end
+
+Before('@failure') do
+  memorize_fact(:exit_status, 255)
+end
+
+After do
+  exit_status = begin
+                  recall_fact(:exit_status)
+                rescue
+                  0
+                end
+
+  step %{the exit status should be #{exit_status}}
+end

data/features/support/fs_helpers.rb

@@ -0,0 +1,82 @@
+require 'pathname'
+module FsHelpers
+  def project_root
+    Pathname.new(File.expand_path(File.join(__FILE__, '..', '..', '..')))
+  end
+
+  def data_path
+    project_root.join('tmp', 'data')
+  end
+
+  def setup_data_path
+    data_path.mkpath
+  end
+
+  def cleanup_data_path
+    data_path.rmtree if data_path.exist?
+  end
+
+  def app_path
+    data_path.join(app_name)
+  end
+
+  def setup_app_path
+    app_path.mkpath
+  end
+
+  def release_path
+    app_path.join('20200212024800')
+  end
+
+  def setup_release_path
+    release_path.mkpath
+  end
+
+  def deploy_hooks_path
+    release_path.join('deploy')
+  end
+
+  def setup_deploy_hooks_path
+    deploy_hooks_path.mkpath
+  end
+
+  def cleanup_deploy_hooks_path
+    deploy_hooks_path.rmtree if deploy_hooks_path.exist?
+  end
+
+  def shared_app_path
+    app_path.join('shared')
+  end
+
+  def shared_hooks_path
+    shared_app_path.join('hooks')
+  end
+
+  def setup_shared_hooks_path
+    shared_hooks_path.mkpath
+  end
+
+  def cleanup_shared_hooks_path
+    shared_hooks_path.rmtree if shared_hooks_path.exist?
+  end
+
+  def service_path(service)
+    shared_hooks_path.join(service)
+  end
+
+  def setup_service_path(service)
+    service_path(service).mkpath
+  end
+
+  def setup_fs
+    setup_deploy_hooks_path
+    setup_shared_hooks_path
+  end
+
+  def cleanup_fs
+    cleanup_data_path
+  end
+
+end
+
+World(FsHelpers)

data/features/support/output_helpers.rb

@@ -0,0 +1,7 @@
+module OutputHelpers
+  def output_text
+    last_command_started.output
+  end
+end
+
+World(OutputHelpers)