r10k 1.4.2 → 1.5.1

data/lib/r10k/source/svn.rb

@@ -1,7 +1,6 @@
 require 'r10k/svn'
 require 'r10k/environment'
-require 'r10k/util/purgeable'
-require 'r10k/util/core_ext/hash_ext'
+require 'r10k/environment/name'
 require 'r10k/util/setopts'
 
 # This class implements a source for SVN environments.
@@ -79,10 +78,9 @@ class R10K::Source::SVN < R10K::Source::Base
   # @return [Array<R10K::Environment::SVN>] An array of environments created
   #   from this source.
   def generate_environments
-
-    branch_names.map do |branch|
+    names_and_paths.map do |(branch, path)|
       options = {
-        :remote   => branch.remote,
+        :remote   => path,
         :username => @username,
         :password => @password
       }
@@ -90,20 +88,8 @@ class R10K::Source::SVN < R10K::Source::Base
     end
   end
 
-  include R10K::Util::Purgeable
-
-  def managed_directory
-    @basedir
-  end
-
-  def current_contents
-    Dir.glob(File.join(@basedir, '*')).map do |fname|
-      File.basename fname
-    end
-  end
-
   # List all environments that should exist in the basedir for this source
-  # @note This implements a required method for the Purgeable mixin
+  # @note This is required by {R10K::Util::Basedir}
   # @return [Array<String>]
   def desired_contents
     @environments.map {|env| env.dirname }
@@ -113,46 +99,16 @@ class R10K::Source::SVN < R10K::Source::Base
 
   private
 
-  def branch_names
+  def names_and_paths
     branches = []
 
-    branch_opts = {
-      :prefix     => @prefix,
-      :sourcename => @name,
-    }
+    opts = {:prefix => @prefix, :correct => false, :validate => false, :source => @name}
 
-    branches << BranchName.new('production', "#{@remote}/trunk", branch_opts)
+    branches << [R10K::Environment::Name.new('production', opts), "#{@remote}/trunk"]
     @svn_remote.branches.each do |branch|
-      branches << BranchName.new(branch, "#{@remote}/branches/#{branch}", branch_opts)
+      branches << [R10K::Environment::Name.new(branch, opts), "#{@remote}/branches/#{branch}"]
     end
 
     branches
   end
-
-  # @api private
-  # @todo respect environment name corrections
-  class BranchName
-
-    attr_reader :name
-    attr_reader :remote
-
-    def initialize(name, remote, opts)
-      @name   = name
-      @remote = remote
-      @opts   = opts
-
-      @prefix = opts[:prefix]
-      @sourcename = opts[:sourcename]
-    end
-
-    def dirname
-      dir = @name.dup
-
-      if @prefix
-        dir = "#{@sourcename}_#{dir}"
-      end
-
-      dir
-    end
-  end
 end

data/lib/r10k/util/basedir.rb

@@ -28,10 +28,10 @@ module R10K
       end
 
       # @param path [String] The path to the directory to manage
-      # @param sources [Array<R10K::Util::Purgeable>] A list of purgeable objects
+      # @param sources [Array<#desired_contents>] A list of objects that may create filesystem entries
       def initialize(path, sources)
         if sources.is_a? R10K::Deployment
-          raise ArgumentError, "Expected Array<Purgeable>, got R10K::Deployment"
+          raise ArgumentError, "Expected Array<#desired_contents>, got R10K::Deployment"
         end
         @path    = path
         @sources = sources
@@ -53,10 +53,10 @@ module R10K
 
       def purge!
         @sources.each do |source|
-          logger.debug1 "Source #{source.name} in #{@path} claimed contents #{source.desired_contents.inspect}"
+          logger.debug1 "Source #{source.name} in #{@path} manages contents #{source.desired_contents.inspect}"
         end
         if !stale_contents.empty?
-          logger.debug "No sources in #{@path} claimed contents #{stale_contents.inspect}"
+          logger.debug "The path #{@path} has unmanaged contents #{stale_contents.inspect}"
         end
         super
       end

data/lib/r10k/util/commands.rb

@@ -0,0 +1,31 @@
+module R10K
+  module Util
+    module Commands
+      module_function
+
+      # Find the full path of a shell command.
+      #
+      # On POSIX platforms, the PATHEXT environment variable will be unset, so
+      # the first command named 'cmd' will be returned.
+      #
+      # On Windows platforms, the PATHEXT environment variable will contain a
+      # semicolon delimited list of executable file extensions, so the first
+      # command with a matching path extension will be returned.
+      #
+      # @param cmd [String] The name of the command to search for
+      # @return [String, nil] The path to the file if found, nil otherwise
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
+          exts.each do |ext|
+            path = File.join(dir, "#{cmd}#{ext}")
+            if File.executable?(path) && File.file?(path)
+              return path
+            end
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/r10k/util/exec_env.rb

