puppet 5.3.4 → 6.29.0

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

@@ -46,14 +46,8 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
 
     # Determine the daemon path.
     def defpath
-      unless @defpath
-        ["/var/lib/service", "/etc"].each do |path|
-          if Puppet::FileSystem.exist?(path)
-            @defpath = path
-            break
-          end
-        end
-        raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
+      @defpath ||= ["/var/lib/service", "/etc"].find do |path|
+        Puppet::FileSystem.exist?(path) && FileTest.directory?(path)
       end
       @defpath
     end
@@ -65,6 +59,10 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
   # ie enabled or not
   def self.instances
     path = self.defpath
+    unless path
+      Puppet.info("#{self.name} is unsuitable because service directory is nil")
+      return
+    end
     unless FileTest.directory?(path)
       Puppet.notice "Service path #{path} does not exist"
       return
@@ -109,7 +107,9 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
   # note that this path can be overridden in the resource
   # definition
   def daemon
-    File.join(resource[:path], resource[:name])
+    path = resource[:path]
+    raise Puppet::Error.new("#{self.class.name} must specify a path for daemon directory") unless path
+    File.join(path, resource[:name])
   end
 
   def status

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

@@ -17,8 +17,11 @@ Puppet::Type.type(:service).provide :debian, :parent => :init do
   commands :invoke_rc => "/usr/sbin/invoke-rc.d"
   commands :service => "/usr/sbin/service"
 
+  confine :false => Puppet::FileSystem.exist?('/proc/1/comm') && Puppet::FileSystem.read('/proc/1/comm').include?('systemd')
+
   defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ['1','2']
   defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ['5','6','7']
+  defaultfor :operatingsystem => :devuan
 
   # Remove the symlinks
   def disable

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

@@ -4,7 +4,7 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
   desc "Standard `init`-style service management."
 
   def self.defpath
-    case Facter.value(:operatingsystem)
+    case Puppet.runtime[:facter].value(:operatingsystem)
     when "FreeBSD", "DragonFly"
       ["/etc/rc.d", "/usr/local/etc/rc.d"]
     when "HP-UX"
@@ -21,8 +21,8 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
   # Debian and Ubuntu should use the Debian provider.
   # RedHat systems should use the RedHat provider.
   confine :true => begin
-      os = Facter.value(:operatingsystem).downcase
-      family = Facter.value(:osfamily).downcase
+      os = Puppet.runtime[:facter].value(:operatingsystem).downcase
+      family = Puppet.runtime[:facter].value(:osfamily).downcase
       !(os == 'debian' || os == 'ubuntu' || family == 'redhat')
   end
 
@@ -54,7 +54,7 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
     # these excludes were found with grep -r -L start /etc/init.d
     excludes += %w{rcS module-init-tools}
     # Prevent puppet failing on unsafe scripts from Yocto Linux
