engineyard-serverside 1.5.35.pre.2 → 1.6.0.pre

data/lib/engineyard-serverside/deploy_hook.rb

@@ -1,40 +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"
+            shell.status "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
+          @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)
@@ -48,19 +59,11 @@ module EY
         end
 
         def run(cmd)
-          system(Escape.shell_command(["sh", "-l", "-c", cmd]))
+          shell.logged_system(Escape.shell_command(["sh", "-l", "-c", cmd]))
         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]))
         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/lockfile_parser.rb

@@ -24,7 +24,7 @@ module EY
           @contents.index(/^\s+#{type}\s\([^\)]+\)$/)
         end
 
-        any_jruby_adapter = %w[mysql postgresql postgres].any? do |type|
+        any_jruby_adapter = %w[mysql postgresql].any? do |type|
           @contents.index(/^\s+jdbc-#{type}\s\([^\)]+\)$/) || @contents.index(/^\s+activerecord-jdbc#{type}-adapter\s\([^\)]+\)$/)
         end
 

data/lib/engineyard-serverside/rails_asset_support.rb

@@ -9,7 +9,7 @@ module EY
           keep_existing_assets
           cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} rake assets:precompile || true"
           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."
           end
@@ -22,24 +22,24 @@ module EY
         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 "app/assets/ found. Attempting Rails asset pre-compilation."
         else
           return false
         end
 
         if app_builds_own_assets?
-          info "~> public/assets already exists, skipping pre-compilation."
+          shell.status "public/assets already exists, skipping pre-compilation."
           return
         end
         if app_disables_assets?(app_rb_path)
-          info "~> application.rb has disabled asset compilation. Skipping."
+          shell.status "application.rb has disabled asset compilation. Skipping."
           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

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}'"
@@ -75,20 +72,20 @@ module EY
 
       def sync_directory(directory)
         return if local?
-        run "mkdir -p #{directory}"
-        logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{directory}/ #{user}@#{hostname}:#{directory}|)
+        yield remote_command("mkdir -p #{directory}")
+        yield Escap.shell_command(%w[rsync --delete -aq -e] + [ssh_command, "#{directory}/", "#{user}@#{hostname}:#{directory}"])
       end
 
       def run(command)