@@ -0,0 +1,36 @@
+module R10K
+  module Util
+
+    # Utility methods for dealing with environment variables
+    module ExecEnv
+      module_function
+
+      # Swap out all environment settings
+      #
+      # @param env [Hash] The new environment to use
+      # @return [void]
+      def reset(env)
+        env.each_pair do |key, value|
+          ENV[key] = value
+        end
+
+        (ENV.keys - env.keys).each do |key|
+          ENV.delete(key)
+        end
+      end
+
+      # Add the specified settings to the env for the supplied block
+      #
+      # @param env [Hash] The values to add to the environment
+      # @param block [Proc] The code to call with the modified environnment
+      # @return [void]
+      def withenv(env, &block)
+        original = ENV.to_hash
+        reset(original.merge(env))
+        block.call
+      ensure
+        reset(original)
+      end
+    end
+  end
+end

data/lib/r10k/util/platform.rb

@@ -14,6 +14,10 @@ module R10K
       def self.windows?
         RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i
       end
+
+      def self.posix?
+        !windows?
+      end
     end
   end
 end

data/lib/r10k/util/purgeable.rb

@@ -46,11 +46,11 @@ module R10K
       # Forcibly remove all unmanaged content in `self.managed_directory`
       def purge!
         if stale_contents.empty?
-          logger.debug1 "No stale contents in #{managed_directory}, nothing to purge"
+          logger.debug1 "No unmanaged contents in #{managed_directory}, nothing to purge"
         else
           stale_contents.each do |fname|
             fpath = File.join(self.managed_directory, fname)
-            logger.debug "Removing stale path #{fpath}"
+            logger.info "Removing unmanaged path #{fpath}"
             FileUtils.rm_rf(fpath, :secure => true)
           end
         end

data/lib/r10k/util/subprocess.rb

@@ -11,19 +11,15 @@ module R10K
     class Subprocess
 
       require 'r10k/util/subprocess/runner'
-      require 'r10k/util/subprocess/io'
       require 'r10k/util/subprocess/result'
       require 'r10k/util/subprocess/subprocess_error'
 
-      require 'r10k/util/subprocess/posix'
-      require 'r10k/util/subprocess/windows'
-
       # @return [Class < R10K::Util::Subprocess::Runner]
       def self.runner
         if R10K::Util::Platform.windows?
-          R10K::Util::Subprocess::Windows::Runner
+          R10K::Util::Subprocess::Runner::Windows
         else
-          R10K::Util::Subprocess::POSIX::Runner
+          R10K::Util::Subprocess::Runner::POSIX
         end
       end
 
@@ -75,7 +71,7 @@ module R10K
         result = subprocess.run
         logger.debug2("Finished process:\n#{result.format}")
 
-        if @raise_on_fail and subprocess.crashed?
+        if @raise_on_fail && result.failed?
           raise SubprocessError.new("Command exited with non-zero exit code", :result => result)
         end
 

data/lib/r10k/util/subprocess/runner.rb

@@ -3,19 +3,14 @@
 # @api private
 class R10K::Util::Subprocess::Runner
 
+  require 'r10k/util/subprocess/runner/windows'
+  require 'r10k/util/subprocess/runner/posix'
+
   # @!attribute [rw] cwd
   #   @return [String] The directory to be used as the cwd when executing
   #     the command.
   attr_accessor :cwd
 
-  attr_reader :io
-
-  attr_reader :pid
-
-  # @!attribute [r] status
-  #   @return [Process::Status]
-  attr_reader :status
-
   # @!attribute [r] result
   #   @return [R10K::Util::Subprocess::Result]
   attr_reader :result
@@ -27,24 +22,4 @@ class R10K::Util::Subprocess::Runner
   def run
     raise NotImplementedError
   end
-
-  # Start the process asynchronously and return. Not all runners will implement this.
-  def start
-    raise NotImplementedError
-  end
-
-  # Wait for the process to exit. Not all runners will implement this.
-  def wait
-    raise NotImplementedError
-  end
-
-  # Did the given process exit with a non-zero exit code?
-  def crashed?
-    raise NotImplementedError
-  end
-
-  # @return [Integer] The exit status of the given process.
-  def exit_code
-    raise NotImplementedError
-  end
 end

data/lib/r10k/util/subprocess/runner/posix.rb

