puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/util/storage.rb

@@ -1,8 +1,6 @@
 require 'yaml'
 require 'sync'
 
-require 'puppet/util/file_locking'
-
 # a class for storing state
 class Puppet::Util::Storage
   include Singleton
@@ -45,27 +43,26 @@ class Puppet::Util::Storage
 
   def self.load
     Puppet.settings.use(:main) unless FileTest.directory?(Puppet[:statedir])
+    filename = Puppet[:statefile]
 
-    unless File.exists?(Puppet[:statefile])
+    unless File.exists?(filename)
       self.init unless !@@state.nil?
       return
     end
-    unless File.file?(Puppet[:statefile])
-      Puppet.warning("Checksumfile #{Puppet[:statefile]} is not a file, ignoring")
+    unless File.file?(filename)
+      Puppet.warning("Checksumfile #{filename} is not a file, ignoring")
       return
     end
     Puppet::Util.benchmark(:debug, "Loaded state") do
-      Puppet::Util::FileLocking.readlock(Puppet[:statefile]) do |file|
+      begin
+        @@state = YAML.load(::File.read(filename))
+      rescue => detail
+        Puppet.err "Checksumfile #{filename} is corrupt (#{detail}); replacing"
+
         begin
-          @@state = YAML.load(file)
-        rescue => detail
-          Puppet.err "Checksumfile #{Puppet[:statefile]} is corrupt (#{detail}); replacing"
-          begin
-            File.rename(Puppet[:statefile], Puppet[:statefile] + ".bad")
-          rescue
-            raise Puppet::Error,
-              "Could not rename corrupt #{Puppet[:statefile]}; remove manually"
-          end
+          File.rename(filename, filename + ".bad")
+        rescue
+          raise Puppet::Error, "Could not rename corrupt #{filename}; remove manually"
         end
       end
     end
@@ -74,8 +71,6 @@ class Puppet::Util::Storage
       Puppet.err "State got corrupted"
       self.init
     end
-
-    #Puppet.debug "Loaded state is #{@@state.inspect}"
   end
 
   def self.stateinspect
@@ -88,8 +83,8 @@ class Puppet::Util::Storage
     Puppet.info "Creating state file #{Puppet[:statefile]}" unless FileTest.exist?(Puppet[:statefile])
 
     Puppet::Util.benchmark(:debug, "Stored state") do
-      Puppet::Util::FileLocking.writelock(Puppet[:statefile], 0660) do |file|
-        file.print YAML.dump(@@state)
+      Puppet::Util.replace_file(Puppet[:statefile], 0660) do |fh|
+        fh.print YAML.dump(@@state)
       end
     end
   end

data/lib/puppet/util/suidmanager.rb

@@ -165,8 +165,33 @@ module Puppet::Util::SUIDManager
 
   module_function :initgroups
 
-  def run_and_capture(command, new_uid=nil, new_gid=nil)
-    output = Puppet::Util.execute(command, :failonfail => false, :combine => true, :uid => new_uid, :gid => new_gid)
+  # Run a command and capture the output
+  # Parameters:
+  # [command] the command to execute
+  # [new_uid] (optional) a userid to run the command as
+  # [new_gid] (optional) a groupid to run the command as
+  # [options] (optional, defaults to {}) a hash of option key/value pairs; currently supported:
+  #   :override_locale (defaults to true) a flag indicating whether or puppet should temporarily override the
+  #     system locale for the duration of the command.  If true, the locale will be set to 'C' to ensure consistent
+  #     output / formatting from the command, which makes it much easier to parse the output.  If false, the system
+  #     locale will be respected.
+  #   :custom_environment (default {}) -- a hash of key/value pairs to set as environment variables for the duration
+  #     of the command
+  def run_and_capture(command, new_uid=nil, new_gid=nil, options = {})
+
+    # specifying these here rather than in the method signature to allow callers to pass in a partial
+    # set of overrides without affecting the default values for options that they don't pass in
+    default_options = {
+        :override_locale => true,
+        :custom_environment => {},
+    }
+
+    options = default_options.merge(options)
+
+    output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
+                                  :uid => new_uid, :gid => new_gid,
+                                  :override_locale => options[:override_locale],
+                                  :custom_environment => options[:custom_environment])
     [output, $CHILD_STATUS.dup]
   end
   module_function :run_and_capture

data/lib/puppet/util/windows.rb

@@ -1,8 +1,11 @@
 module Puppet::Util::Windows
-  require 'puppet/util/windows/error'
-  require 'puppet/util/windows/sid'
-  require 'puppet/util/windows/security'
-  require 'puppet/util/windows/user'
-  require 'puppet/util/windows/process'
-  require 'puppet/util/windows/file'
+  if Puppet::Util::Platform.windows?
+    # these reference platform specific gems
+    require 'puppet/util/windows/error'
+    require 'puppet/util/windows/security'
+    require 'puppet/util/windows/user'
+    require 'puppet/util/windows/process'
+    require 'puppet/util/windows/file'
+  end
+  require 'puppet/util/windows/registry'
 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/registry.rb

