puppet 2.7.11 → 2.7.12

data/lib/puppet/util/colors.rb

@@ -0,0 +1,98 @@
+module Puppet::Util::Colors
+  BLACK      = {:console => "\e[0;30m", :html => "color: #FFA0A0"     }
+  RED        = {:console => "\e[0;31m", :html => "color: #FFA0A0"     }
+  GREEN      = {:console => "\e[0;32m", :html => "color: #00CD00"     }
+  YELLOW     = {:console => "\e[0;33m", :html => "color: #FFFF60"     }
+  BLUE       = {:console => "\e[0;34m", :html => "color: #80A0FF"     }
+  PURPLE     = {:console => "\e[0;35m", :html => "color: #FFA500"     }
+  CYAN       = {:console => "\e[0;36m", :html => "color: #40FFFF"     }
+  WHITE      = {:console => "\e[0;37m", :html => "color: #FFFFFF"     }
+  HBLACK     = {:console => "\e[1;30m", :html => "color: #FFA0A0"     }
+  HRED       = {:console => "\e[1;31m", :html => "color: #FFA0A0"     }
+  HGREEN     = {:console => "\e[1;32m", :html => "color: #00CD00"     }
+  HYELLOW    = {:console => "\e[1;33m", :html => "color: #FFFF60"     }
+  HBLUE      = {:console => "\e[1;34m", :html => "color: #80A0FF"     }
+  HPURPLE    = {:console => "\e[1;35m", :html => "color: #FFA500"     }
+  HCYAN      = {:console => "\e[1;36m", :html => "color: #40FFFF"     }
+  HWHITE     = {:console => "\e[1;37m", :html => "color: #FFFFFF"     }
+  BG_RED     = {:console => "\e[0;41m", :html => "background: #FFA0A0"}
+  BG_GREEN   = {:console => "\e[0;42m", :html => "background: #00CD00"}
+  BG_YELLOW  = {:console => "\e[0;43m", :html => "background: #FFFF60"}
+  BG_BLUE    = {:console => "\e[0;44m", :html => "background: #80A0FF"}
+  BG_PURPLE  = {:console => "\e[0;45m", :html => "background: #FFA500"}
+  BG_CYAN    = {:console => "\e[0;46m", :html => "background: #40FFFF"}
+  BG_WHITE   = {:console => "\e[0;47m", :html => "background: #FFFFFF"}
+  BG_HRED    = {:console => "\e[1;41m", :html => "background: #FFA0A0"}
+  BG_HGREEN  = {:console => "\e[1;42m", :html => "background: #00CD00"}
+  BG_HYELLOW = {:console => "\e[1;43m", :html => "background: #FFFF60"}
+  BG_HBLUE   = {:console => "\e[1;44m", :html => "background: #80A0FF"}
+  BG_HPURPLE = {:console => "\e[1;45m", :html => "background: #FFA500"}
+  BG_HCYAN   = {:console => "\e[1;46m", :html => "background: #40FFFF"}
+  BG_HWHITE  = {:console => "\e[1;47m", :html => "background: #FFFFFF"}
+  RESET      = {:console => "\e[0m",    :html => ""                   }
+
+  Colormap = {
+    :debug => WHITE,
+    :info => GREEN,
+    :notice => CYAN,
+    :warning => YELLOW,
+    :err => HPURPLE,
+    :alert => RED,
+    :emerg => HRED,
+    :crit => HRED,
+
+    :black      => BLACK,
+    :red        => RED,
+    :green      => GREEN,
+    :yellow     => YELLOW,
+    :blue       => BLUE,
+    :purple     => PURPLE,
+    :cyan       => CYAN,
+    :white      => WHITE,
+    :hblack     => HBLACK,
+    :hred       => HRED,
+    :hgreen     => HGREEN,
+    :hyellow    => HYELLOW,
+    :hblue      => HBLUE,
+    :hpurple    => HPURPLE,
+    :hcyan      => HCYAN,
+    :hwhite     => HWHITE,
+    :bg_red     => BG_RED,
+    :bg_green   => BG_GREEN,
+    :bg_yellow  => BG_YELLOW,
+    :bg_blue    => BG_BLUE,
+    :bg_purple  => BG_PURPLE,
+    :bg_cyan    => BG_CYAN,
+    :bg_white   => BG_WHITE,
+    :bg_hred    => BG_HRED,
+    :bg_hgreen  => BG_HGREEN,
+    :bg_hyellow => BG_HYELLOW,
+    :bg_hblue   => BG_HBLUE,
+    :bg_hpurple => BG_HPURPLE,
+    :bg_hcyan   => BG_HCYAN,
+    :bg_hwhite  => BG_HWHITE,
+    :reset      => { :console => "\e[m", :html => "" }
+  }
+
+  def colorize(color, str)
+    case Puppet[:color]
+    when true, :ansi, "ansi", "yes"
+      console_color(color, str)
+    when :html, "html"
+      html_color(color, str)
+    else
+      str
+    end
+  end
+
+  def console_color(color, str)
+    Colormap[color][:console] +
+    str.gsub(RESET[:console], Colormap[color][:console]) +
+    RESET[:console]
+  end
+
+  def html_color(color, str)
+    span = '<span style="%s">' % Colormap[color][:html]
+    "#{span}%s</span>" % str.gsub(/<span .*?<\/span>/, "</span>\\0#{span}")
+  end
+end

