puppet 2.7.18 → 2.7.19

data/lib/puppet/parser/functions/sha1.rb

@@ -1,5 +1,5 @@
-Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
-      require 'digest/sha1'
+require 'digest/sha1'
 
+Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
       Digest::SHA1.hexdigest(args[0])
 end

data/lib/puppet/parser/functions/template.rb

@@ -5,8 +5,6 @@ Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :doc =>
   
   Note that if multiple templates are specified, their output is all
   concatenated and returned as the output of the function.") do |vals|
-    require 'erb'
-
     vals.collect do |file|
       # Use a wrapper, so the template can't get access to the full
       # Scope object.

data/lib/puppet/parser/type_loader.rb

@@ -1,3 +1,4 @@
+require 'find'
 require 'puppet/node/environment'
 
 class Puppet::Parser::TypeLoader
@@ -93,8 +94,6 @@ class Puppet::Parser::TypeLoader
   end
 
   def import_all
-    require 'find'
-
     module_names = []
     # Collect the list of all known modules
     environment.modulepath.each do |path|

data/lib/puppet/provider/augeas/augeas.rb

@@ -147,7 +147,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       flags = Augeas::TYPE_CHECK if resource[:type_check] == :true
       flags |= Augeas::NO_MODL_AUTOLOAD if resource[:incl]
       root = resource[:root]
-      load_path = resource[:load_path]
+      load_path = get_load_path(resource)
       debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}")
       @aug = Augeas::open(root, load_path,flags)
 
@@ -253,6 +253,24 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     !!return_value
   end
 
+  # Generate lens load paths from user given paths and local pluginsync dir
+  def get_load_path(resource)
+    load_path = []
+
+    # Permits colon separated strings or arrays
+    if resource[:load_path]
+      load_path = [resource[:load_path]].flatten
+      load_path.map! { |path| path.split(/:/) }
+      load_path.flatten!
+    end
+
+    if File.exists?("#{Puppet[:libdir]}/augeas/lenses")
+      load_path << "#{Puppet[:libdir]}/augeas/lenses"
+    end
+
+    load_path.join(":")
+  end
+
   def get_augeas_version
     @aug.get("/augeas/version") || ""
   end

data/lib/puppet/provider/confine.rb

@@ -25,7 +25,7 @@ class Puppet::Provider::Confine
       begin
         require "puppet/provider/confine/#{name}"
       rescue LoadError => detail
-        unless detail.to_s =~ /No such file/i
+        unless detail.to_s =~ /No such file|cannot load such file/i
           warn "Could not load confine test '#{name}': #{detail}"
         end
         # Could not find file

data/lib/puppet/provider/package/msi.rb

@@ -4,89 +4,135 @@ Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package)
   desc "Windows package management by installing and removing MSIs.
 
     This provider requires a `source` attribute, and will accept paths to local
-    files or files on mapped drives.
-
-    This provider cannot uninstall arbitrary MSI packages; it can only uninstall
-    packages which were originally installed by Puppet."
+    files, mapped drives, or UNC paths."
 
   confine    :operatingsystem => :windows
   defaultfor :operatingsystem => :windows
 
+  has_feature :installable
+  has_feature :uninstallable
   has_feature :install_options
 
-  # This is just here to make sure we can find it, and fail if we
-  # can't.  Unfortunately, we need to do "special" quoting of the
-  # install options or msiexec.exe won't know what to do with them, if
-  # the value contains a space.
-  commands :msiexec => "msiexec.exe"
+  class MsiPackage
+    extend Enumerable
 
