engineyard-serverside 2.8.0.pre → 3.0.3

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)

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.rb

@@ -13,13 +13,10 @@ if defined?(Encoding) && Encoding.respond_to?(:default_internal=) # String.insta
 end
 
 $LOAD_PATH.unshift File.expand_path('vendor/thor/lib', File.dirname(__FILE__))
-$LOAD_PATH.unshift File.expand_path('vendor/systemu/lib', File.dirname(__FILE__))
 $LOAD_PATH.unshift File.expand_path('vendor/escape/lib', File.dirname(__FILE__))
-$LOAD_PATH.unshift File.expand_path('vendor/json_pure/lib', File.dirname(__FILE__))
-$LOAD_PATH.unshift File.expand_path('vendor/multi_json/lib', File.dirname(__FILE__))
 
 require 'escape'
-require 'multi_json'
+require 'json'
 require 'uri'
 
 require 'engineyard-serverside/version'
@@ -39,7 +36,7 @@ module EY
     RemoteFailure = Class.new StandardError
 
     def self.node
-      @node ||= deep_indifferentize(MultiJson.load(dna_json))
+      @node ||= deep_indifferentize(JSON.load(dna_json))
     end
 
     def self.dna_json

data/lib/engineyard-serverside/callbacks/collection/base.rb

@@ -20,6 +20,10 @@ module EY
             hooks
           end
 
+          def empty?
+            hooks.empty?
+          end
+
           def matching(callback)
             favor(
               :ruby,
@@ -37,11 +41,14 @@ module EY
           end
 
           def execute(config, shell, callback)
-            Executor.execute(
-              config,
-              shell,
-              matching(callback)
-            )
+            matches = matching(callback)
+
+            if matches.empty?
+              shell.info("No hooks detected for #{callback}. Skipping.")
+              return
+            end
+
+            Executor.execute(config, shell, matches)
           end
 
           private

data/lib/engineyard-serverside/callbacks/distributor.rb

@@ -6,13 +6,8 @@ module EY
     module Callbacks
 
       module Distributor
-        def self.distribute(runner, hooks)
-          ViabilityFilter.
-            new.
-            call({:candidates => hooks, :shell => runner.shell}).
-            and_then {|callback_name|
-              Remote.distribute(runner, callback_name)
-            }
+        def self.distribute(runner, callback_name)
+          Remote.distribute(runner, callback_name)
         end
       end
 

data/lib/engineyard-serverside/callbacks/executor/executable.rb

@@ -29,6 +29,8 @@ module EY
 
           def validate_hook(input = {})
             unless hook_path.executable?
+              shell.warning("Skipping possible deploy hook #{hook} because it is not executable.")
+
               return Failure(
                 input.merge(
                   {

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/cli/workflows/calling_deploy_hooks.rb

@@ -11,8 +11,7 @@ module EY
         class CallingDeployHooks < Base
           private
           def procedure
-            Callbacks.
-              load(config.paths).
+            Callbacks.load(config.paths).
               execute(config, shell, hook_name)
           end
 

data/lib/engineyard-serverside/configuration.rb

@@ -1,4 +1,4 @@
-require 'multi_json'
+require 'json'
 require 'thor'
 require 'pp'
 require 'yaml'
@@ -131,7 +131,7 @@ module EY
 
       def initialize(options)
         opts = string_keys(options)
-        config = MultiJson.load(opts.delete("config") || "{}")
+        config = JSON.load(opts.delete("config") || "{}")
         append_config_source opts # high priority
         append_config_source config # lower priority
       end
@@ -216,7 +216,7 @@ module EY
       end
 
       def to_json
-        MultiJson.dump(configuration)
+        JSON.dump(configuration)
       end
 
       def node

data/lib/engineyard-serverside/deploy.rb

@@ -1,11 +1,12 @@
 # Inspired by capistrano, thanks Jamis!
 require 'base64'
-require 'multi_json'
+#require 'multi_json'
+require 'json'
 require 'engineyard-serverside/rails_assets'
 require 'engineyard-serverside/maintenance'
 require 'engineyard-serverside/dependency_manager'
 require 'engineyard-serverside/dependency_manager/legacy_helpers'
-require 'engineyard-serverside/callbacks'
+require 'engineyard-serverside/callbacks/distributor'
 
 module EY
   module Serverside
@@ -451,9 +452,8 @@ defaults:
       end
 
       def callback(what)
-        load_callbacks
         @callbacks_reached ||= true
-        @callbacks_collection.distribute(self, what)
+        Callbacks::Distributor.distribute(self, what)
       end
 
       def source
@@ -512,10 +512,6 @@ defaults:
       def compile_assets
         RailsAssets.detect_and_compile(config, shell, self)
       end
-
-      def load_callbacks
-        @callbacks_collection ||= Callbacks.load(paths)
-      end
     end   # DeployBase
 
     class Deploy < DeployBase

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)