-    if Facter.value(:osfamily) == "cisco-wrlinux"
+    if Puppet.runtime[:facter].value(:osfamily) == "cisco-wrlinux"
       excludes += %w{banner.sh bootmisc.sh checkroot.sh devpts.sh dmesg.sh
                    hostname.sh mountall.sh mountnfs.sh populate-volatile.sh
                    rmnologin.sh save-rtc.sh sendsigs sysfs.sh umountfs
@@ -72,6 +72,7 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
     excludes += %w{cryptdisks-udev}
     excludes += %w{statd-mounting}
     excludes += %w{gssd-mounting}
+    excludes
   end
 
   # List all services of this type.
@@ -83,7 +84,7 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
     defpath = [defpath] unless defpath.is_a? Array
     instances = []
     defpath.each do |path|
-      unless FileTest.directory?(path)
+      unless Puppet::FileSystem.directory?(path)
         Puppet.debug "Service path #{path} does not exist"
         next
       end
@@ -96,8 +97,9 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
         fullpath = File.join(path, name)
         next if name =~ /^\./
         next if exclude.include? name
-        next if not FileTest.executable?(fullpath)
-        next if not is_init?(fullpath)
+        next if Puppet::FileSystem.directory?(fullpath)
+        next unless Puppet::FileSystem.executable?(fullpath)
+        next unless is_init?(fullpath)
         instances << new(:name => name, :path => path, :hasstatus => true)
       end
     end
@@ -121,7 +123,7 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
 
   def paths
     @paths ||= @resource[:path].find_all do |path|
-      if File.directory?(path)
+      if Puppet::FileSystem.directory?(path)
         true
       else
         if Puppet::FileSystem.exist?(path)
@@ -170,7 +172,7 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
   end
 
   def texecute(type, command, fof = true, squelch = false, combine = true)
-    if type == :start && Facter.value(:osfamily) == "Solaris"
+    if type == :start && Puppet.runtime[:facter].value(:osfamily) == "Solaris"
         command =  ["/usr/bin/ctrun -l child", command].flatten.join(" ")
     end
     super(type, command, fof, squelch, combine)

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

@@ -4,10 +4,9 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     This provider manages jobs with `launchd`, which is the default service
     framework for Mac OS X (and may be available for use on other platforms).
 
-    For `launchd` documentation, see:
+    For more information, see the `launchd` man page:
 
-    * <https://developer.apple.com/macosx/launchd.html>
-    * <http://launchd.macosforge.org/>
+    * <https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man8/launchd.8.html>
 
     This provider reads plists out of the following directories:
 
@@ -71,7 +70,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   #
   # @api private
   def self.get_os_version
-    @os_version ||= Facter.value(:operatingsystemmajrelease).to_i
+    @os_version ||= Puppet.runtime[:facter].value(:operatingsystemmajrelease).to_i
   end
 
   # Defines the path to the overrides plist file where service enabling
@@ -93,7 +92,8 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # clear out our cache when we're done.
   def self.prefetch(resources)
     instances.each do |prov|
-      if resource = resources[prov.name]
+      resource = resources[prov.name]
+      if resource
         resource.provider = prov
       end
     end
@@ -138,11 +138,11 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
         Puppet.debug("Reading launchd plist #{filepath}")
         job = read_plist(filepath)
         next if job.nil?
-        if job.has_key?("Label")
+        if job.respond_to?(:key) && job.key?("Label")
           @label_to_path_map[job["Label"]] = filepath
         else
           #TRANSLATORS 'plist' and label' should not be translated
-          Puppet.warning(_("The %{file} plist does not contain a 'label' key; Puppet is skipping it") % { file: filepath })
+          Puppet.debug(_("The %{file} plist does not contain a 'label' key; Puppet is skipping it") % { file: filepath })
           next
         end
       end
@@ -197,6 +197,22 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     Puppet::Util::Plist.read_plist_file(path)
   end
 
+  # Read overrides plist, retrying if necessary
+  def self.read_overrides
+    i = 1
+    overrides = nil
+    loop do
+      Puppet.debug(_("Reading overrides plist, attempt %{i}") % {i: i}) if i > 1
+      overrides = read_plist(launchd_overrides)
+      break unless overrides.nil?
+      raise Puppet::Error.new(_('Unable to read overrides plist, too many attempts')) if i == 20
+      Puppet.info(_('Overrides file could not be read, trying again.'))
+      Kernel.sleep(0.1)
+      i += 1
+    end
+    overrides
+  end
+
   # Clean out the @property_hash variable containing the cached list of services
   def flush
     @property_hash.clear
@@ -225,12 +241,20 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   def status
     if @resource && ((@resource[:hasstatus] == :false) || (@resource[:status]))
       return super
-    else
-      if @property_hash[:status].nil?
-        :absent
+    elsif @property_hash[:status].nil?
+      # property_hash was flushed so the service changed status
+      service_name = @resource[:name]
+      # Updating services with new statuses
+      job_list = self.class.job_list
+      # if job is present in job_list, return its status
+      if job_list.key?(service_name)
+        job_list[service_name]
+      # if job is no longer present in job_list, it was stopped
       else
-        @property_hash[:status]
+        :stopped
       end
+    else
+      @property_hash[:status]
     end
   end
 
@@ -239,7 +263,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # directly.
   def start
     return ucommand(:start) if resource[:start]
-    job_path, job_plist = plist_from_label(resource[:name])
+    job_path, _ = plist_from_label(resource[:name])
     did_enable_job = false
     cmds = []
     cmds << :launchctl << :load
@@ -262,7 +286,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
 
   def stop
     return ucommand(:stop) if resource[:stop]
-    job_path, job_plist = plist_from_label(resource[:name])
+    job_path, _ = plist_from_label(resource[:name])
     did_disable_job = false
     cmds = []
     cmds << :launchctl << :unload
@@ -298,10 +322,18 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     job_plist_disabled = nil
     overrides_disabled = nil
 
-    job_path, job_plist = plist_from_label(resource[:name])
+    begin
+      _, job_plist = plist_from_label(resource[:name])
+    rescue Puppet::Error => err
+      # if job does not exist, log the error and return false as on other platforms
+      Puppet.log_exception(err)
+      return :false
+    end
+
     job_plist_disabled = job_plist["Disabled"] if job_plist.has_key?("Disabled")
 
-    if FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_plist(self.class.launchd_overrides)
+    overrides = self.class.read_overrides if FileTest.file?(self.class.launchd_overrides)
+    if overrides
       if overrides.has_key?(resource[:name])
         if self.class.get_os_version < 14
           overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
@@ -325,7 +357,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # rather than dealing with launchctl as it is unable to change the Disabled flag
   # without actually loading/unloading the job.
   def enable
-    overrides = self.class.read_plist(self.class.launchd_overrides)
+    overrides = self.class.read_overrides
     if self.class.get_os_version < 14
       overrides[resource[:name]] = { "Disabled" => false }
     else
@@ -335,7 +367,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   end
 
   def disable
-    overrides = self.class.read_plist(self.class.launchd_overrides)
+    overrides = self.class.read_overrides
     if self.class.get_os_version < 14
       overrides[resource[:name]] = { "Disabled" => true }
     else

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

@@ -79,7 +79,7 @@ Puppet::Type.type(:service).provide :openbsd, :parent => :init do
   def running?
     output = execute([command(:rcctl), "check", @resource[:name]],
                      :failonfail => false, :combine => false, :squelch => false).chomp
-    return true if output.match(/\(ok\)/)
+    return true if output =~ /\(ok\)/
   end
 
   # Uses the wrapper to prevent failure when the service is not running;

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

@@ -17,7 +17,7 @@ Puppet::Type.type(:service).provide :rcng, :parent => :bsd do
     if Puppet::FileSystem.exist?(rcfile)
       File.open(rcfile).readlines.each do |line|
         # Now look for something that looks like "service=${service:=YES}" or "service=YES"
-        if line.match(/^\s*#{@resource[:name]}=(?:YES|\${#{@resource[:name]}:=YES})/)
+        if line =~ /^\s*#{@resource[:name]}=(?:YES|\${#{@resource[:name]}:=YES})/
           return :true
         end
       end
@@ -34,7 +34,7 @@ Puppet::Type.type(:service).provide :rcng, :parent => :bsd do
     if Puppet::FileSystem.exist?(rcfile)
       newcontents = []
       File.open(rcfile).readlines.each do |line|
-        if line.match(/^\s*#{@resource[:name]}=(NO|\$\{#{@resource[:name]}:NO\})/)
+        if line =~ /^\s*#{@resource[:name]}=(NO|\$\{#{@resource[:name]}:NO\})/
           line = "#{@resource[:name]}=${#{@resource[:name]}:=YES}"
         end
         newcontents.push(line)

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

@@ -33,8 +33,9 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init
     end
 
     # For Suse OS family, chkconfig returns 0 even if the service is disabled or non-existent
-    # Therefore, check the output for '<name>  on' to see if it is enabled
-    return :false unless Facter.value(:osfamily) != 'Suse' || output =~ /^#{name}\s+on$/
+    # Therefore, check the output for '<name>  on' (or '<name>  B for boot services)
+    # to see if it is enabled
+    return :false unless Puppet.runtime[:facter].value(:osfamily) != 'Suse' || output =~ /^#{name}\s+(on|B)$/
 
     :true
   end

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

@@ -40,14 +40,8 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
     # this is necessary to autodetect a valid resource
     # default path, since there is no standard for such directory.
     def defpath
-      unless @defpath
-        ["/etc/sv", "/var/lib/service"].each do |path|
-          if Puppet::FileSystem.exist?(path)
-            @defpath = path
-            break
-          end
-        end
-        raise "Could not find the daemon directory (tested [/etc/sv,/var/lib/service])" unless @defpath
+      @defpath ||= ["/var/lib/service", "/etc/sv"].find do |path|
+        Puppet::FileSystem.exist?(path) && FileTest.directory?(path)
       end
       @defpath
     end

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

@@ -31,7 +31,8 @@ Puppet::Type.type(:service).provide :service do
 
   # Use either a specified command or the default for our provider.
   def ucommand(type, fof = true)
-    if c = @resource[type]
+    c = @resource[type]
+    if c
       cmd = [c]
     else
       cmd = [send("#{type}cmd")].flatten

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

@@ -25,8 +25,9 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
 
   def setupservice
       if resource[:manifest]
-        [command(:svcs), "-l", @resource[:name]]
-        if $CHILD_STATUS.exitstatus == 1
+        begin
+          svcs("-l", @resource[:name])
+        rescue Puppet::ExecutionFailure
           Puppet.notice "Importing #{@resource[:manifest]} for #{@resource[:name]}"
           svccfg :import, resource[:manifest]
         end
@@ -48,6 +49,52 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
    end
   end
 
+  # Returns the service's FMRI. We fail if multiple FMRIs correspond to
+  # @resource[:name].
+  #
+  # If the service does not exist or we fail to get any FMRIs from svcs,
+  # this method will raise a Puppet::Error
+  def service_fmri
+    return @fmri if @fmri
+
+    # `svcs -l` is better to use because we can detect service instances
+    # that have not yet been activated or enabled (i.e. it lets us detect
+    # services that svcadm has not yet touched). `svcs -H -o fmri` is a bit
+    # more limited.
+    lines = svcs("-l", @resource[:name]).chomp.lines.to_a
+    lines.select! { |line| line =~ /^fmri/ }
+    fmris = lines.map! { |line| line.split(' ')[-1].chomp }
+    unless fmris.length == 1
+      raise Puppet::Error, _("Failed to get the FMRI of the %{service} service: The pattern '%{service}' matches multiple FMRIs! These are the FMRIs it matches: %{all_fmris}") % { service: @resource[:name], all_fmris: fmris.join(', ') }
+    end
+
+    @fmri = fmris.first
+  end
+
+  # Returns true if the provider supports incomplete services.
+  def supports_incomplete_services?
+    Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemrelease), '11.1') >= 0
+  end
+
+  # Returns true if the service is complete. A complete service is a service that
+  # has the general/complete property defined.
+  def complete_service?
+    unless supports_incomplete_services?
+      raise Puppet::Error, _("Cannot query if the %{service} service is complete: The concept of complete/incomplete services was introduced in Solaris 11.1. You are on a Solaris %{release} machine.") % { service: @resource[:name], release: Puppet.runtime[:facter].value(:operatingsystemrelease) }
+    end
+
+    return @complete_service if @complete_service
+
+    # We need to use the service's FMRI when querying its config. because
+    # general/complete is an instance-specific property.
+    fmri = service_fmri
+
+    # Check if the general/complete property is defined. If it is undefined,
+    # then svccfg will not print anything to the console.
+    property_defn = svccfg("-s", fmri, "listprop", "general/complete").chomp
+    @complete_service = ! property_defn.empty?
+  end
+
   def enable
     self.start
   end
@@ -66,7 +113,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   end
 
   def restartcmd
-    if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.2') >= 0
+    if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemrelease), '11.2') >= 0
       [command(:adm), :restart, "-s", @resource[:name]]
     else
       # Synchronous restart only supported in Solaris 11.2 and above
