puppet 6.0.0 → 6.1.0

data/lib/puppet/provider/exec.rb

@@ -4,71 +4,73 @@ require 'puppet/util/execution'
 class Puppet::Provider::Exec < Puppet::Provider
   include Puppet::Util::Execution
 
-  def run(command, check = false)
-    output = nil
-    sensitive = resource.parameters[:command].sensitive
+  def environment
+    env = {}
 
-    checkexe(command)
+    if (path = resource[:path])
+      env[:PATH] = path.join(File::PATH_SEPARATOR)
+    end
+
+    return env unless (envlist = resource[:environment])
 
-    if dir = resource[:cwd]
-      unless File.directory?(dir)
-        if check
-          dir = nil
-        else
-          self.fail _("Working directory '%{dir}' does not exist") % { dir: dir }
-        end
+    envlist = [envlist] unless envlist.is_a? Array
+    envlist.each do |setting|
+      unless (match = /^(\w+)=((.|\n)*)$/.match(setting))
+        warning _("Cannot understand environment setting %{setting}") % { setting: setting.inspect }
+        next
       end
+      var = match[1]
+      value = match[2]
+
+      if env.include?(var) || env.include?(var.to_sym)
+        warning _("Overriding environment setting '%{var}' with '%{value}'") % { var: var, value: value }
+      end
+
+      if value.nil? || value.empty?
+        msg = _("Empty environment setting '%{var}'") % {var: var}
+        Puppet.warn_once('undefined_variables', "empty_env_var_#{var}", msg, resource.file, resource.line)
+      end
+
+      env[var] = value
     end
 
-    dir ||= Dir.pwd
+    env
+  end
+
+  def run(command, check = false)
+    output = nil
+    sensitive = resource.parameters[:command].sensitive
+
+    checkexe(command)
 
     debug "Executing#{check ? " check": ""} '#{sensitive ? '[redacted]' : command}'"
-    begin
-      # Do our chdir
-      Dir.chdir(dir) do
-        environment = {}
-
-        environment[:PATH] = resource[:path].join(File::PATH_SEPARATOR) if resource[:path]
-
-        if envlist = resource[:environment]
-          envlist = [envlist] unless envlist.is_a? Array
-          envlist.each do |setting|
-            if setting =~ /^(\w+)=((.|\n)+)$/
-              env_name = $1
-              value = $2
-              if environment.include?(env_name) || environment.include?(env_name.to_sym)
-                warning _("Overriding environment setting '%{env_name}' with '%{value}'") % { env_name: env_name, value: value }
-              end
-              environment[env_name] = value
-            else
-              warning _("Cannot understand environment setting %{setting}") % { setting: setting.inspect }
-            end
-          end
-        end
-
-        # Ruby 2.1 and later interrupt execution in a way that bypasses error
-        # handling by default. Passing Timeout::Error causes an exception to be
-        # raised that can be rescued inside of the block by cleanup routines.
-        #
-        # This is backwards compatible all the way to Ruby 1.8.7.
-        Timeout::timeout(resource[:timeout], Timeout::Error) do
-          # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
-          # default/system locale will be respected.  Callers may override this behavior by setting locale-related
-          # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.
-          output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
-                                  :uid => resource[:user], :gid => resource[:group],
-                                  :override_locale => false,
-                                  :custom_environment => environment,
-                                  :sensitive => sensitive)
-        end
-        # The shell returns 127 if the command is missing.
-        if output.exitstatus == 127
-          raise ArgumentError, output
-        end
 
-      end
-    rescue Errno::ENOENT => detail
-      self.fail Puppet::Error, detail.to_s, detail
+    # Ruby 2.1 and later interrupt execution in a way that bypasses error
+    # handling by default. Passing Timeout::Error causes an exception to be
+    # raised that can be rescued inside of the block by cleanup routines.
+    #
+    # This is backwards compatible all the way to Ruby 1.8.7.
+    Timeout::timeout(resource[:timeout], Timeout::Error) do
+      cwd = resource[:cwd]
+      cwd ||= Dir.pwd
+
+      # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
+      # default/system locale will be respected.  Callers may override this behavior by setting locale-related
+      # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.
+      output = Puppet::Util::Execution.execute(
+        command,
+        :failonfail => false,
+        :combine => true,
+        :cwd => cwd,
+        :uid => resource[:user], :gid => resource[:group],
+        :override_locale => false,
+        :custom_environment => environment(),
+        :sensitive => sensitive
+      )
+    end
+    # The shell returns 127 if the command is missing.
+    if output.exitstatus == 127
+      raise ArgumentError, output
     end
 
     # Return output twice as processstatus was returned before, but only exitstatus was ever called.

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

@@ -57,8 +57,14 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
     # Define some Puppet Property => AIX Attribute (and vice versa)
     # conversion functions here. This is so we can unit test them.
 
