engineyard-serverside 1.6.5 → 1.7.0.pre2

data/lib/engineyard-serverside.rb

@@ -26,6 +26,8 @@ require 'engineyard-serverside/cli'
 require 'engineyard-serverside/configuration'
 require 'engineyard-serverside/deprecation'
 require 'engineyard-serverside/future'
+require 'engineyard-serverside/shell'
+
 
 module EY
   module Serverside

data/lib/engineyard-serverside/cli.rb

@@ -1,5 +1,8 @@
 require 'thor'
 require 'pathname'
+require 'engineyard-serverside/deploy'
+require 'engineyard-serverside/shell'
+require 'engineyard-serverside/server'
 
 module EY
   module Serverside
@@ -22,6 +25,14 @@ module EY
                                       :desc     => "Application to deploy",
                                       :aliases  => ["-a"]
 
+      method_option :environment_name,:type     => :string,
+                                      :required => true,
+                                      :desc     => "Environment name"
+
+      method_option :account_name,    :type     => :string,
+                                      :required => true,
+                                      :desc     => "Account name"
+
       method_option :framework_env,   :type     => :string,
                                       :desc     => "Ruby web framework environment",
                                       :aliases  => ["-e"]
@@ -44,21 +55,13 @@ module EY
                                       :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
 
       method_option :verbose,         :type     => :boolean,
-                                      :default  => false,
                                       :desc     => "Verbose output",
                                       :aliases  => ["-v"]
 
       desc "deploy", "Deploy code from /data/<app>"
       def deploy(default_task=:deploy)
-        config = EY::Serverside::Deploy::Configuration.new(options)
-        load_servers(config)
-
-        EY::Serverside::LoggedOutput.verbose = options[:verbose]
-        EY::Serverside::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-deploy.log")
-
-        invoke :propagate
-
-        EY::Serverside::Deploy.new(config).send(default_task)
+        config, shell = init_and_propagate(options, 'deploy')
+        EY::Serverside::Deploy.new(config, shell).send(default_task)
       end
 
       method_option :app,           :type     => :string,
@@ -66,6 +69,14 @@ module EY
                                     :desc     => "Which application's hooks to run",
                                     :aliases  => ["-a"]
 
+      method_option :environment_name, :type     => :string,
+                                       :required => true,
+                                       :desc     => "Environment name"
+
+      method_option :account_name,  :type     => :string,
+                                    :required => true,
+                                    :desc     => "Account name"
+
       method_option :release_path,  :type     => :string,
                                     :desc     => "Value for #release_path in hooks (mostly for internal coordination)",
                                     :aliases  => ["-r"]
@@ -84,9 +95,14 @@ module EY
       method_option :current_name,  :type     => :string,
                                     :desc     => "Value for #current_name in hooks"
 
+      method_option :verbose,       :type     => :boolean,
+                                    :desc     => "Verbose output",
+                                    :aliases  => ["-v"]
+
       desc "hook [NAME]", "Run a particular deploy hook"
       def hook(hook_name)
-        EY::Serverside::DeployHook.new(options).run(hook_name)
+        config, shell = init(options, "hook-#{hook_name}")
+        EY::Serverside::DeployHook.new(config, shell).run(hook_name)
       end
 
 
@@ -95,6 +111,14 @@ module EY
                                       :desc     => "Application to deploy",
                                       :aliases  => ["-a"]
 
+      method_option :environment_name,:type     => :string,
+                                      :required => true,
+                                      :desc     => "Environment name"
+
+      method_option :account_name,    :type     => :string,
+                                      :required => true,
+                                      :desc     => "Account name"
+
       method_option :framework_env,   :type     => :string,
                                       :required => true,
                                       :desc     => "Ruby web framework environment",
@@ -115,13 +139,10 @@ module EY
                                       :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
 
       method_option :verbose,         :type     => :boolean,
-                                      :default  => false,
                                       :desc     => "Verbose output",
                                       :aliases  => ["-v"]
       desc "integrate", "Integrate other instances into this cluster"
       def integrate
