engineyard-serverside 1.6.5 → 1.7.0.pre2

data/lib/engineyard-serverside/deploy_hook.rb

@@ -1,41 +1,51 @@
+require 'engineyard-serverside/shell/helpers'
+
 module EY
   module Serverside
     class DeployHook < Task
-      def initialize(options)
-        super(EY::Serverside::Deploy::Configuration.new(options))
-      end
-
       def callback_context
-        @context ||= CallbackContext.new(config)
+        @context ||= CallbackContext.new(config, shell)
       end
 
       def run(hook)
         hook_path = "#{c.release_path}/deploy/#{hook}.rb"
         if File.exist?(hook_path)
           Dir.chdir(c.release_path) do
-            puts "~> running deploy hook: deploy/#{hook}.rb"
             if desc = syntax_error(hook_path)
               hook_name = File.basename(hook_path)
               abort "*** [Error] Invalid Ruby syntax in hook: #{hook_name} ***\n*** #{desc.chomp} ***"
             else
-              callback_context.instance_eval(IO.read(hook_path))
+              eval_hook(IO.read(hook_path))
             end
           end
         end
       end
 
+      def eval_hook(code)
+        callback_context.instance_eval(code)
+      end
+
       def syntax_error(file)
         output = `ruby -c #{file} 2>&1`
         output unless output =~ /Syntax OK/
       end
 
       class CallbackContext
-        def initialize(config)
+        include EY::Serverside::Shell::Helpers
+
+        attr_reader :shell
+
+        def initialize(config, shell)
           @configuration = config
           @configuration.set_framework_envs
+          @shell = shell
           @node = node
         end
 
+        def config
+          @configuration
+        end
+
         def method_missing(meth, *args, &blk)
           if @configuration.respond_to?(meth)
             @configuration.send(meth, *args, &blk)
@@ -44,24 +54,16 @@ module EY
           end
         end
 
-        def respond_to?(meth, include_private=false)
-          @configuration.respond_to?(meth, include_private) || super
+        def respond_to?(*a)
+          @configuration.respond_to?(*a) || super
         end
 
         def run(cmd)
-          system(Escape.shell_command(["sh", "-l", "-c", cmd]))
+          shell.logged_system(Escape.shell_command(["sh", "-l", "-c", cmd])).success?
         end
 
         def sudo(cmd)
-          system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd]))
-        end
-
-        def info(*args)
-          $stderr.puts *args
-        end
-
-        def debug(*args)
-          $stdout.puts *args
+          shell.logged_system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd])).success?
         end
 
         # convenience functions for running on certain instance types

data/lib/engineyard-serverside/deprecation.rb

@@ -1,26 +1,18 @@
+require 'engineyard-serverside/shell/helpers'
+
 module EY
   module Serverside
     def self.deprecation_warning(msg)
       $stderr.puts "DEPRECATION WARNING: #{msg}"
     end
-  end
 
-  def self.const_missing(const)
-    if EY::Serverside.const_defined?(const)
-      EY::Serverside.deprecation_warning("EY::#{const} has been deprecated. use EY::Serverside::#{const} instead")
-      EY::Serverside.class_eval(const.to_s)
-    else
-      super
+    def self.const_missing(const)
+      if const == :LoggedOutput
+        EY::Serverside.deprecation_warning("EY::Serverside::LoggedOutput has been deprecated. Use EY::Serverside::Shell::Helpers instead.")
+        EY::Serverside::Shell::Helpers
+      else
+        super
+      end
     end
   end
-
-  def self.node
-    EY::Serverside.deprecation_warning("EY.node has been deprecated. use EY::Serverside.node instead")
-    EY::Serverside.node
-  end
-
-  def self.dna_json
-    EY::Serverside.deprecation_warning("EY.dna_json has been deprecated. use EY::Serverside.dna_json instead")
-    EY::Serverside.dna_json
-  end
 end

data/lib/engineyard-serverside/future.rb

@@ -1,18 +1,24 @@
 module EY
   module Serverside
     class Future
+      def self.map(blocks)
+        blocks.map { |block| new(&block) }
+      end
+
       def self.success?(futures)
         futures.empty? || futures.all? {|f| f.success?}
       end
 
-      def initialize(server, *args, &block)
-        @server = server
-        @args = args
+      def initialize(&block)
         @block = block
       end
 
+      def result
+        @result ||= call
+      end
+
       def success?
-        @value == true
+        result.success?
       end
 
       def error?

data/lib/engineyard-serverside/futures/celluloid.rb

@@ -3,22 +3,12 @@ module EY
     $LOAD_PATH.unshift File.expand_path('../../vendor/celluloid/lib', File.dirname(__FILE__))
     require 'celluloid'
     class Future