@@ -0,0 +1,36 @@
+require 'puppet/util/windows'
+
+module Puppet::Util::Windows
+  module Registry
+    # http://msdn.microsoft.com/en-us/library/windows/desktop/aa384129(v=vs.85).aspx
+    KEY64 = 0x100
+    KEY32 = 0x200
+
+    KEY_READ       = 0x20019
+    KEY_WRITE      = 0x20006
+    KEY_ALL_ACCESS = 0x2003f
+
+    def root(name)
+      Win32::Registry.const_get(name)
+    rescue NameError
+      raise Puppet::Error, "Invalid registry key '#{name}'"
+    end
+
+    def open(name, path, mode = KEY_READ | KEY64, &block)
+      hkey = root(name)
+      begin
+        hkey.open(path, mode) do |subkey|
+          return yield subkey
+        end
+      rescue Win32::Registry::Error => error
+        raise Puppet::Util::Windows::Error.new("Failed to open registry key '#{hkey.keyname}\\#{path}'", error.code)
+      end
+    end
+
+    def values(subkey)
+      values = {}
+      subkey.each_value { |name, type, data| values[name] = data }
+      values
+    end
+  end
+end

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

@@ -72,15 +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 Puppet::Util::Windows::SID
+  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
 
@@ -555,6 +553,45 @@ module Puppet::Util::Windows::Security
     end
   end
 
+  # Convert a SID pointer to a string, e.g. "S-1-5-32-544".
+  def sid_ptr_to_string(psid)
+    sid_buf = 0.chr * 256
+    str_ptr = 0.chr * 4
+
+    raise Puppet::Util::Windows::Error.new("Invalid SID") unless IsValidSid(psid)
+
+    raise Puppet::Util::Windows::Error.new("Failed to convert binary SID") unless ConvertSidToStringSid(psid, str_ptr)
+
+    begin
+      strncpy(sid_buf, str_ptr.unpack('L')[0], sid_buf.size - 1)
+      sid_buf[sid_buf.size - 1] = 0.chr
+      return sid_buf.strip
+    ensure
+      LocalFree(str_ptr.unpack('L')[0])
+    end
+  end
+
+  # Convert a SID string, e.g. "S-1-5-32-544" to a pointer (containing the
+  # address of the binary SID structure). The returned value can be used in
+  # Win32 APIs that expect a PSID, e.g. IsValidSid.
+  def string_to_sid_ptr(string)
+    sid_buf = 0.chr * 80
+    string_addr = [string].pack('p*').unpack('L')[0]
+
+    raise Puppet::Util::Windows::Error.new("Failed to convert string SID: #{string}") unless ConvertStringSidToSid(string_addr, sid_buf)
+
+    sid_ptr = sid_buf.unpack('L')[0]
+    begin
+      if block_given?
+        yield sid_ptr
+      else
+        true
+      end
+    ensure
+      LocalFree(sid_ptr)
+    end
+  end
+
   # Open an existing file with the specified access mode, and execute a
   # block with the opened file HANDLE.
   def open_file(path, access)

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,67 +40,4 @@ 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,35 +18,13 @@
 #
 # http://github.com/hallettj/zaml
 #
-# ## License (from upstream)
+# Authors: Markus Roberts, Jesse Hallett, Ian McIntosh, Igal Koshevoy, Simon Chiang
 #
-# 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.3"
+  VERSION = "0.1.1"
   #
   # Class Methods
   #
@@ -55,7 +33,6 @@ class ZAML
     stuff.to_zaml(z)
     where << z.to_s
   end
-
   #
   # Instance Methods
   #
@@ -67,14 +44,12 @@ 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
@@ -93,69 +68,51 @@ 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
-      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/
+      if @structured_key_prefix and not obj.is_a? String
         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 = nil)
+  def nl(s='')
     emit(@indent || "\n") unless @recent_nl
-    emit(s) if s
+    emit(s)
     @recent_nl = true
   end
-
   def to_s
     @result.join
   end
-
   def prefix_structured_keys(x)
     @structured_key_prefix = x
     yield
@@ -191,7 +148,7 @@ class Object
         else
           instance_variables.each { |v|
             z.nl
-            v[1..-1].to_zaml(z)       # Remove leading '@'
+            v.to_s[1..-1].to_zaml(z)       # Remove leading '@'
             z.emit(': ')
             yaml_property_munge(instance_variable_get(v)).to_zaml(z)
           }
@@ -271,13 +228,23 @@ class Exception
 end
 
 class String
-  ZAML_ESCAPES = {
-    "\a" => "\\a", "\e" => "\\e", "\f" => "\\f", "\n" => "\\n",
-    "\r" => "\\r", "\t" => "\\t", "\v" => "\\v"
-  }
-
+  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
   def to_zaml(z)
-    z.with_structured_prefix(self) do
+    z.first_time_only(self) {
+      hex_num = '0x[a-f\d]+'
+      float = '\d+\.?\d*'
+      num = "[-+]?(?:#{float}|#{hex_num})"
       case
       when self == ''
         z.emit('""')
@@ -291,50 +258,39 @@ 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 ")
-        [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.
+        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/
         if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
-        z.nested { split("\n",-1).each { |line| z.nl; z.emit(line) } }
+        z.nested { split("\n",-1).each { |line| z.nl; z.emit(line.chomp("\n")) } }
       else
-        # ...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}\"")
+        z.emit(self)
       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.
-  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
+  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
     end
   end
 end