-    def members_to_users(members)
-      return members unless members.is_a?(Array)
+    def members_to_users(provider, members)
+      members = members.split(',') if members.is_a?(String)
+      unless provider.resource[:auth_membership]
+        current_members = provider.members
+        current_members = [] if current_members == :absent
+        members = (members + current_members).uniq
+      end
+
       members.join(',')
     end
 
@@ -79,4 +85,14 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
   # the resource methods (property getters + setters for our mapped
   # properties + a getter for the attributes property).
   mk_resource_methods
+
+  # We could add this to the top-level members property since the
+  # implementation is not platform-specific; however, it is best
+  # to do it this way so that we do not accidentally break something.
+  # This is ok for now, since we do plan on moving this and the
+  # auth_membership management over to the property class in a future
+  # Puppet release.
+  def members_insync?(current, should)
+    current.sort == @resource.parameter(:members).actual_should(current, should)
+  end
 end

data/lib/puppet/provider/group/windows_adsi.rb

@@ -23,9 +23,12 @@ Puppet::Type.type(:group).provide :windows_adsi do
     # Cannot use munge of the group property to canonicalize @should
     # since the default array_matching comparison is not commutative
 
-    current_sids = current.map(&:sid)
     # dupes automatically weeded out when hashes built
-    specified_sids = Puppet::Util::Windows::ADSI::Group.name_sid_hash(should).keys.to_a
+    current_members = Puppet::Util::Windows::ADSI::Group.name_sid_hash(current)
+    specified_members = Puppet::Util::Windows::ADSI::Group.name_sid_hash(should)
+
+    current_sids = current_members.keys.to_a
+    specified_sids = specified_members.keys.to_a
 
     if @resource[:auth_membership]
       current_sids.sort == specified_sids.sort
@@ -63,7 +66,8 @@ Puppet::Type.type(:group).provide :windows_adsi do
   end
 
   def members
-    group.members
+    @members ||= Puppet::Util::Windows::ADSI::Group.name_sid_hash(group.members)
+    @members.keys
   end
 
   def members=(members)

data/lib/puppet/provider/nameservice.rb

@@ -247,31 +247,7 @@ class Puppet::Provider::NameService < Puppet::Provider
   # The list of all groups the user is a member of.  Different
   # user mgmt systems will need to override this method.
   def groups
-    groups = []
-
-    # Reset our group list
-    Puppet::Etc.setgrent
-
-    user = @resource[:name]
-
-    # Now iterate across all of the groups, adding each one our
-    # user is a member of
-    while group = Puppet::Etc.getgrent
-      members = group.mem
-
-      groups << group.name if members.include? user
-    end
-
-    # We have to close the file, so each listing is a separate
-    # reading of the file.
-    Puppet::Etc.endgrent
-
-    uniq_groups = groups.uniq
-    if groups != uniq_groups
-      debug("Removing any duplicate group entries")
-    end
-    # remove any double listed groups
-    uniq_groups.join(",")
+    Puppet::Util::POSIX.groups_of(@resource[:name]).join(',')
   end
 
   # Convert the Etc struct into a hash.

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

@@ -30,6 +30,8 @@ Puppet::Type.type(:package).provide :dnf, :parent => :yum do
 
   defaultfor :operatingsystem => :fedora
   notdefaultfor :operatingsystem => :fedora, :operatingsystemmajrelease => (19..21).to_a
+  defaultfor :osfamily => :redhat
+  notdefaultfor :osfamily => :redhat, :operatingsystemmajrelease => (4..7).to_a
 
   def self.update_command
     # In DNF, update is deprecated for upgrade

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

@@ -16,42 +16,53 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
     pkg(['query', '-a', '%n %v %o'])
   end
 
+  def self.get_resource_info(name)
+    pkg(['query', '%n %v %o', name])
+  end
+
+  def self.cached_version_list
+    @version_list ||= get_version_list
+  end
+
   def self.get_version_list
-    pkg(['version', '-voRL='])
+    @version_list = pkg(['version', '-voRL='])
   end
 