-        EY::Serverside::LoggedOutput.verbose = options[:verbose]
-        EY::Serverside::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-integrate.log")
 
         app_dir = Pathname.new "/data/#{options[:app]}"
         current_app_dir = app_dir + "current"
@@ -133,26 +154,19 @@ module EY
         # we have to deploy the same SHA there as here
         integrate_options[:branch] = (current_app_dir + 'REVISION').read.strip
 
-        config = EY::Serverside::Deploy::Configuration.new(integrate_options)
-
-        # We have to rsync the entire app dir, so we need all the permissions to be correct!
-        system "sudo sh -l -c 'find #{app_dir} -not -user #{config.user} -or -not -group #{config.group} -exec chown #{config.user}:#{config.group} {} +'"
-
-        load_servers(config)
-
-        invoke :propagate
+        config, shell = init_and_propagate(integrate_options, 'integrate')
 
         EY::Serverside::Server.all.each do |server|
-          server.sync_directory app_dir
+          shell.logged_system server.sync_directory_command(app_dir)
           # we're just about to recreate this, so it has to be gone
           # first. otherwise, non-idempotent deploy hooks could screw
           # things up, and since we don't control deploy hooks, we must
           # assume the worst.
-          server.run("rm -rf #{current_app_dir}")
+          run_on_server(server,"rm -rf #{current_app_dir}")
         end
 
         # deploy local-ref to other instances into /data/$app/local-current
-        EY::Serverside::Deploy.new(config).cached_deploy
+        EY::Serverside::Deploy.new(config, shell).cached_deploy
       end
 
       method_option :app,             :type     => :string,
@@ -160,6 +174,14 @@ module EY
                                       :desc     => "Application to deploy",
                                       :aliases  => ["-a"]
 
+      method_option :environment_name,:type     => :string,
+                                      :required => true,
+                                      :desc     => "Environment name"
+
+      method_option :account_name,    :type     => :string,
+                                      :required => true,
+                                      :desc     => "Account name"
+
       method_option :stack,           :type     => :string,
                                       :desc     => "Web stack (so we can restart it correctly)"
 
@@ -175,20 +197,13 @@ module EY
                                       :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
 
       method_option :verbose,         :type     => :boolean,
-                                      :default  => false,
                                       :desc     => "Verbose output",
                                       :aliases  => ["-v"]
       desc "restart", "Restart app servers, conditionally enabling maintenance page"
       def restart
-        EY::Serverside::LoggedOutput.verbose = options[:verbose]
-        EY::Serverside::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-restart.log")
+        config, shell = init_and_propagate(options, 'restart')
 
-        config = EY::Serverside::Deploy::Configuration.new(options)
-        load_servers(config)
-
-        invoke :propagate
-
-        EY::Serverside::Deploy.new(config).restart_with_maintenance_page
+        EY::Serverside::Deploy.new(config, shell).restart_with_maintenance_page
       end
 
       desc "install_bundler [VERSION]", "Make sure VERSION of bundler is installed (in system ruby)"
@@ -206,8 +221,10 @@ module EY
         end
       end
 
-      desc "propagate", "Propagate the engineyard-serverside gem to the other instances in the cluster. This will install exactly version #{EY::Serverside::VERSION}."
-      def propagate
+      private
+
+      # Put the same engineyard-serverside on all the servers (Used to be public but is unused as an actual CLI command now)
+      def propagate(shell)
         config          = EY::Serverside::Deploy::Configuration.new
         gem_filename    = "engineyard-serverside-#{EY::Serverside::VERSION}.gem"
         local_gem_file  = File.join(Gem.dir, 'cache', gem_filename)
@@ -216,29 +233,47 @@ module EY
 
         servers = EY::Serverside::Server.all.find_all { |server| !server.local? }
 