-  def self.instances
-    Dir.entries(installed_listing_dir).reject {|d| d == '.' or d == '..'}.collect do |name|
-      new(:name => File.basename(name, '.yml'), :provider => :msi, :ensure => :installed)
+    # From msi.h
+    INSTALLSTATE_DEFAULT = 5 # product is installed for the current user
+    INSTALLUILEVEL_NONE  = 2 # completely silent installation
+
+    def self.installer
+      require 'win32ole'
+      WIN32OLE.new("WindowsInstaller.Installer")
+    end
+
+    def self.each(&block)
+      inst = installer
+      inst.UILevel = INSTALLUILEVEL_NONE
+
+      inst.Products.each do |guid|
+        # products may be advertised, installed in a different user
+        # context, etc, we only want to know about products currently
+        # installed in our context.
+        next unless inst.ProductState(guid) == INSTALLSTATE_DEFAULT
+
+        package = {
+          :name        => inst.ProductInfo(guid, 'ProductName'),
+          # although packages have a version, the provider isn't versionable,
+          # so we can't return a version
+          # :ensure      => inst.ProductInfo(guid, 'VersionString'),
+          :ensure      => :installed,
+          :provider    => :msi,
+          :productcode => guid,
+          :packagecode => inst.ProductInfo(guid, 'PackageCode')
+        }
+
+        yield package
+      end
     end
   end
 
+  # Get an array of provider instances for currently installed packages
+  def self.instances
+    MsiPackage.enum_for.map { |package| new(package) }
+  end
+
+  # Find first package whose PackageCode, e.g. {B2BE95D2-CD2C-46D6-8D27-35D150E58EC9},
+  # matches the resource name (case-insensitively due to hex) or the ProductName matches
+  # the resource name. The ProductName is not guaranteed to be unique, but the PackageCode
+  # should be if the package is authored correctly.
   def query
-    {:name => resource[:name], :ensure => :installed} if FileTest.exists?(state_file)
+    MsiPackage.enum_for.find do |package|
+      resource[:name].casecmp(package[:packagecode]) == 0 || resource[:name] == package[:name]
+    end
   end
 
   def install
-    properties_for_command = nil
-    if resource[:install_options]
-      properties_for_command = resource[:install_options].collect do |k,v|
-        property = shell_quote k
-        value    = shell_quote v
-
-        "#{property}=#{value}"
-      end
-    end
+    fail("The source parameter is required when using the MSI provider.") unless resource[:source]
 
     # Unfortunately, we can't use the msiexec method defined earlier,
     # because of the special quoting we need to do around the MSI
     # properties to use.
-    execute ['msiexec.exe', '/qn', '/norestart', '/i', shell_quote(msi_source), properties_for_command].flatten.compact.join(' ')
-
-    File.open(state_file, 'w') do |f|
-      metadata = {
-        'name'            => resource[:name],
-        'install_options' => resource[:install_options],
-        'source'          => msi_source
-      }
+    command = ['msiexec.exe', '/qn', '/norestart', '/i', shell_quote(resource[:source]), install_options].flatten.compact.join(' ')
+    execute(command, :combine => true)
 
-      f.puts(YAML.dump(metadata))
-    end
+    check_result(exit_status)
   end
 
   def uninstall
-    msiexec '/qn', '/norestart', '/x', msi_source
+    fail("The productcode property is missing.") unless properties[:productcode]
 
-    File.delete state_file
-  end
+    command = ['msiexec.exe', '/qn', '/norestart', '/x', properties[:productcode]].flatten.compact.join(' ')
+    execute(command, :combine => true)
 
-  def validate_source(value)
-    fail("The source parameter cannot be empty when using the MSI provider.") if value.empty?
+    check_result(exit_status)
   end
 
-  private
-
-  def msi_source
-    resource[:source] ||= YAML.load_file(state_file)['source'] rescue nil
-
-    fail("The source parameter is required when using the MSI provider.") unless resource[:source]
+  def exit_status
+    $CHILD_STATUS.exitstatus
+  end
 
-    resource[:source]
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
+  ERROR_SUCCESS                  = 0
+  ERROR_SUCCESS_REBOOT_INITIATED = 1641
+  ERROR_SUCCESS_REBOOT_REQUIRED  = 3010
+
+  # (Un)install may "fail" because the package requested a reboot, the system requested a
+  # reboot, or something else entirely. Reboot requests mean the package was installed
+  # successfully, but we warn since we don't have a good reboot strategy.
+  def check_result(hr)
+    operation = resource[:ensure] == :absent ? 'uninstall' : 'install'
+
+    case hr
+    when ERROR_SUCCESS
+      # yeah
+    when 194
+      warning("The package requested a reboot to finish the operation.")
+    when ERROR_SUCCESS_REBOOT_INITIATED
+      warning("The package #{operation}ed successfully and the system is rebooting now.")
+    when ERROR_SUCCESS_REBOOT_REQUIRED
+      warning("The package #{operation}ed successfully, but the system must be rebooted.")
+    else
+      raise Puppet::Util::Windows::Error.new("Failed to #{operation}", hr)
+    end
   end
 
