engineyard-serverside 2.8.0.pre4 → 3.0.4

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/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,6 +1,7 @@
 # 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'

data/lib/engineyard-serverside/propagator.rb

@@ -52,7 +52,7 @@ module EY
       end
 
       def install_command
-        "#{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'"
+        "#{gem_binary} install '#{remote_gem_file}'"
       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 = '3.0.4'
   end
 end

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/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

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

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'engineyard-serverside/callbacks/collection'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Collection
+
+        describe DeployHooks do
+          
+          let(:paths) {Object.new}
+          let(:app_base_path) {Pathname.new('/data/some_app')}
+          let(:deploy_hooks_path) {
+            app_base_path.join('releases', 'TIMESTAMP', 'deploy')
+          }
+
+          let(:hook_1_path) {deploy_hooks_path.join('hook_1.rb')}
+          let(:hook_2_path) {deploy_hooks_path.join('hook_2.rb')}
+          let(:hook_paths) {[hook_1_path.to_s, hook_2_path.to_s]}
+
+          let(:collection) {described_class.load(paths)}
+
+          before(:each) do
+            allow(paths).to receive(:deploy_hooks).and_return(deploy_hooks_path)
+            allow(Dir).to receive(:[]).and_return([])
+          end
+
+          describe '.load' do
+            let(:result) {described_class.load(paths)}
+
+            context 'with application hooks present' do
+              before(:each) do
+                allow(Dir).
+                  to receive(:[]).
+                  with("#{deploy_hooks_path}/*").
+                  and_return(hook_paths)
+              end
+
+              it 'loads those application hooks' do
+                expect(Hooks::App).to receive(:new).with(hook_1_path.to_s)
+                expect(Hooks::App).to receive(:new).with(hook_2_path.to_s)
+
+                result
+              end
+            end
+
+            it 'is a callbacks collection' do
+              expect(result).to be_a(Collection::Base)
+            end
+          end
+
+          describe '#all' do
+            let(:result) {collection.all}
+
+            before(:each) do
+              allow(Dir).
+                to receive(:[]).
+                with("#{deploy_hooks_path}/*").
+                and_return(hook_paths)
+            end
+
+            it 'is an Array' do
+              expect(result).to be_a(Array)
+            end
+
+            it 'contains all of the hooks detected at load time' do
+              hook_paths.each do |path|
+                expect(
+                  result.select {|h| h.path == Pathname(path)}.length
+                ).to eql(1)
+              end
+            end
+          end
+
+          describe '#matching' do
+            let(:name) {:hook_2}
+            let(:result) {collection.matching(name)}
+
+            before(:each) do
+              allow(Dir).
+                to receive(:[]).
+                with("#{deploy_hooks_path}/*").
+                and_return(hook_paths)
+            end
+
+            it 'is an Array' do
+              expect(result).to be_a(Array)
+            end
+
+            it 'contains hooks with the desired name' do
+              expect(
+                result.select {|h| h.path == Pathname(hook_2_path)}.length
+              ).to eql(1)
+            end
+
+            it 'omits hooks without the desired name' do
+              expect(
+                result.select {|h| h.path == Pathname(hook_1_path)}.length
+              ).to eql(0)
+            end
+
+            context "when a hook is represented by more than one format" do
+              let(:hook_1_path) {deploy_hooks_path.join('hook_2')}
+              let(:hook_2_path) {deploy_hooks_path.join('hook_2.rb')}
+
+              it 'contains the ruby hook' do
+                expect(
+                  result.select {|h| h.path == Pathname(hook_2_path)}.length
+                ).to eql(1)
+              end
+
+              it 'omits the other hooks' do
+                expect(
+                  result.select {|h| h.path == Pathname(hook_1_path)}.length
+                ).to eql(0)
+              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) {Object.new}
+            let(:result) {collection.distribute(runner, name)}
+
+            before(:each) do
+              allow(Dir).
+                to receive(:[]).
+                with("#{deploy_hooks_path}/*").
+                and_return(hook_paths)
+
+              allow(collection).
+                to receive(:matching).
+                with(name).
+                and_return(matched)
+
+              # Bypass Base#minimize_ruby
+              allow(collection).to receive(:minimize_ruby) {|matches|
+                matches
+              }
+
+              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
+          end
+        end
+
+      end
+    end
+  end
+end