data/lib/puppet/util/diff.rb

@@ -4,7 +4,9 @@ module Puppet::Util::Diff
   require 'tempfile'
 
   def diff(old, new)
-    command = [Puppet[:diff]]
+    return '' unless diff_cmd = Puppet[:diff] and diff_cmd != ""
+
+    command = [diff_cmd]
     if args = Puppet[:diff_args] and args != ""
       command << args
     end

data/lib/puppet/util/log.rb

@@ -189,12 +189,16 @@ class Puppet::Util::Log
       }
     rescue => detail
       if @destinations.empty?
-        Log.newdestination(:syslog)
+        Log.setup_default
         Puppet.err detail.to_s
       end
     end
   end
 
+  def self.setup_default
+    Log.newdestination(Puppet.features.syslog? ? :syslog : Puppet[:puppetdlog])
+  end
+
   # Is the passed level a valid log level?
   def self.validlevel?(level)
     @levels.include?(level)

data/lib/puppet/util/log/destinations.rb

@@ -41,6 +41,8 @@ Puppet::Util::Log.newdesttype :syslog do
 end
 
 Puppet::Util::Log.newdesttype :file do
+  require 'fileutils'
+
   def self.match?(obj)
     Puppet::Util.absolute_path?(obj)
   end
@@ -64,7 +66,7 @@ Puppet::Util::Log.newdesttype :file do
     # We can't just use 'Config.use' here, because they've
     # specified a "special" destination.
     unless FileTest.exist?(File.dirname(path))
-      Puppet.recmkdir(File.dirname(path))
+      FileUtils.mkdir_p(File.dirname(path), :mode => 0755)
       Puppet.info "Creating log directory #{File.dirname(path)}"
     end
 
@@ -84,62 +86,53 @@ Puppet::Util::Log.newdesttype :file do
 end
 
 Puppet::Util::Log.newdesttype :console do
+  require 'puppet/util/colors'
+  include Puppet::Util::Colors
 
+  def initialize
+    # Flush output immediately.
+    $stdout.sync = true
+  end
 
-  RED     = {:console => "", :html => "FFA0A0"}
-  GREEN   = {:console => "", :html => "00CD00"}
-  YELLOW  = {:console => "", :html => "FFFF60"}
-  BLUE    = {:console => "", :html => "80A0FF"}
-  PURPLE  = {:console => "", :html => "FFA500"}
-  CYAN    = {:console => "", :html => "40FFFF"}
-  WHITE   = {:console => "", :html => "FFFFFF"}
-  HRED    = {:console => "", :html => "FFA0A0"}
-  HGREEN  = {:console => "", :html => "00CD00"}
-  HYELLOW = {:console => "", :html => "FFFF60"}
-  HBLUE   = {:console => "", :html => "80A0FF"}
-  HPURPLE = {:console => "", :html => "FFA500"}
-  HCYAN   = {:console => "", :html => "40FFFF"}
-  HWHITE  = {:console => "", :html => "FFFFFF"}
-  RESET   = {:console => "",    :html => ""      }
-
-  Colormap = {
-    :debug => WHITE,
-    :info => GREEN,
-    :notice => CYAN,
-    :warning => YELLOW,
-    :err => HPURPLE,
-    :alert => RED,
-    :emerg => HRED,
-    :crit => HRED
-  }
-
-  def colorize(level, str)
-    case Puppet[:color]
-    when true, :ansi, "ansi", "yes"; console_color(level, str)
-    when :html, "html"; html_color(level, str)
+  def handle(msg)
+    if msg.source == "Puppet"
+      puts colorize(msg.level, "#{msg.level}: #{msg}")
     else
-      str
+      puts colorize(msg.level, "#{msg.level}: #{msg.source}: #{msg}")
     end
   end
+end
 
-  def console_color(level, str)
-    Colormap[level][:console] + str + RESET[:console]
-  end
-
-  def html_color(level, str)
-    %{<span style="color: %s">%s</span>} % [Colormap[level][:html], str]
-  end
+Puppet::Util::Log.newdesttype :telly_prototype_console do
+  require 'puppet/util/colors'
+  include Puppet::Util::Colors
 
   def initialize
     # Flush output immediately.