-  def self.installed_listing_dir
-    listing_dir = File.join(Puppet[:vardir], 'db', 'package', 'msi')
+  def validate_source(value)
+    fail("The source parameter cannot be empty when using the MSI provider.") if value.empty?
+  end
 
-    FileUtils.mkdir_p listing_dir unless File.directory? listing_dir
+  def install_options
+    # properties is a string delimited by spaces, so each key value must be quoted
+    properties_for_command = nil
+    if resource[:install_options]
+      properties_for_command = resource[:install_options].collect do |k,v|
+        property = shell_quote k
+        value    = shell_quote v
 
-    listing_dir
-  end
+        "#{property}=#{value}"
+      end
+    end
 
-  def state_file
-    File.join(self.class.installed_listing_dir, "#{resource[:name]}.yml")
+    properties_for_command
   end
 
   def shell_quote(value)

data/lib/puppet/provider/scheduled_task/win32_taskscheduler.rb

@@ -232,6 +232,7 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
     unless resource[:ensure] == :absent
       self.fail('Parameter command is required.') unless resource[:command]
       task.save
+      @task = nil
     end
   end
 

data/lib/puppet/provider/service/gentoo.rb

@@ -12,8 +12,6 @@ Puppet::Type.type(:service).provide :gentoo, :parent => :init do
 
   confine :operatingsystem => :gentoo
 
-  defaultfor :operatingsystem => :gentoo
-
   def self.defpath
     superclass.defpath
   end

data/lib/puppet/provider/service/openrc.rb

@@ -0,0 +1,69 @@
+# Gentoo OpenRC
+Puppet::Type.type(:service).provide :openrc, :parent => :base do
+  desc <<-EOT
+    Support for Gentoo's OpenRC initskripts
+
+    Uses rc-update, rc-status and rc-service to manage services.
+
+  EOT
+
+  defaultfor :operatingsystem => :gentoo
+  defaultfor :operatingsystem => :funtoo
+
+  commands :rcservice => '/sbin/rc-service'
+  commands :rcstatus  => '/bin/rc-status'
+  commands :rcupdate  => '/sbin/rc-update'
+
+  self::STATUSLINE = /^\s+(.*?)\s*\[\s*(.*)\s*\]$/
+
+  def enable
+    rcupdate('-C', :add, @resource[:name])
+  end
+
+  def disable
+    rcupdate('-C', :del, @resource[:name])
+  end
+
+  # rc-status -a shows all runlevels and dynamic runlevels which
+  # are not considered as enabled. We have to find out under which
+  # runlevel our service is listed
+  def enabled?
+    enabled = :false
+    rcstatus('-C', '-a').each_line do |line|
+      case line.chomp
+      when /^Runlevel: /
+        enabled = :true
+      when /^\S+/ # caption of a dynamic runlevel
+        enabled = :false
+      when self.class::STATUSLINE
+        return enabled if @resource[:name] == $1
+      end
+    end
+    :false
+  end
+
+  def self.instances
+    instances = []
+    rcservice('-C', '--list').each_line do |line|
+      instances << new(:name => line.chomp)
+    end
+    instances
+  end
+
+  def restartcmd
+    (@resource[:hasrestart] == :true) && [command(:rcservice), @resource[:name], :restart]
+  end
+
+  def startcmd
+    [command(:rcservice), @resource[:name], :start ]
+  end
+
+  def stopcmd
+    [command(:rcservice), @resource[:name], :stop]
+  end
+
+  def statuscmd
+    ((@resource.provider.get(:hasstatus) == true) || (@resource[:hasstatus] == :true)) && [command(:rcservice), @resource[:name], :status]
+  end
+
+end

data/lib/puppet/provider/service/windows.rb

@@ -18,6 +18,8 @@ Puppet::Type.type(:service).provide :windows do
 
   has_feature :refreshable
 
