puppet 3.0.0.rc5 → 3.0.0.rc7

data/lib/puppet/util.rb

@@ -363,30 +363,17 @@ module Util
   # will recognize as links to the line numbers in the trace)
   def self.pretty_backtrace(backtrace = caller(1))
     backtrace.collect do |line|
-      file_path, line_num = line.split(":")
-      file_path = expand_symlinks(File.expand_path(file_path))
-
-      file_path + ":" + line_num
-    end .join("\n")
-
-  end
-
-  # utility method that takes a path as input, checks each component of the path to see if it is a symlink, and expands
-  # it if it is.  returns the expanded path.
-  def self.expand_symlinks(file_path)
-    file_path.split("/").inject do |full_path, next_dir|
-      next_path = full_path + "/" + next_dir
-      if File.symlink?(next_path) then
-        link = File.readlink(next_path)
-        next_path =
-            case link
-              when /^\// then link
-              else
-                File.expand_path(full_path + "/" + link)
-            end
+      _, path, rest = /^(.*):(\d+.*)$/.match(line).to_a
+      # If the path doesn't exist - like in one test, and like could happen in
+      # the world - we should just tolerate it and carry on. --daniel 2012-09-05
+      # Also, if we don't match, just include the whole line.
+      if path
+        path = Pathname(path).realpath rescue path
+        "#{path}:#{rest}"
+      else
+        line
       end
-      next_path
-    end
+    end.join("\n")
   end
 
   # Replace a file, securely.  This takes a block, and passes it the file

data/lib/puppet/util/adsi.rb

@@ -45,8 +45,12 @@ module Puppet::Util::ADSI
       "#{computer_uri}/#{resource_name},#{resource_type}"
     end
 
+    def wmi_connection
+      connect(wmi_resource_uri)
+    end
+
     def execquery(query)
-      connect(wmi_resource_uri).execquery(query)
+      wmi_connection.execquery(query)
     end
 
     def sid_for_account(name)
@@ -85,19 +89,7 @@ module Puppet::Util::ADSI
     end
 
     def self.logon(name, password)
-      fLOGON32_LOGON_NETWORK = 3
-      fLOGON32_PROVIDER_DEFAULT = 0
-
-      logon_user = Win32API.new("advapi32", "LogonUser", ['P', 'P', 'P', 'L', 'L', 'P'], 'L')
-      close_handle = Win32API.new("kernel32", "CloseHandle", ['P'], 'V')
-
-      token = ' ' * 4
-      if logon_user.call(name, "", password, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, token) != 0
-        close_handle.call(token.unpack('L')[0])
-        true
-      else
-        false
-      end
+      Puppet::Util::Windows::User.password_is?(name, password)
     end
 
     def [](attribute)
@@ -200,6 +192,22 @@ module Puppet::Util::ADSI
     end
   end
 
+  class UserProfile
+    def self.delete(sid)
+      begin
+        Puppet::Util::ADSI.wmi_connection.Delete("Win32_UserProfile.SID='#{sid}'")
+      rescue => e
+        # http://social.technet.microsoft.com/Forums/en/ITCG/thread/0f190051-ac96-4bf1-a47f-6b864bfacee5
+        # Prior to Vista SP1, there's no builtin way to programmatically
+        # delete user profiles (except for delprof.exe). So try to delete
+        # but warn if we fail
+        raise e unless e.message.include?('80041010')
+
+        Puppet.warning "Cannot delete user profile for '#{sid}' prior to Vista SP1"
+      end
+    end
+  end
+
   class Group
     extend Enumerable
 

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

@@ -76,6 +76,13 @@ Puppet::Util::Log.newdesttype :file do
     # create the log file, if it doesn't already exist
     file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
 
+    # Give ownership to the user and group puppet will run as
+    begin
+      FileUtils.chown(Puppet[:user], Puppet[:group], path) unless Puppet::Util::Platform.windows?
+    rescue ArgumentError, Errno::EPERM
+      Puppet.err "Unable to set ownership of log file"
+    end
+
     @file = file
 
     @autoflush = Puppet[:autoflush]

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

