puppet 3.4.2 → 3.4.3

data/lib/puppet/type/file.rb

@@ -369,6 +369,10 @@ Puppet::Type.newtype(:file) do
     stat ? true : false
   end
 
+  def present?(current_values)
+    super && current_values[:ensure] != :false
+  end
+
   # We have to do some extra finishing, to retrieve our bucket if
   # there is one.
   def finish

data/lib/puppet/type/interface.rb

@@ -109,4 +109,8 @@ Puppet::Type.newtype(:interface) do
         super(currentvalue, newvalue)
       end
     end
+
+  def present?(current_values)
+    super && current_values[:ensure] != :shutdown
+  end
 end

data/lib/puppet/type/mount.rb

@@ -7,8 +7,10 @@ module Puppet
       information into the mount table. The actual behavior depends
       on the value of the 'ensure' parameter.
 
-      Note that if a `mount` receives an event from another resource,
-      it will try to remount the filesystems if `ensure` is set to `mounted`.
+      **Refresh:** `mount` resources can respond to refresh events (via
+      `notify`, `subscribe`, or the `~>` arrow). If a `mount` receives an event
+      from another resource **and** its `ensure` attribute is set to `mounted`,
+      Puppet will try to unmount then remount that filesystem.
 
       **Autorequires:** If Puppet is managing any parents of a mount resource ---
       that is, other mount points higher up in the filesystem --- the child

data/lib/puppet/type/package.rb

@@ -376,5 +376,9 @@ module Puppet
     def exists?
       @provider.get(:ensure) != :absent
     end
+
+    def present?(current_values)
+      super && current_values[:ensure] != :purged
+    end
   end
 end

data/lib/puppet/type/schedule.rb

@@ -52,16 +52,16 @@ module Puppet
 
     newparam(:name) do
       desc <<-EOT
-        The name of the schedule.  This name is used to retrieve the
-        schedule when assigning it to an object:
+        The name of the schedule.  This name is used when assigning the schedule
+        to a resource with the `schedule` metaparameter:
 
