engineyard-serverside 2.7.8pre2 → 2.8.0.pre

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

@@ -0,0 +1,66 @@
+require 'railway'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Distributor
+
+        class ViabilityFilter
+          include Railway
+
+          step :normalize_input
+          step :check_ruby_candidates
+          step :check_executable_candidates
+          step :calculate_callback_name
+
+          def normalize_input(input = {})
+            input[:viable] = []
+
+            unless input[:candidates].respond_to?(:each)
+              input[:candidates] = [input[:candidates]]
+            end
+
+            Success(input)
+          end
+
+          def check_ruby_candidates(input = {})
+            hooks = input[:candidates].
+              select {|hook| hook.flavor == :ruby}
+
+            hooks.each do |hook|
+              input[:viable].push(hook)
+            end
+
+            Success(input)
+          end
+
+          def check_executable_candidates(input = {})
+            hooks = input[:candidates].
+              select {|hook| hook.flavor == :executable}
+
+            hooks.each do |hook|
+              if hook.path.executable?
+                input[:viable].push(hook)
+              else
+                input[:shell].warning(
+                  "Skipping possible deploy hook #{hook} because it is not executable."
+                )
+              end
+            end
+
+            Success(input)
+          end
+
+          def calculate_callback_name(input = {})
+            if input[:viable].empty?
+              return Failure(input.merge({:reason => :no_viable_hooks}))
+            end
+
+            Success(input[:viable].first.callback_name)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'engineyard-serverside/callbacks/executor/executable'
+require 'engineyard-serverside/callbacks/executor/ruby'
+
+module EY
+  module Serverside
+    module Callbacks
+
+      module Executor
+        FLAVORS = {
+          :ruby => Ruby,
+          :executable => Executable
+        }
+
+        def self.execute(config, shell, hooks)
+          hooks.each do |hook|
+            FLAVORS[hook.flavor].execute(config, shell, hook)
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'railway'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+
+        class Base
+          include Railway
+
+          attr_reader :config, :shell, :hook
+
+          def self.execute(config, shell, hook)
+            new(config, shell, hook).execute
+          end
+
+          def initialize(config, shell, hook)
+            @config = config
+            @shell = shell
+            @hook = hook
+          end
+
+          def execute
+            call.or_else {|payload| handle_failure(payload)}
+          end
+
+          def handle_failure(payload = {})
+            raise "Unimplemented Hook Executor!"
+          end
+
+          def paths
+            config.paths
+          end
+
+          def hook_path
+            hook.path
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'escape'
+require 'runner'
+require 'engineyard-serverside/callbacks/executor/base'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+
+        class Executable < Base
+          include Runner
+
+          step :validate_hook
+          step :populate_environment
+          step :calculate_wrapper
+          step :run_hook
+
+          def handle_failure(payload = {})
+            case payload[:reason]
+
+            when :not_executable
+              true
+            when :execution_failed
+              abort "*** [Error] Hook failed to exit cleanly: #{hook_path} ***\n"
+            else
+              abort "*** [Error] An unknown error occurred for hook: #{hook_path} ***\n"
+            end
+          end
+
+          def validate_hook(input = {})
+            unless hook_path.executable?
+              return Failure(
+                input.merge(
+                  {
+                    :reason => :not_executable
+                  }
+                )
+              )
+            end
+
+            Success(input)
+          end
+
+          def calculate_wrapper(input = {})
+            Success(
+              input.merge(
+                {
+                  :wrapper => hook.respond_to?(:service_name) ?
+                    About.service_hook_executor :
+                    About.hook_executor
+                }
+              )
+            )
+          end
+
+          def run_hook(input = {})
+            env = "#{input[:environment]} #{config.framework_envs}"
+            wrapper = input[:wrapper]
+            name = hook.short_name
+
+            result = run("#{env} #{wrapper} #{name}")
+
+            unless result.success?
+              return Failure(
+                input.merge(
+                  {
+                    :reason => :execution_failed
+                  }
+                )
+              )
+            end
+
+            Success(input)
+          end
+
+          def populate_environment(input = {})
+            env = {
+              'EY_DEPLOY_ACCOUNT_NAME' => config.account_name,
+              'EY_DEPLOY_APP' => config.app,
+              'EY_DEPLOY_CONFIG' => config.to_json,
+              'EY_DEPLOY_CURRENT_ROLES' => current_roles,
+              'EY_DEPLOY_CURRENT_NAME' => current_name,
+              'EY_DEPLOY_ENVIRONMENT_NAME' => config.environment_name,
+              'EY_DEPLOY_FRAMEWORK_ENV' => config.framework_env.to_s,
+              'EY_DEPLOY_RELEASE_PATH' => paths.active_release.to_s,
+              'EY_DEPLOY_VERBOSE' => verbose,
+            }
+
+            Success(
+              input.merge(
+                {
+                  :environment => env.
+                    reject {|name, value| value.nil?}.
+                    map {|name, value| "#{name}=#{Escape.shell_command([value])}"}.
+                    join(' ')
+                }
+              )
+            )
+          end
+
+          def verbose
+            config.verbose ? '1' : '0'
+          end
+
+          def current_roles
+            config.current_roles.to_a.join(' ')
+          end
+
+          def current_name
+            name = config.current_name
+
+            unless name
+              return nil
+            end
+
+            name.to_s
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'rbconfig'
+require 'railway'
+
+require 'engineyard-serverside/callbacks/executor/ruby/executor'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+
+        module Ruby
+          def self.execute(config, shell, hook)
+            Executor.execute(config, shell,hook)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/callbacks/executor/ruby/context.rb