@@ -0,0 +1,103 @@
+require 'r10k/util/subprocess/runner'
+require 'r10k/util/subprocess/runner/pump'
+require 'fcntl'
+
+# Implement a POSIX command runner by using fork/exec.
+#
+# This implementation is optimized to run commands in the background, and has
+# a few noteworthy implementation details.
+#
+# First off, when the child process is forked, it calls setsid() to detach from
+# the controlling TTY. This has two main ramifications: sending signals will
+# never be send to the forked process, and the forked process does not have
+# access to stdin.
+#
+# @api private
+class R10K::Util::Subprocess::Runner::POSIX < R10K::Util::Subprocess::Runner
+
+  def initialize(argv)
+    @argv = argv
+    mkpipes
+  end
+
+  def run
+    # Create a pipe so that the parent can verify that the child process
+    # successfully executed. The pipe will be closed on a successful exec(),
+    # and will contain an error message on failure.
+    exec_r, exec_w = pipe
+
+    @stdout_pump = R10K::Util::Subprocess::Runner::Pump.new(@stdout_r)
+    @stderr_pump = R10K::Util::Subprocess::Runner::Pump.new(@stderr_r)
+    @stdout_pump.start
+    @stderr_pump.start
+
+    pid = fork do
+      exec_r.close
+      execute_child(exec_w)
+    end
+
+    exec_w.close
+    execute_parent(exec_r, pid)
+
+    @result
+  end
+
+  private
+
+  def execute_child(exec_w)
+    if @cwd
+      Dir.chdir @cwd
+    end
+
+    # Create a new session for the forked child. This prevents children from
+    # ever being the foreground process on a TTY, which is almost always what
+    # we want in r10k.
+    Process.setsid
+
+    # Reopen file descriptors
+    STDOUT.reopen(@stdout_w)
+    STDERR.reopen(@stderr_w)
+
+    executable = @argv.shift
+    exec([executable, executable], *@argv)
+  rescue SystemCallError => e
+    exec_w.write("#{e.class}: #{e.message}")
+    exit(254)
+  end
+
+  def execute_parent(exec_r, pid)
+    @stdout_w.close
+    @stderr_w.close
+
+    stdout = ''
+    stderr = ''
+
+    if !exec_r.eof?
+      stderr = exec_r.read || "exec() failed"
+      _, @status = Process.waitpid2(pid)
+    else
+      _, @status = Process.waitpid2(pid)
+      @stdout_pump.wait
+      @stderr_pump.wait
+      stdout = @stdout_pump.string
+      stderr = @stderr_pump.string
+    end
+    exec_r.close
+
+    @stdout_r.close
+    @stderr_r.close
+
+    @result = R10K::Util::Subprocess::Result.new(@argv, stdout, stderr, @status.exitstatus)
+  end
+
+  def mkpipes
+    @stdout_r, @stdout_w = pipe
+    @stderr_r, @stderr_w = pipe
+  end
+
+  def pipe
+    ::IO.pipe.tap do |pair|
+      pair.each { |p| p.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
+  end
+end

data/lib/r10k/util/subprocess/runner/pump.rb

@@ -0,0 +1,59 @@
+require 'r10k/util/subprocess/runner'
+
+# Perform nonblocking reads on a streaming IO instance.
+#
+# @api private
+class R10K::Util::Subprocess::Runner::Pump
+
+  # !@attribute [r] string
+  #   @return [String] The output collected from the IO device
+  attr_reader :string
+
+  # @!attribute [r] min_delay
+  #   @return [Float] The minimum time to wait while polling the IO device
+  attr_accessor :min_delay
+
+  # @!attribute [r] max_delay
+  #   @return [Float] The maximum time to wait while polling the IO device
+  attr_accessor :max_delay
+
+  def initialize(io)
+    @io     = io
+    @thread = nil
+    @string = ''
+    @run    = true
+    @min_delay = 0.05
+    @max_delay = 1.0
+  end
+
+  def start
+    @thread = Thread.new { pump }
+  end
+
+  def halt!
+    @run = false
+    @thread.join
+  end
+
+  # Block until the pumping thread reaches EOF on the IO object.
+  def wait
+    @thread.join
+  end
+
+  private
+
+  def pump
+    backoff = @min_delay
+    while @run
+      begin
+        @string << @io.read_nonblock(4096)
+        backoff /= 2 if backoff > @min_delay
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+        backoff *= 2 if backoff < @max_delay
+        IO.select([@io], [], [], backoff)
+      rescue EOFError
+        @run = false
+      end
+    end
+  end
+end