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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
require 'puppet/parser/ast/branch'
class Puppet::Parser::AST
# Evaluate the stored parse tree for a given component. This will
# receive the arguments passed to the component and also the type and
# name of the component.
class Definition < AST::Branch
include Puppet::Util
include Puppet::Util::Warnings
include Puppet::Util::MethodHelper
class << self
attr_accessor :name
end
# The class name
@name = :definition
attr_accessor :classname, :arguments, :code, :scope, :keyword
attr_accessor :exported, :namespace, :parser, :virtual
# These are retrieved when looking up the superclass
attr_accessor :name
attr_reader :parentclass
def child_of?(klass)
false
end
def evaluate(options)
origscope = options[:scope]
resource = options[:resource]
# Create a new scope.
scope = subscope(origscope, resource)
# Additionally, add a tag for whatever kind of class
# we are
if @classname != "" and ! @classname.nil?
@classname.split(/::/).each { |tag| scope.tag(tag) }
end
[resource.name, resource.title].each do |str|
unless str.nil? or str =~ /[^\w]/ or str == ""
scope.tag(str)
end
end
set_resource_parameters(scope, resource)
if self.code
return self.code.safeevaluate(:scope => 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 name" %
name
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
if @parentclass
# Cache our result, since it should never change.
unless defined?(@parentobj)
unless tmp = find_parentclass
parsefail "Could not find %s %s" % [self.class.name, @parentclass]
end
if tmp == self
parsefail "Parent classes must have dissimilar names"
end
@parentobj = tmp
end
@parentobj
else
nil
end
end
# Create a new subscope in which to evaluate our code.
def subscope(scope, resource = nil)
unless resource
raise ArgumentError, "Resources are required when creating subscopes"
end
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 = symbolize(arg)
unless args.include?(arg)
if defined? default and ! default.nil?
default = default.safeevaluate :scope => 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,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
end
|