@@ -107,8 +154,6 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   end
 
   def stop
-    # Don't try to stop non-existing services (PUP-8167)
-    return if self.status == :absent
     # Wait for the service to actually stop before returning.
     super
     self.wait('offline', 'disabled', 'uninitialized')
@@ -132,13 +177,22 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
     end
 
     begin
+      if supports_incomplete_services?
+        unless complete_service?
+          debug _("The %{service} service is incomplete so its status will be reported as :stopped. See `svcs -xv %{fmri}` for more details.") % { service: @resource[:name], fmri: service_fmri }
+
+          return :stopped
+        end
+      end
+
       # get the current state and the next state, and if the next
       # state is set (i.e. not "-") use it for state comparison
       states = service_states
       state = states[1] == "-" ? states[0] : states[1]
     rescue Puppet::ExecutionFailure
+      # TODO (PUP-8957): Should this be set back to INFO ?
       debug "Could not get status on service #{self.name} #{$!}"
-      return :absent
+      return :stopped
     end
 
     case state

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

@@ -1,5 +1,7 @@
 # Manage systemd services using systemctl
 
+require 'puppet/file_system'
+
 Puppet::Type.type(:service).provide :systemd, :parent => :base do
   desc "Manages `systemd` services using `systemctl`.
 
@@ -9,29 +11,27 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
 
   commands :systemctl => "systemctl"
 
