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: Validator Classes: Catalog, Ral, Status, StoreConfigs, Type, TypeCollection
Constant Summary collapse
- EMPTY_ARRAY =
[].freeze
- EMPTY_HASH =
{}.freeze
- ATTRIBUTES =
[:file, :line, :exported, :kind].freeze
- TYPE_CLASS =
'Class'.freeze
- TYPE_NODE =
'Node'.freeze
- CLASS_STRING =
'class'.freeze
- DEFINED_TYPE_STRING =
'defined_type'.freeze
- COMPILABLE_TYPE_STRING =
'compilable_type'.freeze
- UNKNOWN_TYPE_STRING =
'unknown'.freeze
- PCORE_TYPE_KEY =
'__ptype'.freeze
- VALUE_KEY =
'value'.freeze
Constants included from Indirector
Constants included from Util::Tagging
Instance Attribute Summary collapse
- #catalog ⇒ Object
- #exported ⇒ Object
- #file ⇒ Object
- #kind ⇒ Object
- #line ⇒ Object
- #parameters ⇒ 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.
- .to_kind(resource_type) ⇒ Object
- .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
- #include?(parameter) ⇒ Boolean
-
#initialize(type, title = nil, attributes = EMPTY_HASH) ⇒ Resource
constructor
Construct a resource from data.
- #initialize_from_hash(data) ⇒ Object
- #inspect ⇒ Object
- #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.
- #stage? ⇒ Boolean
-
#to_data_hash ⇒ Object
Produces a Data compliant hash of the resource.
-
#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_hiera_hash ⇒ Object
Convert our resource to a hiera hash suitable for serialization.
-
#to_hierayaml ⇒ Object
deprecated
Deprecated.
Use #to_hiera_hash instead.
-
#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_parameter(name) ⇒ Object
- #yaml_property_munge(x) ⇒ Object
Methods included from Indirector
Methods included from Util::PsychSupport
Methods included from Util::Tagging
#merge_into, #merge_tags_from, #raw_tagged?, #set_tags, #tag, #tag_if_valid, #tagged?, #tags, #tags=, #valid_tag?
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.
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 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 |
# File 'lib/puppet/resource.rb', line 259 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.kind = src.kind 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) #TRANSLATORS 'Puppet::Resource.new' should not be translated raise ArgumentError, _("Puppet::Resource.new does not take a hash as the first argument.") + ' ' + _("Did you mean (%{type}, %{title}) ?") % { type: (type[:type] || type["type"]).inspect, title: (type[:title] || type["title"]).inspect } end # 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 environment, 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 self.kind = self.class.to_kind(rt) unless kind if strict? && rt.nil? if self.class? raise ArgumentError, _("Could not find declared class %{title}") % { title: title } else raise ArgumentError, _("Invalid resource type %{type}") % { 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 |
#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
44 45 46 47 48 |
# File 'lib/puppet/resource.rb', line 44 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
371 372 373 374 375 376 377 378 379 380 381 382 383 |
# File 'lib/puppet/resource.rb', line 371 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) else result = Puppet::Type.type(type) if !result krt = environment.known_resource_types result = krt.definition(type) end result end end |
.to_kind(resource_type) ⇒ Object
201 202 203 204 205 206 207 208 209 210 211 |
# File 'lib/puppet/resource.rb', line 201 def self.to_kind(resource_type) if resource_type == CLASS_STRING CLASS_STRING elsif resource_type.is_a?(Puppet::Resource::Type) && resource_type.type == :definition DEFINED_TYPE_STRING elsif resource_type.is_a?(Puppet::CompilableResourceType) COMPILABLE_TYPE_STRING else UNKNOWN_TYPE_STRING 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.
563 564 565 566 567 568 569 570 |
# File 'lib/puppet/resource.rb', line 563 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
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
# File 'lib/puppet/resource.rb', line 141 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
182 183 184 185 186 187 |
# File 'lib/puppet/resource.rb', line 182 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.
178 179 180 |
# File 'lib/puppet/resource.rb', line 178 def [](param) parameters[parameter_name(param)] end |
#[]=(param, value) ⇒ Object
Set a given parameter. Converts all passed names to lower-case symbols.
171 172 173 174 |
# File 'lib/puppet/resource.rb', line 171 def []=(param, value) validate_parameter(param) if validate_parameters parameters[parameter_name(param)] = value end |
#builtin? ⇒ Boolean
Compatibility method.
190 191 192 193 |
# File 'lib/puppet/resource.rb', line 190 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?
196 197 198 199 |
# File 'lib/puppet/resource.rb', line 196 def builtin_type? # Note - old implementation only checked if the resource_type was a Class resource_type.is_a?(Puppet::CompilableResourceType) end |
#class? ⇒ Boolean
228 229 230 |
# File 'lib/puppet/resource.rb', line 228 def class? @is_class ||= @type == TYPE_CLASS end |
#copy_as_resource ⇒ Object
526 527 528 |
# File 'lib/puppet/resource.rb', line 526 def copy_as_resource Puppet::Resource.new(self) end |
#each ⇒ Object
Iterate over each param/value pair, as required for Enumerable.
214 215 216 |
# File 'lib/puppet/resource.rb', line 214 def each parameters.each { |p,v| yield p, v } end |
#environment ⇒ Object
392 393 394 395 396 397 398 |
# File 'lib/puppet/resource.rb', line 392 def environment @environment ||= if catalog catalog.environment_instance else Puppet.lookup(:current_environment) { Puppet::Node::Environment::NONE } end end |
#environment=(environment) ⇒ Object
400 401 402 |
# File 'lib/puppet/resource.rb', line 400 def environment=(environment) @environment = environment end |
#include?(parameter) ⇒ Boolean
218 219 220 |
# File 'lib/puppet/resource.rb', line 218 def include?(parameter) super || parameters.keys.include?( parameter_name(parameter) ) end |
#initialize_from_hash(data) ⇒ Object
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
# File 'lib/puppet/resource.rb', line 50 def initialize_from_hash(data) type = data['type'] raise ArgumentError, _('No resource type provided in serialized data') unless type title = data['title'] raise ArgumentError, _('No resource title provided in serialized data') unless title @type, @title = self.class.type_and_title(type, title) params = data['parameters'] if params params = Puppet::Pops::Serialization::FromDataConverter.convert(params) @parameters = {} params.each { |param, value| self[param] = value } else @parameters = EMPTY_HASH end sensitives = data['sensitive_parameters'] if sensitives @sensitive_parameters = sensitives.map(&:to_sym) else @sensitive_parameters = EMPTY_ARRAY end = data['tags'] if tag(*) end ATTRIBUTES.each do |a| value = data[a.to_s] send("#{a}=", value) unless value.nil? end end |
#inspect ⇒ Object
84 85 86 |
# File 'lib/puppet/resource.rb', line 84 def inspect "#{@type}[#{@title}]#{to_hash.inspect}" end |
#key_attributes ⇒ Object
424 425 426 |
# File 'lib/puppet/resource.rb', line 424 def key_attributes resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name] end |
#name ⇒ Object
511 512 513 514 515 516 |
# File 'lib/puppet/resource.rb', line 511 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.
540 541 542 |
# File 'lib/puppet/resource.rb', line 540 def pos nil end |
#prune_parameters(options = EMPTY_HASH) ⇒ Object
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 |
# File 'lib/puppet/resource.rb', line 544 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 = resource_type.parameters_to_include 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.
357 358 359 |
# File 'lib/puppet/resource.rb', line 357 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
364 365 366 |
# File 'lib/puppet/resource.rb', line 364 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
388 389 390 |
# File 'lib/puppet/resource.rb', line 388 def resource_type=(type) @rstype = type end |
#stage? ⇒ Boolean
232 233 234 |
# File 'lib/puppet/resource.rb', line 232 def stage? @is_stage ||= @type.to_s.casecmp("stage").zero? end |
#to_data_hash ⇒ Object
Produces a Data compliant hash of the resource. The result depends on the –rich_data setting, and the context value for Puppet.lookup(:stringify_rich), that if it is `true` will use the ToStringifiedConverter to produce the value per parameter. (Note that the ToStringifiedConverter output is lossy and should not be used when producing a catalog serialization).
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 |
# File 'lib/puppet/resource.rb', line 95 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 # To get stringified parameter values the flag :stringify_rich can be set # in the puppet context. # stringify = Puppet.lookup(:stringify_rich) { false } converter = stringify ? Puppet::Pops::Serialization::ToStringifiedConverter.new : nil params = {} self.to_hash.each_pair do |param, value| # Don't duplicate the title as the namevar unless param == namevar && value == title if stringify params[param.to_s] = converter.convert(value) else params[param.to_s] = Puppet::Resource.value_to_json_data(value) end end end unless params.empty? data['parameters'] = Puppet::Pops::Serialization::ToDataConverter.convert(params, { :rich_data => Puppet.lookup(: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.
407 408 409 |
# File 'lib/puppet/resource.rb', line 407 def to_hash parse_title.merge parameters end |
#to_hiera_hash ⇒ Object
Convert our resource to a hiera hash suitable for serialization.
451 452 453 454 455 456 457 458 459 460 461 462 463 |
# File 'lib/puppet/resource.rb', line 451 def to_hiera_hash # to_data_hash converts to safe Data types, e.g. no symbols, unicode replacement character h = to_data_hash params = h['parameters'] || {} value = params.delete('ensure') res = {} res['ensure'] = value if value res.merge!(Hash[params.sort]) return { h['title'] => res } end |
#to_hierayaml ⇒ Object
Use #to_hiera_hash instead.
Convert our resource to yaml for Hiera purposes.
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 |
# File 'lib/puppet/resource.rb', line 431 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.
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 |
# File 'lib/puppet/resource.rb', line 466 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 are not of a compilable_type kind. In case the resource doesn’t exist and it’s compilable_type kind, raise an error. There are certain cases where a resource won't be in a catalog, such as when we create a resource directly by using Puppet::Resource.new(…), so we must check its kind before deciding whether the catalog format is of an older version or not.
497 498 499 500 501 502 503 504 505 506 507 508 509 |
# File 'lib/puppet/resource.rb', line 497 def to_ral if self.kind == COMPILABLE_TYPE_STRING typeklass = Puppet::Type.type(self.type) elsif self.catalog && self.catalog.catalog_format >= 2 typeklass = Puppet::Type.type(:component) else typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component) end raise(Puppet::Error, "Resource type '#{self.type}' was not found") unless typeklass typeklass.new(self) end |
#to_s ⇒ Object
411 412 413 |
# File 'lib/puppet/resource.rb', line 411 def to_s "#{type}[#{title}]" end |
#uniqueness_key ⇒ Object
415 416 417 418 419 420 421 422 |
# File 'lib/puppet/resource.rb', line 415 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
530 531 532 |
# File 'lib/puppet/resource.rb', line 530 def valid_parameter?(name) resource_type.valid_parameter?(name) end |
#validate_parameter(name) ⇒ Object
534 535 536 |
# File 'lib/puppet/resource.rb', line 534 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
157 158 159 |
# File 'lib/puppet/resource.rb', line 157 def yaml_property_munge(x) self.value.to_json_data(x) end |