-      def self.call(servers, *args, &block)
-        futures = servers.map do |server|
-          new(server, *args, &block)
-        end
-
-        futures.each {|f| f.call}
-        futures
-      end
-
-      def future
-        Celluloid::Future.new(@server, *@args, &@block)
+      def self.call(blocks)
+        map(blocks).each {|f| f.result }
       end
 
       def call
-        # Celluloid needs to call the block explicitely
-        @value ||= future.call
+        Celluloid::Future.new(&@block).call
       end
     end
   end

data/lib/engineyard-serverside/futures/dataflow.rb

@@ -6,25 +6,20 @@ module EY
     class Future
       extend Dataflow
 
-      def self.call(servers, *args, &block)
-        futures = []
-        # Dataflow needs to call `barrier` and `need_later` in the same object
-        barrier(*servers.map do |server|
-          future = new(server, *args, &block)
-          futures << future
+      def self.call(blocks)
+        futures = map(blocks)
 
-          need_later { future.call }
-        end)
+        # Dataflow needs to call `barrier` and `need_later` in the same object
+        need_laters = futures.map do |future|
+          need_later { future.result }
+        end
+        barrier(*need_laters)
 
         futures
       end
 
-      def future
-        @block.call(@server, *@args)
-      end
-
       def call
-        @value ||= future
+        @block.call
       end
     end
   end

data/lib/engineyard-serverside/lockfile_parser.rb

@@ -2,7 +2,7 @@ require 'yaml'
 module EY
   module Serverside
     class LockfileParser
-      DEFAULT = "1.0.21"
+      DEFAULT = "1.1.3"
 
       def self.default_version
         DEFAULT

data/lib/engineyard-serverside/rails_asset_support.rb

@@ -2,44 +2,60 @@ module EY
   module Serverside
     module RailsAssetSupport
       def compile_assets
-        asset_dir = "#{c.release_path}/app/assets"
         return unless app_needs_assets?
         rails_version = bundled_rails_version
         roles :app_master, :app, :solo do
           keep_existing_assets
-          cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} rake assets:precompile || true"
+          cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} rake assets:precompile"
+
+          unless config.precompile_assets?
+            # If specifically requested, then we want to fail if compilation fails.
+            # If we are implicitly precompiling, we want to fail non-destructively
+            # because we don't know if the rake task exists or if the user
+            # actually intended for assets to be compiled.
+            cmd << %{ || (echo "Asset compilation failure ignored.\n Add 'precompile_assets: true' to ey.yml to abort deploy on failure." && true)}
+          end
+
           if rails_version
-            info "~> Precompiling assets for rails v#{rails_version}"
+            shell.status "Precompiling assets for rails v#{rails_version}"
           else
-            warning "Precompiling assets even though Rails was not bundled."
+            shell.warning "Precompiling assets even though Rails was not bundled."
           end
           run(cmd)
         end
       end
 
       def app_needs_assets?
+        if config.precompile_assets?
+          shell.status "Attempting Rails asset precompilation. (enabled in config)"
+          return true
+        elsif config.skip_precompile_assets?
+          shell.status "Skipping asset precompilation. (disabled in config)"
+          return false
+        end
+
         app_rb_path = File.join(c.release_path, 'config', 'application.rb')
         return unless File.readable?(app_rb_path) # Not a Rails app in the first place.
 
         if File.directory?(File.join(c.release_path, 'app', 'assets'))
-          info "~> app/assets/ found. Attempting Rails asset pre-compilation."
+          shell.status "Attempting Rails asset precompilation. (found directory: 'app/assets')"
         else
           return false
         end
 
         if app_builds_own_assets?
-          info "~> public/assets already exists, skipping pre-compilation."
+          shell.status "Skipping asset compilation. (found directory: 'public/assets')"
           return
         end
         if app_disables_assets?(app_rb_path)
-          info "~> application.rb has disabled asset compilation. Skipping."
+          shell.status "Skipping asset compilation. (application.rb has disabled asset compilation)"
           return
         end
 # This check is very expensive, and has been deemed not worth the time.
 # Leaving this here in case someone comes up with a faster way.
 =begin
         unless app_has_asset_task?
-          info "~> No 'assets:precompile' Rake task found. Skipping."
+          shell.status "No 'assets:precompile' Rake task found. Skipping."
           return
         end
 =end
@@ -62,8 +78,7 @@ module EY
         # have the same code anyway.
         task_check = "PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} rake -T assets:precompile |grep 'assets:precompile'"
         cmd = "cd #{c.release_path} && #{task_check}"
-        logged_system "cd #{c.release_path} && #{task_check}"
-        $? == 0
+        shell.logged_system("cd #{c.release_path} && #{task_check}").success?
       end
 
       def app_builds_own_assets?