-        futures = EY::Serverside::Future.call(servers) do |server|
+        commands = servers.each do |server|
           egrep_escaped_version = EY::Serverside::VERSION.gsub(/\./, '\.')
           # the [,)] is to stop us from looking for e.g. 0.5.1, seeing
           # 0.5.11, and mistakenly thinking 0.5.1 is there
           has_gem_cmd = "#{gem_binary} list engineyard-serverside | grep \"engineyard-serverside\" | egrep -q '#{egrep_escaped_version}[,)]'"
 
-          if !server.run(has_gem_cmd)  # doesn't have this exact version
-            puts "~> Installing engineyard-serverside on #{server.hostname}"
-
-            system(Escape.shell_command([
-              'scp', '-i', "#{ENV['HOME']}/.ssh/internal",
-              "-o", "StrictHostKeyChecking=no",
-              local_gem_file,
-             "#{config.user}@#{server.hostname}:#{remote_gem_file}",
-            ]))
-            server.run("sudo #{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'")
+          proc do
+            if !run_on_server(server,has_gem_cmd).success? # doesn't have this exact version
+              shell.status "Installing engineyard-serverside on #{server.hostname}"
+
+              shell.logged_system(Escape.shell_command([
+                'scp', '-i', "#{ENV['HOME']}/.ssh/internal",
+                "-o", "StrictHostKeyChecking=no",
+                local_gem_file,
+               "#{config.user}@#{server.hostname}:#{remote_gem_file}",
+              ]))
+              run_on_server(server,"sudo #{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'")
+            end
           end
         end
 
+        futures = EY::Serverside::Future.call(commands)
         EY::Serverside::Future.success?(futures)
       end
 
-      private
+      def init_and_propagate(*args)
+        config, shell = init(*args)
+        load_servers(config)
+        propagate(shell)
+        [config, shell]
+      end
+
+      def init(options, action)
+        config = EY::Serverside::Deploy::Configuration.new(options)
+        shell  = EY::Serverside::Shell.new(:verbose  => config.verbose, :log_path => File.join(ENV['HOME'], "#{config.app}-#{action}.log"))
+        [config, shell]
+      end
+
+      def run_on_server(server, command)
+        shell.logged_system(server.command_on_server('sh -l -c', command))
+      end
 
       def load_servers(config)
         EY::Serverside::Server.load_all_from_array(assemble_instance_hashes(config))

data/lib/engineyard-serverside/configuration.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'thor'
+require 'pp'
 
 module EY
   module Serverside
@@ -10,41 +11,54 @@ module EY
         "bundle_without" => "test development",
       })
 
-      attr_reader :configuration
-      alias :c :configuration
-
       attr_writer :release_path
 
       def initialize(options={})
-        opts = options.dup
-        @release_path = opts[:release_path]
+        opts = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+        @release_path = opts['release_path']
         config = JSON.parse(opts.delete("config") || "{}")
-        @configuration = DEFAULT_CONFIG.merge(config).merge(opts)
+        @configs = [config, opts] # low to high priority
+      end
+
+      def configuration
+        @configuration ||= @configs.inject(DEFAULT_CONFIG) {|low,high| low.merge(high)}
       end
+      alias :c :configuration # FIXME: awful, but someone is probably using it :(
 
       # Delegate to the configuration objects
       def method_missing(meth, *args, &blk)
-        c.key?(meth.to_s) ? c[meth.to_s] : super
+        configuration.key?(meth.to_s) ? configuration[meth.to_s] : super
       end
 
       def respond_to?(meth, include_private=false)
-        c.key?(meth.to_s) ? true : super
+        configuration.key?(meth.to_s) ? true : super
+      end
+
+      def load_ey_yml_data(data, shell)
+        environments = data['environments']
+        if environments && (env_data = environments[environment_name])
+          shell.substatus "ey.yml configuration loaded for environment #{environment_name.inspect}."
+          shell.debug "#{environment_name}: #{env_data.pretty_inspect}"
+          @configuration = nil # reset cached configuration hash
+          @configs.unshift(env_data) # insert just above default configuration
+          true
+        else
+          shell.info "No matching ey.yml configuration found for environment #{environment_name.inspect}."
+          shell.debug "ey.yml:\n#{data.pretty_inspect}"
+          false
+        end
       end
 
       def [](key)
         if respond_to?(key.to_sym)
           send(key.to_sym)
         else
