puppet 4.4.2 → 4.5.0

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

@@ -19,9 +19,9 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
 
     ...or this can be overriden in the resource's attributes:
 
-        service { "myservice":
-          provider => "daemontools",
-          path     => "/path/to/daemons",
+        service { 'myservice':
+          provider => 'daemontools',
+          path     => '/path/to/daemons',
         }
 
     This provider supports out of the box:

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

@@ -17,9 +17,11 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
   end
 
   # Debian and Ubuntu should use the Debian provider.
+  # RedHat systems should use the RedHat provider.
   confine :true => begin
-     os = Facter.value(:operatingsystem).downcase
-     !(os == 'debian' || os == 'ubuntu')
+      os = Facter.value(:operatingsystem).downcase
+      family = Facter.value(:osfamily).downcase
+      !(os == 'debian' || os == 'ubuntu' || family == 'redhat')
   end
 
   # We can't confine this here, because the init path can be overridden.

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

@@ -19,9 +19,9 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
 
     or this can be overriden in the service resource parameters::
 
-        service { "myservice":
-          provider => "runit",
-          path => "/path/to/daemons",
+        service { 'myservice':
+          provider => 'runit',
+          path     => '/path/to/daemons',
         }
 
     This provider supports out of the box:

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

@@ -34,11 +34,12 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   end
 
   def self.instances
-   svcs("-H").split("\n").select{|l| l !~ /^legacy_run/ }.collect do |line|
-     state,stime,fmri = line.split(/\s+/)
+   svcs("-H", "-o", "state,fmri" ).split("\n").select{|l| l !~ /^legacy_run/ }.collect do |line|
+     state,fmri = line.split(/\s+/)
      status =  case state
                when /online/; :running
                when /maintenance/; :maintenance
+               when /degraded/; :degraded
                else :stopped
                end
      new({:name => fmri, :ensure => status})
@@ -69,7 +70,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   def startcmd
     self.setupservice
     case self.status
-    when :maintenance
+    when :maintenance, :degraded
       [command(:adm), :clear, @resource[:name]]
     else
       [command(:adm), :enable, "-s", @resource[:name]]
@@ -140,6 +141,8 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
       return :stopped
     when "maintenance"
       return :maintenance
+    when "degraded"
+      return :degraded
     when "legacy_run"
       raise Puppet::Error,
         "Cannot manage legacy services through SMF"

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

@@ -1,7 +1,11 @@
 # Manage systemd services using systemctl
 
 Puppet::Type.type(:service).provide :systemd, :parent => :base do
-  desc "Manages `systemd` services using `systemctl`."
+  desc "Manages `systemd` services using `systemctl`.
+
+  Because `systemd` defaults to assuming the `.service` unit type, the suffix
+  may be omitted.  Other unit types (such as `.path`) may be managed by
+  providing the proper suffix."
 
   commands :systemctl => "systemctl"
 
@@ -32,10 +36,21 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     return []
   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])
+  rescue
+    raise Puppet::Error, "Could not #{action} #{self.name}: #{output}", $!.backtrace
+  ensure
+    @cached_enabled = nil
+  end
+
   def disable
-    output = systemctl(:disable, @resource[:name])
-  rescue Puppet::ExecutionFailure
-    raise Puppet::Error, "Could not disable #{self.name}: #{output}", $!.backtrace
+    systemctl_change_enable(:disable)
   end
 
   def get_start_link_count
@@ -49,38 +64,27 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     Dir.glob("/etc/rc*.d/S??#{link_name}").length
   end
 
-  def enabled?
-    begin
-      systemctl_info = systemctl(
-         'show',
-         @resource[:name],
-         '--property', 'LoadState',
-         '--property', 'UnitFileState',
-         '--no-pager'
-      )
-
-      svc_info = Hash.new
-      systemctl_info.split.each do |svc|
-        entry_pair = svc.split('=')
-        svc_info[entry_pair.first.to_sym] = entry_pair.last
-      end
+  def cached_enabled?
+    return @cached_enabled if @cached_enabled
+    cmd = [command(:systemctl), 'is-enabled', @resource[:name]]
+    @cached_enabled = execute(cmd, :failonfail => false).strip
+  end
 