-        if local?
-          logged_system(command)
-        else
-          logged_system("#{ssh_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
 
       def ssh_command
-        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PasswordAuthentication=no"
+        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no "
       end
 
     end

data/lib/engineyard-serverside/shell.rb

@@ -0,0 +1,101 @@
+require 'logger'
+require 'pathname'
+require 'open4'
+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
+
+      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
+
+      # 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 command_stdout(msg)
+        debug msg.gsub(/^/,'     ')
+      end
+
+      def command_stderr(msg)
+        unknown msg.gsub(/^/,'     ')
+      end
+
+      def fatal(msg)   logger.fatal   msg end
+      def error(msg)   logger.error   msg end
+      def warning(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
+
+      # Return an IO that outputs to stdout or not according to the verbosity settings
+      # debug is hidden in non-verbose mode
+      def out
+        YieldIO.new { |msg| command_stdout(msg) }
+      end
+
+      # Return an IO that outputs to stderr
+      # unknown always shows, but without a severity title
+      def err
+        YieldIO.new { |msg| command_stderr(msg) }
+      end
+
+      def logged_system(cmd)
+        show_command(cmd)
+        spawn_process(cmd, out, err)
+      end
+
+      protected
+
+      # spawn_process is a separate utility method so tests can override just the meat
+      # of the process spawning and not couple the tests too tightly with the implementation.
+      # we do this because Open4 LOVES to segfault in CI. FUN!
+      def spawn_process(cmd, cmd_stdout, cmd_stderr)
+        # :quiet means don't raise an error on nonzero exit status
+        result = Open4.spawn cmd, 0 => '', 1 => cmd_stdout, 2 => cmd_stderr, :quiet => true
+        result.exitstatus == 0
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/shell/formatter.rb

@@ -0,0 +1,70 @@
+module EY
+  module Serverside
+    class Shell
+      class Formatter
+        def initialize(stdout, stderr, start_time, verbose)
+          @stdout, @stderr = stdout, stderr
+          @start = start_time.to_i
+          @verbose = verbose
+        end
+
+        def call(severity, time, _, message)
+          msg = build_message(severity, timestamp(time), message)
+          put_to_io(severity, msg)
+          msg
+        end
+
+        def build_message(severity, stamp, message)
+          if %w[WARN ERROR FATAL].include?(severity)
+            prepend("#{stamp}!> ", "#{severity_name(severity)}#{message}")
+          elsif severity == "INFO"
+            prepend(stamp, message)
+          else
+            prepend(' ' * stamp.size, message)
+          end
+        end
+
+        def prepend(pre, str)
+          str.gsub(/^/, pre).sub(/\n?\z/m,"\n")
+        end
+
+        def put_to_io(severity, msg)
+          if severity == "DEBUG"
+            if @verbose
+              @stdout << msg
+            end
+          elsif severity == "INFO"
+            # Need to differentiate info messages more when we're running in verbose mode
+            @stdout << (@verbose ? "\n\e[1m#{msg}\e[0m" : msg)
+            @stdout.flush
+          else
+            @stderr << msg
+            @stderr.flush
+          end
+        end
+
+        def timestamp(datetime)
+          diff = datetime.to_i - @start
+          diff = 0 if diff < 0
+          div, mod = diff.divmod(60)
+          if div.zero?
+            "+    %02ds  " % mod
+          else
+            "+%2dm %02ds  " % [div,mod]
+          end
+        end
+
+        def severity_name(severity)
+          if %w[INFO DEBUG ANY].include?(severity)
+            ""
+          elsif severity =='WARN'
+            "WARNING: "
+          else
+            "#{severity}: "
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/engineyard-serverside/shell/helpers.rb

@@ -0,0 +1,29 @@
+module EY
+  module Serverside
+    class Shell
+      # Compatibility with old LoggedOutput where the module was included into the class.
+      module Helpers
+        def verbose?
+          shell.verbose?
+        end
+
+        def warning(*a)
+          shell.warning(*a)
+        end
+
+        def info(*a)
+          shell.info(*a)
+        end
+
+        def debug(*a)
+          shell.debug(*a)
+        end
+
+        def logged_system(*a)
+          shell.logged_system(*a)
+        end
+      end
+    end
+  end
+end
+

data/lib/engineyard-serverside/strategies/git.rb

@@ -1,5 +1,3 @@
-require 'engineyard-serverside/logged_output'
-
 module EY
   module Serverside
     module Strategies
@@ -28,7 +26,7 @@ module EY
             #
             # Rollback doesn't know about the repository location (nor
             # should it need to), but it would like to use #short_log_message.
-            klass.new(
+            klass.new(shell,
               :repository_cache => c[:repository_cache],
               :app => c[:app],
               :repo => c[:repo],
@@ -37,11 +35,10 @@ module EY
           end
         end
 
-        include LoggedOutput
-
-        attr_reader :opts
+        attr_reader :shell, :opts
 
-        def initialize(opts)
+        def initialize(shell, opts)
+          @shell = shell
           @opts = opts
         end
 
@@ -51,21 +48,21 @@ module EY
 
         def fetch
           if usable_repository?
-            logged_system("#{git} fetch -q origin 2>&1")
+            shell.logged_system("#{git} fetch -q origin 2>&1")
           else
             FileUtils.rm_rf(opts[:repository_cache])
-            logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
+            shell.logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
           end
         end
 
         def checkout
-          info "~> Deploying revision #{short_log_message(to_checkout)}"
+          shell.status "Deploying revision #{short_log_message(to_checkout)}"
           in_git_work_tree do
-            (logged_system("git checkout -q '#{to_checkout}'") ||
-              logged_system("git reset -q --hard '#{to_checkout}'")) &&
-              logged_system("git submodule sync") &&
-              logged_system("git submodule update --init") &&
-              logged_system("git clean -dfq")
+            (shell.logged_system("git checkout -q '#{to_checkout}'") ||
+              shell.logged_system("git reset -q --hard '#{to_checkout}'")) &&
+              shell.logged_system("git submodule sync") &&
+              shell.logged_system("git submodule update --init") &&
+              shell.logged_system("git clean -dfq")
           end
         end