-          c[key]
+          configuration[key]
         end
       end
 
       def has_key?(key)
-        if respond_to?(key.to_sym)
-          true
-        else
-          c.has_key?(key)
-        end
+        respond_to?(key.to_sym) || configuration.has_key?(key)
       end
 
       def to_json
@@ -55,9 +69,30 @@ module EY
         EY::Serverside.node
       end
 
+      def verbose
+        configuration['verbose']
+      end
+
       def app
         configuration['app'].to_s
       end
+      alias app_name app
+
+      def environment_name
+        configuration['environment_name'].to_s
+      end
+
+      def account_name
+        configuration['account_name'].to_s
+      end
+
+      def ssh_identity_file
+        "~/.ssh/#{c.app}-deploy-key"
+      end
+
+      def strategy_class
+        EY::Serverside::Strategies.const_get(strategy)
+      end
 
       def revision
         IO.read(File.join(latest_release, 'REVISION'))
@@ -95,6 +130,10 @@ module EY
         node['instance_role']
       end
 
+      def current_roles
+        configuration['current_roles'] || []
+      end
+
       def current_role
         current_roles.first
       end
@@ -116,10 +155,6 @@ module EY
         all_releases[index-1]
       end
 
-      def oldest_release
-        all_releases.first
-      end
-
       def all_releases
         Dir.glob("#{release_dir}/*").sort
       end
@@ -184,10 +219,42 @@ module EY
         @release_path ||= File.join(release_dir, Time.now.utc.strftime("%Y%m%d%H%M%S"))
       end
 
+      def precompile_assets?
+        configuration['precompile_assets'] == true
+      end
+
+      def skip_precompile_assets?
+        configuration['precompile_assets'] == false
+      end
+
+      def required_downtime_stack?
+        %w[ nginx_mongrel glassfish ].include? stack
+      end
+
+      def enable_maintenance_page_on_restart?
+        configuration.fetch('maintenance_on_restart', required_downtime_stack?)
+      end
+
+      def enable_maintenance_page_on_migrate?
+        configuration.fetch('maintenance_on_migrate', true)
+      end
+
+      def enable_maintenance_page?
+        enable_maintenance_page_on_restart? || (migrate? && enable_maintenance_page_on_migrate?)
+      end
+
+      def maintenance_page_enabled_path
+        File.join(shared_path, "system", "maintenance.html")
+      end
+
       def exclusions
         copy_exclude.map { |e| %|--exclude="#{e}"| }.join(' ')
       end
 
+      def ignore_database_adapter_warning?
+        configuration.fetch('ignore_database_adapter_warning', false)
+      end
+
     end
   end
 end

data/lib/engineyard-serverside/deploy.rb

@@ -7,22 +7,22 @@ require 'engineyard-serverside/rails_asset_support'
 module EY
   module Serverside
     class DeployBase < Task
-      include LoggedOutput
       include ::EY::Serverside::RailsAssetSupport
 
       # default task
       def deploy
-        debug "Starting deploy at #{Time.now.asctime}"
+        shell.status "Starting deploy at #{shell.start_time.asctime}"
         update_repository_cache
         cached_deploy
       end
 
       def cached_deploy
-        debug "Deploying app from cached copy at #{Time.now.asctime}"
+        shell.status "Deploying app from cached copy at #{Time.now.asctime}"
         require_custom_tasks
+        load_ey_yml
         push_code
 
-        info "~> Starting full deploy"
+        shell.status "Starting full deploy"
         copy_repository_cache
         check_repository
 
@@ -47,13 +47,25 @@ module EY
         disable_maintenance_page
 
         cleanup_old_releases
-        debug "Finished deploy at #{Time.now.asctime}"
+        shell.status "Finished deploy at #{Time.now.asctime}"
       rescue Exception
