Class: Puppet::Pops::Resource::ResourceTypeImpl

Inherits:
Object
  • Object
show all
Includes:
CompilableResourceType, Types::PuppetObject
Defined in:
lib/puppet/pops/resource/resource_type_impl.rb

Constant Summary collapse

METAPARAMS = 
[
:noop,
:schedule,
:audit,
:loglevel,
:alias,
:tag,
:require,
:subscribe,
:before,
:notify,
:stage
].freeze
METAPARAMSET =

Speed up lookup

Set.new(METAPARAMS).freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Types::PuppetObject

#_pcore_all_contents, #_pcore_contents, #_pcore_init_hash, #_pcore_type, #to_s

Constructor Details

#initialize(name, properties = EMPTY_ARRAY, parameters = EMPTY_ARRAY, title_patterns_hash = nil, isomorphic = true, capability = false) ⇒ ResourceTypeImpl

Returns a new instance of ResourceTypeImpl.


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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 102

def initialize(name, properties = EMPTY_ARRAY, parameters = EMPTY_ARRAY, title_patterns_hash = nil, isomorphic = true, capability = false)
  @name = name
  @properties = properties
  @parameters = parameters
  @title_patterns_hash = title_patterns_hash
  @isomorphic = isomorphic
  # ignore capability parameter

  # Compute attributes hash
  # Compute key_names (possibly compound key if there are multiple name vars).
  @attributes = {}
  @key_attributes = []

  # Name to kind of attribute
  @attr_types = {}

  # Add all meta params
  METAPARAMS.each {|p| @attr_types[p] = :meta }

  @property_set = Set.new(properties.map do |p|
    symname = p.name.to_sym
    @attributes[symname] = p
    @key_attributes << symname if p.name_var
    @attr_types[symname] = :property
    symname
  end).freeze

  @param_set = Set.new(parameters.map do |p|
    symname = p.name.to_sym
    @attributes[symname] = p
    @key_attributes << symname if p.name_var
    @attr_types[symname] = :param
    symname
  end).freeze

  # API for title patterns is [ [regexp, [ [ [sym, <lambda>], [sym, <lambda>] ] ] ] ]
  # Where lambdas are optional. This resource type impl does not support lambdas
  # Note that the pcore file has a simpler hashmap that is post processed here
  # since the structure must have Symbol instances for names which the .pp representation
  # does not deliver.
  #
  @title_patterns =
    case @key_attributes.length
    when 0
      # TechDebt: The case of specifying title patterns when having no name vars is unspecified behavior in puppet
      # Here it is silently ignored.
      nil
    when 1
      if @title_patterns_hash.nil?
        [ [ /(.*)/m, [ [@key_attributes.first] ] ] ]
      else
        # TechDebt: The case of having one namevar and an empty title patterns is unspecified behavior in puppet.
        # Here, it may lead to an empty map which may or may not trigger the wanted/expected behavior.
        #
        @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym ] } ] }
      end
    else
      if @title_patterns_hash.nil? || @title_patterns_hash.empty?
        # TechDebt: While title patterns must be specified when more than one is used, they do not have
        # to match/set them all since some namevars can be omitted (to support the use case in
        # the 'package' type where 'provider' attribute is handled as part of the key without being
        # set from the title.
        #
        raise Puppet::DevError, _("you must specify title patterns when there are two or more key attributes")
      end
      @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym] } ] }
    end
end

Instance Attribute Details

#name ⇒ Object (readonly) 


96
97
98
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 96

def name
  @name
end

#parameters ⇒ Object (readonly) 


98
99
100
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 98

def parameters
  @parameters
end

#properties ⇒ Object (readonly) 


97
98
99
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 97

def properties
  @properties
end

#title_patterns ⇒ Object (readonly) 


100
101
102
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 100

def title_patterns
  @title_patterns
end

#title_patterns_hash ⇒ Object (readonly) 


99
100
101
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 99

def title_patterns_hash
  @title_patterns_hash
end

Class Method Details

._pcore_type ⇒ Object

Returns the Puppet Type for this instance.


24
25
26
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 24

def self._pcore_type
  @ptype
end

.register_ptype(loader, ir) ⇒ Object 


28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 28

def self.register_ptype(loader, ir)
  param_ref = Types::PTypeReferenceType.new('Puppet::Resource::Param')
  @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::ResourceType3', nil,
    {
      Types::KEY_NAME => Types::PStringType::NON_EMPTY,
      'properties' => {
        Types::KEY_TYPE => Types::PArrayType.new(param_ref),
        Types::KEY_VALUE => EMPTY_ARRAY
      },
      'parameters' => {
        Types::KEY_TYPE => Types::PArrayType.new(param_ref),
        Types::KEY_VALUE => EMPTY_ARRAY
      },
      'title_patterns_hash' => {
        Types::KEY_TYPE => Types::POptionalType.new(
          Types::PHashType.new(Types::PRegexpType::DEFAULT, Types::PArrayType.new(Types::PStringType::NON_EMPTY))),
        Types::KEY_VALUE => nil
      },
      'isomorphic' => {
        Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
        Types::KEY_VALUE => true
      },
      'capability' => {
        Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
        Types::KEY_VALUE => false
      },
    },
    EMPTY_HASH,
    [Types::KEY_NAME]
  )
end

Instance Method Details

#<=>(other) ⇒ -1, ...

Compares this type against the given other (type) and returns -1, 0, or +1 depending on the order.

Parameters:

  • other (Object) —

    the object to compare against (produces nil, if not kind of Type}

Returns:

  • (-1, 0, +1, nil) —

    produces -1 if this type is before the given other type, 0 if equals, and 1 if after. Returns nil, if the given other is not a kind of Type.