-            schedule { 'daily':
+            schedule { 'everyday':
               period => daily,
               range  => "2 - 4",
             }
 
             exec { "/usr/bin/apt-get update":
-              schedule => 'daily',
+              schedule => 'everyday',
             }
 
         EOT
@@ -236,8 +236,8 @@ module Puppet
 
     newparam(:period) do
       desc <<-EOT
-        The period of repetition for a resource. The default is for a resource
-        to get applied every time Puppet runs.
+        The period of repetition for resources on this schedule. The default is
+        for resources to get applied every time Puppet runs.
 
         Note that the period defines how often a given resource will get
         applied but not when; if you would like to restrict the hours
@@ -256,10 +256,11 @@ module Puppet
 
         This can cause Puppet to apply that resource up to every 10 minutes.
 
-        At the moment, Puppet cannot guarantee that level of
-        repetition; that is, it can run up to every 10 minutes, but
-        internal factors might prevent it from actually running that
-        often (e.g., long-running Puppet runs will squash conflictingly scheduled runs).
+        At the moment, Puppet cannot guarantee that level of repetition; that
+        is, the resource can applied _up to_ every 10 minutes, but internal
+        factors might prevent it from actually running that often (e.g. if a
+        Puppet run is still in progress when the next run is scheduled to start,
+        that next run will be suppressed).
 
         See the `periodmatch` attribute for tuning whether to match
         times by their distance apart or by their specific value.
@@ -347,9 +348,9 @@ module Puppet
         The days of the week in which the schedule should be valid.
         You may specify the full day name (Tuesday), the three character
         abbreviation (Tue), or a number corresponding to the day of the
-        week where 0 is Sunday, 1 is Monday, etc. You may pass an array
-        to specify multiple days. If not specified, the day of the week
-        will not be considered in the schedule.
+        week where 0 is Sunday, 1 is Monday, etc. Multiple days can be specified
+        as an array. If not specified, the day of the week will not be
+        considered in the schedule.
 
         If you are also using a range match that spans across midnight
         then this parameter will match the day that it was at the start

data/lib/puppet/type/service.rb

@@ -19,12 +19,15 @@ module Puppet
       need to set `hasstatus` to false and possibly specify a custom status
       command in the `status` attribute.
 
-      Note that if a `service` receives an event from another resource,
-      the service will get restarted. The actual command to restart the
-      service depends on the platform. You can provide an explicit command for
-      restarting with the `restart` attribute, or you can set `hasrestart` to
-      true to use the init script's restart command; if you do neither, the
-      service's stop and start commands will be used."
+      **Refresh:** `service` resources can respond to refresh events (via
+      `notify`, `subscribe`, or the `~>` arrow). If a `service` receives an
+      event from another resource, Puppet will restart the service it manages.
+      The actual command used to restart the service depends on the platform and
+      can be configured:
+
+      * If you set `hasrestart` to true, Puppet will use the init script's restart command.
+      * You can provide an explicit command for restarting with the `restart` attribute.
+      * If you do neither, the service's stop and start commands will be used."
 
     feature :refreshable, "The provider can restart the service.",
       :methods => [:restart]

data/lib/puppet/type/stage.rb

@@ -1,19 +1,27 @@
 Puppet::Type.newtype(:stage) do
-  desc "A resource type for specifying run stages.  The actual stage should
-  be specified on resources:
+  desc "A resource type for creating new run stages.  Once a stage is available,
+    classes can be assigned to it by declaring them with the resource-like syntax
+    and using
+    [the `stage` metaparameter](http://docs.puppetlabs.com/references/latest/metaparameter.html#stage).
 
-      class { foo: stage => pre }
+    Note that new stages are not useful unless you also declare their order
+    in relation to the default `main` stage.
 
-  And you must manually control stage order:
+    A complete run stage example:
 
-      stage { pre: before => Stage[main] }
+        stage { 'pre':
+          before => Stage['main'],
+        }
 
-  You automatically get a 'main' stage created, and by default all resources
-  get inserted into that stage.
+        class { 'apt-updates':
+          stage => 'pre',
+        }
 
-  You can only set stages on class resources, not normal builtin resources."
+    Individual resources cannot be assigned to run stages; you can only set stages
+    for classes."
 
   newparam :name do
-    desc "The name of the stage. This will be used as the 'stage' for each resource."
+    desc "The name of the stage. Use this as the value for the `stage` metaparameter
+      when assigning classes to this stage."
   end
 end

data/lib/puppet/type/user.rb

@@ -165,7 +165,7 @@ module Puppet
     newproperty(:comment) do
       desc "A description of the user.  Generally the user's full name."
       munge do |v|
-        v.respond_to?(:encode) ? v.encode(Encoding::ASCII_8BIT) : v
+        v.respond_to?(:force_encoding) ? v.force_encoding(Encoding::ASCII_8BIT) : v
       end
     end
 

data/lib/puppet/util/monkey_patches.rb

@@ -67,19 +67,24 @@ class Object
 end
 
 class Symbol
-  # So, it turns out that one of the biggest memory allocation hot-spots in
-  # our code was using symbol-to-proc - because it allocated a new instance
-  # every time it was called, rather than caching.
+  # So, it turns out that one of the biggest memory allocation hot-spots in our
+  # code was using symbol-to-proc - because it allocated a new instance every
+  # time it was called, rather than caching (in Ruby 1.8.7 and earlier).
+  #
+  # In Ruby 1.9.3 and later Symbol#to_proc does implement a cache so we skip
+  # our monkey patch.
   #
   # Changing this means we can see XX memory reduction...
-  if method_defined? :to_proc
-    alias __original_to_proc to_proc
-    def to_proc
-      @my_proc ||= __original_to_proc
-    end
-  else
-    def to_proc
-      @my_proc ||= Proc.new {|*args| args.shift.__send__(self, *args) }
+  if RUBY_VERSION < "1.9.3"
+    if method_defined? :to_proc
+      alias __original_to_proc to_proc
+      def to_proc
+        @my_proc ||= __original_to_proc
+      end
+    else
+      def to_proc
+        @my_proc ||= Proc.new {|*args| args.shift.__send__(self, *args) }
+      end
     end
   end
 

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

@@ -146,6 +146,10 @@ module RDoc
       @childs = []
     end
 
+    def aref_prefix
+      'puppet_class'
+    end
+
     def add_resource(resource)
       add_to(@resource_list, resource)
     end

data/lib/puppet/util/windows.rb

@@ -6,6 +6,7 @@ module Puppet::Util::Windows
     require 'puppet/util/windows/security'
     require 'puppet/util/windows/user'
     require 'puppet/util/windows/process'
+    require 'puppet/util/windows/string'
     require 'puppet/util/windows/file'
     require 'puppet/util/windows/root_certs'
     require 'puppet/util/windows/access_control_entry'

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

@@ -3,22 +3,31 @@ require 'puppet/util/windows'
 module Puppet::Util::Windows::File
   require 'ffi'
   require 'windows/api'
-  require 'windows/wide_string'
 
-  ReplaceFileWithoutBackupW = Windows::API.new('ReplaceFileW', 'PPVLVV', 'B')
   def replace_file(target, source)
-    result = ReplaceFileWithoutBackupW.call(WideString.new(target.to_s),
-                                   WideString.new(source.to_s),
-                                   0, 0x1, 0, 0)
-    return true unless result == 0
+    target_encoded = Puppet::Util::Windows::String.wide_string(target.to_s)
+    source_encoded = Puppet::Util::Windows::String.wide_string(source.to_s)
+
+    flags = 0x1
+    backup_file = nil
+    result = API.replace_file(
+      target_encoded,
+      source_encoded,
+      backup_file,
+      flags,
+      0,
+      0
+    )
+
+    return true if result
     raise Puppet::Util::Windows::Error.new("ReplaceFile(#{target}, #{source})")
   end
   module_function :replace_file
 
   MoveFileEx = Windows::API.new('MoveFileExW', 'PPL', 'B')
   def move_file_ex(source, target, flags = 0)
-    result = MoveFileEx.call(WideString.new(source.to_s),
-                             WideString.new(target.to_s),
+    result = MoveFileEx.call(Puppet::Util::Windows::String.wide_string(source.to_s),
+                             Puppet::Util::Windows::String.wide_string(target.to_s),
                              flags)
     return true unless result == 0
     raise Puppet::Util::Windows::Error.
@@ -31,6 +40,20 @@ module Puppet::Util::Windows::File
     ffi_lib 'kernel32'
     ffi_convention :stdcall
 
+    # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365512(v=vs.85).aspx
+    # BOOL WINAPI ReplaceFile(
+    #   _In_        LPCTSTR lpReplacedFileName,
+    #   _In_        LPCTSTR lpReplacementFileName,
+    #   _In_opt_    LPCTSTR lpBackupFileName,
+    #   _In_        DWORD dwReplaceFlags - 0x1 REPLACEFILE_WRITE_THROUGH,
+    #                                      0x2 REPLACEFILE_IGNORE_MERGE_ERRORS,
+    #                                      0x4 REPLACEFILE_IGNORE_ACL_ERRORS
+    #   _Reserved_  LPVOID lpExclude,
+    #   _Reserved_  LPVOID lpReserved
+    # );
+    attach_function :replace_file, :ReplaceFileW,
+      [:buffer_in, :buffer_in, :buffer_in, :uint, :uint, :uint], :bool
+
     # BOOLEAN WINAPI CreateSymbolicLink(
     #   _In_  LPTSTR lpSymlinkFileName, - symbolic link to be created
     #   _In_  LPTSTR lpTargetFileName, - name of target for symbolic link
@@ -102,8 +125,8 @@ module Puppet::Util::Windows::File
 
   def symlink(target, symlink)
     flags = File.directory?(target) ? 0x1 : 0x0
-    result = API.create_symbolic_link(WideString.new(symlink.to_s),
-      WideString.new(target.to_s), flags)
+    result = API.create_symbolic_link(Puppet::Util::Windows::String.wide_string(symlink.to_s),
+      Puppet::Util::Windows::String.wide_string(target.to_s), flags)
     return true if result
     raise Puppet::Util::Windows::Error.new(
       "CreateSymbolicLink(#{symlink}, #{target}, #{flags.to_s(8)})")
@@ -112,7 +135,7 @@ module Puppet::Util::Windows::File
 
   INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF #define INVALID_FILE_ATTRIBUTES (DWORD (-1))
   def self.get_file_attributes(file_name)
-    result = API.get_file_attributes(WideString.new(file_name.to_s))
+    result = API.get_file_attributes(Puppet::Util::Windows::String.wide_string(file_name.to_s))
     return result unless result == INVALID_FILE_ATTRIBUTES
     raise Puppet::Util::Windows::Error.new("GetFileAttributes(#{file_name})")
   end
@@ -121,7 +144,7 @@ module Puppet::Util::Windows::File
   def self.create_file(file_name, desired_access, share_mode, security_attributes,
     creation_disposition, flags_and_attributes, template_file_handle)
 
-    result = API.create_file(WideString.new(file_name.to_s),
+    result = API.create_file(Puppet::Util::Windows::String.wide_string(file_name.to_s),
       desired_access, share_mode, security_attributes, creation_disposition,
       flags_and_attributes, template_file_handle)
 
@@ -173,7 +196,7 @@ module Puppet::Util::Windows::File
   def self.open_symlink(link_name)
     begin
       yield handle = create_file(
-      WideString.new(link_name.to_s),
+      Puppet::Util::Windows::String.wide_string(link_name.to_s),
       GENERIC_READ,
       FILE_SHARE_READ,
       nil, # security_attributes

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

@@ -52,8 +52,8 @@ module Puppet::Util::Windows::Process
     #   _In_      LPCTSTR lpName,
     #   _Out_     PLUID lpLuid
     # );
-    attach_function :lookup_privilege_value, :LookupPrivilegeValueW,
-      [:buffer_in, :buffer_in, :pointer], :bool
+    attach_function :lookup_privilege_value, :LookupPrivilegeValueA,
+      [:string, :string, :pointer], :bool
 
     Token_Information = enum(
         :token_user, 1,
@@ -169,8 +169,11 @@ module Puppet::Util::Windows::Process
 
   def lookup_privilege_value(name, system_name = '')
     luid = FFI::MemoryPointer.new(API::LUID.size)
-    result = API.lookup_privilege_value(WideString.new(system_name),
-      WideString.new(name.to_s), luid)
+    result = API.lookup_privilege_value(
+      system_name,
+      name.to_s,
+      luid
+      )
 
     return API::LUID.new(luid) if result
     raise Puppet::Util::Windows::Error.new(

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

@@ -29,8 +29,42 @@ module Puppet::Util::Windows
 
     def values(subkey)
       values = {}
-      subkey.each_value { |name, type, data| values[name] = data }
+      subkey.each_value do |name, type, data|
+        case type
+        when Win32::Registry::REG_MULTI_SZ
+          data.each { |str| force_encoding(str) }
+        when Win32::Registry::REG_SZ, Win32::Registry::REG_EXPAND_SZ
+          force_encoding(data)
+        end
+        values[name] = data
+      end
       values
     end
+
+    if defined?(Encoding)
+      def force_encoding(str)
+        if @encoding.nil?
+          # See https://bugs.ruby-lang.org/issues/8943
+          # Ruby uses ANSI versions of Win32 APIs to read values from the
+          # registry. The encoding of these strings depends on the active
+          # code page. However, ruby incorrectly sets the string
+          # encoding to US-ASCII. So we must force the encoding to the
+          # correct value.
+          require 'windows/national'
+          begin
+            cp = Windows::National::GetACP.call
+            @encoding = Encoding.const_get("CP#{cp}")
+          rescue
+            @encoding = Encoding.default_external
+          end
+        end
+
+        str.force_encoding(@encoding)
+      end
+    else
+      def force_encoding(str, enc)
+      end
+    end
+    private :force_encoding
   end
 end

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

@@ -0,0 +1,14 @@
+require 'puppet/util/windows'
+
+module Puppet::Util::Windows::String
+  def wide_string(str)
+    # ruby (< 2.1) does not respect multibyte terminators, so it is possible
+    # for a string to contain a single trailing null byte, followed by garbage
+    # causing buffer overruns.
+    #
+    # See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
+    newstr = str + "\0".encode(str.encoding)
+    newstr.encode!('UTF-16LE')
+  end
+  module_function :wide_string
+end

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.4.2'
+  PUPPETVERSION = '3.4.3'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/util_spec.rb

@@ -77,4 +77,35 @@ describe Puppet::Util do
       new_sd.dacl.should == expected_sd.dacl
     end
   end
+
+  it "replace_file should work with filenames that include - and . (PUP-1389)", :if => Puppet.features.microsoft_windows? do
+    expected_content = 'some content'
+    dir = tmpdir('ReplaceFile_playground')
+    destination_file = File.join(dir, 'some-file.xml')
+
+    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+        temp_file.open
+        temp_file.write(expected_content)
+    end
+
+    actual_content = File.read(destination_file)
+    actual_content.should == expected_content
+  end
+
+  it "replace_file should work with filenames that include special characters (PUP-1389)", :if => Puppet.features.microsoft_windows? do
+    expected_content = 'some content'
+    dir = tmpdir('ReplaceFile_playground')
+    # http://www.fileformat.info/info/unicode/char/00e8/index.htm
+    # dest_name = "somèfile.xml"
+    dest_name = "som\u00E8file.xml"
+    destination_file = File.join(dir, dest_name)
+
+    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+        temp_file.open
+        temp_file.write(expected_content)
+    end
+
+    actual_content = File.read(destination_file)
+    actual_content.should == expected_content
+  end
 end