-        debug "Finished failing to deploy at #{Time.now.asctime}"
+        shell.status "Finished failing to deploy at #{Time.now.asctime}"
         puts_deploy_failure
         raise
       end
 
+      def update_repository_cache
+        strategy.update_repository_cache
+      end
+
+      def create_revision_file_command
+        strategy.create_revision_file_command(config.release_path)
+      end
+
+      def short_log_message(revision)
+        strategy.short_log_message(revision)
+      end
+
       def parse_configured_services
         result = YAML.load_file "#{c.shared_path}/config/ey_services_config_deploy.yml"
         return {} unless result.is_a?(Hash)
@@ -66,18 +78,18 @@ module EY
         if gemfile? && lockfile
           configured_services = parse_configured_services
           if !configured_services.empty? && !lockfile.has_ey_config?
-            warning "Gemfile.lock does not contain ey_config. Add it to get EY::Config access to: #{configured_services.keys.join(', ')}."
+            shell.warning "Gemfile.lock does not contain ey_config. Add it to get EY::Config access to: #{configured_services.keys.join(', ')}."
           end
         end
       end
 
       def check_repository
         if gemfile?
-          info "~> Gemfile found."
+          shell.status "Gemfile found."
           if lockfile
-            info "~> Gemfile.lock found."
-            unless lockfile.any_database_adapter?
-              warning <<-WARN
+            shell.status "Gemfile.lock found."
+            if !config.ignore_database_adapter_warning? && !lockfile.any_database_adapter?
+              shell.warning <<-WARN
 Gemfile.lock does not contain a recognized database adapter.
 A database-adapter gem such as mysql2, mysql, or do_mysql was expected.
 This can prevent applications that use MySQL or PostreSQL from booting.
@@ -87,7 +99,7 @@ Applications that don't use MySQL or PostgreSQL can safely ignore this warning.
               WARN
             end
           else
-            warning <<-WARN
+            shell.warning <<-WARN
 Gemfile.lock is missing!
 You can get different versions of gems in production than what you tested with.
 You can get different versions of gems on every deployment even if your Gemfile hasn't changed.
@@ -97,15 +109,13 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
             WARN
           end
         else
-          info "~> No Gemfile. Deploying without bundler support."
+          shell.status "No Gemfile. Deploying without bundler support."
         end
       end
 
       def restart_with_maintenance_page
         require_custom_tasks
-        conditionally_enable_maintenance_page
-        restart
-        disable_maintenance_page
+        with_maintenance_page { restart }
       end
 
       def enable_maintenance_page
@@ -119,10 +129,7 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
         end
 
         # this one is guaranteed to exist
-        maintenance_page_candidates <<  File.expand_path(
-          "default_maintenance_page.html",
-          File.dirname(__FILE__)
-          )
+        maintenance_page_candidates << File.expand_path("default_maintenance_page.html", File.dirname(__FILE__))
 
         # put in the maintenance page
         maintenance_file = maintenance_page_candidates.detect do |file|
@@ -131,27 +138,21 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
 
         @maintenance_up = true
         roles :app_master, :app, :solo do
-          maint_page_dir = File.join(c.shared_path, "system")
-          visible_maint_page = File.join(maint_page_dir, "maintenance.html")
-          run Escape.shell_command(['mkdir', '-p', maint_page_dir])
-          run Escape.shell_command(['cp', maintenance_file, visible_maint_page])
+          run Escape.shell_command(['mkdir', '-p', File.dirname(c.maintenance_page_enabled_path)])
+          run Escape.shell_command(['cp', maintenance_file, c.maintenance_page_enabled_path])
         end
       end
 
       def conditionally_enable_maintenance_page
-        if c.migrate? || required_downtime_stack?
+        if c.enable_maintenance_page?
           enable_maintenance_page
         end
       end
 
-      def required_downtime_stack?
-        %w[ nginx_mongrel glassfish ].include? c.stack
-      end
-
       def disable_maintenance_page
         @maintenance_up = false
         roles :app_master, :app, :solo do
