module CORL::Util::Puppet

Public Class Methods

add(type_name, resources, defaults = {}, options = {}) click to toggle source
    # File lib/core/util/puppet.rb
 88 def self.add(type_name, resources, defaults = {}, options = {})
 89   config  = Config.ensure(options)
 90 
 91   puppet_scope = config.get(:puppet_scope, nil)
 92   return unless puppet_scope
 93 
 94   info = type_info(type_name, options)
 95 
 96   if config.get(:debug, false)
 97     CORL.ui.info("\n", { :prefix => false })
 98     CORL.ui_group(Util::Console.purple(info[:name])) do |ui|
 99       ui.info("-----------------------------------------------------")
100     end
101   end
102   ResourceGroup.new(info, defaults).add(resources, config)
103 end
add_class(title, properties, options = {}) click to toggle source
    # File lib/core/util/puppet.rb
144 def self.add_class(title, properties, options = {})
145   config       = Config.ensure(options)
146   puppet_scope = config.get(:puppet_scope, nil)
147 
148   if puppet_scope
149     klass = puppet_scope.find_hostclass(title)
150     return unless klass
151 
152     debug_resource(config, title, properties)
153     klass.ensure_in_catalog(puppet_scope, properties)
154     puppet_scope.catalog.add_class(title)
155   end
156 end
add_definition(type, title, properties, options = {}) click to toggle source
    # File lib/core/util/puppet.rb
160 def self.add_definition(type, title, properties, options = {})
161   config = Config.ensure(options)
162 
163   puppet_scope = config.get(:puppet_scope, nil)
164   return unless puppet_scope
165 
166   type = type_info(type, config) if type.is_a?(String)
167 
168   resource          = ::Puppet::Parser::Resource.new(type[:name], title, :scope => puppet_scope, :source => type[:resource])
169   resource.virtual  = type[:virtual]
170   resource.exported = type[:exported]
171 
172   namevar       = namevar(type[:name], title).to_sym
173   resource_name = properties.has_key?(namevar) ? properties[namevar] : title
174   properties    = { :name => resource_name }.merge(properties)
175 
176   properties.each do |key, value|
177     resource.set_parameter(key, value)
178   end
179   if type[:type] == :define
180     type[:resource].instantiate_resource(puppet_scope, resource)
181   end
182 
183   debug_resource(config, title, properties)
184   puppet_scope.compiler.add_resource(puppet_scope, resource)
185 end
add_resource(type, title, properties, options = {}) click to toggle source
    # File lib/core/util/puppet.rb
107 def self.add_resource(type, title, properties, options = {})
108   config  = Config.ensure(options)
109 
110   puppet_scope = config.get(:puppet_scope, nil)
111   return unless puppet_scope
112 
113   if type.is_a?(String)
114     type = type_info(type, config)
115   end
116 
117   display_name = puppet_scope.parent_module_name ? puppet_scope.parent_module_name : 'toplevel'
118   display      = [ :debug, :info, :warn, :error ].include? CORL.log_level
119 
120   case type[:type]
121   when :type, :define
122     if display
123       CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
124         rendered_title    = Util::Console.blue(title)
125         rendered_resource = Util::Console.green("#{type_name(type[:name])}[#{rendered_title}]")
126         ui.info("Adding #{type[:type]} #{rendered_resource}")
127       end
128     end
129     add_definition(type, title, properties, config)
130   when :class
131     if display
132       CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
133         rendered_title    = Util::Console.blue(title)
134         rendered_resource = Util::Console.green("Class[#{rendered_title}]")
135         ui.info("Adding class #{rendered_resource}")
136       end
137     end
138     add_class(title, properties, config)
139   end
140 end
debug_resource(config, title, properties) click to toggle source
    # File lib/core/util/puppet.rb
352 def self.debug_resource(config, title, properties)
353   if config.get(:debug, false)
354     CORL.ui_group(Util::Console.cyan(title.to_s)) do |ui|
355       dump = Util::Console.green(Util::Data.to_json(properties, true))
356 
357       ui.info(":\n#{dump}")
358       ui.info("\n", { :prefix => false })
359     end
360   end
361 end
each_module(options = {}, &code) click to toggle source
    # File lib/core/util/puppet.rb
311 def self.each_module(options = {}, &code)
312   config = Config.ensure(options)
313   values = []
314 
315   puppet_scope = config.get(:puppet_scope, nil)
316   return nil unless puppet_scope
317 
318   puppet_scope.compiler.environment.modules.each do |mod|
319     values << code.call(mod)
320   end
321   values
322 end
import(files, options = {}) click to toggle source
    # File lib/core/util/puppet.rb
189 def self.import(files, options = {})
190   config = Config.ensure(options)
191 
192   puppet_scope = config.get(:puppet_scope, nil)
193   return unless puppet_scope
194 
195   if types = puppet_scope.environment.known_resource_types
196     Util::Data.array(files).each do |file|
197       types.loader.import(file, config.get(:puppet_import_base, nil))
198     end
199   end
200 end
include(resource_name, properties = {}, options = {}) click to toggle source
    # File lib/core/util/puppet.rb