@@ -0,0 +1,81 @@
+require 'engineyard-serverside/shell/helpers'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+        module Ruby
+
+          class Context
+            include EY::Serverside::Shell::Helpers
+
+            attr_reader :configuration, :shell, :hook
+
+            def initialize(config, shell, hook)
+              @configuration = config
+              @configuration.set_framework_envs
+              @shell = shell
+              @node = config.node
+              @hook = hook
+            end
+
+            def config
+              @configuration
+            end
+
+            def inspect
+              "#<Callbacks::Executor::Ruby::Context #{hook.path.inspect}>"
+            end
+
+            def method_missing(meth, *args, &blk)
+              if config.respond_to?(meth)
+                shell.warning "Use of `#{meth}` (via method_missing) is deprecated in favor of `config.#{meth}` for improved error messages and compatibility.\n\tin #{hook.path}"
+                config.send(meth, *args, &blk)
+              else
+                super
+              end
+            end
+
+            def respond_to?(*a)
+              config.respond_to?(*a) || super
+            end
+
+            def run(cmd)
+              shell.logged_system(Escape.shell_command(["sh", "-l", "-c", cmd])).success?
+            end
+
+            def run!(cmd)
+              run(cmd) or raise("run!: Command failed. #{cmd}")
+            end
+
+            def sudo(cmd)
+              shell.logged_system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd])).success?
+            end
+
+            def sudo!(cmd)
+              sudo(cmd) or raise("sudo!: Command failed. #{cmd}")
+            end
+
+            # convenience functions for running on certain instance types
+            def on_app_master(&blk)                 on_roles(%w[solo app_master],          &blk) end
+            def on_app_servers(&blk)                on_roles(%w[solo app_master app],      &blk) end
+            def on_app_servers_and_utilities(&blk)  on_roles(%w[solo app_master app util], &blk) end
+
+            def on_utilities(*names, &blk)
+              names.flatten!
+              on_roles(%w[util]) do
+                blk.call if names.empty? || names.include?(config.current_name)
+              end
+            end
+
+            private
+            def on_roles(desired_roles)
+              yield if desired_roles.any? { |role| config.current_roles.include?(role) }
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+require 'rbconfig'
+require 'railway'
+require 'engineyard-serverside/callbacks/executor/base'
+require 'engineyard-serverside/callbacks/executor/ruby/context'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+        module Ruby
+
+          # An executor for Ruby hooks
+          class  Executor < Base
+            step :validate_hook
+            step :display_deprecation_warnings
+            step :announce_execution
+            step :context_eval
+
+            def handle_failure(payload = {})
+              case payload[:reason]
+
+              # We tried to execute the hook, but doing so raised an exception.
+              # So, let us tell you all about that and propagate the error to
+              # the caller.
+              when :execution_failed
+                exception = payload[:exception]
+                display_hook_error(exception)
+                raise exception
+
+              # A syntax error was detected in the hook, so rather than trying
+              # to run it, we bail with some information for the user.
+              when :syntax_error
+                abort "*** [Error] Invalid Ruby syntax in hook: #{hook_path} ***\n*** #{payload[:syntax_error]} ***"
+
+              # Something most out of the ordinary happened, to the point that
+              # we don't know how to handle it. That being the case, we're going
+              # to just flat out bail.
+              else
+                abort "*** [Error] An unknown error occurred for hook: #{hook_path} ***"
+              end
+            end
+
+            def display_deprecation_warnings(input = {})
+              code = input[:code]
+
+              if code =~ /@configuration/
+                shell.warning("Use of `@configuration` in deploy hooks is deprecated.\nPlease use `config`, which provides access to the same object.\n\tin #{hook_path}")
+              end
+
+              if code =~ /@node/
+                shell.warning("Use of `@node` in deploy hooks is deprecated.\nPlease use `config.node`, which provides access to the same object.\n\tin #{hook_path}")
+              end
+
+              Success(input)
+            end
+
+            def announce_execution(input = {})
+              shell.info "Executing #{hook.path} ..."
+              Success(input)
+            end
+
+            def context_eval(input = {})
+              Dir.chdir(paths.active_release.to_s) do
+                begin
+                  Context.new(config, shell, hook).instance_eval(input[:code])
+                rescue Exception => exception
+                  return Failure(
+                    input.merge(
+                      {
+                        :reason => :execution_failed,
+                        :exception => exception
+                      }
+                    )
+                  )
+                end
+              end
+
+              Success(input)
+            end
+
+            def validate_hook(input = {})
+              output = `#{ruby_bin} -c #{hook_path} 2>&1`
+              unless output =~ /Syntax OK/
+                return Failure(
+                  input.merge(
+                    {
+                      :reason => :syntax_error,
+                      :syntax_error => output
+                    }
+                  )
+                )
+              end
+
+              Success(input.merge({:code => hook.read}))
+            end
+
+            def ruby_bin
+              # Ideally, we'd use RbConfig.ruby, but that doesn't work on 1.8.7
+              File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+            end
+
+            def display_hook_error(exception)
+              shell.fatal <<-ERROR
+  Exception raised in hook #{hook_path}.
+
+  #{exception.class}: #{exception.to_s}
+
+  Please fix this error before retrying.
+              ERROR
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end