-  if Facter.value(:osfamily).downcase == 'debian'
-    # With multiple init systems on Debian, it is possible to have
-    # pieces of systemd around (e.g. systemctl) but not really be
-    # using systemd.  We do not do this on other platforms as it can
-    # cause issues when running in a chroot without /run mounted
-    # (PUP-5577)
-    confine :exists => "/run/systemd/system"
-  end
+  confine :true => Puppet::FileSystem.exist?('/proc/1/comm') && Puppet::FileSystem.read('/proc/1/comm').include?('systemd')
 
   defaultfor :osfamily => [:archlinux]
-  defaultfor :osfamily => :redhat, :operatingsystemmajrelease => "7"
+  defaultfor :osfamily => :redhat, :operatingsystemmajrelease => ["7", "8", "9"]
   defaultfor :osfamily => :redhat, :operatingsystem => :fedora
   defaultfor :osfamily => :suse
   defaultfor :osfamily => :coreos
   defaultfor :operatingsystem => :amazon, :operatingsystemmajrelease => ["2"]
-  defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ["8", "stretch/sid", "9", "buster/sid"]
-  defaultfor :operatingsystem => :ubuntu, :operatingsystemmajrelease => ["15.04","15.10","16.04","16.10"]
-  defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ["3"]
+  defaultfor :operatingsystem => :debian
+  notdefaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ["5", "6", "7"] # These are using the "debian" method
+  defaultfor :operatingsystem => :LinuxMint
+  notdefaultfor :operatingsystem => :LinuxMint, :operatingsystemmajrelease => ["10", "11", "12", "13", "14", "15", "16", "17"] # These are using upstart
+  defaultfor :operatingsystem => :ubuntu
+  notdefaultfor :operatingsystem => :ubuntu, :operatingsystemmajrelease => ["10.04", "12.04", "14.04", "14.10"] # These are using upstart
+  defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ["3", "4"]
 
   def self.instances
     i = []
     output = systemctl('list-unit-files', '--type', 'service', '--full', '--all',  '--no-pager')