@@ -0,0 +1,40 @@
+require 'puppet/util/logging'
+
+# Logging utility class that limits the frequency of identical log messages
+class Puppet::Util::Log::RateLimitedLogger
+  include Puppet::Util::Logging
+
+  def initialize(interval)
+    raise ArgumentError, "Logging rate-limit interval must be an integer" unless interval.is_a?(Integer)
+    @interval = interval
+    @log_record = {}
+  end
+
+  # Override the logging entry point to rate-limit it
+  def send_log(level, message)
+    Puppet::Util::Log.create({:level => level, :message => message}) if should_log?(level, message)
+  end
+
+  private
+
+  def should_log?(level, message)
+    # Initialize separate records for different levels, and only when needed
+    record = (@log_record[level] ||= {})
+    last_log = record[message]
+
+    # Skip logging if the time interval since the last logging hasn't elapsed yet
+    return false if last_log and within_interval?(last_log)
+
+    # Purge stale entries; do this after the interval check to reduce passes through the cache
+    record.delete_if { |key, time| !within_interval?(time) }
+
+    # Reset the beginning of the interval to the current time
+    record[message] = Time.now
+
+    true
+  end
+
+  def within_interval?(time)
+    time + @interval > Time.now
+  end
+end

data/lib/puppet/util/metric.rb

@@ -46,9 +46,9 @@ class Puppet::Util::Metric
 
     begin
       if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
-        @rrd.create( Puppet[:rrdinterval].to_i, start, args)
+        @rrd.create( Puppet[:rrdinterval], start, args)
       else
-        RRD.create( self.path, '-s', Puppet[:rrdinterval].to_i.to_s, '-b', start.to_i.to_s, *args)
+        RRD.create( self.path, '-s', Puppet[:rrdinterval].to_s, '-b', start.to_i.to_s, *args)
       end
     rescue => detail
       raise "Could not create RRD file #{path}: #{detail}"

data/lib/puppet/util/monkey_patches.rb

@@ -81,6 +81,14 @@ if RUBY_VERSION == '1.8.1' || RUBY_VERSION == '1.8.2'
   }
 end
 
+class Fixnum
+  # Returns the int itself. This method is intended for compatibility to
+  # character constant in Ruby 1.9.  1.8.5 is missing it; add it.
+  def ord
+    self
+  end unless method_defined? 'ord'
+end
+
 class Array
   # Ruby < 1.8.7 doesn't have this method but we use it in tests
   def combination(num)

data/lib/puppet/util/platform.rb

@@ -10,6 +10,13 @@ module Puppet
         !!File::ALT_SEPARATOR
       end
       module_function :windows?
+
+      def default_paths
+        return [] if windows?
+
+        %w{/usr/sbin /sbin}
+      end
+      module_function :default_paths
     end
   end
 end

data/lib/puppet/util/selinux.rb

@@ -136,6 +136,21 @@ module Puppet::Util::SELinux
     nil
   end
 
+  ########################################################################
+  # Internal helper methods from here on in, kids.  Don't fiddle.
+  private
+
+  # Check filesystem a path resides on for SELinux support against
+  # whitelist of known-good filesystems.
+  # Returns true if the filesystem can support SELinux labels and
+  # false if not.
+  def selinux_label_support?(file)
+    fstype = find_fs(file)
+    return false if fstype.nil?
+    filesystems = ['ext2', 'ext3', 'ext4', 'gfs', 'gfs2', 'xfs', 'jfs']
+    filesystems.include?(fstype)
+  end
+
   # Internal helper function to read and parse /proc/mounts
   def read_mounts
     mounts = ""
@@ -171,46 +186,26 @@ module Puppet::Util::SELinux
     mntpoint
   end
 
-  def realpath(path)
-    path, rest = Pathname.new(path), []
-    path, rest = path.dirname, [path.basename] + rest while ! path.exist?
-    File.join( path.realpath, *rest )
-  end
-
-  def parent_directory(path)
-    Pathname.new(path).dirname.to_s
-  end
-
-  # Internal helper function to return which type of filesystem a
-  # given file path resides on
+  # Internal helper function to return which type of filesystem a given file
+  # path resides on
   def find_fs(path)
-    unless mnts = read_mounts
-      return nil
+    return nil unless mounts = read_mounts
+
+    # cleanpath eliminates useless parts of the path (like '.', or '..', or
+    # multiple slashes), without touching the filesystem, and without
+    # following symbolic links.  This gives the right (logical) tree to follow
+    # while we try and figure out what file-system the target lives on.
+    path = Pathname(path).cleanpath
+    unless path.absolute?
+      raise Puppet::DevError, "got a relative path in SELinux find_fs: #{path}"
     end
 
