engineyard-serverside 1.5.28.pre.timestamps4 → 1.5.28

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
-            shell.status "Precompiling assets for rails v#{rails_version}"
+            info "~> 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'))
-          shell.status "app/assets/ found. Attempting Rails asset pre-compilation."
+          info "~> app/assets/ found. Attempting Rails asset pre-compilation."
         else
           return false
         end
 
         if app_builds_own_assets?
-          shell.status "public/assets already exists, skipping pre-compilation."
+          info "~> public/assets already exists, skipping pre-compilation."
           return
         end
         if app_disables_assets?(app_rb_path)
-          shell.status "application.rb has disabled asset compilation. Skipping."
+          info "~> 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?
-          shell.status "No 'assets:precompile' Rake task found. Skipping."
+          info "~> No 'assets:precompile' Rake task found. Skipping."
           return
         end
 =end

data/lib/engineyard-serverside/server.rb

@@ -1,8 +1,11 @@
 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}'"
@@ -70,22 +73,22 @@ module EY
         hostname == 'localhost'
       end
 
-      def sync_directory(directory, &block)
+      def sync_directory(directory)
         return if local?
-        yield remote_command("mkdir -p #{directory}")
-        yield Escap.shell_command(%w[rsync --delete -aq -e] + [ssh_command, "#{directory}/", "#{user}@#{hostname}:#{directory}"])
+        run "mkdir -p #{directory}"
+        logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{directory}/ #{user}@#{hostname}:#{directory}|)
       end
 
       def run(command)
-        yield local? ? command : remote_command(command)
-      end
-
-      def remote_command(command)
-        ssh_command + Escape.shell_command(["#{user}@#{hostname}", command])
+        if local?
+          logged_system(command)
+        else
+          logged_system(ssh_command + " " + Escape.shell_command(["#{user}@#{hostname}", command]))
+        end
       end
 
       def ssh_command
-        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no "
+        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no"
       end
 
     end

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

@@ -1,3 +1,5 @@
+require 'engineyard-serverside/logged_output'
+
 module EY
   module Serverside
     module Strategies
