class Puppet::Parser::Resource

The primary difference between this class and its parent is that this class has rules on who can set parameters

Attributes

catalog[RW]

collector_id[RW]

evaluated[RW]

exported[R]

file[RW]

line[RW]

override[RW]

parameters[R]

scope[RW]

source[RW]

translated[RW]

virtual[RW]

Public Instance Methods

[](param) click to toggle source

# File lib/puppet/parser/resource.rb, line 37
def [](param)
  param = param.intern
  if param == :title
    return self.title
  end
  if @parameters.has_key?(param)
    @parameters[param].value
  else
    nil
  end
end

[]=(param, value = nil) click to toggle source

Alias for: set_parameter

add_edge_to_stage() click to toggle source

Process the stage metaparameter for a class. A containment edge is drawn from the class to the stage. The stage for containment defaults to main, if none is specified.

# File lib/puppet/parser/resource.rb, line 62
def add_edge_to_stage
  return unless self.class?

  unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
    raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
  end

  self[:stage] ||= stage.title unless stage.title == :main
  catalog.add_edge(stage, self)
end

eachparam() { |param| ... } click to toggle source

# File lib/puppet/parser/resource.rb, line 49
def eachparam
  @parameters.each do |name, param|
    yield param
  end
end

environment() click to toggle source

# File lib/puppet/parser/resource.rb, line 55
def environment
  scope.environment
end

evaluate() click to toggle source

Retrieve the associated definition and evaluate it.

# File lib/puppet/parser/resource.rb, line 74
def evaluate
  return if evaluated?

  Puppet::Util::Profiler.profile("Evaluated resource #{self}", [:compiler, :evaluate_resource, self]) do
    @evaluated = true
    if klass = resource_type and ! builtin_type?
      finish
      evaluated_code = klass.evaluate_code(self)

      return evaluated_code
    elsif builtin?
      devfail "Cannot evaluate a builtin type (#{type})"
    else
      self.fail "Cannot find definition #{type}"
    end
  end
end

evaluated?() click to toggle source

# File lib/puppet/parser/resource.rb, line 35
def evaluated?;  !!@evaluated;  end

exported=(value) click to toggle source

Mark this resource as both exported and virtual, or remove the exported mark.

# File lib/puppet/parser/resource.rb, line 94
def exported=(value)
  if value
    @virtual = true
    @exported = value
  else
    @exported = value
  end
end

finish() click to toggle source

Do any finishing work on this object, called before evaluation or before storage/translation.

# File lib/puppet/parser/resource.rb, line 105
def finish
  return if finished?
  @finished = true
  add_defaults
  add_scope_tags
  validate
end

finished?() click to toggle source

Has this resource already been finished?

# File lib/puppet/parser/resource.rb, line 114
def finished?
  @finished
end

isomorphic?() click to toggle source

Is this resource modeling an isomorphic resource type?

# File lib/puppet/parser/resource.rb, line 127
def isomorphic?
  if builtin_type?
    return resource_type.isomorphic?
  else
    return true
  end
end

merge(resource) click to toggle source

Merge an override resource in. This will throw exceptions if any overrides aren’t allowed.

# File lib/puppet/parser/resource.rb, line 137
def merge(resource)
  # Test the resource scope, to make sure the resource is even allowed
  # to override.
  unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
    raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
  end
  # Some of these might fail, but they'll fail in the way we want.
  resource.parameters.each do |name, param|
    override_parameter(param)
  end
end

metaparam_compatibility_mode?() click to toggle source

This only mattered for clients < 0.25, which we don’t support any longer. …but, since this hasn’t been deprecated, and at least some functions used it, deprecate now rather than just eliminate. –daniel 2012-07-15

# File lib/puppet/parser/resource.rb, line 152
def metaparam_compatibility_mode?
  Puppet.deprecation_warning "metaparam_compatibility_mode? is obsolete since < 0.25 clients are really, really not supported any more"
  false
end

name() click to toggle source

# File lib/puppet/parser/resource.rb, line 157
def name
  self[:name] || self.title
end

override?() click to toggle source

# File lib/puppet/parser/resource.rb, line 34
def override?;   !!@override;   end

raw_tagged?(tag_array) click to toggle source

Answers if this resource is tagged with at least one of the tags given in downcased string form.

The method is a faster variant of the tagged? method that does no conversion of its arguments.

The match takes into account the tags that a resource will inherit from its container but have not been set yet. It does not take tags set via resource defaults as these will never be set on the resource itself since all resources always have tags that are automatically assigned.

@param tag_array [Array] list tags to look for @return [Boolean] true if this instance is tagged with at least one of the provided tags

# File lib/puppet/parser/resource.rb, line 209
def raw_tagged?(tag_array)
  super || ((scope_resource = scope.resource) && !scope_resource.equal?(self) && scope_resource.raw_tagged?(tag_array))
end

set_parameter(param, value = nil) click to toggle source

Define a parameter in our resource. if we ever receive a parameter named ‘tag’, set the resource tags with its value.

# File lib/puppet/parser/resource.rb, line 167
def set_parameter(param, value = nil)
  if ! param.is_a?(Puppet::Parser::Resource::Param)
    param = Puppet::Parser::Resource::Param.new(
      :name => param, :value => value, :source => self.source
    )
  end

  tag(*param.value) if param.name == :tag

  # And store it in our parameter hash.
  @parameters[param.name] = param
end

Also aliased as: []=

to_hash() click to toggle source

# File lib/puppet/parser/resource.rb, line 181
def to_hash
  @parameters.inject({}) do |hash, ary|
    param = ary[1]
    # Skip "undef" and nil values.
    hash[param.name] = param.value if param.value != :undef && !param.value.nil?
    hash
  end
end

to_ral() click to toggle source

Convert this resource to a RAL resource.

# File lib/puppet/parser/resource.rb, line 191
def to_ral
  copy_as_resource.to_ral
end

translated?() click to toggle source

Set up some boolean test methods

# File lib/puppet/parser/resource.rb, line 33
def translated?; !!@translated; end

Public Class Methods

new(*args) click to toggle source

# File lib/puppet/parser/resource.rb, line 118
def initialize(*args)
  raise ArgumentError, "Resources require a hash as last argument" unless args.last.is_a? Hash
  raise ArgumentError, "Resources require a scope" unless args.last[:scope]
  super

  @source ||= scope.source
end

relationship_parameter?(name) click to toggle source

Determine whether the provided parameter name is a relationship parameter.

# File lib/puppet/parser/resource.rb, line 27
def self.relationship_parameter?(name)
  @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
  @relationship_names.include?(name)
end