See Also:

  • Comparable

71
72
73
74
75
76
77
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 71

def <=>(other)
  # Order is only maintained against other types, not arbitrary objects.
  # The natural order is based on the reference name used when comparing
  return nil unless other.is_a?(Puppet::CompilableResourceType)
  # against other type instances.
  self.ref <=> other.ref
end

#allattrs ⇒ Object

PROBABLY NOT USED WHEN COMPILING Returns the names of all attributes in a defined order:

  • all key attributes (the composite id)

  • :provider if it is specified

  • all properties

  • all parameters

  • meta parameters

Raises:

  • (NotImplementedError) 

266
267
268
269
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 266

def allattrs
  raise NotImplementedError, "allattrs() - return all attribute names in order - probably not used master side"
  # key_attributes | (parameters & [:provider]) | properties.collect { |property| property.name } | parameters | metaparams
end

#apply_to ⇒ Object

Sets “applies to host”

Raises:

  • (NotImplementedError) 

272
273
274
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 272

def apply_to
  raise NotImplementedError, "apply_to() - probably used when selecting a provider (device/host support)"
end

#apply_to_all ⇒ Object

Raises:

  • (NotImplementedError) 

284
285
286
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 284

def apply_to_all
  raise NotImplementedError, "apply_to_all() - probably used when selecting a provider (device/host support)"
end

#apply_to_device ⇒ Object

Raises:

  • (NotImplementedError) 

280
281
282
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 280

def apply_to_device
  raise NotImplementedError, "apply_to_device() - probably used when selecting a provider (device/host support)"
end

#apply_to_host ⇒ Object

Raises:

  • (NotImplementedError) 

276
277
278
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 276

def apply_to_host
  raise NotImplementedError, "apply_to_host() - probably used when selecting a provider (device/host support)"
end

#attrclass(name) ⇒ Object

Returns the implementation of a param/property/attribute - i.e. a Param class

Raises:

  • (NotImplementedError) 

254
255
256
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 254

def attrclass(name)
  raise NotImplementedError, "attrclass() - returns the (param) class of the parameter"
end

#attrtype(name) ⇒ Object

Answers :property, :param or :meta depending on the type of the attribute According to original version, this is called millions of times and a cache is required.

Parameters:

  • name (Symbol)

Raises:

  • (NotImplementedError) 

248
249
250
251
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 248

def attrtype(name)
  raise NotImplementedError, "attrtype() - returns the kind (:meta, :param, or :property) of the parameter"
  # @attr_types[name]
end

#can_apply_to_target(target) ⇒ Object

Raises:

  • (NotImplementedError) 

288
289
290
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 288

def can_apply_to_target(target)
  raise NotImplementedError, "can_apply_to_target() - probably used when selecting a provider (device/host support)"
end

#deprecate_params(title, attributes) ⇒ Object

Gives a type a chance to issue deprecations for parameters.

Parameters:

  • title (String) —

    the title of the resource of this type

  • attributes (Array<Param>) —

    the set parameters in the resource instance


235
236
237
238
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 235

def deprecate_params(title, attributes)
  # TODO: Current API somewhat unclear, if done at type level, or per
  #       Param.
end

#eql?(other) ⇒ Boolean Also known as: ==

Returns:

  • (Boolean) 

60
61
62
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 60

def eql?(other)
  other.is_a?(Puppet::CompilableResourceType) && @name == other.name
end

#finish ⇒ Object

The type implementation of finish does a lot of things

  • iterates over all parameters and calls post_compile on them if the parameter impl responds to post_compile

  • validates the relationship parameters

This implementation does nothing - it is assumed that the catalog is already validated via the relationship validator (done late in the game).


190
191
192
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 190

def finish()
  # Do nothing.
end

#instantiate_resource(scope, resource) ⇒ Object

This is called on a resource type it performs tagging if it is a Class or Node. It also ensure the parent type is in the catalog, but that is weird since resource types cannot really inherit


198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 198

def instantiate_resource(scope, resource)
  # Do nothing because nothing is needed when compiling.

  # This is what the Puppet::Type implementation does
  # None of this should be needed

    #    # Make sure our parent class has been evaluated, if we have one.
    #    if parent && !scope.catalog.resource(resource.type, parent)
    #      parent_type(scope).ensure_in_catalog(scope)
    #    end

  # This will never happen

    #    if ['Class', 'Node'].include? resource.type
    #      scope.catalog.tag(*resource.tags)
    #    end
end

#is_3x_ruby_plugin? ⇒ Boolean

Override CompilableResource inclusion

Returns:

  • (Boolean) 

172
173
174
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 172

def is_3x_ruby_plugin?
  false
end

#isomorphic? ⇒ Boolean

Being isomorphic in puppet means that the resource is managing a state (as opposed to a resource like Exec that is a function, possibly with side effect. In a Ruby implementation of a resource type, @isomorphic = false is used to turn off isomorphism, it is true by default. This is part of the Puppet::Type API.

Returns:

  • (Boolean) 

222
223
224
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 222

def isomorphic?
  @isomorphic
end

#key_attributes ⇒ Object

Produces the names of the attributes that make out the unique id of a resource


228
229
230
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 228

def key_attributes
  @key_attributes
end

#valid_parameter?(name) ⇒ Boolean

Answers if the parameter name is a parameter/attribute of this type This is part of the Puppet::Type API Check if used when compiling (it is triggered in an apply)

Returns:

  • (Boolean) 

180
181
182
 
# File 'lib/puppet/pops/resource/resource_type_impl.rb', line 180

def valid_parameter?(name)
  @attributes.include?(name) || METAPARAMSET.include?(name)
end