@@ -26,7 +28,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(shell,
+            klass.new(
               :repository_cache => c[:repository_cache],
               :app => c[:app],
               :repo => c[:repo],
@@ -35,10 +37,11 @@ module EY
           end
         end
 
-        attr_reader :shell, :opts
+        include LoggedOutput
+
+        attr_reader :opts
 
-        def initialize(shell, opts)
-          @shell = shell
+        def initialize(opts)
           @opts = opts
         end
 
@@ -48,21 +51,21 @@ module EY
 
         def fetch
           if usable_repository?
-            shell.logged_system("#{git} fetch -q origin 2>&1")
+            logged_system("#{git} fetch -q origin 2>&1")
           else
             FileUtils.rm_rf(opts[:repository_cache])
-            shell.logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
+            logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
           end
         end
 
         def checkout
-          shell.status "Deploying revision #{short_log_message(to_checkout)}"
+          info "~> Deploying revision #{short_log_message(to_checkout)}"
           in_git_work_tree do
-            (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")
+            (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")
           end
         end
 

data/lib/engineyard-serverside/task.rb

@@ -1,16 +1,12 @@
-require 'engineyard-serverside/shell'
-
 module EY
   module Serverside
     class Task
-      include EY::Serverside::Shell::Helpers
 
-      attr_reader :config, :shell
+      attr_reader :config
       alias :c :config
 
-      def initialize(conf, shell = nil)
+      def initialize(conf)
         @config = conf
-        @shell = shell
         @roles = :all
       end
 
@@ -22,7 +18,7 @@ module EY
         end
 
         if deploy_file
-          shell.status "Loading deployment task overrides from #{deploy_file}"
+          puts "~> Loading deployment task overrides from #{deploy_file}"
           instance_eval(File.read(deploy_file))
           true
         else
@@ -58,7 +54,7 @@ module EY
         servers = EY::Serverside::Server.from_roles(@roles)
         futures = EY::Serverside::Future.call(servers, block_given?) do |server, exec_block|
           to_run = exec_block ? block.call(server, cmd.dup) : cmd
-          server.run(Escape.shell_command(wrapper + [to_run])) { |cmd| shell.logged_system(cmd) }
+          server.run(Escape.shell_command(wrapper + [to_run]))
         end
 
         unless EY::Serverside::Future.success?(futures)

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '1.5.28.pre.timestamps4'
+    VERSION = '1.5.28'
   end
 end

data/lib/vendor/open4/lib/open4.rb

@@ -4,23 +4,65 @@ require 'timeout'
 require 'thread'
 
 module Open4
-#--{{{
-  VERSION = '1.1.0'
+  VERSION = '1.3.0'
   def self.version() VERSION end
 
   class Error < ::StandardError; end
 
+  def pfork4(fun, &b)
+    Open4.do_popen(b, :block) do |ps_read, _|
+      ps_read.close
+      begin
+        fun.call
+      rescue SystemExit => e
+        # Make it seem to the caller that calling Kernel#exit in +fun+ kills
+        # the child process normally. Kernel#exit! bypasses this rescue
+        # block.
+        exit! e.status
+      else
+        exit! 0
+      end
+    end
+  end
+  module_function :pfork4
+
   def popen4(*cmd, &b)
-#--{{{
+    Open4.do_popen(b, :init) do |ps_read, ps_write|
+      ps_read.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      ps_write.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      exec(*cmd)
+      raise 'forty-two'   # Is this really needed?
+    end
+  end
+  alias open4 popen4
+  module_function :popen4
+  module_function :open4
+
+  def popen4ext(closefds=false, *cmd, &b)
+    Open4.do_popen(b, :init, closefds) do |ps_read, ps_write|
+      ps_read.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      ps_write.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      exec(*cmd)
+      raise 'forty-two'   # Is this really needed?
+    end
+  end
+  module_function :popen4ext
+
+  def self.do_popen(b = nil, exception_propagation_at = nil, closefds=false, &cmd)
     pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
 
     verbose = $VERBOSE
     begin
       $VERBOSE = nil
-      ps.first.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
       cid = fork {
+        if closefds
+          exlist = [0, 1, 2] | [pw,pr,pe,ps].map{|p| [p.first.fileno, p.last.fileno] }.flatten
+          ObjectSpace.each_object(IO){|io|
+            io.close if (not io.closed?) and (not exlist.include? io.fileno)
+          }
+        end
+
         pw.last.close
         STDIN.reopen pw.first
         pw.first.close
@@ -36,52 +78,59 @@ module Open4
         STDOUT.sync = STDERR.sync = true
 
         begin
-          exec(*cmd)
-          raise 'forty-two' 
+          cmd.call(ps)
         rescue Exception => e
           Marshal.dump(e, ps.last)
           ps.last.flush
+        ensure
+          ps.last.close unless ps.last.closed?
         end
-        ps.last.close unless (ps.last.closed?)
+
         exit!
       }
     ensure
       $VERBOSE = verbose
     end
 
-    [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
+    [ pw.first, pr.last, pe.last, ps.last ].each { |fd| fd.close }
 
-    begin
-      e = Marshal.load ps.first
-      raise(Exception === e ? e : "unknown failure!")
-    rescue EOFError # If we get an EOF error, then the exec was successful
-      42
-    ensure
-      ps.first.close
-    end
+    Open4.propagate_exception cid, ps.first if exception_propagation_at == :init
 
     pw.last.sync = true
 
-    pi = [pw.last, pr.first, pe.first]
+    pi = [ pw.last, pr.first, pe.first ]
+
+    begin
+      return [cid, *pi] unless b
 
-    if b 
       begin
-        b[cid, *pi]
-        Process.waitpid2(cid).last
+        b.call(cid, *pi)
       ensure
-        pi.each{|fd| fd.close unless fd.closed?}
+        pi.each { |fd| fd.close unless fd.closed? }
       end
-    else
-      [cid, pw.last, pr.first, pe.first]
+
+      Open4.propagate_exception cid, ps.first if exception_propagation_at == :block
+
+      Process.waitpid2(cid).last
+    ensure
+      ps.first.close unless ps.first.closed?
     end
-#--}}}
   end
-  alias open4 popen4
-  module_function :popen4
-  module_function :open4
+
+  def self.propagate_exception(cid, ps_read)
+    e = Marshal.load ps_read
+    raise Exception === e ? e : "unknown failure!"
+  rescue EOFError
+    # Child process did not raise exception.
+  rescue
+    # Child process raised exception; wait it in order to avoid a zombie.
+    Process.waitpid2 cid
+    raise
+  ensure
+    ps_read.close
+  end
 
   class SpawnError < Error
-#--{{{
     attr 'cmd'
     attr 'status'
     attr 'signals'
@@ -98,11 +147,9 @@ module Open4
       sigs = @signals.map{|k,v| "#{ k }:#{ v.inspect }"}.join(' ')
       super "cmd <#{ cmd }> failed with status <#{ exitstatus.inspect }> signals <#{ sigs }>"
     end
-#--}}}
   end
 
   class ThreadEnsemble
-#--{{{
     attr 'threads'
 
     def initialize cid
@@ -154,18 +201,14 @@ module Open4
     def all_done
       @threads.size.times{ @done.pop }
     end
-#--}}}
   end
 
   def to timeout = nil
-#--{{{
     Timeout.timeout(timeout){ yield }
-#--}}}
   end
   module_function :to
 
   def new_thread *a, &b
-#--{{{
     cur = Thread.current
     Thread.new(*a) do |*a|
       begin
@@ -174,29 +217,25 @@ module Open4
         cur.raise e
       end
     end
-#--}}}
   end
   module_function :new_thread
 
   def getopts opts = {}
-#--{{{
     lambda do |*args|
       keys, default, ignored = args
-      catch('opt') do
+      catch(:opt) do
         [keys].flatten.each do |key|
           [key, key.to_s, key.to_s.intern].each do |key|
-            throw 'opt', opts[key] if opts.has_key?(key)
+            throw :opt, opts[key] if opts.has_key?(key)
           end
         end
         default
       end
     end
-#--}}}
   end
   module_function :getopts
 
   def relay src, dst = nil, t = nil
-#--{{{
     send_dst =
       if dst.respond_to?(:call)
         lambda{|buf| dst.call(buf)}
@@ -244,12 +283,10 @@ module Open4
         send_dst[buf]
       end
     end
-#--}}}
   end
   module_function :relay
 
   def spawn arg, *argv 
-#--{{{
     argv.unshift(arg)
     opts = ((argv.size > 1 and Hash === argv.last) ? argv.pop : {})
     argv.flatten!
@@ -325,7 +362,6 @@ module Open4
       (ignore_exit_failure or (status.nil? and ignore_exec_failure) or exitstatus.include?(status.exitstatus))
 
     status
-#--}}}
   end
   module_function :spawn
 
@@ -336,7 +372,6 @@ module Open4
   module_function :chdir
 
   def background arg, *argv 
-#--{{{
     require 'thread'
     q = Queue.new
     opts = { 'pid' => q, :pid => q }
@@ -354,14 +389,12 @@ module Open4
       define_method(:exitstatus){ @exitstatus ||= spawn_status.exitstatus }
     }
     thread
-#--}}}
   end
   alias bg background
   module_function :background
   module_function :bg
 
   def maim pid, opts = {}
-#--{{{
     getopt = getopts opts
     sigs = getopt[ 'signals', %w(SIGTERM SIGQUIT SIGKILL) ]
     suspend = getopt[ 'suspend', 4 ]
@@ -379,12 +412,10 @@ module Open4
       return true unless alive? pid
     end
     return(not alive?(pid)) 
-#--}}}
   end
   module_function :maim
 
   def alive pid
-#--{{{
     pid = Integer pid
     begin
       Process.kill 0, pid
@@ -392,12 +423,10 @@ module Open4
     rescue Errno::ESRCH
       false
     end
-#--}}}
   end
   alias alive? alive
   module_function :alive
   module_function :'alive?'
-#--}}}
 end
 
 def open4(*cmd, &b) cmd.size == 0 ? Open4 : Open4::popen4(*cmd, &b) end