@@ -90,6 +105,7 @@ ln -nfs #{current} #{last_asset_path} #{c.release_path}/public
 
       def bundled_rails_version(lockfile_path = nil)
         lockfile_path ||= File.join(c.release_path, 'Gemfile.lock')
+        return unless File.exist?(lockfile_path)
         lockfile = File.open(lockfile_path) {|f| f.read}
         lockfile.each_line do |line|
           # scan for gemname (version) toplevel deps.

data/lib/engineyard-serverside/server.rb

@@ -1,11 +1,8 @@
 require 'open-uri'
-require 'engineyard-serverside/logged_output'
 
 module EY
   module Serverside
     class Server < Struct.new(:hostname, :roles, :name, :user)
-      include LoggedOutput
-
       class DuplicateHostname < StandardError
         def initialize(hostname)
           super "There is already an EY::Serverside::Server with hostname '#{hostname}'"
@@ -73,18 +70,26 @@ module EY
         hostname == 'localhost'
       end
 
-      def sync_directory(directory)
-        return if local?
-        run "mkdir -p #{directory}"
-        logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{directory}/ #{user}@#{hostname}:#{directory}|)
+      def sync_directory_command(directory)
+        return nil if local?
+        [
+          remote_command("mkdir -p #{directory}"),
+          Escape.shell_command(%w[rsync --delete -aq -e] + [ssh_command, "#{directory}/", "#{user}@#{hostname}:#{directory}"])
+        ].join(' && ')
+      end
+
+      def command_on_server(prefix, cmd, &block)
+        command = block ? block.call(self, cmd.dup) : cmd
+        command = "#{prefix} #{Escape.shell_command([command])}"
+        local? ? command : remote_command(command)
       end
 
       def run(command)
-        if local?
-          logged_system(command)
-        else
-          logged_system(ssh_command + " " + Escape.shell_command(["#{user}@#{hostname}", command]))
-        end
+        yield local? ? command : remote_command(command)
+      end
+
+      def remote_command(command)
+        ssh_command + Escape.shell_command(["#{user}@#{hostname}", command])
       end
 
       # Make a known hosts tempfile to absorb host fingerprints so we don't show

data/lib/engineyard-serverside/shell.rb

@@ -0,0 +1,98 @@
+require 'logger'
+require 'pathname'
+require 'systemu'
+require 'engineyard-serverside/shell/formatter'
+
+module EY
+  module Serverside
+    class Shell
+      class YieldIO
+        def initialize(&block)
+          @block = block
+        end
+        def <<(str)
+          @block.call str
+        end
+      end
+
+      class CommandResult < Struct.new(:command, :exitstatus, :output)
+        def success?
+          exitstatus.zero?
+        end
+
+        def inspect
+          <<-EOM
+$ #{command}
+#{output}
+
+# => #{exitstatus}
+          EOM
+        end
+      end
+
+      attr_reader :logger
+
+      def initialize(options)
+        @start_time = options[:start_time]
+        @verbose    = options[:verbose]
+
+
+        @stdout = options[:stdout] || $stdout
+        @stderr = options[:stderr] || $stderr
+
+        log_pathname = Pathname.new(options[:log_path])
+        log_pathname.unlink if log_pathname.exist? # start fresh
+        @logger = Logger.new(log_pathname.to_s)
+        @logger.level = Logger::DEBUG # Always log to the file at debug, formatter hides debug for non-verbose
+        @logger.formatter = EY::Serverside::Shell::Formatter.new(@stdout, @stderr, start_time, @verbose)
+      end
+
+      def start_time
+        @start_time ||= Time.now
+      end
+
+      # a nice info outputter that prepends spermy operators for some reason.
+      def status(msg)
+        info msg.gsub(/^/, '~> ')
+      end
+
+      def substatus(msg)
+        debug msg.gsub(/^/, ' ~ ')
+      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 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 show_command(cmd)
+        debug cmd.gsub(/^/, '   > ').sub(/>/, '$')
+      end
+
+      def logged_system(cmd)
+        show_command(cmd)
+        output = ""
+        outio = YieldIO.new { |msg| output << msg; debug   msg.gsub(/^/,'     ') }
+        errio = YieldIO.new { |msg| output << msg; unknown msg.gsub(/^/,'     ') }
+        result = spawn_process(cmd, outio, errio)
+        CommandResult.new(cmd, result.exitstatus, output)
+      end
+
+      protected
+
+      # This is the meat of process spawning. It's nice to keep it separate even
+      # though it's simple because we've had to modify it frequently.
+      def spawn_process(cmd, outio, errio)
+        systemu cmd, 'stdout' => outio, 'stderr' => errio
+      end
+    end
+  end
+end