puppet 5.0.0 → 6.0.0

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

@@ -16,54 +16,48 @@ Puppet::Type.type(:service).provide :windows, :parent => :service 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? )
+    Puppet::Util::Windows::Service.set_startup_mode( @resource[:name], :SERVICE_AUTO_START )
   rescue => detail
-    raise Puppet::Error.new("Cannot enable #{@resource[:name]}, error was: #{detail}", detail )
+    raise Puppet::Error.new(_("Cannot enable %{resource_name}, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
 
   def disable
-    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DISABLED )
-    raise Puppet::Error.new("Win32 service disable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+    Puppet::Util::Windows::Service.set_startup_mode( @resource[:name], :SERVICE_DISABLED )
   rescue => detail
-    raise Puppet::Error.new("Cannot disable #{@resource[:name]}, error was: #{detail}", detail )
+    raise Puppet::Error.new(_("Cannot disable %{resource_name}, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
 
   def manual_start
-    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DEMAND_START )
-    raise Puppet::Error.new("Win32 service manual enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+    Puppet::Util::Windows::Service.set_startup_mode( @resource[:name], :SERVICE_DEMAND_START )
   rescue => detail
-    raise Puppet::Error.new("Cannot enable #{@resource[:name]} for manual start, error was: #{detail}", detail )
+    raise Puppet::Error.new(_("Cannot enable %{resource_name} for manual start, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
 
   def enabled?
-    w32ss = Win32::Service.config_info( @resource[:name] )
-    raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceConfigInfo ) )
-    debug("Service #{@resource[:name]} start type is #{w32ss.start_type}")
-    case w32ss.start_type
-      when Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START),
-           Win32::Service.get_start_type(Win32::Service::SERVICE_BOOT_START),
-           Win32::Service.get_start_type(Win32::Service::SERVICE_SYSTEM_START)
+    start_type = Puppet::Util::Windows::Service.service_start_type(@resource[:name])
+    debug("Service #{@resource[:name]} start type is #{start_type}")
+    case start_type
+      when :SERVICE_AUTO_START,
+           :SERVICE_BOOT_START,
+           :SERVICE_SYSTEM_START
         :true
-      when Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
+      when :SERVICE_DEMAND_START
         :manual
-      when Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
+      when :SERVICE_DISABLED
         :false
       else
-        raise Puppet::Error.new("Unknown start type: #{w32ss.start_type}")
+        raise Puppet::Error.new(_("Unknown start type: %{start_type}") % { start_type: start_type })
     end
   rescue => detail
-    raise Puppet::Error.new("Cannot get start type for #{@resource[:name]}, error was: #{detail}", detail )
+    raise Puppet::Error.new(_("Cannot get start type %{resource_name}, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
 
   def start
     if enabled? == :false
       # If disabled and not managing enable, respect disabled and fail.
       if @resource[:enable].nil?
-        raise Puppet::Error, "Will not start disabled service #{@resource[:name]} without managing enable. Specify 'enable => false' to override."
+        raise Puppet::Error.new(_("Will not start disabled service %{resource_name} without managing enable. Specify 'enable => false' to override.") % { resource_name: @resource[:name] })
       # Otherwise start. If enable => false, we will later sync enable and
       # disable the service again.
       elsif @resource[:enable] == :true
@@ -72,35 +66,38 @@ Puppet::Type.type(:service).provide :windows, :parent => :service do
         manual_start
       end
     end
-
-    net(:start, @resource[:name])
-  rescue Puppet::ExecutionFailure => detail
-    raise Puppet::Error.new("Cannot start #{@resource[:name]}, error was: #{detail}", detail )
+    Puppet::Util::Windows::Service.start(@resource[:name])
   end
 
   def stop
-    net(:stop, @resource[:name])
-  rescue Puppet::ExecutionFailure => detail
-    raise Puppet::Error.new("Cannot stop #{@resource[:name]}, error was: #{detail}", detail )
+    Puppet::Util::Windows::Service.stop(@resource[:name])
   end
 
   def status
-    w32ss = Win32::Service.status( @resource[:name] )
-    raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceStatus ) )
-    state = case w32ss.current_state
-      when "stopped", "pause pending", "stop pending", "paused" then :stopped
-      when "running", "continue pending", "start pending"       then :running
+    current_state = Puppet::Util::Windows::Service.service_state(@resource[:name])
+    state = case current_state
+      when :SERVICE_STOPPED,
+           :SERVICE_PAUSED,
+           :SERVICE_STOP_PENDING,
+           :SERVICE_PAUSE_PENDING
+        :stopped
+      when :SERVICE_RUNNING,
+           :SERVICE_CONTINUE_PENDING,
+           :SERVICE_START_PENDING
+        :running
       else
-        raise Puppet::Error.new("Unknown service state '#{w32ss.current_state}' for service '#{@resource[:name]}'")
+        raise Puppet::Error.new(_("Unknown service state '%{current_state}' for service '%{resource_name}'") % { current_state: current_state, resource_name: @resource[:name] })
     end
-    debug("Service #{@resource[:name]} is #{w32ss.current_state}")
+    debug("Service #{@resource[:name]} is #{current_state}")
     return state
-  rescue => detail
-    raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}", detail )
   end
 
   # returns all providers for all existing services and startup state
   def self.instances
-    Win32::Service.services.collect { |s| new(:name => s.service_name) }
+    services = []
+    Puppet::Util::Windows::Service.services.each do |service_name, _|
+      services.push(new(:name => service_name))
+    end
+    services
   end
 end

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

@@ -1,25 +1,21 @@
-#
 # User Puppet provider for AIX. It uses standard commands to manage users:
 #  mkuser, rmuser, lsuser, chuser
 #
 # Notes:
 # - AIX users can have expiry date defined with minute granularity,
-#   but puppet does not allow it. There is a ticket open for that (#5431)
+#   but Puppet does not allow it. There is a ticket open for that (#5431)
+#
 # - AIX maximum password age is in WEEKs, not days
 #
-# See  https://docs.puppetlabs.com/guides/provider_development.html
+# See https://puppet.com/docs/puppet/latest/provider_development.html
 # for more information
-#
-# Author::    Hector Rivas Gandara <keymon@gmail.com>
-#
-require 'puppet/provider/aixobject'
+require 'puppet/provider/aix_object'
 require 'tempfile'
 require 'date'
 
 Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   desc "User management for AIX."
 
-  # This will the default provider for this platform
   defaultfor :operatingsystem => :aix
   confine :operatingsystem => :aix
 
@@ -29,7 +25,6 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   commands :delete    => "/usr/sbin/rmuser"
   commands :modify    => "/usr/bin/chuser"
 
-  commands :lsgroup   => "/usr/sbin/lsgroup"
   commands :chpasswd  => "/bin/chpasswd"
 
   # Provider features
@@ -37,288 +32,189 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   has_features :manages_homedir, :manages_passwords, :manages_shell
   has_features :manages_expiry,  :manages_password_age
 
-  # Attribute verification (TODO)
-  #verify :gid, "GID must be a string or int of a valid group" do |value|
-  #  value.is_a? String || value.is_a? Integer
-  #end
-  #
-  #verify :groups, "Groups must be comma-separated" do |value|
-  #  value !~ /\s/
-  #end
-
-  # User attributes to ignore from AIX output.
-  def self.attribute_ignore
-    ["name"]
-  end
-
-  # AIX attributes to properties mapping.
-  #
-  # Valid attributes to be managed by this provider.
-  # It is a list with of hash
-  #  :aix_attr      AIX command attribute name
-  #  :puppet_prop   Puppet property name
-  #  :to            Method to adapt puppet property to aix command value. Optional.
-  #  :from          Method to adapt aix command value to puppet property. Optional
-  self.attribute_mapping = [
-    {:aix_attr => :pgrp,       :puppet_prop => :gid,
-                                :to => :gid_to_attr,
-                                :from => :gid_from_attr },
-    {:aix_attr => :id,         :puppet_prop => :uid},
-    {:aix_attr => :groups,     :puppet_prop => :groups},
-    {:aix_attr => :home,       :puppet_prop => :home},
-    {:aix_attr => :shell,      :puppet_prop => :shell},
-    {:aix_attr => :expires,    :puppet_prop => :expiry,
-                                :to => :expiry_to_attr,
-                                :from => :expiry_from_attr },
-    {:aix_attr => :maxage,     :puppet_prop => :password_max_age},
-    {:aix_attr => :minage,     :puppet_prop => :password_min_age},
-    {:aix_attr => :attributes, :puppet_prop => :attributes},
-    { :aix_attr => :gecos,      :puppet_prop => :comment },
-  ]
-
-  #--------------
-  # Command definition
-
-  # Return the IA module arguments based on the resource param ia_load_module
-  def get_ia_module_args
-    if @resource[:ia_load_module]
-      ["-R", @resource[:ia_load_module].to_s]
-    else
-      []
+  class << self
+    def group_provider
+      @group_provider ||= Puppet::Type.type(:group).provider(:aix)
     end
-  end
 
-  # List groups and Ids
-  def lsgroupscmd(value=@resource[:name])
-    [command(:lsgroup)] +
-      self.get_ia_module_args +
-      ["-a", "id", value]
-  end
+    # Define some Puppet Property => AIX Attribute (and vice versa)
+    # conversion functions here.
 
-  def lscmd(value=@resource[:name])
-    [self.class.command(:list), "-c"] + self.get_ia_module_args + [ value]
-  end
+    def gid_to_pgrp(provider, gid)
+      group = group_provider.find(gid, provider.ia_module_args)
 
-  def lsallcmd()
-    lscmd("ALL")
-  end
-
-  def addcmd(extra_attrs = [])
-    # Here we use the @resource.to_hash to get the list of provided parameters
-    # Puppet does not call to self.<parameter>= method if it does not exists.
-    #
-    # It gets an extra list of arguments to add to the user.
-    [self.class.command(:add)] + self.get_ia_module_args +
-      self.hash2args(@resource.to_hash) +
-      extra_attrs + [@resource[:name]]
-  end
-
-  # Get modify command. Set translate=false if no mapping must be used.
-  # Needed for special properties like "attributes"
-  def modifycmd(hash = property_hash)
-    args = self.hash2args(hash)
-    return nil if args.empty?
-
-    [self.class.command(:modify)] + self.get_ia_module_args +
-      args + [@resource[:name]]
-  end
-
-  def deletecmd
-    [self.class.command(:delete)] + self.get_ia_module_args + [@resource[:name]]
-  end
+      group[:name]
+    end
 
-  #--------------
-  # We overwrite the create function to change the password after creation.
-  def create
-    super
-    # Reset the password if needed
-    self.password = @resource[:password] if @resource[:password]
-  end
+    def pgrp_to_gid(provider, pgrp)
+      group = group_provider.find(pgrp, provider.ia_module_args)
 
+      group[:gid]
+    end
 
-  def get_arguments(key, value, mapping, objectinfo)
-    # In the case of attributes, return a list of key=vlaue
-    if key == :attributes
-      raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]" \
-        unless value and value.is_a? Hash
-      return value.map { |k,v| k.to_s.strip + "=" + v.to_s.strip}
+    def expiry_to_expires(expiry)
+      return '0' if expiry == "0000-00-00" || expiry.to_sym == :absent
+      
+      DateTime.parse(expiry, "%Y-%m-%d %H:%M")
+        .strftime("%m%d%H%M%y")
     end
 
-    super(key, value, mapping, objectinfo)
-  end
+    def expires_to_expiry(provider, expires)
+      return :absent if expires == '0'
 
-  # Get the groupname from its id
-  def groupname_by_id(gid)
-    groupname=nil
-    execute(lsgroupscmd("ALL")).each_line { |entry|
-      attrs = self.parse_attr_list(entry, nil)
-      if attrs and attrs.include? :id and gid == attrs[:id].to_i
-        groupname = entry.split(" ")[0]
+      unless (match_obj = /\A(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)\z/.match(expires))
+        #TRANSLATORS 'AIX' is the name of an operating system and should not be translated
+        Puppet.warning(_("Could not convert AIX expires date '%{expires}' on %{class_name}[%{resource_name}]") % { expires: expires, class_name: provider.resource.class.name, resource_name: provider.resource.name })
+        return :absent
       end
-    }
-    groupname
-  end
-
-  # Get the groupname from its id
-  def groupid_by_name(groupname)
-    attrs = self.parse_attr_list(execute(lsgroupscmd(groupname)).split("\n")[0], nil)
-    attrs ? attrs[:id].to_i : nil
-  end
 
-  # Check that a group exists and is valid
-  def verify_group(value)
-    if value.is_a? Integer
-      groupname = groupname_by_id(value)
-      raise ArgumentError, "AIX group must be a valid existing group" unless groupname
-    else
-      raise ArgumentError, "AIX group must be a valid existing group" unless groupid_by_name(value)
-      groupname = value
+      month, day, year = match_obj[1], match_obj[2], match_obj[-1]
+      return "20#{year}-#{month}-#{day}"
     end
-    groupname
-  end
-
-  # The user's primary group.  Can be specified numerically or by name.
-  def gid_to_attr(value)
-    verify_group(value)
-  end
 
-  # Get the group gid from its name
-  def gid_from_attr(value)
-    groupid_by_name(value)
-  end
+    # We do some validation before-hand to ensure the value's an Array,
+    # a String, etc. in the property. This routine does a final check to
+    # ensure our value doesn't have whitespace before we convert it to
+    # an attribute.
+    def groups_to_groups(groups)
+      if groups =~ /\s/
+        raise ArgumentError, _("Invalid value %{groups}: Groups must be comma separated!") % { groups: groups }
+      end
 
-  # The expiry date for this user. Must be provided in
-  # a zero padded YYYY-MM-DD HH:MM format
-  def expiry_to_attr(value)
-    # For chuser the expires parameter is a 10-character string in the MMDDhhmmyy format
-    # that is,"%m%d%H%M%y"
-    newdate = '0'
-    if value.is_a? String and value!="0000-00-00"
-      d = DateTime.parse(value, "%Y-%m-%d %H:%M")
-      newdate = d.strftime("%m%d%H%M%y")
+      groups
     end
-    newdate
   end
 
-  def expiry_from_attr(value)
-    if value =~ /(..)(..)(..)(..)(..)/
-      #d= DateTime.parse("20#{$5}-#{$1}-#{$2} #{$3}:#{$4}")
-      #expiry_date = d.strftime("%Y-%m-%d %H:%M")
-      #expiry_date = d.strftime("%Y-%m-%d")
-      expiry_date = "20#{$5}-#{$1}-#{$2}"
-    else
-      Puppet.warn("Could not convert AIX expires date '#{value}' on #{@resource.class.name}[#{@resource.name}]") \
-        unless value == '0'
-      expiry_date = :absent
+  mapping puppet_property: :comment,
+          aix_attribute: :gecos
+
+  mapping puppet_property: :expiry,
+          aix_attribute: :expires,
+          property_to_attribute: method(:expiry_to_expires),
+          attribute_to_property: method(:expires_to_expiry)
+
+  mapping puppet_property: :gid,
+          aix_attribute: :pgrp,
+          property_to_attribute: method(:gid_to_pgrp),
+          attribute_to_property: method(:pgrp_to_gid)
+
+  mapping puppet_property: :groups, 
+          property_to_attribute: method(:groups_to_groups)
+
+  mapping puppet_property: :home
+  mapping puppet_property: :shell
+
+  numeric_mapping puppet_property: :uid,
+                  aix_attribute: :id
+
+  numeric_mapping puppet_property: :password_max_age,
+                  aix_attribute: :maxage
+
+  numeric_mapping puppet_property: :password_min_age,
+                  aix_attribute: :minage
+
+  numeric_mapping puppet_property: :password_warn_days,
+                  aix_attribute: :pwdwarntime
+
+  # Now that we have all of our mappings, let's go ahead and make
+  # the resource methods (property getters + setters for our mapped
+  # properties + a getter for the attributes property).
+  mk_resource_methods
+
+  # Helper function that parses the password from the given
+  # password filehandle. This is here to make testing easier
+  # for #password since we cannot configure Mocha to mock out
+  # a method and have it return a block's value, meaning we
+  # cannot test #password directly (not in a simple and obvious
+  # way, at least).
+  # @api private
+  def parse_password(f)
+    # From the docs, a user stanza is formatted as (newlines are explicitly
+    # stated here for clarity):
+    #   <user>:\n
+    #     <attribute1>=<value1>\n
+    #     <attribute2>=<value2>\n
+    #
+    # First, find our user stanza
+    stanza = f.each_line.find { |line| line =~ /\A#{@resource[:name]}:/ }
+    return :absent unless stanza
+
+    # Now find the password line, if it exists. Note our call to each_line here
+    # will pick up right where we left off.
+    match_obj = nil
+    f.each_line.find do |line|
+      # Break if we find another user stanza. This means our user
+      # does not have a password.
+      break if line =~ /^\S+:$/
+
+      match_obj = /password = (\S+)/.match(line)
     end
-    expiry_date
-  end
+    return :absent unless match_obj
 
-  def open_security_passwd
-    # helper method for tests
-    # AIX reference indicates this file is ASCII
-    # https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/com.ibm.aix.files/passwd_security.htm
-    Puppet::FileSystem.open("/etc/security/passwd", nil, "r:ASCII")
+    match_obj[1]
   end
 
-  #--------------------------------
-  # Getter and Setter
-  # When the provider is initialized, create getter/setter methods for each
-  # property our resource type supports.
-  # If setter or getter already defined it will not be overwritten
-
   #- **password**
   #    The user's password, in whatever encrypted format the local machine
   #    requires. Be sure to enclose any value that includes a dollar sign ($)
   #    in single quotes (').  Requires features manages_passwords.
   #
-  # Retrieve the password parsing directly the /etc/security/passwd
+  # Retrieve the password parsing the /etc/security/passwd file.
   def password
-    password = :absent
-    user = @resource[:name]
-    f = open_security_passwd
-    # Skip to the user
-    f.each_line { |l| break if l  =~ /^#{user}:\s*$/ }
-    if ! f.eof?
-      f.each_line { |l|
-        # If there is a new user stanza, stop
-        break if l  =~ /^\S*:\s*$/
-        # If the password= entry is found, return it, stripping trailing space
-        if l  =~ /^\s*password\s*=\s*(\S*)\s*$/
-          password = $1; break;
-        end
-      }
+    # AIX reference indicates this file is ASCII
+    # https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/com.ibm.aix.files/passwd_security.htm
+    Puppet::FileSystem.open("/etc/security/passwd", nil, "r:ASCII") do |f|
+      parse_password(f)
     end
-    f.close()
-    return password
   end
 
   def password=(value)
     user = @resource[:name]
 
-    # Puppet execute does not support strings as input, only files.
-    # The password is expected to be in an encrypted format given -e is specified:
-    # https://www.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.cmds1/chpasswd.htm
-    # /etc/security/passwd is specified as an ASCII file per the AIX documentation
-    tmpfile = Tempfile.new("puppet_#{user}_pw", :encoding => Encoding::ASCII)
-    tmpfile << "#{user}:#{value}\n"
-    tmpfile.close()
-
-    # Options '-e', '-c', use encrypted password and clear flags
-    # Must receive "user:enc_password" as input
-    # command, arguments = {:failonfail => true, :combine => true}
-    # Fix for bugs #11200 and #10915
-    cmd = [self.class.command(:chpasswd), get_ia_module_args, '-e', '-c', user].flatten
     begin
-      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
+      # Puppet execute does not support strings as input, only files.
+      # The password is expected to be in an encrypted format given -e is specified:
+      # https://www.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.cmds1/chpasswd.htm
+      # /etc/security/passwd is specified as an ASCII file per the AIX documentation
+      tempfile = nil
+      tempfile = Tempfile.new("puppet_#{user}_pw", :encoding => Encoding::ASCII)
+      tempfile << "#{user}:#{value}\n"
+      tempfile.close()
+  
+      # Options '-e', '-c', use encrypted password and clear flags
+      # Must receive "user:enc_password" as input
+      # command, arguments = {:failonfail => true, :combine => true}
+      # Fix for bugs #11200 and #10915
+      cmd = [self.class.command(:chpasswd), *ia_module_args, '-e', '-c']
+      execute_options = {
+        :failonfail => false,
+        :combine => true,
+        :stdinfile => tempfile.path
+      }
+      output = execute(cmd, execute_options)
+
+      # 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}", detail.backtrace
+      raise Puppet::Error, "Could not set password on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
     ensure
-      tmpfile.delete()
+      if tempfile
+        # Extra close will noop. This is in case the write to our tempfile
+        # fails.
+        tempfile.close()
+        tempfile.delete()
+      end
     end
   end
 
-  def managed_attribute_keys(hash)
-    managed_attributes ||= @resource.original_parameters[:attributes] || hash.keys.map{|k| k.to_s}
-    managed_attributes = [managed_attributes] unless managed_attributes.is_a?(Array)
-    managed_attributes.map {|attr| key, value = attr.split("="); key.strip.to_sym}
-  end
-
-  def should_include?(key, managed_keys)
-    !self.class.attribute_mapping_from.include?(key) and
-            !self.class.attribute_ignore.include?(key) and
-            managed_keys.include?(key)
-  end
-
-  def filter_attributes(hash)
-    # Return only managed attributes.
-    managed_keys = managed_attribute_keys(hash)
-    results = hash.select {
-        |k,v| should_include?(k, managed_keys)
-      }.inject({}) {
-        |h, array| h[array[0]] = array[1]; h
-      }
-    results
-  end
-
-  def attributes
-    filter_attributes(getosinfo(false))
-  end
+  def create
+    super
 
-  def attributes=(attr_hash)
-    #self.class.validate(param, value)
-    param = :attributes
-    cmd = modifycmd({param => filter_attributes(attr_hash)})
-    if cmd
-      begin
-        execute(cmd)
-      rescue Puppet::ExecutionFailure  => detail
-        raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
-      end
+    if (password = @resource.should(:password))
+      self.password = password
     end
   end
 

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

@@ -45,8 +45,9 @@ Puppet::Type.type(:user).provide :openbsd, :parent => :useradd do
           # sp_loginclass field.
           begin
             return unmunge(shadow_property, ent.send(method))
-          rescue => detail
-            Puppet.warning "ruby-shadow doesn't support #{method}"
+          rescue
+            #TRANSLATORS 'ruby-shadow' is a Ruby gem library
+            Puppet.warning _("ruby-shadow doesn't support %{method}") % { method: method }
           end
         end
       end

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

@@ -67,7 +67,7 @@ Puppet::Type.type(:user).provide :pw, :parent => Puppet::Provider::NameService::
   # use pw to update password hash
   def password=(cryptopw)
     Puppet.debug "change password for user '#{@resource[:name]}' method called with hash '#{cryptopw}'"
-    stdin, stdout, stderr = Open3.popen3("pw user mod #{@resource[:name]} -H 0")
+    stdin, _, _ = Open3.popen3("pw user mod #{@resource[:name]} -H 0")
     stdin.puts(cryptopw)
     stdin.close
     Puppet.debug "finished password for user '#{@resource[:name]}' method called with hash '#{cryptopw}'"

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

@@ -18,6 +18,7 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source =>
   options :profiles, :flag => "-P"
   options :password_min_age, :flag => "-n"
   options :password_max_age, :flag => "-x"
+  options :password_warn_days, :flag => "-w"
 
   verify :gid, "GID must be an integer" do |value|
     value.is_a? Integer
@@ -48,7 +49,7 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source =>
     cmd = []
     Puppet::Type.type(:user).validproperties.each do |property|
       #skip the password because we can't create it with the solaris useradd
-      next if [:ensure, :password, :password_min_age, :password_max_age].include?(property)
+      next if [:ensure, :password, :password_min_age, :password_max_age, :password_warn_days].include?(property)
       # 1680 Now you can set the hashed passwords on solaris:lib/puppet/provider/user/user_role_add.rb
       # the value needs to be quoted, mostly because -c might
       # have spaces in it
@@ -196,6 +197,11 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source =>
     shadow_entry[4].empty? ? -1 : shadow_entry[4]
   end
 
+  def password_warn_days
+    return :absent unless shadow_entry
+    shadow_entry[5].empty? ? -1 : shadow_entry[5]
+  end
+
   # Read in /etc/shadow, find the line for our used and rewrite it with the
   # new pw.  Smooth like 80 grit sandpaper.
   #