-          run "rm -f #{File.join(c.shared_path, "system", "maintenance.html")}"
+          run "rm -f #{c.maintenance_page_enabled_path}"
         end
       end
 
@@ -163,17 +164,19 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
 
       # task
       def push_code
-        info "~> Pushing code to all servers"
-        futures = EY::Serverside::Future.call(EY::Serverside::Server.all) do |server|
-          server.sync_directory(config.repository_cache)
+        shell.status "Pushing code to all servers"
+        commands = EY::Serverside::Server.all.reject { |server| server.local? }.map do |server|
+          cmd = server.sync_directory_command(config.repository_cache)
+          proc { shell.logged_system(cmd) }
         end
+        futures = EY::Serverside::Future.call(commands)
         EY::Serverside::Future.success?(futures)
       end
 
       # task
       def restart
         @restart_failed = true
-        info "~> Restarting app servers"
+        shell.status "Restarting app servers"
         roles :app_master, :app, :solo do
           run(restart_command)
         end
@@ -189,14 +192,14 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
         %Q[export GIT_SSH="#{ssh_executable}" && export LANG="en_US.UTF-8" && unset RUBYOPT BUNDLE_PATH BUNDLE_FROZEN BUNDLE_WITHOUT BUNDLE_BIN BUNDLE_GEMFILE]
       end
 
-      # If we don't have a local version of the ssh wrapper script yet,
-      # create it on all the servers that will need it.
-      # TODO - This logic likely fails when people change deploy keys.
+      # create ssh wrapper on all servers
       def ssh_executable
-        roles :app_master, :app, :solo, :util do
-          run(generate_ssh_wrapper)
-        end
-        ssh_wrapper_path
+        @ssh_executable ||= begin
+                              roles :app_master, :app, :solo, :util do
+                                run(generate_ssh_wrapper)
+                              end
+                              ssh_wrapper_path
+                            end
       end
 
       # We specify 'IdentitiesOnly' to avoid failures on systems with > 5 private keys available.
@@ -206,15 +209,15 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
       # (Thanks Jim L.)
       def generate_ssh_wrapper
         path = ssh_wrapper_path
-        identity_file = "~/.ssh/#{c.app}-deploy-key"
-<<-WRAP
+        <<-SCRIPT
+mkdir -p #{File.dirname(path)}
 [[ -x #{path} ]] || cat > #{path} <<'SSH'
 #!/bin/sh
 unset SSH_AUTH_SOCK
-ssh -o CheckHostIP=no -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o LogLevel=INFO -o IdentityFile=#{identity_file} -o IdentitiesOnly=yes $*
+ssh -o CheckHostIP=no -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o LogLevel=INFO -o IdentityFile=#{c.ssh_identity_file} -o IdentitiesOnly=yes $*
 SSH
 chmod 0700 #{path}
-WRAP
+        SCRIPT
       end
 
       def ssh_wrapper_path
@@ -242,7 +245,7 @@ WRAP
       def clean_release_directory(dir, count = 3)
         @cleanup_failed = true
         ordinal = count.succ.to_s
-        info "~> Cleaning release directory: #{dir}"
+        shell.status "Cleaning release directory: #{dir}"
         sudo "ls -r #{dir} | tail -n +#{ordinal} | xargs -I@ rm -rf #{dir}/@"
         @cleanup_failed = false
       end
@@ -254,15 +257,15 @@ WRAP
           c.release_path = c.previous_release(rolled_back_release)
 
           revision = File.read(File.join(c.release_path, 'REVISION')).strip
-          info "~> Rolling back to previous release: #{short_log_message(revision)}"
+          shell.status "Rolling back to previous release: #{short_log_message(revision)}"
 
           run_with_callbacks(:symlink)
           sudo "rm -rf #{rolled_back_release}"
           bundle
-          info "~> Restarting with previous release."
+          shell.status "Restarting with previous release."
           with_maintenance_page { run_with_callbacks(:restart) }
         else
-          info "~> Already at oldest release, nothing to roll back to."
+          shell.status "Already at oldest release, nothing to roll back to."
           exit(1)
         end
       end
@@ -273,17 +276,17 @@ WRAP
         @migrations_reached = true
         roles :app_master, :solo do
           cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} #{c.migration_command}"
-          info "~> Migrating: #{cmd}"
+          shell.status "Migrating: #{cmd}"
           run(cmd)
         end
       end
 
       # task
       def copy_repository_cache
-        info "~> Copying to #{c.release_path}"
+        shell.status "Copying to #{c.release_path}"
         run("mkdir -p #{c.release_path} #{c.failed_release_dir} && rsync -aq #{c.exclusions} #{c.repository_cache}/ #{c.release_path}")
 
-        info "~> Ensuring proper ownership."
+        shell.status "Ensuring proper ownership."
         sudo("chown -R #{c.user}:#{c.group} #{c.deploy_to}")
       end
 
@@ -300,18 +303,18 @@ WRAP
       end
 
       def setup_services
-        info "~> Setting up external services."
+        shell.status "Setting up external services."
         previously_configured_services = parse_configured_services
         begin
           sudo(services_command_check)
         rescue StandardError => e
-          info "Could not setup services. Upgrade your environment to get services configuration."
+          shell.info "Could not setup services. Upgrade your environment to get services configuration."
           return
         end
         sudo(services_setup_command)
       rescue StandardError => e
         unless previously_configured_services.empty?
-          warning <<-WARNING
+          shell.warning <<-WARNING
 External services configuration not updated. Using previous version.
 Deploy again if your services configuration appears incomplete or out of date.
 #{e}
@@ -336,24 +339,24 @@ YML
 WRAP
            ["Symlink database.yml", "ln -nfs #{c.shared_path}/config/database.sqlite3.yml #{c.release_path}/config/database.yml"],
           ].each do |what, cmd|
