1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
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
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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
require 'puppet/parser/ast/branch'
require 'puppet/util/warnings'
# The AST class for defined types, which is also the base class
# nodes and classes.
class Puppet::Parser::AST::Definition < Puppet::Parser::AST::Branch
include Puppet::Util::Warnings
class << self
attr_accessor :name
end
# The class name
@name = :definition
attr_accessor :classname, :arguments, :code, :scope, :keyword
attr_accessor :exported, :namespace, :parser, :virtual, :name
attr_reader :parentclass
def child_of?(klass)
false
end
# Create a resource that knows how to evaluate our actual code.
def evaluate(scope)
resource = Puppet::Parser::Resource.new(:type => self.class.name, :title => self.classname, :scope => scope, :source => scope.source)
scope.catalog.tag(*resource.tags)
scope.compiler.add_resource(scope, resource)
return resource
end
# Now evaluate the code associated with this class or definition.
def evaluate_code(resource)
# Create a new scope.
scope = subscope(resource.scope, resource)
set_resource_parameters(scope, resource)
if self.code
return self.code.safeevaluate(scope)
else
return nil
end
end
def initialize(hash = {})
@arguments = nil
@parentclass = nil
super
# Convert the arguments to a hash for ease of later use.
if @arguments
unless @arguments.is_a? Array
@arguments = [@arguments]
end
oldargs = @arguments
@arguments = {}
oldargs.each do |arg, val|
@arguments[arg] = val
end
else
@arguments = {}
end
# Deal with metaparams in the argument list.
@arguments.each do |arg, defvalue|
next unless Puppet::Type.metaparamclass(arg)
if defvalue
warnonce "%s is a metaparam; this value will inherit to all contained resources" % arg
else
raise Puppet::ParseError, "%s is a metaparameter; please choose another parameter name in the %s definition" % [arg, self.classname]
end
end
end
def find_parentclass
@parser.findclass(namespace, parentclass)
end
# Set our parent class, with a little check to avoid some potential
# weirdness.
def parentclass=(name)
if name == self.classname
parsefail "Parent classes must have dissimilar names"
end
@parentclass = name
end
# Hunt down our class object.
def parentobj
return nil unless @parentclass
# Cache our result, since it should never change.
unless defined?(@parentobj)
unless tmp = find_parentclass
parsefail "Could not find %s parent %s" % [self.class.name, @parentclass]
end
if tmp == self
parsefail "Parent classes must have dissimilar names"
end
@parentobj = tmp
end
@parentobj
end
# Create a new subscope in which to evaluate our code.
def subscope(scope, resource)
args = {
:resource => resource,
:keyword => self.keyword,
:namespace => self.namespace,
:source => self
}
oldscope = scope
scope = scope.newscope(args)
scope.source = self
return scope
end
def to_s
classname
end
# Check whether a given argument is valid. Searches up through
# any parent classes that might exist.
def validattr?(param)
param = param.to_s
if @arguments.include?(param)
# It's a valid arg for us
return true
elsif param == "name"
return true
# elsif defined? @parentclass and @parentclass
# # Else, check any existing parent
# if parent = @scope.lookuptype(@parentclass) and parent != []
# return parent.validarg?(param)
# elsif builtin = Puppet::Type.type(@parentclass)
# return builtin.validattr?(param)
# else
# raise Puppet::Error, "Could not find parent class %s" %
# @parentclass
# end
elsif Puppet::Type.metaparam?(param)
return true
else
# Or just return false
return false
end
end
private
# Set any arguments passed by the resource as variables in the scope.
def set_resource_parameters(scope, resource)
args = symbolize_options(resource.to_hash || {})
# Verify that all required arguments are either present or
# have been provided with defaults.
if self.arguments
self.arguments.each { |arg, default|
arg = arg.to_sym
unless args.include?(arg)
if defined? default and ! default.nil?
default = default.safeevaluate scope
args[arg] = default
#Puppet.debug "Got default %s for %s in %s" %
# [default.inspect, arg.inspect, @name.inspect]
else
parsefail "Must pass %s to %s of type %s" %
[arg, resource.title, @classname]
end
end
}
end
# Set each of the provided arguments as variables in the
# definition's scope.
args.each { |arg,value|
unless validattr?(arg)
parsefail "%s does not accept attribute %s" % [@classname, arg]
end
exceptwrap do
scope.setvar(arg.to_s, args[arg])
end
}
scope.setvar("title", resource.title) unless args.include? :title
scope.setvar("name", resource.name) unless args.include? :name
end
end
|