-    # For a given file:
-    # Check if the filename is in the data structure;
-    #   return the fstype if it is.
-    # Just in case: return something if you're down to "/" or ""
-    # Remove the last slash and everything after it,
-    #   and repeat with that as the file for the next loop through.
-    path = realpath(path)
-    while not path.empty?
-      return mnts[path] if mnts.has_key?(path)
-      path = parent_directory(path)
+    # Now, walk up the tree until we find a match for that path in the hash.
+    path.ascend do |segment|
+      return mounts[segment.to_s] if mounts.has_key?(segment.to_s)
     end
-    mnts['/']
-  end
 
-  # Check filesystem a path resides on for SELinux support against
-  # whitelist of known-good filesystems.
-  # Returns true if the filesystem can support SELinux labels and
-  # false if not.
-  def selinux_label_support?(file)
-    fstype = find_fs(file)
-    return false if fstype.nil?
-    filesystems = ['ext2', 'ext3', 'ext4', 'gfs', 'gfs2', 'xfs', 'jfs']
-    filesystems.include?(fstype)
+    # Should never be reached...
+    return mounts['/']
   end
-
 end

data/lib/puppet/util/windows/error.rb

@@ -3,7 +3,7 @@ require 'puppet/util/windows'
 # represents an error resulting from a Win32 error code
 class Puppet::Util::Windows::Error < Puppet::Error
   require 'windows/error'
-  include Windows::Error
+  include ::Windows::Error
 
   attr_reader :code
 

data/lib/puppet/util/windows/process.rb

@@ -1,9 +1,9 @@
 require 'puppet/util/windows'
 
 module Puppet::Util::Windows::Process
-  extend Windows::Process
-  extend Windows::Handle
-  extend Windows::Synchronize
+  extend ::Windows::Process
+  extend ::Windows::Handle
+  extend ::Windows::Synchronize
 
   def execute(command, arguments, stdin, stdout, stderr)
     Process.create( :command_line => command, :startup_info => {:stdin => stdin, :stdout => stdout, :stderr => stderr}, :close_handles => false )

data/lib/puppet/util/windows/security.rb

@@ -72,13 +72,13 @@ require 'windows/memory'
 require 'windows/volume'
 
 module Puppet::Util::Windows::Security
-  include Windows::File
-  include Windows::Handle
-  include Windows::Security
-  include Windows::Process
-  include Windows::Memory
-  include Windows::MSVCRT::Buffer
-  include Windows::Volume
+  include ::Windows::File
+  include ::Windows::Handle
+  include ::Windows::Security
+  include ::Windows::Process
+  include ::Windows::Memory
+  include ::Windows::MSVCRT::Buffer
+  include ::Windows::Volume
 
   extend Puppet::Util::Windows::Security
 

data/lib/puppet/util/windows/user.rb

@@ -4,8 +4,8 @@ require 'win32/security'
 require 'facter'
 
 module Puppet::Util::Windows::User
-  include Windows::Security
-  extend Windows::Security
+  include ::Windows::Security
+  extend ::Windows::Security
 
   def admin?
     majversion = Facter.value(:kernelmajversion)
@@ -40,4 +40,67 @@ module Puppet::Util::Windows::User
     member.unpack('L')[0] == 1
   end
   module_function :check_token_membership
+
+  def password_is?(name, password)
+    logon_user(name, password)
+    true
+  rescue Puppet::Util::Windows::Error => e
+    false
+  end
+  module_function :password_is?
+
+  def logon_user(name, password, &block)
+    fLOGON32_LOGON_NETWORK = 3
+    fLOGON32_PROVIDER_DEFAULT = 0
+
+    logon_user = Win32API.new("advapi32", "LogonUser", ['P', 'P', 'P', 'L', 'L', 'P'], 'L')
+    close_handle = Win32API.new("kernel32", "CloseHandle", ['P'], 'V')
+
+    token = 0.chr * 4
+    if logon_user.call(name, ".", password, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, token) == 0
+      raise Puppet::Util::Windows::Error.new("Failed to logon user #{name.inspect}")
+    end
+
+    begin
+      yield token.unpack('L')[0] if block_given?
+    ensure
+      close_handle.call(token.unpack('L')[0])
+    end
+  end
+  module_function :logon_user
+
+  def load_profile(user, password)
+    logon_user(user, password) do |token|
+      # Set up the PROFILEINFO structure that will be used to load the
+      # new user's profile
+      # typedef struct _PROFILEINFO {
+      #   DWORD  dwSize;
+      #   DWORD  dwFlags;
+      #   LPTSTR lpUserName;
+      #   LPTSTR lpProfilePath;
+      #   LPTSTR lpDefaultPath;
+      #   LPTSTR lpServerName;
+      #   LPTSTR lpPolicyPath;
+      #   HANDLE hProfile;
+      # } PROFILEINFO, *LPPROFILEINFO;
+      fPI_NOUI = 1
+      profile = 0.chr * 4
+      pi = [4 * 8, fPI_NOUI, user, nil, nil, nil, nil, profile].pack('LLPPPPPP')
+
+      load_user_profile   = Win32API.new('userenv', 'LoadUserProfile', ['L', 'P'], 'L')
+      unload_user_profile = Win32API.new('userenv', 'UnloadUserProfile', ['L', 'P'], 'L')
+
+      # Load the profile. Since it doesn't exist, it will be created
+      if load_user_profile.call(token, pi) == 0
+        raise Puppet::Util::Windows::Error.new("Failed to load user profile #{user.inspect}")
+      end
+
+      Puppet.debug("Loaded profile for #{user}")
+
+      if unload_user_profile.call(token, pi.unpack('LLLLLLLL').last) == 0
+        raise Puppet::Util::Windows::Error.new("Failed to unload user profile #{user.inspect}")
+      end
+    end
+  end
+  module_function :load_profile
 end

