engineyard-serverside 2.8.0.pre4 → 2.8.0

data/features/step_definitions/app_steps.rb

@@ -0,0 +1,10 @@
+def setup_release
+  setup_public_path
+  setup_system_link
+  setup_shared_system_path
+  setup_shared_app_path
+end
+
+Given %(I've previously deployed my app) do
+  setup_release
+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/server_steps.rb

@@ -0,0 +1,14 @@
+Given %{my environment has the following servers:} do |dataset|
+  servers = []
+  dataset.hashes.each do |row|
+    servers.push(
+      {
+        :hostname => row['Hostname'],
+        :name => row['Name'].strip,
+        :roles => row['Roles'].split(',').map{|s| s.strip},
+      }
+    )
+  end
+
+  memorize_fact(:servers, servers)
+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)

data/features/support/runner.rb

@@ -0,0 +1,41 @@
+require 'runner'
+require 'engineyard-serverside/spawner'
+
+module ExecutedCommands
+  def self.record(cmd)
+    executed.push(cmd)
+
+    EY::Serverside::Spawner::Result.new(cmd, true, nil, nil)
+  end
+
+  def self.executed
+    @executed ||= []
+  end
+
+  def self.reset
+    @executed = nil
+  end
+
+  def self.deploy_hook_executed?(callback_name)
+    executed.
+      select {|x|
+        x.match(%r{engineyard-serverside-execute-hook #{callback_name}})
+      }.length > 0
+  end
+
+  def self.service_hook_executed?(service_name, callback_name)
+    executed.
+      select {|x|
+        x.match(
+          %r{engineyard-serverside-execute-service-hook #{service_name}/#{callback_name}}
+        )
+      }.length > 0
+  end
+
+end
+
+module Runner
+  def run(cmd)
+    ExecutedCommands.record(cmd)
+  end
+end

data/features/version.feature

@@ -0,0 +1,7 @@
+Feature: Showing the version
+  In order to know what iteration of engineyard-serverside I'm using, I want to
+  be able to have it print out the version.
+
+  Scenario: User issues the vesion command
+    When I run `engineyard-serverside version`
+    Then the current version is displayed

data/lib/engineyard-serverside/cli/app.rb

@@ -8,6 +8,7 @@ require 'engineyard-serverside/cli/server_hash_extractor'
 require 'engineyard-serverside/servers'
 require 'engineyard-serverside/cli/helpers'
 require 'engineyard-serverside/cli/workflows'
+require 'engineyard-serverside/version'
 
 module EY
   module Serverside
@@ -130,6 +131,11 @@ module EY
         def restart
           Workflows.perform(:restart, options)
         end
+
+        desc "version", "Show the engineyard-serverside version"
+        def version
+          puts EY::Serverside::VERSION
+        end
       end
     end
   end

data/lib/engineyard-serverside/shell.rb

@@ -48,23 +48,51 @@ module EY
         debug msg.gsub(BOL, SUBSTATUS_PREFIX)
       end
 
-      def fatal(msg)   logger.fatal   "FATAL: #{msg}" end
-      def error(msg)   logger.error   "ERROR: #{msg}" end
-      def warning(msg) logger.warn    "WARNING: #{msg}" end
+      def fatal(msg)
+        logger.fatal("FATAL: #{msg}")
+      end
+
+      def error(msg)
+        logger.error("ERROR: #{msg}")
+      end
+
+      def warning(msg)
+        logger.warn("WARNING: #{msg}")
+      end
       alias warn warning
-      def notice(msg)  logger.warn    msg end
-      def info(msg)    logger.info    msg end
-      def debug(msg)   logger.debug   msg end
-      def unknown(msg) logger.unknown msg end
+
+      def notice(msg)
+        logger.warn(msg)
+      end
+
+      def info(msg)
+        logger.info(msg)
+      end
+
+      def debug(msg)
+        logger.debug(msg)
+      end
+
+      def unknown(msg)
+        logger.unknown(msg)
+      end
 
       # a debug outputter that displays a command being run
       # Formatis like this:
       #   $ cmd blah do \
       #   > something more
       #   > end
-      def command_show(cmd) debug   cmd.gsub(BOL,CMD_CONTINUE).sub(CMD_CONTINUE, CMD_PREFIX) end
-      def command_out(msg)  debug   msg.gsub(BOL,CMD_INDENT) end
-      def command_err(msg)  unknown msg.gsub(BOL,CMD_INDENT) end
+      def command_show(cmd)
+        debug(cmd.gsub(BOL,CMD_CONTINUE).sub(CMD_CONTINUE, CMD_PREFIX))
+      end
+
+      def command_out(msg)
+        debug(msg.gsub(BOL,CMD_INDENT))
+      end
+
+      def command_err(msg)
+        unknown(msg.gsub(BOL,CMD_INDENT))
+      end
 
       def logged_system(cmd, server = nil)
         EY::Serverside::Spawner.run(cmd, self, server)

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '2.8.0.pre4'
+    VERSION = '2.8.0'
   end
 end

data/spec/engineyard-serverside/callbacks/collection/combined_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'engineyard-serverside/callbacks/collection/combined'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Collection
+
+        describe Combined do
+          let(:paths) {Object.new}
+          let(:deploy_hook_1) {Object.new}
+          let(:deploy_hook_2) {Object.new}
+          let(:service_hook_1) {Object.new}
+          let(:service_hook_2) {Object.new}
+          let(:deploy_hooks) {Object.new}
+          let(:service_hooks) {Object.new}
+
+          let(:collection) {described_class.load(paths)}
+
+          before(:each) do
+            # Stub out the DeployHooks collection upon which we depend
+            allow(DeployHooks).
+              to receive(:load).
+              with(paths).
+              and_return(deploy_hooks)
+
+            allow(deploy_hooks).
+              to receive(:all).
+              and_return([deploy_hook_1, deploy_hook_2])
+
+            allow(deploy_hooks).
+              to receive(:matching).
+              and_return([deploy_hook_1])
+
+            # Stub out the ServiceHooks collection upon which we depend
+            allow(ServiceHooks).
+              to receive(:load).
+              with(paths).
+              and_return(service_hooks)
+
+            allow(service_hooks).
+              to receive(:all).
+              and_return([service_hook_1, service_hook_2])
+
+            allow(service_hooks).
+              to receive(:matching).
+              and_return([service_hook_2])
+
+            # Make all of our "hooks" of the executable flavor by default
+            [
+              deploy_hook_1, deploy_hook_2, service_hook_1, service_hook_2
+            ].each do |hook|
+              allow(hook).to receive(:flavor).and_return(:executable)
+            end
+
+          end
+
+          describe '.load' do
+            let(:deploy_hooks) {Object.new}
+            let(:service_hooks) {Object.new}
+            let(:result) {described_class.load(paths)}
+
+
+            it 'loads deploy hooks' do
+              expect(DeployHooks).to receive(:load).with(paths)
+
+              result
+            end
+
+            it 'loads service hooks' do
+              expect(ServiceHooks).to receive(:load).with(paths)
+
+              result
+            end
+
+            it 'is a callbacks collection' do
+              expect(result).to be_a(Collection::Base)
+            end
+          end
+
+          describe '#all' do
+            let(:result) {collection.all}
+
+            it 'is an Array' do
+              expect(result).to be_a(Array)
+            end
+
+            it 'contains the deploy hooks' do
+              [deploy_hook_1, deploy_hook_2].each do |hook|
+                expect(result).to include(hook)
+              end
+            end
+
+            it 'contains the service hooks' do
+              [service_hook_1, service_hook_2].each do |hook|
+                expect(result).to include(hook)
+              end
+            end
+
+            it 'gives more priority to service hooks' do
+              expect(result).to eql(
+                [service_hook_1, service_hook_2, deploy_hook_1, deploy_hook_2]
+              )
+            end
+          end
+
+          describe '#matching' do
+            let(:name) {:hook_2}
+            let(:result) {collection.matching(name)}
+
+            it 'is an Array' do
+              expect(result).to be_a(Array)
+            end
+
+            it 'contains hooks with the desired name' do
+              [service_hook_2, deploy_hook_1].each do |hook|
+                expect(result).to include(hook)
+              end
+            end
+
+            it 'omits hooks without the desired name' do
+              [service_hook_1, deploy_hook_2].each do |hook|
+                expect(result).not_to include(hook)
+              end
+            end
+          end
+
+          describe '#execute' do
+            let(:config) {Object.new}
+            let(:shell) {Object.new}
+            let(:callback) {Object.new}
+            let(:matches) {[]}
+
+            let(:result) {collection.execute(config, shell, callback)}
+
+            before(:each) do
+              allow(Executor).to receive(:execute)
+              allow(shell).to receive(:info)
+              allow(collection).
+                to receive(:matching).
+                with(callback).
+                and_return(matches)
+            end
+
+            context 'when there are matching hooks' do
+              let(:matches) {[Object.new]}
+
+              it 'executes those matching hooks' do
+                expect(Executor).to receive(:execute).with(config, shell, matches)
+
+                result
+              end
+            end
+
+            context 'when there are not matching hooks' do
+              let(:matches) {[]}
+
+              it 'logs a message about the lack of matching hooks' do
+                expect(shell).
+                  to receive(:info).
+                  with("No hooks detected for #{callback}. Skipping.")
+
+                result
+              end
+
+              it 'does not execute any hooks' do
+                expect(Executor).not_to receive(:execute)
+
+                result
+              end
+            end
+          end
+
+          describe '#distribute' do
+            let(:runner) {Object.new}
+            let(:name) {:hook_2}
+            let(:distributor) {Callbacks::Distributor}
+            let(:distribution_result) {Object.new}
+            let(:matched) {[service_hook_2, deploy_hook_1]}
+            let(:result) {collection.distribute(runner, name)}
+
+            before(:each) do
+              allow(distributor).to receive(:distribute)
+            end
+
+            it 'distributes matching hooks via an distributor' do
+              expect(distributor).
+                to receive(:distribute).
+                with(runner, matched).
+                and_return(distribution_result)
+
+              expect(result).to eql(distribution_result)
+            end
+
+            it 'skips non-matching hooks' do
+              expect(distributor).not_to receive(:distribute).with(runner, :hook_1)
+
+              result
+            end
+
+            context 'when there are multiple matching ruby hooks' do
+              before(:each) do
+                allow(service_hook_2).to receive(:flavor).and_return(:ruby)
+                allow(deploy_hook_1).to receive(:flavor).and_return(:ruby)
+              end
+
+              it 'distributes the first ruby hook' do
+                expect(distributor).
+                  to receive(:distribute).
+                  with(runner, [service_hook_2])
+
+                result
+              end
+
+              it 'does not distribute any other ruby hook' do
+                expect(distributor).
+                  not_to receive(:distribute).
+                  with(runner, [service_hook_2, deploy_hook_1])
+
+                result
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end