-            info "~> #{what}"
+            shell.status "#{what}"
             run(cmd)
           end
 
           owner = [c.user, c.group].join(':')
-          info "~> Setting ownership to #{owner}"
+          shell.status "Setting ownership to #{owner}"
           sudo "chown -R #{owner} #{c.release_path}"
         end
       end
 
       def symlink_configs(release_to_link=c.release_path)
-        info "~> Preparing shared resources for release."
+        shell.status "Preparing shared resources for release."
         symlink_tasks(release_to_link).each do |what, cmd|
-          info "~> #{what}"
+          shell.substatus what
           run(cmd)
         end
         owner = [c.user, c.group].join(':')
-        info "~> Setting ownership to #{owner}"
+        shell.status "Setting ownership to #{owner}"
         sudo "chown -R #{owner} #{release_to_link}"
       end
 
@@ -376,7 +379,7 @@ WRAP
 
       # task
       def symlink(release_to_link=c.release_path)
-        info "~> Symlinking code."
+        shell.status "Symlinking code."
         run "rm -f #{c.current_path} && ln -nfs #{release_to_link} #{c.current_path} && chown -R #{c.user}:#{c.group} #{c.current_path}"
         @symlink_changed = true
       rescue Exception
@@ -388,12 +391,12 @@ WRAP
       def callback(what)
         @callbacks_reached ||= true
         if File.exist?("#{c.release_path}/deploy/#{what}.rb")
+          shell.status "Running deploy hook: deploy/#{what}.rb"
           run Escape.shell_command(base_callback_command_for(what)) do |server, cmd|
-            per_instance_args = [
-              '--current-roles', server.roles.join(' '),
-              '--config', c.to_json,
-            ]
-            per_instance_args << '--current-name' << server.name.to_s if server.name
+            per_instance_args = []
+            per_instance_args << '--current-roles' << server.roles.join(' ')
+            per_instance_args << '--current-name'  << server.name.to_s if server.name
+            per_instance_args << '--config'        << c.to_json
             cmd << " " << Escape.shell_command(per_instance_args)
           end
         end
@@ -401,8 +404,20 @@ WRAP
 
       protected
 