data/lib/puppet/util/zaml.rb

@@ -18,13 +18,35 @@
 #
 # http://github.com/hallettj/zaml
 #
-# Authors: Markus Roberts, Jesse Hallett, Ian McIntosh, Igal Koshevoy, Simon Chiang
+# ## License (from upstream)
 #
+# Copyright (c) 2008-2009 ZAML contributers
+#
+# This program is dual-licensed under the GNU General Public License
+# version 3 or later and under the Apache License, version 2.0.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version; or under the terms of the Apache License,
+# Version 2.0.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License and the Apache License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#
+# You may obtain a copy of the Apache License at
+# <https://www.apache.org/licenses/LICENSE-2.0.html>.
 
 require 'yaml'
 
 class ZAML
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
   #
   # Class Methods
   #
@@ -33,6 +55,7 @@ class ZAML
     stuff.to_zaml(z)
     where << z.to_s
   end
+
   #
   # Instance Methods
   #
@@ -44,12 +67,14 @@ class ZAML
     @next_free_label_number = 0
     emit('--- ')
   end
+
   def nested(tail='  ')
     old_indent = @indent
     @indent = "#{@indent || "\n"}#{tail}"
     yield
     @indent = old_indent
   end
+
   class Label
     #
     # YAML only wants objects in the datastream once; if the same object
@@ -68,51 +93,69 @@ class ZAML
     #    it can be handled).
     #
     attr_accessor :this_label_number
+
     def initialize(obj,indent)
       @indent = indent
       @this_label_number = nil
       @obj = obj # prevent garbage collection so that object id isn't reused
     end
+
     def to_s
       @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
     end
+
     def reference
       @reference         ||= '*id%03d' % @this_label_number
     end
   end
+
   def label_for(obj)
     @previously_emitted_object[obj.object_id]
   end
+
   def new_label_for(obj)
     label = Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"}  " : ' ')
     @previously_emitted_object[obj.object_id] = label
     label
   end
+
   def first_time_only(obj)
     if label = label_for(obj)
       label.this_label_number ||= (@next_free_label_number += 1)
       emit(label.reference)
     else
-      if @structured_key_prefix and not obj.is_a? String
+      with_structured_prefix(obj) do
+        emit(new_label_for(obj))
+        yield
+      end
+    end
+  end
+
+  def with_structured_prefix(obj)
+    if @structured_key_prefix
+      unless obj.is_a?(String) and obj !~ /\n/
         emit(@structured_key_prefix)
         @structured_key_prefix = nil
       end
-      emit(new_label_for(obj))
-      yield
     end
+    yield
   end
+
   def emit(s)
     @result << s
     @recent_nl = false unless s.kind_of?(Label)
   end
-  def nl(s='')
+
+  def nl(s = nil)
     emit(@indent || "\n") unless @recent_nl
-    emit(s)
+    emit(s) if s
     @recent_nl = true
   end
+
   def to_s
     @result.join
   end
+
   def prefix_structured_keys(x)
     @structured_key_prefix = x
     yield
@@ -228,23 +271,13 @@ class Exception
 end
 
 class String