-      # 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
-      # it masked.
-      #
-      # We only return :mask if we're trying to mask the service. This prevents
-      # flapping when simply trying to disable a masked service.
-      return :mask if (@resource[:enable] == :mask) && (svc_info[:LoadState] == 'masked')
-      return :true if svc_info[:UnitFileState] == 'enabled'
-      if Facter.value(:osfamily).downcase == 'debian'
-        ret = debian_enabled?(svc_info)
-        return ret if ret
-      end
-    rescue Puppet::ExecutionFailure
-      # The execution of the systemd command can fail for quite a few reasons.
-      # In all of these cases, the failure of the query indicates that the
-      # service is disabled and therefore we simply return :false.
+  def enabled?
+    output = cached_enabled?
+
+    # 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
+    # it masked.
+    #
+    # We only return :mask if we're trying to mask the service. This prevents
+    # flapping when simply trying to disable a masked service.
+    return :mask if (@resource[:enable] == :mask) && (output == 'masked')
+    return :true if ['static', 'enabled'].include? output
+    return :false if ['disabled', 'linked', 'indirect', 'masked'].include? output
+    if (output.empty?) && (Facter.value(:osfamily).downcase == 'debian')
+      ret = debian_enabled?
+      return ret if ret
     end
 
     return :false
@@ -91,60 +95,38 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
   # have a Systemd unit file, we need to go through the old init script to determine
   # whether it is enabled or not. See PUP-5016 for more details.
   #
-  def debian_enabled?(svc_info)
-    # If UnitFileState == UnitFileState then we query the older way.
-    if svc_info[:UnitFileState] == 'UnitFileState'
-      system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
-      if [104, 106].include?($CHILD_STATUS.exitstatus)
+  def debian_enabled?
+    system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
+    if [104, 106].include?($CHILD_STATUS.exitstatus)
+      return :true
+    elsif [101, 105].include?($CHILD_STATUS.exitstatus)
+      # 101 is action not allowed, which means we have to do the check manually.
+      # 105 is unknown, which generally means the iniscript does not support query
+      # The debian policy states that the initscript should support methods of query
+      # For those that do not, peform the checks manually
+      # http://www.debian.org/doc/debian-policy/ch-opersys.html
+      if get_start_link_count >= 4
         return :true
-      elsif [101, 105].include?($CHILD_STATUS.exitstatus)
-        # 101 is action not allowed, which means we have to do the check manually.
-        # 105 is unknown, which generally means the iniscript does not support query
-        # The debian policy states that the initscript should support methods of query
-        # For those that do not, peform the checks manually
-        # http://www.debian.org/doc/debian-policy/ch-opersys.html
-        if get_start_link_count >= 4
-          return :true
-        else
-          return :false
-        end
       else
         return :false
       end
+    else
+      return :false
     end
   end
 