204 def self.include(resource_name, properties = {}, options = {})
205   config     = Config.ensure(options)
206   class_data = {}
207 
208   puppet_scope = config.get(:puppet_scope, nil)
209   return false unless puppet_scope
210 
211   display_name = puppet_scope.parent_module_name ? puppet_scope.parent_module_name : 'toplevel'
212   display      = [ :debug, :info, :warn, :error ].include? CORL.log_level
213 
214   if resource_name.is_a?(Array)
215     resource_name = resource_name.flatten
216   else
217     resource_name = [ resource_name ]
218   end
219 
220   resource_name.each do |name|
221     classes = Config.lookup(name, nil, config)
222     if classes.is_a?(Array)
223       classes.each do |klass|
224         if display
225           CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
226             rendered_klass    = Util::Console.blue(klass)
227             rendered_resource = Util::Console.green("Class[#{rendered_klass}]")
228             ui.info("Including #{rendered_resource}")
229           end
230         end
231         class_data[klass] = properties
232       end
233     end
234   end
235 
236   if config.get(:debug, false)
237     CORL.ui.info("\n", { :prefix => false })
238     CORL.ui_group(Util::Console.cyan("#{display_name} include")) do |ui|
239       ui.info("-----------------------------------------------------")
240 
241       dump = Util::Console.green(Util::Data.to_json(class_data, true))
242 
243       ui.info(":\n#{dump}")
244       ui.info("\n", { :prefix => false })
245     end
246   end
247 
248   klasses = puppet_scope.compiler.evaluate_classes(class_data, puppet_scope, false)
249   missing = class_data.keys.find_all do |klass|
250     ! klasses.include?(klass)
251   end
252   return false unless missing.empty?
253   true
254 end
logger() click to toggle source
  # File lib/core/util/puppet.rb
6 def self.logger
7   CORL.logger
8 end
lookup(property, default = nil, options = {}) click to toggle source
    # File lib/core/util/puppet.rb
259 def self.lookup(property, default = nil, options = {})
260   config = Config.ensure(options)
261   value  = nil
262 
263   puppet_scope   = config.get(:puppet_scope, nil)
264   base_names     = config.get(:search, nil)
265   search_name    = config.get(:search_name, true)
266   reverse_lookup = config.get(:reverse_lookup, true)
267 
268   return default unless puppet_scope
269 
270   log_level = ::Puppet::Util::Log.level
271   ::Puppet::Util::Log.level = :err # Don't want failed parameter lookup warnings here.
272 
273   if base_names
274     if base_names.is_a?(String)
275       base_names = [ base_names ]
276     end
277     base_names = base_names.reverse if reverse_lookup
278 
279     base_names.each do |base|
280       search_property_name = "#{base}::#{property}"
281 
282       value = puppet_scope.lookupvar("::#{search_property_name}")
283       Config.debug_lookup(config, search_property_name, value, "Puppet override lookup")
284 
285       break unless value.nil?
286     end
287   end
288   if value.nil?
289     components = property.to_s.split('::')
290 
291     if components.length > 1
292       components          += [ 'default', components.pop ]
293       search_property_name = components.flatten.join('::')
294 
295       value = puppet_scope.lookupvar("::#{search_property_name}")
296       Config.debug_lookup(config, search_property_name, value, "Puppet default lookup")
297     end
298   end
299   if value.nil? && search_name
300     value = puppet_scope.lookupvar("::#{property}")
301     Config.debug_lookup(config, property, value, "Puppet name lookup")
302   end
303 
304   ::Puppet::Util::Log.level = log_level
305   value
306 end
namevar(type_name, resource_name) click to toggle source
    # File lib/core/util/puppet.rb
340 def self.namevar(type_name, resource_name)
341   resource = ::Puppet::Resource.new(type_name.sub(/^\@?\@/, ''), resource_name)
342 
343   if resource.builtin_type? and type = resource.resource_type and type.key_attributes.length == 1
344     type.key_attributes.first.to_s
345   else
346     'name'
347   end
348 end
register_plugins(options = {}) click to toggle source
   # File lib/core/util/puppet.rb
17 def self.register_plugins(options = {})
18   config = Config.ensure(options)
19 
20   puppet_scope = config.get(:puppet_scope, nil)
21   return unless puppet_scope
22 
23   each_module(config) do |mod|
24     unless @@register.has_key?(mod.path)
25       lib_dir = File.join(mod.path, 'lib')
26       if File.directory?(lib_dir)
27         logger.debug("Registering Puppet module at #{lib_dir}")
28         CORL.register(lib_dir)
29         @@register[mod.path] = true
30       end
31     end
32   end
33 end
to_name(name) click to toggle source
    # File lib/core/util/puppet.rb
326 def self.to_name(name)
327   Util::Data.value(name).to_s.gsub(/[\/\\\-\.]/, '_')
328 end
type_info(type_name, options = {}) click to toggle source
   # File lib/core/util/puppet.rb
38 def self.type_info(type_name, options = {})
39   config = Config.ensure(options)
40   reset  = config.get(:reset, false)
41 
42   puppet_scope = config.get(:puppet_scope, nil)
43   return nil unless puppet_scope
44 
45   type_name = type_name.to_s.downcase
46   type_info = config.get(:type_info, {})
47 
48   if reset || ! type_info.has_key?(type_name)
49     resource_type = nil
50     type_exported, type_virtual = false
51 
52     if type_name.start_with?('@@')
53       type_name     = type_name[2..-1]
54       type_exported = true
55 
56     elsif type_name.start_with?('@')
57       type_name    = type_name[1..-1]
58       type_virtual = true
59     end
60 
61     if type_name == 'class'
62       resource_type = :class
63     else
64       if resource = ::Puppet::Type.type(type_name.to_sym)
65         resource_type = :type
66 
67       elsif resource = puppet_scope.find_definition(type_name)
68         resource_type = :define
69       end
70     end
71 
72     type_info[type_name] = {
73       :name     => type_name,
74       :type     => resource_type,
75       :resource => resource,
76       :exported => type_exported,
77       :virtual  => type_virtual
78     }
79     config.set(:type_info, type_info)
80   end
81 
82   type_info[type_name]
83 end
type_name(value) click to toggle source
    # File lib/core/util/puppet.rb
332 def self.type_name(value)
333   return :main if value == :main
334   return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
335   value.to_s.split("::").collect { |s| s.capitalize }.join("::")
336 end