Class: Puppet::Resource
- Extended by:
- Indirector
- Includes:
- Enumerable, Util::PsychSupport, Util::Tagging
- Defined in:
- lib/puppet/resource.rb,
lib/puppet/resource/status.rb
Overview
The simplest resource class. Eventually it will function as the base class for all resource-like behaviour.
Direct Known Subclasses
Defined Under Namespace
Modules: CapabilityFinder, Validator Classes: Catalog, Ral, Status, StoreConfigs, Type, TypeCollection
Constant Summary collapse
- EMPTY_ARRAY =
[].freeze
- EMPTY_HASH =
{}.freeze
- ATTRIBUTES =
[:file, :line, :exported].freeze
- TYPE_CLASS =
'Class'.freeze
- TYPE_NODE =
'Node'.freeze
- TYPE_SITE =
'Site'.freeze
- PCORE_TYPE_KEY =
'__pcore_type__'.freeze
- VALUE_KEY =
'value'.freeze
Constants included from Indirector
Constants included from Util::Tagging
Instance Attribute Summary collapse
- #catalog ⇒ Object
- #exported ⇒ Object
- #file ⇒ Object
- #line ⇒ Object
- #parameters ⇒ Object readonly
- #rich_data_enabled ⇒ Object readonly
-
#sensitive_parameters ⇒ Array<Symbol>
private
A list of parameters to be treated as sensitive.
- #strict ⇒ Object
- #title ⇒ Object readonly
- #type ⇒ Object readonly
- #validate_parameters ⇒ Object deprecated Deprecated.
- #virtual ⇒ Object
Class Method Summary collapse
- .from_data_hash(data) ⇒ Object
-
.resource_type(type, title, environment) ⇒ Puppet::Type, Puppet::Resource::Type
private
The resource’s type implementation.
- .type_and_title(type, title) ⇒ Object private
- .value_to_json_data(value) ⇒ Object
Instance Method Summary collapse
- #==(other) ⇒ Object
-
#[](param) ⇒ Object
Return a given parameter’s value.
-
#[]=(param, value) ⇒ Object
Set a given parameter.
-
#builtin? ⇒ Boolean
Compatibility method.
-
#builtin_type? ⇒ Boolean
Is this a builtin resource type?.
- #class? ⇒ Boolean
- #copy_as_resource ⇒ Object
-
#each ⇒ Object
Iterate over each param/value pair, as required for Enumerable.
- #environment ⇒ Object
- #environment=(environment) ⇒ Object
-
#export ⇒ Object
private
Returns the value of the ‘export’ metaparam as an Array.
- #include?(parameter) ⇒ Boolean
-
#initialize(type, title = nil, attributes = EMPTY_HASH) ⇒ Resource
constructor
Construct a resource from data.
- #initialize_from_hash(data) ⇒ Object
- #inspect ⇒ Object
-
#is_application_component? ⇒ Boolean
A resource is an application component if it exports or consumes one or more capabilities, or if it requires a capability resource.
-
#is_capability? ⇒ Boolean
A resource is a capability (instance) if its underlying type is a capability type.
- #key_attributes ⇒ Object
- #name ⇒ Object
-
#pos ⇒ Integer
This method, together with #file and #line, makes it possible for a Resource to be a ‘source_pos’ in a reported issue.
- #prune_parameters(options = EMPTY_HASH) ⇒ Object
- #ref ⇒ Object
-
#resolve ⇒ Object
Find our resource.
-
#resource_type ⇒ Puppet::Type, Puppet::Resource::Type
private
The resource’s type implementation.
-
#resource_type=(type) ⇒ Object
private
Set the resource’s type implementation.
-
#set_default_parameters(scope) ⇒ Object
deprecated
private
Deprecated.
Not used by Puppet
- #stage? ⇒ Boolean
- #to_data_hash ⇒ Object
-
#to_hash ⇒ Object
Produces a hash of attribute to value mappings where the title parsed into its components acts as the default values overridden by any parameter values explicitly given as parameters.
-
#to_hierayaml ⇒ Object
Convert our resource to yaml for Hiera purposes.
-
#to_manifest ⇒ Object
Convert our resource to Puppet code.
-
#to_ral ⇒ Object
Convert our resource to a RAL resource instance.
- #to_ref ⇒ Object
- #to_s ⇒ Object
- #uniqueness_key ⇒ Object
- #valid_parameter?(name) ⇒ Boolean
-
#validate_complete ⇒ Object
deprecated
private
Deprecated.
Not used by Puppet
- #validate_parameter(name) ⇒ Object
- #yaml_property_munge(x) ⇒ Object
Methods included from Indirector
Methods included from Enumerable
Methods included from Util::PsychSupport
Methods included from Util::Tagging
#merge_into, #merge_tags, #raw_tagged?, #set_tags, #tag, #tag_if_valid, #tagged?, #tags, #tags=
Constructor Details
#initialize(type, title = nil, attributes = EMPTY_HASH) ⇒ Resource
Construct a resource from data.
Constructs a resource instance with the given ‘type` and `title`. Multiple type signatures are possible for these arguments and most will result in an expensive call to Node::Environment#known_resource_types in order to resolve `String` and `Symbol` Types to actual Ruby classes.
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 |
# File 'lib/puppet/resource.rb', line 221 def initialize(type, title = nil, attributes = EMPTY_HASH) @parameters = {} @sensitive_parameters = [] if type.is_a?(Puppet::Resource) # Copy constructor. Let's avoid munging, extracting, tagging, etc src = type self.file = src.file self.line = src.line self.exported = src.exported self.virtual = src.virtual self.(src) self.environment = src.environment @rstype = src.resource_type @type = src.type @title = src.title src.to_hash.each do |p, v| if v.is_a?(Puppet::Resource) v = v.copy_as_resource elsif v.is_a?(Array) # flatten resource references arrays v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) } v = v.collect do |av| av = av.copy_as_resource if av.is_a?(Puppet::Resource) av end end self[p] = v end @sensitive_parameters.replace(type.sensitive_parameters) 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] # In order to avoid an expensive search of 'known_resource_types" and # to obey/preserve the implementation of the resource's type - if the # given type is a resource type implementation (one of): # * a "classic" 3.x ruby plugin # * a compatible implementation (e.g. loading from pcore metadata) # * a resolved user defined type # # ...then, modify the parameters to the "old" (agent side compatible) way # of describing the type/title with string/symbols. # # TODO: Further optimizations should be possible as the "type juggling" is # not needed when the type implementation is known. # if type.is_a?(Puppet::CompilableResourceType) || type.is_a?(Puppet::Resource::Type) # set the resource type implementation self.resource_type = type # set the type name to the symbolic name type = type.name end @exported = false # Set things like strictness first. attributes.each do |attr, value| next if attr == :parameters send(attr.to_s + "=", value) end @type, @title = self.class.type_and_title(type, title) rt = resource_type if strict? && rt.nil? if self.class? raise ArgumentError, "Could not find declared class #{title}" else raise ArgumentError, "Invalid resource type #{type}" end end params = attributes[:parameters] unless params.nil? || params.empty? extract_parameters(params) if rt && rt.respond_to?(:deprecate_params) rt.deprecate_params(title, params) end end tag(self.type) tag_if_valid(self.title) end end |
Instance Attribute Details
#parameters ⇒ Object (readonly)
15 16 17 |
# File 'lib/puppet/resource.rb', line 15 def parameters @parameters end |
#rich_data_enabled ⇒ Object (readonly)
15 16 17 |
# File 'lib/puppet/resource.rb', line 15 def rich_data_enabled @rich_data_enabled end |
#sensitive_parameters ⇒ Array<Symbol>
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Returns A list of parameters to be treated as sensitive.
20 21 22 |
# File 'lib/puppet/resource.rb', line 20 def sensitive_parameters @sensitive_parameters end |
#validate_parameters ⇒ Object
23 24 25 |
# File 'lib/puppet/resource.rb', line 23 def validate_parameters @validate_parameters end |
Class Method Details
.from_data_hash(data) ⇒ Object
40 41 42 43 44 |
# File 'lib/puppet/resource.rb', line 40 def self.from_data_hash(data) resource = self.allocate resource.initialize_from_hash(data) resource end |
.resource_type(type, title, environment) ⇒ Puppet::Type, Puppet::Resource::Type
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
The resource’s type implementation
353 354 355 356 357 358 359 360 361 362 363 364 365 366 |
# File 'lib/puppet/resource.rb', line 353 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 krt = environment.known_resource_types result = krt.definition(type) || krt.application(type) end result end end |
.type_and_title(type, title) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
575 576 577 578 579 580 581 582 |
# File 'lib/puppet/resource.rb', line 575 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 |
.value_to_json_data(value) ⇒ Object
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
# File 'lib/puppet/resource.rb', line 115 def self.value_to_json_data(value) if value.is_a?(Array) value.map{|v| value_to_json_data(v) } elsif value.is_a?(Hash) result = {} value.each_pair { |k, v| result[value_to_json_data(k)] = value_to_json_data(v) } result elsif value.is_a?(Puppet::Resource) value.to_s elsif value.is_a?(Symbol) && value == :undef nil else value end end |
Instance Method Details
#==(other) ⇒ Object
156 157 158 159 160 161 |
# File 'lib/puppet/resource.rb', line 156 def ==(other) return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title return false unless to_hash == other.to_hash true end |
#[](param) ⇒ Object
Return a given parameter’s value. Converts all passed names to lower-case symbols.
152 153 154 |
# File 'lib/puppet/resource.rb', line 152 def [](param) parameters[parameter_name(param)] end |
#[]=(param, value) ⇒ Object
Set a given parameter. Converts all passed names to lower-case symbols.
145 146 147 148 |
# File 'lib/puppet/resource.rb', line 145 def []=(param, value) validate_parameter(param) if validate_parameters parameters[parameter_name(param)] = value end |
#builtin? ⇒ Boolean
Compatibility method.
164 165 166 167 |
# File 'lib/puppet/resource.rb', line 164 def builtin? # TODO: should be deprecated (was only used in one place in puppet codebase) builtin_type? end |
#builtin_type? ⇒ Boolean
Is this a builtin resource type?
170 171 172 173 |
# File 'lib/puppet/resource.rb', line 170 def builtin_type? # Note - old implementation only checked if the resource_type was a Class resource_type.is_a?(Puppet::CompilableResourceType) end |
#class? ⇒ Boolean
190 191 192 |
# File 'lib/puppet/resource.rb', line 190 def class? @is_class ||= @type == TYPE_CLASS end |
#copy_as_resource ⇒ Object
510 511 512 |
# File 'lib/puppet/resource.rb', line 510 def copy_as_resource Puppet::Resource.new(self) end |
#each ⇒ Object
Iterate over each param/value pair, as required for Enumerable.
176 177 178 |
# File 'lib/puppet/resource.rb', line 176 def each parameters.each { |p,v| yield p, v } end |
#environment ⇒ Object
375 376 377 378 379 380 381 |
# File 'lib/puppet/resource.rb', line 375 def environment @environment ||= if catalog catalog.environment_instance else Puppet.lookup(:current_environment) { Puppet::Node::Environment::NONE } end end |
#environment=(environment) ⇒ Object
383 384 385 |
# File 'lib/puppet/resource.rb', line 383 def environment=(environment) @environment = environment end |
#export ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Returns the value of the ‘export’ metaparam as an Array
338 339 340 341 |
# File 'lib/puppet/resource.rb', line 338 def export v = self[:export] || [] v.is_a?(Array) ? v : [ v ] end |
#include?(parameter) ⇒ Boolean
180 181 182 |
# File 'lib/puppet/resource.rb', line 180 def include?(parameter) super || parameters.keys.include?( parameter_name(parameter) ) end |
#initialize_from_hash(data) ⇒ Object
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
# File 'lib/puppet/resource.rb', line 46 def initialize_from_hash(data) raise ArgumentError, _('No resource type provided in serialized data') unless type = data['type'] raise ArgumentError, _('No resource title provided in serialized data') unless title = data['title'] @type, @title = self.class.type_and_title(type, title) if params = data['parameters'] params = Puppet::Pops::Serialization::FromDataConverter.convert(params) @parameters = {} params.each { |param, value| self[param] = value } else @parameters = EMPTY_HASH end if sensitives = data['sensitive_parameters'] @sensitive_parameters = sensitives.map(&:to_sym) else @sensitive_parameters = EMPTY_ARRAY end if = data['tags'] .each { |t| tag(t) } end ATTRIBUTES.each do |a| value = data[a.to_s] send("#{a}=", value) unless value.nil? end end |
#inspect ⇒ Object
75 76 77 |
# File 'lib/puppet/resource.rb', line 75 def inspect "#{@type}[#{@title}]#{to_hash.inspect}" end |
#is_application_component? ⇒ Boolean
A resource is an application component if it exports or consumes one or more capabilities, or if it requires a capability resource
322 323 324 325 326 327 328 |
# File 'lib/puppet/resource.rb', line 322 def is_application_component? return true if ! export.empty? || self[:consume] # Array(self[:require]) does not work for Puppet::Resource instances req = self[:require] || [] req = [ req ] unless req.is_a?(Array) req.any? { |r| r.is_capability? } end |
#is_capability? ⇒ Boolean
A resource is a capability (instance) if its underlying type is a capability type
332 333 334 |
# File 'lib/puppet/resource.rb', line 332 def is_capability? !resource_type.nil? && resource_type.is_capability? end |
#key_attributes ⇒ Object
407 408 409 |
# File 'lib/puppet/resource.rb', line 407 def key_attributes resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name] end |
#name ⇒ Object
463 464 465 466 467 468 |
# File 'lib/puppet/resource.rb', line 463 def name # this is potential namespace conflict # between the notion of an "indirector name" # and a "resource name" [ type, title ].join('/') end |
#pos ⇒ Integer
This method, together with #file and #line, makes it possible for a Resource to be a ‘source_pos’ in a reported issue.
554 555 556 |
# File 'lib/puppet/resource.rb', line 554 def pos nil end |
#prune_parameters(options = EMPTY_HASH) ⇒ Object
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 |
# File 'lib/puppet/resource.rb', line 558 def prune_parameters( = EMPTY_HASH) properties = resource_type.properties.map(&:name) dup.collect do |attribute, value| if value.to_s.empty? or Array(value).empty? delete(attribute) elsif value.to_s == "absent" and attribute.to_s != "ensure" delete(attribute) end parameters_to_include = [:parameters_to_include] || [] delete(attribute) unless properties.include?(attribute) || parameters_to_include.include?(attribute) end self end |
#resolve ⇒ Object
Find our resource.
316 317 318 |
# File 'lib/puppet/resource.rb', line 316 def resolve catalog ? catalog.resource(to_s) : nil end |
#resource_type ⇒ Puppet::Type, Puppet::Resource::Type
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
The resource’s type implementation
346 347 348 |
# File 'lib/puppet/resource.rb', line 346 def resource_type @rstype ||= self.class.resource_type(type, title, environment) end |
#resource_type=(type) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Set the resource’s type implementation
371 372 373 |
# File 'lib/puppet/resource.rb', line 371 def resource_type=(type) @rstype = type end |
#set_default_parameters(scope) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Not used by Puppet
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 |
# File 'lib/puppet/resource.rb', line 480 def set_default_parameters(scope) Puppet.deprecation_warning(_('The method Puppet::Resource.set_default_parameters is deprecated and will be removed in the next major release of Puppet.')) return [] unless resource_type and resource_type.respond_to?(:arguments) unless is_a?(Puppet::Parser::Resource) fail Puppet::DevError, _("Cannot evaluate default parameters for %{resource} - not a parser resource") % { resource: self } end missing_arguments.collect do |param, default| rtype = resource_type if rtype.type == :hostclass using_bound_value = false catch(:no_such_key) do bound_value = Puppet::Pops::Lookup.search_and_merge("#{rtype.name}::#{param}", Puppet::Pops::Lookup::Invocation.new(scope), nil) # Assign bound value but don't let an undef trump a default expression unless bound_value.nil? && !default.nil? self[param.to_sym] = bound_value using_bound_value = true end end end unless using_bound_value next if default.nil? self[param.to_sym] = default.safeevaluate(scope) end param end.compact end |
#stage? ⇒ Boolean
194 195 196 |
# File 'lib/puppet/resource.rb', line 194 def stage? @is_stage ||= @type.to_s.downcase == "stage" end |
#to_data_hash ⇒ Object
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
# File 'lib/puppet/resource.rb', line 79 def to_data_hash data = { 'type' => type, 'title' => title.to_s, 'tags' => .to_data_hash } ATTRIBUTES.each do |param| value = send(param) data[param.to_s] = value unless value.nil? end data['exported'] ||= false params = {} self.to_hash.each_pair do |param, value| # Don't duplicate the title as the namevar unless param == namevar && value == title params[param.to_s] = Puppet::Resource.value_to_json_data(value) end end unless params.empty? data['parameters'] = Puppet::Pops::Serialization::ToDataConverter.convert(params, { :rich_data => environment.rich_data?, :symbol_as_string => true, :local_reference => false, :type_by_reference => true, :message_prefix => ref, :semantic => self }) end data['sensitive_parameters'] = sensitive_parameters.map(&:to_s) unless sensitive_parameters.empty? data end |
#to_hash ⇒ Object
Produces a hash of attribute to value mappings where the title parsed into its components acts as the default values overridden by any parameter values explicitly given as parameters.
390 391 392 |
# File 'lib/puppet/resource.rb', line 390 def to_hash parse_title.merge parameters end |
#to_hierayaml ⇒ Object
Convert our resource to yaml for Hiera purposes.
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 |
# File 'lib/puppet/resource.rb', line 412 def to_hierayaml # Collect list of attributes to align => and move ensure first attr = parameters.keys attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max } attr.sort! if attr.first != :ensure && attr.include?(:ensure) attr.delete(:ensure) attr.unshift(:ensure) end attributes = attr.collect { |k| v = parameters[k] " %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)] }.join " %s:\n%s" % [self.title, attributes] end |
#to_manifest ⇒ Object
Convert our resource to Puppet code.
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 |
# File 'lib/puppet/resource.rb', line 432 def to_manifest # Collect list of attributes to align => and move ensure first attr = parameters.keys attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max } attr.sort! if attr.first != :ensure && attr.include?(:ensure) attr.delete(:ensure) attr.unshift(:ensure) end attributes = attr.collect { |k| v = parameters[k] " %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)] }.join escaped = self.title.gsub(/'/,"\\\\'") "%s { '%s':\n%s}" % [self.type.to_s.downcase, escaped, attributes] end |
#to_ral ⇒ Object
Convert our resource to a RAL resource instance. Creates component instances for resource types that don’t exist.
458 459 460 461 |
# File 'lib/puppet/resource.rb', line 458 def to_ral typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component) typeklass.new(self) end |
#to_s ⇒ Object
394 395 396 |
# File 'lib/puppet/resource.rb', line 394 def to_s "#{type}[#{title}]" end |
#uniqueness_key ⇒ Object
398 399 400 401 402 403 404 405 |
# File 'lib/puppet/resource.rb', line 398 def uniqueness_key # Temporary kludge to deal with inconsistent use patterns; ensure we don't return nil for namevar/:name h = self.to_hash name = h[namevar] || h[:name] || self.name h[namevar] ||= name h[:name] ||= name h.values_at(*key_attributes.sort_by { |k| k.to_s }) end |
#valid_parameter?(name) ⇒ Boolean
514 515 516 |
# File 'lib/puppet/resource.rb', line 514 def valid_parameter?(name) resource_type.valid_parameter?(name) end |
#validate_complete ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Not used by Puppet
Verify that all required arguments are either present or have been provided with defaults. Must be called after ‘set_default_parameters’. We can’t join the methods because Type#set_parameters needs specifically ordered behavior.
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 |
# File 'lib/puppet/resource.rb', line 525 def validate_complete Puppet.deprecation_warning(_('The method Puppet::Resource.validate_complete is deprecated and will be removed in the next major release of Puppet.')) return unless resource_type and resource_type.respond_to?(:arguments) resource_type.arguments.each do |param, default| param = param.to_sym fail Puppet::ParseError, _("Must pass %{param} to %{resource}") % { param: param, resource: self } unless parameters.include?(param) end # Perform optional type checking arg_types = resource_type.argument_types # Parameters is a map from name, to parameter, and the parameter again has name and value parameters.each do |name, value| next unless t = arg_types[name.to_s] # untyped, and parameters are symbols here (aargh, strings in the type) unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value) inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value) actual = inferred_type.generalize() fail Puppet::ParseError, _("Expected parameter '%{name}' of '%{value0}' to have type %{value1}, got %{value2}") % { name: name, value0: self, value1: t.to_s, value2: actual.to_s } end end end |
#validate_parameter(name) ⇒ Object
548 549 550 |
# File 'lib/puppet/resource.rb', line 548 def validate_parameter(name) raise Puppet::ParseError.new(_("no parameter named '%{name}'") % { name: name }, file, line) unless valid_parameter?(name) end |
#yaml_property_munge(x) ⇒ Object
131 132 133 |
# File 'lib/puppet/resource.rb', line 131 def yaml_property_munge(x) self.value.to_json_data(x) end |