-    output.scan(/^(\S+)\s+(disabled|enabled|masked|indirect)\s*$/i).each do |m|
+    output.scan(/^(\S+)\s+(disabled|enabled|masked|indirect|bad|static)\s*([^-]\S+)?\s*$/i).each do |m|
+      Puppet.debug("#{m[0]} marked as bad by `systemctl`. It is recommended to be further checked.") if m[1] == "bad"
       i << new(:name => m[0])
     end
     return i
@@ -39,13 +39,34 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     return []
   end
 
+  # Static services cannot be enabled or disabled manually. Indirect services 
+  # should not be enabled or disabled due to limitations in systemd (see 
+  # https://github.com/systemd/systemd/issues/6681).
+  def enabled_insync?(current)
+    case cached_enabled?[:output]
+    when 'static'
+      # masking static services is OK, but enabling/disabling them is not
+      if @resource[:enable] == :mask
+        current == @resource[:enable]
+      else
+        Puppet.debug("Unable to enable or disable static service #{@resource[:name]}")
+        return true
+      end
+    when 'indirect'
+      Puppet.debug("Service #{@resource[:name]} is in 'indirect' state and cannot be enabled/disabled")
+      return true
+    else
+      current == @resource[:enable]
+    end
+  end
+
   # This helper ensures that the enable state cache is always reset
   # after a systemctl enable operation. A particular service state is not guaranteed
   # after such an operation, so the cache must be emptied to prevent inconsistencies
   # in the provider's believed state of the service and the actual state.
   # @param action [String,Symbol] One of 'enable', 'disable', 'mask' or 'unmask'
   def systemctl_change_enable(action)
-    output = systemctl(action, @resource[:name])
+    output = systemctl(action, '--', @resource[:name])
   rescue
     raise Puppet::Error, "Could not #{action} #{self.name}: #{output}", $!.backtrace
   ensure
@@ -58,7 +79,7 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
 
   def get_start_link_count
     # Start links don't include '.service'. Just search for the service name.
-    if @resource[:name].match(/\.service/)
+    if @resource[:name] =~ /\.service/
       link_name = @resource[:name].split('.')[0]
     else
       link_name = @resource[:name]