+    $stderr.sync = true
     $stdout.sync = true
   end
 
   def handle(msg)
-    if msg.source == "Puppet"
-      puts colorize(msg.level, "#{msg.level}: #{msg}")
+    error_levels = {
+      :warning => 'Warning',
+      :err     => 'Error',
+      :alert   => 'Alert',
+      :emerg   => 'Emergency',
+      :crit    => 'Critical'
+    }
+
+    str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
+
+    case msg.level
+    when *error_levels.keys
+      $stderr.puts colorize(:hred, "#{error_levels[msg.level]}: #{str}")
+    when :info
+      $stdout.puts "#{colorize(:green, 'Info')}: #{str}"
+    when :debug
+      $stdout.puts "#{colorize(:cyan, 'Debug')}: #{str}"
     else
-      puts colorize(msg.level, "#{msg.level}: #{msg.source}: #{msg}")
+      $stdout.puts str
     end
   end
 end
@@ -167,7 +160,7 @@ Puppet::Util::Log.newdesttype :host do
         @domain = Facter["domain"].value
         @hostname += ".#{@domain}" if @domain
       end
-      if msg.source =~ /^\//
+      if Puppet::Util.absolute_path?(msg.source)
         msg.source = @hostname + ":#{msg.source}"
       elsif msg.source == "Puppet"
         msg.source = @hostname + " #{msg.source}"

data/lib/puppet/util/monkey_patches.rb

@@ -129,6 +129,38 @@ class IO
     block_given? and lines.each {|line| yield line }
     lines
   end
+
+  def self.binread(name, length = nil, offset = 0)
+    File.open(name, 'rb') do |f|
+      f.seek(offset) if offset > 0
+      f.read(length)
+    end
+  end unless singleton_methods.include?(:binread)
+
+  def self.binwrite(name, string, offset = 0)
+    File.open(name, 'wb') do |f|
+      f.write(offset > 0 ? string[offset..-1] : string)
+    end
+  end unless singleton_methods.include?(:binwrite)
+
+end
+
+class Range
+  def intersection(other)
+    raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
+    return unless other === self.first || self === other.first
+
+    start = [self.first, other.first].max
+    if self.exclude_end? && self.last <= other.last
+      start ... self.last
+    elsif other.exclude_end? && self.last >= other.last
+      start ... other.last
+    else
+      start .. [ self.last, other.last ].min
+    end
+  end unless method_defined? :intersection
+
+  alias_method :&, :intersection unless method_defined? :&
 end
 
 # Ruby 1.8.5 doesn't have tap

data/lib/puppet/util/pidlock.rb

@@ -1,10 +1,20 @@
 require 'fileutils'
-require 'puppet/util/anonymous_filelock'
 
-class Puppet::Util::Pidlock < Puppet::Util::AnonymousFilelock
+class Puppet::Util::Pidlock
+  attr_reader :lockfile
+
+  def initialize(lockfile)
+    @lockfile = lockfile
+  end
 
   def locked?
     clear_if_stale
+    return true if File.exists? @lockfile
+
+    # HACK!  There was a temporary change to the lockfile behavior introduced in 2.7.10 and 2.7.11, and reverted
+    # in 2.7.12.  We need to pull some chicanery to be backwards-compatible with those versions.  For more info,
+    # see the comments on the method... and this hack should be removed for the 3.x series.
+    handle_2_7_10_disabled_lockfile
     File.exists? @lockfile
   end
 
@@ -13,36 +23,39 @@ class Puppet::Util::Pidlock < Puppet::Util::AnonymousFilelock
   end
 
   def anonymous?
-    false
+    return false unless File.exists?(@lockfile)
+    File.read(@lockfile) == ""
   end
 
-  def lock
-    return mine? if locked?
+  def lock(opts = {})
+    opts = {:anonymous => false}.merge(opts)
 
-    File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
-    true
+    if locked?
+      mine?
+    else
+      if opts[:anonymous]
+        File.open(@lockfile, 'w') { |fd| true }
+      else
+        File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
+      end
+      true
+    end
   end
 
   def unlock(opts = {})
-    if mine?
-      begin
-        File.unlink(@lockfile)
-      rescue Errno::ENOENT
-        # Someone deleted it for us ...and so we do nothing.  No point whining
-        # about a problem that the user can't actually do anything about.
-      rescue SystemCallError => e
-        # This one is a real failure though.  No idea what went wrong, but it
-        # is most likely "read only file(system)" or wrong permissions or
-        # something like that.
-        Puppet.err "Could not remove PID file #{@lockfile}: #{e}"
-        puts e.backtrace if Puppet[:trace]
-      end
+    return false unless locked?
+
+    opts = {:anonymous => false}.merge(opts)
+
+    if mine? or (opts[:anonymous] and anonymous?)
+      File.unlink(@lockfile)
       true
     else
       false
     end
   end
 