+  commands :net => 'net.exe'
+
   def enable
     w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_AUTO_START )
     raise Puppet::Error.new("Win32 service enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
@@ -73,14 +75,14 @@ Puppet::Type.type(:service).provide :windows do
       end
     end
 
-    Win32::Service.start( @resource[:name] )
-  rescue Win32::Service::Error => detail
+    net(:start, @resource[:name])
+  rescue Puppet::ExecutionFailure => detail
     raise Puppet::Error.new("Cannot start #{@resource[:name]}, error was: #{detail}" )
   end
 
   def stop
-    Win32::Service.stop( @resource[:name] )
-  rescue Win32::Service::Error => detail
+    net(:stop, @resource[:name])
+  rescue Puppet::ExecutionFailure => detail
     raise Puppet::Error.new("Cannot stop #{@resource[:name]}, error was: #{detail}" )
   end
 

data/lib/puppet/provider/user/aix.rb

@@ -253,12 +253,16 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     tmpfile.close()
 
     # Options '-e', '-c', use encrypted password and clear flags
-    # Must receibe "user:enc_password" as input
+    # Must receive "user:enc_password" as input
     # command, arguments = {:failonfail => true, :combine => true}
-    cmd = [self.class.command(:chpasswd),"-R", self.class.ia_module,
-           '-e', '-c', user]
+    # Fix for bugs #11200 and #10915
+    cmd = [self.class.command(:chpasswd), get_ia_module_args, '-e', '-c', user].flatten
     begin
-      execute(cmd, {:failonfail => true, :combine => true, :stdinfile => tmpfile.path })
+      output = execute(cmd, {:failonfail => false, :combine => true, :stdinfile => tmpfile.path })
+      # chpasswd can return 1, even on success (at least on AIX 6.1); empty output indicates success
+      if output != ""
+        raise Puppet::ExecutionFailure, "chpasswd said #{output}"
+      end
     rescue Puppet::ExecutionFailure  => detail
       raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
     ensure

data/lib/puppet/provider/user/useradd.rb

@@ -75,6 +75,12 @@ Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameServ
     cmd += check_system_users
     cmd << @resource[:name]
   end
+  
+  def deletecmd
+    cmd = [command(:delete)]
+    cmd += @resource.managehome? ? ['-r'] : []
+    cmd << @resource[:name]
+  end
 
   def passcmd
     age_limits = [:password_min_age, :password_max_age].select { |property| @resource.should(property) }

data/lib/puppet/rails/benchmark.rb

@@ -1,4 +1,6 @@
 require 'benchmark'
+require 'yaml'
+
 module Puppet::Rails::Benchmark
   $benchmarks = {:accumulated => {}}
 
@@ -50,8 +52,6 @@ module Puppet::Rails::Benchmark
 
     file = "/tmp/time_debugging.yaml"
 
-    require 'yaml'
-
     if FileTest.exist?(file)
       data = YAML.load_file(file)
     else

data/lib/puppet/reports/store.rb

@@ -13,11 +13,7 @@ Puppet::Reports.register_report(:store) do
     default report)."
 
   def process
-    # We don't want any tracking back in the fs.  Unlikely, but there
-    # you go.
-    if host =~ Regexp.union(/[#{SEPARATOR}]/, /\A\.\.?\Z/)
-      raise ArgumentError, "Invalid node name #{host.inspect}"
-    end
+    validate_host(host)
 
     dir = File.join(Puppet[:reportdir], host)
 
@@ -55,9 +51,7 @@ Puppet::Reports.register_report(:store) do
 
   # removes all reports for a given host?
   def self.destroy(host)
-    if host =~ Regexp.union(/[#{SEPARATOR}]/, /\A\.\.?\Z/)
-      raise ArgumentError, "Invalid node name #{host.inspect}"
-    end
+    validate_host(host)
 
     dir = File.join(Puppet[:reportdir], host)
 
@@ -70,5 +64,11 @@ Puppet::Reports.register_report(:store) do
       Dir.rmdir(dir)
     end
   end
-end
 
+  def validate_host(host)
+    if host =~ Regexp.union(/[#{SEPARATOR}]/, /\A\.\.?\Z/)
+      raise ArgumentError, "Invalid node name #{host.inspect}"
+    end
+  end
+  module_function :validate_host
+end