-      def starting_time
-        @starting_time ||= Time.now
+      # Use [] to access attributes instead of calling methods so
+      # that we get nils instead of NoMethodError.
+      #
+      # Rollback doesn't know about the repository location (nor
+      # should it need to), but it would like to use #short_log_message.
+      def strategy
+        ENV['GIT_SSH'] = ssh_executable
+        @strategy ||= config.strategy_class.new(
+          shell,
+          :repository_cache => config[:repository_cache],
+          :app              => config[:app],
+          :repo             => config[:repo],
+          :ref              => config[:branch]
+        )
       end
 
       def gemfile?
@@ -410,11 +425,14 @@ WRAP
       end
 
       def base_callback_command_for(what)
-        [serverside_bin, 'hook', what.to_s,
-          '--app', config.app,
-          '--release-path', config.release_path.to_s,
-          '--framework-env', c.environment.to_s,
-        ].compact
+        cmd =  [serverside_bin, 'hook', what.to_s]
+        cmd << '--app'              << config.app
+        cmd << '--environment-name' << config.environment_name
+        cmd << '--account-name'     << config.account_name
+        cmd << '--release-path'     << config.release_path.to_s
+        cmd << '--framework-env'    << config.environment.to_s
+        cmd << '--verbose' if config.verbose
+        cmd
       end
 
       def serverside_bin
@@ -424,21 +442,22 @@ WRAP
 
       def puts_deploy_failure
         if @cleanup_failed
-          info "~> [Relax] Your site is running new code, but clean up of old deploys failed."
+          shell.notice "[Relax] Your site is running new code, but clean up of old deploys failed."
         elsif @maintenance_up
-          info "~> [Attention] Maintenance page still up, consider the following before removing:"
-          info " * Deploy hooks ran. This might cause problems for reverting to old code." if @callbacks_reached
-          info " * Migrations ran. This might cause problems for reverting to old code." if @migrations_reached
+          message = "[Attention] Maintenance page still up, consider the following before removing:\n"
+          message << " * Deploy hooks ran. This might cause problems for reverting to old code.\n" if @callbacks_reached
+          message << " * Migrations ran. This might cause problems for reverting to old code.\n" if @migrations_reached
           if @symlink_changed
-            info " * Your new code is symlinked as current."
+            message << " * Your new code is symlinked as current.\n"
           else
-            info " * Your old code is still symlinked as current."
+            message << " * Your old code is still symlinked as current.\n"
           end
-          info " * Application servers failed to restart." if @restart_failed
-          info ""
-          info "~> Need help? File a ticket for support."
+          message << " * Application servers failed to restart.\n" if @restart_failed
+          message << "\n"
+          message << "Need help? File a ticket for support.\n"
+          shell.notice message
         else
-          info "~> [Relax] Your site is still running old code and nothing destructive has occurred."
+          shell.notice "[Relax] Your site is still running old code and nothing destructive has occurred."
         end
       end
 
@@ -451,7 +470,7 @@ WRAP
       def with_failed_release_cleanup
         yield
       rescue Exception
-        info "~> Release #{c.release_path} failed, saving release to #{c.failed_release_dir}."
+        shell.status "Release #{c.release_path} failed, saving release to #{c.failed_release_dir}."
         sudo "mv #{c.release_path} #{c.failed_release_dir}"
         raise
       end
@@ -484,7 +503,7 @@ WRAP
 
       def check_ruby_bundler
         if gemfile?
-          info "~> Bundling gems..."
+          shell.status "Bundling gems..."
 
           clean_bundle_on_system_version_change
 
@@ -515,18 +534,13 @@ WRAP
 
       def check_node_npm
         if File.exist?("#{c.release_path}/package.json")
-          info "~> package.json detected, installing npm packages"
+          shell.info "~> package.json detected, installing npm packages"
           run "cd #{c.release_path} && npm install"
         end
       end
     end   # DeployBase
 
     class Deploy < DeployBase
-      def self.new(config)
-        # include the correct fetch strategy
-        include EY::Serverside::Strategies.const_get(config.strategy)::Helpers
-        super
-      end
     end
   end
 end