@@ -69,13 +90,14 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
 
   def cached_enabled?
     return @cached_enabled if @cached_enabled
-    cmd = [command(:systemctl), 'is-enabled', @resource[:name]]
-    @cached_enabled = execute(cmd, :failonfail => false).strip
+    cmd = [command(:systemctl), 'is-enabled', '--', @resource[:name]]
+    result = execute(cmd, :failonfail => false)
+    @cached_enabled = { output: result.chomp, exitcode: result.exitstatus }
   end
 
   def enabled?
-    output = cached_enabled?
-    code = $CHILD_STATUS.exitstatus
+    output = cached_enabled?[:output]
+    code = cached_enabled?[:exitcode]
 
     # The masked state is equivalent to the disabled state in terms of
     # comparison so we only care to check if it is masked if we want to keep
@@ -88,7 +110,7 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     # The indirect state indicates that the unit is not enabled.
     return :false if output == 'indirect'
     return :true if (code == 0)
-    if (output.empty?) && (code > 0) && (Facter.value(:osfamily).downcase == 'debian')
+    if (output.empty?) && (code > 0) && (Puppet.runtime[:facter].value(:osfamily).casecmp('debian').zero?)
       ret = debian_enabled?
       return ret if ret
     end
@@ -121,39 +143,60 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     end
   end
 
+  # Define the daemon_reload? function to check if the unit is requiring to trigger a "systemctl daemon-reload"
+  # If the unit file is flagged with NeedDaemonReload=yes, then a systemd daemon-reload will be run.
+  # If multiple unit files have been updated, the first one flagged will trigger the daemon-reload for all of them.
+  # The others will be then flagged with NeedDaemonReload=no. So the command will run only once in a puppet run.
+  # This function is called only on start & restart unit options.
+  # Reference: (PUP-3483) Systemd provider doesn't scan for changed units
+  def daemon_reload?
+    cmd = [command(:systemctl), 'show', '--property=NeedDaemonReload', '--', @resource[:name]]
+    daemon_reload = execute(cmd, :failonfail => false).strip.split('=').last
+    if daemon_reload == 'yes'
+      daemon_reload_cmd = [command(:systemctl), 'daemon-reload']
+      execute(daemon_reload_cmd, :failonfail => false)
+    end
+  end
+
   def enable
     self.unmask
     systemctl_change_enable(:enable)
   end
 
   def mask
-    self.disable
+    disable if exist?
     systemctl_change_enable(:mask)
   end
 
+  def exist?
+    result = execute([command(:systemctl), 'cat', '--', @resource[:name]], :failonfail => false)
+    result.exitstatus == 0
+  end
+
   def unmask
     systemctl_change_enable(:unmask)
   end
 
   def restartcmd
-    [command(:systemctl), "restart", @resource[:name]]
+    [command(:systemctl), "restart", '--', @resource[:name]]
   end
 
   def startcmd
     self.unmask
-    [command(:systemctl), "start", @resource[:name]]
+    [command(:systemctl), "start", '--', @resource[:name]]
   end
 
   def stopcmd
-    [command(:systemctl), "stop", @resource[:name]]
+    [command(:systemctl), "stop", '--', @resource[:name]]
   end
 
   def statuscmd
-    [command(:systemctl), "is-active", @resource[:name]]
+    [command(:systemctl), "is-active", '--', @resource[:name]]
   end
 
   def restart
     begin
+      daemon_reload?
       super
     rescue Puppet::Error => e
       raise Puppet::Error.new(prepare_error_message(@resource[:name], 'restart', e))
@@ -162,6 +205,7 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
 
   def start
     begin
+      daemon_reload?
       super
     rescue Puppet::Error => e
       raise Puppet::Error.new(prepare_error_message(@resource[:name], 'start', e))
@@ -179,7 +223,7 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
   def prepare_error_message(name, action, exception)
     error_return = "Systemd #{action} for #{name} failed!\n"
     journalctl_command = "journalctl -n 50 --since '5 minutes ago' -u #{name} --no-pager"
-    Puppet.debug("Runing journalctl command to get logs for systemd #{action} failure: #{journalctl_command}")
+    Puppet.debug("Running journalctl command to get logs for systemd #{action} failure: #{journalctl_command}")
     journalctl_output = execute(journalctl_command)
     error_return << "journalctl log for #{name}:\n#{journalctl_output}"
   end