-  ZAML_ESCAPES = %w{\x00 \x01 \x02 \x03 \x04 \x05 \x06 \a \x08 \t \n \v \f \r \x0e \x0f \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 \x1a \e \x1c \x1d \x1e \x1f }
-  def escaped_for_zaml
-    # JJM (Note the trailing dots to construct a multi-line method chain.) This
-    # code is meant to escape all bytes which are not ASCII-8BIT printable
-    # characters.  Multi-byte unicode characters are handled just fine because
-    # each byte of the character results in an escaped string emitted to the
-    # YAML stream.  When the YAML is de-serialized back into a String the bytes
-    # will be reconstructed properly into the unicode character.
-    self.to_ascii8bit.gsub( /\x5C/n, "\\\\\\" ).  # Demi-kludge for Maglev/rubinius; the regexp should be /\\/ but parsetree chokes on that.
-    gsub( /"/n, "\\\"" ).
-    gsub( /([\x00-\x1F])/n ) { |x| ZAML_ESCAPES[ x.unpack("C")[0] ] }
-  end
+  ZAML_ESCAPES = {
+    "\a" => "\\a", "\e" => "\\e", "\f" => "\\f", "\n" => "\\n",
+    "\r" => "\\r", "\t" => "\\t", "\v" => "\\v"
+  }
+
   def to_zaml(z)
-    z.first_time_only(self) {
-      hex_num = '0x[a-f\d]+'
-      float = '\d+\.?\d*'
-      num = "[-+]?(?:#{float}|#{hex_num})"
+    z.with_structured_prefix(self) do
       case
       when self == ''
         z.emit('""')
@@ -258,39 +291,50 @@ class String
                | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
                |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
                )*\z/mnx
-
+        # Emit the binary tag, then recurse. Ruby splits BASE64 output at the 60
+        # character mark when packing strings, and we can wind up a multi-line
+        # string here.  We could reimplement the multi-line string logic,
+        # but why would we - this does just as well for producing solid output.
         z.emit("!binary ")
-        z.emit([self].pack("m*"))
-      when (
-            (self =~ /\A(true|false|yes|no|on|null|off|#{num}(:#{num})*|!|=|~)$/i) or
-            (self =~ /\A\n* /) or
-            (self =~ /[\s:]$/) or
-            (self =~ /^[>|][-+\d]*\s/i) or
-            (self[-1..-1] =~ /\s/) or
-            (self =~ /[,\[\]\{\}\r\t]|:\s|\s#/) or
-            (self =~ /\A([-:?!#&*'"]|<<|%.+:.)/)
-            )
-        z.emit("\"#{escaped_for_zaml}\"")
-      when self =~ /\n/
+        [self].pack("m*").to_zaml(z)
+
+      # Only legal UTF-8 characters can make it this far, so we are safe
+      # against emitting something dubious. That means we don't need to mess
+      # about, just emit them directly. --daniel 2012-07-14
+      when ((self =~ /\A[a-zA-Z\/][-\[\]_\/.:a-zA-Z0-9]*\z/) and
+          (self !~ /^(?:true|false|yes|no|on|null|off)$/i))
+        # simple string literal, safe to emit unquoted.
+        z.emit(self)
+      when (self =~ /\n/ and self !~ /\A\s/ and self !~ /\s\z/)
+        # embedded newline, split line-wise in quoted string block form.
         if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
-        z.nested { split("\n",-1).each { |line| z.nl; z.emit(line.chomp("\n")) } }
+        z.nested { split("\n",-1).each { |line| z.nl; z.emit(line) } }
       else
-        z.emit(self)
+        # ...though we still have to escape unsafe characters.
+        escaped = gsub(/[\\"\x00-\x1F]/) do |c|
+          ZAML_ESCAPES[c] || "\\x#{c[0].ord.to_s(16)}"
+        end
+        z.emit("\"#{escaped}\"")
       end
-    }
+    end
   end
 
   # Return a guranteed ASCII-8BIT encoding for Ruby 1.9 This is a helper
   # method for other methods that perform regular expressions against byte
   # sequences deliberately rather than dealing with characters.
   # The method may or may not return a new instance.
-  def to_ascii8bit
-    if self.respond_to?(:encoding) and self.encoding.name != "ASCII-8BIT" then
-      str = self.dup
-      str.force_encoding("ASCII-8BIT")
-      return str
-    else
-      return self
+  if String.method_defined?(:encoding)
+    ASCII_ENCODING = Encoding.find("ASCII-8BIT")
+    def to_ascii8bit
+      if self.encoding == ASCII_ENCODING
+        self
+      else
+        self.dup.force_encoding(ASCII_ENCODING)
+      end
+    end
+  else
+    def to_ascii8bit
+      self
     end
   end
 end