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
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
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
|
require 'puppet'
require 'yaml'
module Puppet
# The transportable objects themselves. Basically just a hash with some
# metadata and a few extra methods. I used to have the object actually
# be a subclass of Hash, but I could never correctly dump them using
# YAML.
class TransObject
include Enumerable
attr_accessor :type, :name, :file, :line, :collectable, :collected
attr_writer :tags
%w{has_key? include? length delete empty? << [] []=}.each { |method|
define_method(method) do |*args|
@params.send(method, *args)
end
}
def each
@params.each { |p,v| yield p, v }
end
def initialize(name,type)
@type = type
@name = name
@collectable = false
@params = {}
@tags = []
end
def longname
return [@type,@name].join('--')
end
def tags
return @tags
end
def to_hash
@params.dup
end
def to_s
return "%s(%s) => %s" % [@type,@name,super]
end
def to_manifest
"#{self.type.to_s} { \'#{self.name}\':\n%s\n}" % @params.collect { |p, v|
if v.is_a? Array
" #{p} => [\'#{v.join("','")}\']"
else
" #{p} => \'#{v}\'"
end
}.join(",\n")
end
def to_yaml_properties
instance_variables
end
def to_type(parent = nil)
retobj = nil
if typeklass = Puppet::Type.type(self.type)
# FIXME This should really be done differently, but...
if retobj = typeklass[self.name]
self.each do |param, val|
retobj[param] = val
end
else
unless retobj = typeklass.create(self)
return nil
end
end
else
raise Puppet::Error.new("Could not find object type %s" % self.type)
end
if parent
parent.push retobj
end
return retobj
end
end
# Just a linear container for objects. Behaves mostly like an array, except
# that YAML will correctly dump them even with their instance variables.
class TransBucket
include Enumerable
attr_accessor :name, :type, :file, :line, :classes, :keyword, :top
%w{delete shift include? length empty? << []}.each { |method|
define_method(method) do |*args|
#Puppet.warning "Calling %s with %s" % [method, args.inspect]
@children.send(method, *args)
#Puppet.warning @params.inspect
end
}
# Remove all collectable objects from our tree, since the client
# should not see them.
def collectstrip!
@children.dup.each do |child|
if child.is_a? self.class
child.collectstrip!
else
if child.collectable and ! child.collected
@children.delete(child)
end
end
end
end
# Recursively yield everything.
def delve(&block)
@children.each do |obj|
block.call(obj)
if obj.is_a? self.class
obj.delve(&block)
else
obj
end
end
end
def each
@children.each { |c| yield c }
end
# Turn our heirarchy into a flat list
def flatten
@children.collect do |obj|
if obj.is_a? Puppet::TransBucket
obj.flatten
else
obj
end
end.flatten
end
def initialize(children = [])
@children = children
end
def push(*args)
args.each { |arg|
case arg
when Puppet::TransBucket, Puppet::TransObject
# nada
else
raise Puppet::DevError,
"TransBuckets cannot handle objects of type %s" %
arg.class
end
}
@children += args
end
# Convert to a parseable manifest
def to_manifest
unless self.top
unless defined? @keyword and @keyword
raise Puppet::DevError, "No keyword; cannot convert to manifest"
end
end
str = nil
if self.top
str = "%s"
else
str = "#{@keyword} #{@type} {\n%s\n}"
end
str % @children.collect { |child|
child.to_manifest
}.collect { |str|
if self.top
str
else
str.gsub(/^/, " ") # indent everything once
end
}.join("\n\n") # and throw in a blank line
end
def to_yaml_properties
instance_variables
end
def to_type(parent = nil)
# this container will contain the equivalent of all objects at
# this level
#container = Puppet::Component.new(:name => @name, :type => @type)
#unless defined? @name
# raise Puppet::DevError, "TransBuckets must have names"
#end
unless defined? @type
Puppet.debug "TransBucket '%s' has no type" % @name
end
usetrans = true
if usetrans
tmpname = nil
# Nodes have the same name and type
if self.name
tmpname = "%s[%s]" % [@type, self.name]
else
tmpname = @type
end
trans = TransObject.new(tmpname, :component)
if defined? @parameters
@parameters.each { |param,value|
Puppet.debug "Defining %s on %s of type %s" %
[param,@name,@type]
trans[param] = value
}
else
#Puppet.debug "%s[%s] has no parameters" % [@type, @name]
end
container = Puppet::Type::Component.create(trans)
else
hash = {
:name => self.name,
:type => @type
}
if defined? @parameters
@parameters.each { |param,value|
Puppet.debug "Defining %s on %s of type %s" %
[param,@name,@type]
hash[param] = value
}
else
#Puppet.debug "%s[%s] has no parameters" % [@type, @name]
end
#if parent
# hash[:parent] = parent
#end
container = Puppet::Type::Component.create(hash)
end
#Puppet.info container.inspect
if parent
parent.push container
end
# unless we successfully created the container, return an error
unless container
Puppet.warning "Got no container back"
return nil
end
self.each { |child|
# the fact that we descend here means that we are
# always going to execute depth-first
# which is _probably_ a good thing, but one never knows...
unless child.is_a?(Puppet::TransBucket) or
child.is_a?(Puppet::TransObject)
raise Puppet::DevError,
"TransBucket#to_type cannot handle objects of type %s" %
child.class
end
# Now just call to_type on them with the container as a parent
begin
child.to_type(container)
rescue => detail
if Puppet[:trace] and ! detail.is_a?(Puppet::Error)
puts detail.backtrace
end
Puppet.err detail.to_s
end
}
# at this point, no objects at are level are still Transportable
# objects
return container
end
def param(param,value)
unless defined? @parameters
@parameters = {}
end
@parameters[param] = value
end
end
#------------------------------------------------------------
end
# $Id$
|