-  def self.get_latest_version(origin, version_list)
-    if latest_version = version_list.lines.find { |l| l =~ /^#{origin} / }
+  def self.get_latest_version(origin)
+    if latest_version = cached_version_list.lines.find { |l| l =~ /^#{origin} / }
       latest_version = latest_version.split(' ').last.split(')').first
       return latest_version
     end
     nil
   end
 
+  def self.parse_pkg_query_line(line)
+    name, version, origin = line.chomp.split(' ', 3)
+    latest_version  = get_latest_version(origin) || version
+
+    {
+      :ensure   => version,
+      :name     => name,
+      :provider => self.name,
+      :origin   => origin,
+      :version  => version,
+      :latest   => latest_version
+    }
+  end
+
   def self.instances
     packages = []
     begin
       info = self.get_query
-      version_list = self.get_version_list
+      get_version_list
 
       unless info
         return packages
       end
 
       info.lines.each do |line|
-
-        name, version, origin = line.chomp.split(" ", 3)
-        latest_version  = get_latest_version(origin, version_list) || version
-
-        pkg = {
-          :ensure   => version,
-          :name     => name,
-          :provider => self.name,
-          :origin   => origin,
-          :version  => version,
-          :latest   => latest_version
-        }
-        packages << new(pkg)
+        hash = parse_pkg_query_line(line)
+        packages << new(hash)
       end
 
       return packages
@@ -113,18 +124,23 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
   end
 
   def query
-    if @property_hash[:ensure] == nil
+    begin
+      output = self.class.get_resource_info(resource[:name])
+    rescue Puppet::ExecutionFailure
       return nil
-    else
-      version = @property_hash[:version]
-      return { :version => version }
     end
+
+    self.class.parse_pkg_query_line(output)
   end
 
   def version
     @property_hash[:version]
   end
 
+  def version=
+    pkg(['install', '-qfy', "#{resource[:name]}-#{resource[:version]}"])
+  end
+
   # Upgrade to the latest version
   def update
     install

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

@@ -117,7 +117,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
       if match
         result_fields.zip(match.captures) do |field, value|
           # some fields can be empty or (null) (if we are not passed a category in the package name for instance)
-          if value == '(null)'
+          if value == '(null)' || value == '<unset>'
             package_info[field] = nil
           elsif !value or value.empty?
             package_info[field] = nil
@@ -133,7 +133,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   def qatom_output_format
-    '"[%{CATEGORY}] [%{PN}] [%{PV}] [%[PR]] [%[SLOT]] [%[pfx]] [%[sfx]]"'
+    '"[%[CATEGORY]] [%[PN]] [%[PV]] [%[PR]] [%[SLOT]] [%[pfx]] [%[sfx]]"'
   end
 
   def qatom_result_format

data/lib/puppet/provider/package/windows/exe_package.rb

@@ -4,6 +4,19 @@ class Puppet::Provider::Package::Windows
   class ExePackage < Puppet::Provider::Package::Windows::Package
     attr_reader :uninstall_string
 
+    # registry values to load under each product entry in
+    # HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
+    # for this provider
+    REG_VALUE_NAMES = [
+      'DisplayVersion',
+      'UninstallString',
+      'ParentKeyName',
+      'Security Update',
+      'Update Rollup',
+      'Hotfix',
+      'WindowsInstaller',
+    ]
+
     # Return an instance of the package from the registry, or nil
     def self.from_registry(name, values)
       if valid?(name, values)
@@ -42,17 +55,10 @@ class Puppet::Provider::Package::Windows
     end
 
     def self.install_command(resource)
-      ['cmd.exe', '/c', 'start', '"puppet-install"', '/w', munge(resource[:source])]
+      munge(resource[:source])
     end
 
     def uninstall_command
-      # 1. Launch using cmd /c start because if the executable is a console
-      #    application Windows will automatically display its console window
-      # 2. Specify a quoted title, otherwise if uninstall_string is quoted,
-      #    start will interpret that to be the title, and get confused
-      # 3. Specify /w (wait) to wait for uninstall to finish
-      command = ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w']
-
       # Only quote bare uninstall strings, e.g.
       #   C:\Program Files (x86)\Notepad++\uninstall.exe
       # Don't quote uninstall strings that are already quoted, e.g.
@@ -60,9 +66,9 @@ class Puppet::Provider::Package::Windows
       # Don't quote uninstall strings that contain arguments:
       #   "C:\Program Files (x86)\Git\unins000.exe" /SILENT
       if uninstall_string =~ /\A[^"]*.exe\Z/i
-        command << "\"#{uninstall_string}\""
+        command = "\"#{uninstall_string}\""
       else
-        command << uninstall_string
+        command = uninstall_string
       end
 
       command

data/lib/puppet/provider/package/windows/msi_package.rb

@@ -8,6 +8,14 @@ class Puppet::Provider::Package::Windows
     INSTALLSTATE_DEFAULT = 5 # product is installed for the current user
     INSTALLUILEVEL_NONE  = 2 # completely silent installation
 
+    # registry values to load under each product entry in
+    # HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
+    # for this provider
+    REG_VALUE_NAMES = [
+      'DisplayVersion',
+      'WindowsInstaller'
+    ]
+
     # Get the COM installer object, it's in a separate method for testing
     def self.installer
       # REMIND: when does the COM release happen?

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

@@ -11,6 +11,14 @@ class Puppet::Provider::Package::Windows
 
     attr_reader :name, :version
 
+    REG_DISPLAY_VALUE_NAMES = [ 'DisplayName', 'QuietDisplayName' ]
+
+    def self.reg_value_names_to_load
+      REG_DISPLAY_VALUE_NAMES |
+      MsiPackage::REG_VALUE_NAMES |
+      ExePackage::REG_VALUE_NAMES
+    end
+
     # Enumerate each package. The appropriate package subclass
     # will be yielded.
     def self.each(&block)
@@ -37,7 +45,7 @@ class Puppet::Provider::Package::Windows
             open(hive, 'Software\Microsoft\Windows\CurrentVersion\Uninstall', mode) do |uninstall|
               each_key(uninstall) do |name, wtime|
                 open(hive, "#{uninstall.keyname}\\#{name}", mode) do |key|
-                  yield key, values(key)
+                  yield key, values_by_name(key, reg_value_names_to_load)
                 end
               end
             end

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

@@ -63,14 +63,14 @@ Puppet::Type.type(:package).provide(:windows, :parent => Puppet::Provider::Packa
     installer = Puppet::Provider::Package::Windows::Package.installer_class(resource)
 
     command = [installer.install_command(resource), install_options].flatten.compact.join(' ')
-    output = execute(command, :failonfail => false, :combine => true)
+    output = execute(command, :failonfail => false, :combine => true, :cwd => File.dirname(resource[:source]), :suppress_window => true)
 
     check_result(output.exitstatus)
   end
 
   def uninstall
     command = [package.uninstall_command, uninstall_options].flatten.compact.join(' ')
-    output = execute(command, :failonfail => false, :combine => true)
+    output = execute(command, :failonfail => false, :combine => true, :suppress_window => true)
 
     check_result(output.exitstatus)
   end

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

@@ -23,7 +23,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       end
   end
 
-  defaultfor :osfamily => :redhat
+defaultfor :osfamily => :redhat, :operatingsystemmajrelease => (4..7).to_a
 
   def self.prefetch(packages)
     raise Puppet::Error, _("The yum provider can only be used as root") if Process.euid != 0

data/lib/puppet/provider/parsedfile.rb

@@ -10,11 +10,17 @@ require 'puppet/util/fileparsing'
 #
 # Once the provider prefetches the data, it's the resource's job to copy
 # that data over to the @is variables.
+#
+# NOTE: The prefetch method swallows FileReadErrors by treating the
+# corresponding target as an empty file. If you would like to turn this
+# behavior off, then set the raise_prefetch_errors class variable to
+# true. Doing so will error all resources associated with the failed
+# target.
 class Puppet::Provider::ParsedFile < Puppet::Provider
   extend Puppet::Util::FileParsing
 
   class << self
-    attr_accessor :default_target, :target
+    attr_accessor :default_target, :target, :raise_prefetch_errors
   end
 
   attr_accessor :property_hash
@@ -89,6 +95,10 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
   # Flush all of the records relating to a specific target.
   def self.flush_target(target)
+    if @raise_prefetch_errors && @failed_prefetch_targets.key?(target)
+      raise Puppet::Error, _("Failed to read %{target}'s records when prefetching them. Reason: %{detail}") % { target: target, detail: @failed_prefetch_targets[target] }
+    end
+
     backup_target(target)
 
     records = target_records(target).reject { |r|
@@ -142,6 +152,10 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
     @records = []
     @target_objects = {}
 
+    # Hash of <target> => <failure reason>.
+    @failed_prefetch_targets = {}
+    @raise_prefetch_errors = false
+
     @target = nil
 
     # Default to flat files
@@ -260,12 +274,19 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
   # Prefetch an individual target.
   def self.prefetch_target(target)
-
     begin
       target_records = retrieve(target)
     rescue Puppet::Util::FileType::FileReadError => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err _("Could not prefetch %{resource} provider '%{name}' target '%{target}': %{detail}. Treating as empty") % { resource: self.resource_type.name, name: self.name, target: target, detail: detail }
+      if @raise_prefetch_errors
+        # We will raise an error later in flush_target. This way,
+        # only the resources linked to our target will fail
+        # evaluation.
+        @failed_prefetch_targets[target] = detail.to_s
+      else
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err _("Could not prefetch %{resource} provider '%{name}' target '%{target}': %{detail}. Treating as empty") % { resource: self.resource_type.name, name: self.name, target: target, detail: detail }
+      end
+
       target_records = []
     end
 

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

@@ -196,6 +196,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
@@ -300,7 +316,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     _, job_plist = plist_from_label(resource[:name])
     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)
+    if FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_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")
@@ -324,7 +340,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
@@ -334,7 +350,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/smf.rb

@@ -49,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(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: 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
@@ -131,6 +177,14 @@ 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