+  private
   def lock_pid
     if File.exists? @lockfile
       File.read(@lockfile).to_i
@@ -51,7 +64,6 @@ class Puppet::Util::Pidlock < Puppet::Util::AnonymousFilelock
     end
   end
 
-  private
   def clear_if_stale
     return if lock_pid.nil?
 
@@ -65,4 +77,41 @@ class Puppet::Util::Pidlock < Puppet::Util::AnonymousFilelock
       File.unlink(@lockfile)
     end
   end
+
+
+  ######################################################################################
+  # Backwards compatibility hack
+  ######################################################################################
+  # A change to lockfile behavior was introduced in 2.7.10 and 2.7.11; basically,
+  # instead of using a single lockfile to indicate both administrative disabling of
+  # the agent *and* the case where an agent run is already in progress, we started using
+  # two separate lockfiles: the 'normal' one for the "run in progress" case, and a
+  # separate one with a ".disabled" extension to indicate administrative disabling.
+  #
+  # This was determined to cause incompatibilities with mcollective, so the behavior
+  # was reverted for 2.7.12.  Unfortunately this leaves the possibility that someone
+  # may have run "agent --disable" to administratively disable a 2.7.10 or 2.7.11
+  # agent, and then upgraded to a newer version.  This method exists only to
+  # provide backwards compatibility.  Basically, it just recognizes the 2.7.10/2.7.11
+  # ".disabled" lock file, warns, and cleans it up.
+  #
+  # This should be removed for the 3.x series.
+  #
+  # For more information, please see tickets #12844, #3757, #4836, and #11057
+  #
+  # -- cprice 2012-03-01
+  #
+  def handle_2_7_10_disabled_lockfile
+    disabled_lockfile_path = @lockfile + ".disabled"
+    if (File.exists?(disabled_lockfile_path))
+      Puppet.warning("Found special lockfile '#{disabled_lockfile_path}'; this file was " +
+          "generated by a call to 'puppet agent --disable' in puppet 2.7.10 or 2.7.11. " +
+          "The expected lockfile path is '#{@lockfile}'; renaming the lock file.")
+      File.rename(disabled_lockfile_path, @lockfile)
+    end
+  end
+  private :handle_2_7_10_disabled_lockfile
+  ######################################################################################
+  # End backwards compatibility hack
+  ######################################################################################
 end

data/lib/puppet/util/rdoc/parser.rb

@@ -129,8 +129,10 @@ class Parser
   def scan_top_level(container)
     # use the module README as documentation for the module
     comment = ""
-    readme = File.join(File.dirname(File.dirname(@input_file_name)), "README")
-    comment = File.open(readme,"r") { |f| f.read } if FileTest.readable?(readme)
+    %w{README README.rdoc}.each do |rfile|
+      readme = File.join(File.dirname(File.dirname(@input_file_name)), rfile)
+      comment = File.open(readme,"r") { |f| f.read } if FileTest.readable?(readme)
+    end
     look_for_directives_in(container, comment) unless comment.empty?
 
     # infer module name from directory

data/lib/puppet/util/selinux.rb

@@ -163,7 +163,7 @@ module Puppet::Util::SELinux
     # Read all entries in /proc/mounts.  The second column is the
     # mountpoint and the third column is the filesystem type.
     # We skip rootfs because it is always mounted at /
-    mounts.collect do |line|
+    mounts.each_line do |line|
       params = line.split(' ')
       next if params[2] == 'rootfs'
       mntpoint[params[1]] = params[2]

data/lib/puppet/util/suidmanager.rb

@@ -56,18 +56,8 @@ module Puppet::Util::SUIDManager
   def self.root?
     return Process.uid == 0 unless Puppet.features.microsoft_windows?
 
-    require 'sys/admin'
-    require 'win32/security'
-    require 'facter'
-
-    majversion = Facter.value(:kernelmajversion)
-    return false unless majversion
-
-    # if Vista or later, check for unrestricted process token
-    return Win32::Security.elevated_security? unless majversion.to_f < 6.0
-
-    group = Sys::Admin.get_group("Administrators", :sid => Win32::Security::SID::BuiltinAdministrators)
-    group and group.members.index(Sys::Admin.get_login) != nil
+    require 'puppet/util/windows/user'
+    Puppet::Util::Windows::User.admin?
   end
 
   # Methods to handle changing uid/gid of the running process. In general,