-  def status
-    begin
-      systemctl("is-active", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      return :stopped
-    end
-    return :running
-  end
-
   def enable
     self.unmask
-    output = systemctl("enable", @resource[:name])
-  rescue Puppet::ExecutionFailure
-    raise Puppet::Error, "Could not enable #{self.name}: #{output}", $!.backtrace
+    systemctl_change_enable(:enable)
   end
 
   def mask
     self.disable
-    begin
-      output = systemctl("mask", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error, "Could not mask #{self.name}: #{output}", $!.backtrace
-    end
+    systemctl_change_enable(:mask)
   end
 
   def unmask
-    begin
-      output = systemctl("unmask", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error, "Could not unmask #{self.name}: #{output}", $!.backtrace
-    end
+    systemctl_change_enable(:unmask)
   end
 
   def restartcmd
@@ -159,5 +141,9 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
   def stopcmd
     [command(:systemctl), "stop", @resource[:name]]
   end
+
+  def statuscmd
+    [command(:systemctl), "is-active", @resource[:name]]
+  end
 end
 

data/lib/puppet/reference/providers.rb

@@ -1,9 +1,8 @@
-# This doesn't get stored in trac, since it changes every time.
 providers = Puppet::Util::Reference.newreference :providers, :title => "Provider Suitability Report", :depth => 1, :dynamic => true, :doc => "Which providers are valid for this machine" do
   types = []
   Puppet::Type.loadall
   Puppet::Type.eachtype do |klass|
-    next unless klass.providers.length > 0
+    next unless klass && klass.providers.length > 0
     types << klass
   end
   types.sort! { |a,b| a.name.to_s <=> b.name.to_s }

data/lib/puppet/resource.rb

@@ -21,7 +21,10 @@ class Puppet::Resource
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
-  ATTRIBUTES = [:file, :line, :exported]
+  ATTRIBUTES = [:file, :line, :exported].freeze
+  TYPE_CLASS = 'Class'.freeze
+  TYPE_NODE  = 'Node'.freeze
+  TYPE_SITE  = 'Site'.freeze
 
   def self.from_data_hash(data)
     raise ArgumentError, "No resource type provided in serialized data" unless type = data['type']
@@ -162,7 +165,7 @@ class Puppet::Resource
   end
 
   def class?
-    @is_class ||= @type == "Class"
+    @is_class ||= @type == TYPE_CLASS
   end
 
   def stage?
@@ -222,6 +225,11 @@ class Puppet::Resource
         self[p] = v
       end
     else
+      if type.is_a?(Hash)
+        raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
+          "Did you mean (#{(type[:type] || type["type"]).inspect}, #{(type[:title] || type["title"]).inspect }) ?"
+      end
+
       environment = attributes[:environment]
       if type.is_a?(Class) && type < Puppet::Type
         # Set the resource type to avoid an expensive `known_resource_types`
@@ -238,22 +246,15 @@ class Puppet::Resource
         send(attr.to_s + "=", value)
       end
 
-      @type, @title = extract_type_and_title(type, title)
-
-      @type = munge_type_name(@type)
-
-      if self.class?
-        @title = :main if @title == ""
-        @title = munge_type_name(@title)
-      end
+      @type, @title = self.class.type_and_title(type, title)
 
       if params = attributes[:parameters]
         extract_parameters(params)
       end
 
-    	if resource_type && resource_type.respond_to?(:deprecate_params)
+      if resource_type && resource_type.respond_to?(:deprecate_params)
         resource_type.deprecate_params(title, attributes[:parameters])
-    	end
+      end
 
       tag(self.type)
       tag_if_valid(self.title)
@@ -304,10 +305,17 @@ class Puppet::Resource
   # @return [Puppet::Type, Puppet::Resource::Type]
   # @api private
   def resource_type
-    @rstype ||= case type
-    when "Class"; environment.known_resource_types.hostclass(title == :main ? "" : title)
-    when "Node"; environment.known_resource_types.node(title)
-    when "Site"; environment.known_resource_types.site(nil)
+    @rstype ||= self.class.resource_type(type, title, environment)
+  end
+
+  # The resource's type implementation
+  # @return [Puppet::Type, Puppet::Resource::Type]
+  # @api private
+  def self.resource_type(type, title, environment)
+    case type
+    when TYPE_CLASS; environment.known_resource_types.hostclass(title == :main ? "" : title)
+    when TYPE_NODE; environment.known_resource_types.node(title)
+    when TYPE_SITE; environment.known_resource_types.site(nil)
     else
       result = Puppet::Type.type(type)
       if !result
@@ -516,6 +524,35 @@ class Puppet::Resource
     self
   end
 
+  # @api private
+  def self.type_and_title(type, title)
+    type, title = extract_type_and_title(type, title)
+    type = munge_type_name(type)
+    if type == TYPE_CLASS
+      title = title == '' ? :main : munge_type_name(title)
+    end
+    [type, title]
+  end
+
+
+  def self.extract_type_and_title(argtype, argtitle)
+    if (argtype.nil? || argtype == :component || argtype == :whit) &&
+          argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [ $1,                 $2            ]
+    elsif argtitle.nil? && argtype =~ /^([^\[\]]+)\[(.+)\]$/m  then [ $1,                 $2            ]
+    elsif argtitle                                             then [ argtype,            argtitle      ]
+    elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
+    else  raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
+    end
+  end
+  private_class_method :extract_type_and_title
+
+  def self.munge_type_name(value)
+    return :main if value == :main
+    return TYPE_CLASS if value == '' || value.nil? || value.to_s.casecmp('component') == 0
+    Puppet::Pops::Types::TypeFormatter.singleton.capitalize_segments(value.to_s)
+  end
+  private_class_method :munge_type_name
+
   private
 
   # Produce a canonical method name.
@@ -530,7 +567,7 @@ class Puppet::Resource
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
-    if builtin_type? and t = resource_type and t.key_attributes.length == 1
+    if builtin_type? && !(t = resource_type).nil? && t.key_attributes.length == 1
       t.key_attributes.first
     else
       :name
@@ -544,26 +581,6 @@ class Puppet::Resource
     end
   end
 
-  def extract_type_and_title(argtype, argtitle)
-    if    (argtype.nil? || argtype == :component || argtype == :whit) &&
-           argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                 then [ $1,                 $2            ]
-    elsif argtitle.nil? && argtype =~ /^([^\[\]]+)\[(.+)\]$/m  then [ $1,                 $2            ]
-    elsif argtitle                                             then [ argtype,            argtitle      ]
-    elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
-    elsif argtype.is_a?(Hash)                                  then
-      raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
-        "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
-    else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
-    end
-  end
-
-  def munge_type_name(value)
-    return :main if value == :main
-    return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
-
-    value.to_s.split("::").collect { |s| s.capitalize }.join("::")
-  end
-
   def parse_title
     h = {}
     type = resource_type

data/lib/puppet/resource/catalog.rb

@@ -167,14 +167,15 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Create an alias for a resource.
   def alias(resource, key)
-    resource.ref =~ /^(.+)\[/
+    ref = resource.ref
+    ref =~ /^(.+)\[/
     class_name = $1 || resource.class.name
 
     newref = [class_name, key].flatten
 
     if key.is_a? String
       ref_string = "#{class_name}[#{key}]"
-      return if ref_string == resource.ref
+      return if ref_string == ref
     end
 
     # LAK:NOTE It's important that we directly compare the references,
@@ -185,12 +186,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       return if existing == resource
       resource_declaration = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
       existing_declaration = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
-      msg = "Cannot alias #{resource.ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
+      msg = "Cannot alias #{ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
       raise ArgumentError, msg
     end
     @resource_table[newref] = resource
-    @aliases[resource.ref] ||= []
-    @aliases[resource.ref] << newref
+    @aliases[ref] ||= []
+    @aliases[ref] << newref
   end
 
   # Apply our catalog to the local host.
@@ -332,11 +333,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # references to the resource instances.
   def remove_resource(*resources)
     resources.each do |resource|
-      title_key = title_key_for_ref(resource.ref)
+      ref = resource.ref
+      title_key = title_key_for_ref(ref)
       @resource_table.delete(title_key)
-      if aliases = @aliases[resource.ref]
+      if aliases = @aliases[ref]
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
-        @aliases.delete(resource.ref)
+        @aliases.delete(ref)
       end
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
@@ -348,27 +350,27 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Look a resource up by its reference (e.g., File[/etc/passwd]).
   def resource(type, title = nil)
-    # Always create a resource reference, so that it always
-    # canonicalizes how we are referring to them.
-    attributes = { :environment => environment_instance }
-    if title
-      res = Puppet::Resource.new(type, title, attributes)
-    else
-      # If they didn't provide a title, then we expect the first
-      # argument to be of the form 'Class[name]', which our
-      # Reference class canonicalizes for us.
-      res = Puppet::Resource.new(nil, type, attributes)
-    end
-    res.catalog = self
-    title_key      = [res.type, res.title.to_s]
-    uniqueness_key = [res.type, res.uniqueness_key].flatten
-    result = @resource_table[title_key] || @resource_table[uniqueness_key]
-    if ! result && res.resource_type && res.resource_type.is_capability?
-      # @todo lutter 2015-03-10: this assumes that it is legal to just
-      # mention a capability resource in code and have it automatically
-      # made available, even if the current component does not require it
-      result = Puppet::Resource::CapabilityFinder.find(environment, code_id, res)
-      add_resource(result) if result
+    type, title = Puppet::Resource.type_and_title(type, title)
+    title_key   = [type, title.to_s]
+    result = @resource_table[title_key]
+    if result.nil?
+      # an instance has to be created in order to construct the unique key used when
+      # searching for aliases.
+      unless @aliases.empty? && !Puppet[:app_management]
+        res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
+        result = @resource_table[[type, res.uniqueness_key].flatten]
+      end
+
+      if result.nil? && Puppet[:app_management]
+        resource_type = res.resource_type
+        if resource_type && resource_type.is_capability?
+          # @todo lutter 2015-03-10: this assumes that it is legal to just
+          # mention a capability resource in code and have it automatically
+          # made available, even if the current component does not require it
+          result = Puppet::Resource::CapabilityFinder.find(environment, code_id, res)
+          add_resource(result) if result
+        end
+      end
     end
     result
   end