Class: CORL::Provisioner::Puppetnode

Inherits:
Object
  • Object
show all
Defined in:
lib/CORL/provisioner/puppetnode.rb

Constant Summary collapse

@@puppet_lock = 
Mutex.new
@@status = 
{}

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.network ⇒ Object 



18
19
20
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 18

def self.network
  @@network
end

.node ⇒ Object 



22
23
24
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 22

def self.node
  @@node
end

.status ⇒ Object 



12
13
14
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 12

def self.status
  @@status
end

Instance Method Details

#add_search_path(type, resource_name) ⇒ Object 



213
214
215
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 213

def add_search_path(type, resource_name)
  Config.set_options([ :all, type ], { :search => [ resource_name.to_s ] })
end

#build_module(name, project_reference, directory, profile, environment, options = {}) ⇒ Object 



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
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 166

def build_module(name, project_reference, directory, profile, environment, options = {})
  config                = Config.ensure(options)
  module_directory      = File.join(directory, name.to_s)
  full_module_directory = File.join(network.directory, module_directory)
  module_project        = nil
  success               = true

  FileUtils.rm_rf(full_module_directory) if config.get(:clean, false)

  info("Building #{blue(profile)} Puppet module #{blue(name)} at #{purple(project_reference)} into #{green(module_directory)}", { :i18n => false })

  module_project = build_config.manage(:project, extended_config(:puppet_module, {
    :directory     => full_module_directory,
    :url           => project_reference,
    :create        => File.directory?(full_module_directory) ? false : true,
    :pull          => true,
    :internal_ip   => CORL.public_ip, # Needed for seeding Vagrant VMs
    :manage_ignore => false
  }))
  unless module_project
    warn("Puppet module #{cyan(name)} failed to initialize", { :i18n => false })
    success = false
  end
  #success("Build of #{blue(profile)} #{blue(name)} finished", { :i18n => false }) if success
  success
end

#build_profile(name, info, package, environment, profiles, options = {}) ⇒ Object

Provisioner interface operations



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 147

def build_profile(name, info, package, environment, profiles, options = {})
  super do |processed_info|
    package_id = id(package)
    directory  = File.join(internal_path(build_directory), package_id.to_s, name.to_s)
    success    = true

    #info("Building CORL profile #{blue(name)} modules into #{green(directory)}", { :i18n => false })

    if processed_info.has_key?(:modules)
      status  = parallel(:build_module, hash(processed_info[:modules]), directory, name, environment, options)
      success = status.values.include?(false) ? false : true

      build_config.set_location(:puppet_module, profile_id(package, name), directory) if success
    end
    #success("Build of profile #{blue(name)} finished", { :i18n => false }) if success
    success
  end
end

#compiler ⇒ Object

Property accessor / modifiers



74
75
76
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 74

def compiler
  @compiler
end

#import(files, options = {}) ⇒ Object

–



204
205
206
207
208
209
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 204

def import(files, options = {})
  Util::Puppet.import(files, Config.ensure(options).defaults({
    :puppet_scope       => scope,
    :puppet_import_base => network.directory
  }))
end

#lookup(property, default = nil, options = {}) ⇒ Object 



195
196
197
198
199
200
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 195

def lookup(property, default = nil, options = {})
  Util::Puppet.lookup(property, default, Config.ensure(options).defaults({
    :provisioner  => :puppetnode,
    :puppet_scope => scope
  }))
end

#normalize(reload) ⇒ Object

Provisioner plugin interface



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
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 29

def normalize(reload)
  super do
    if [ :debug, :info, :warn ].include? CORL.log_level
      Puppet.debug = true
    end
    unless reload
      Puppet::Util::Log.newdesttype id do
        def handle(msg)
          levels = {
            :emerg => { :name => 'emergency', :send => :error },
            :alert => { :name => 'alert', :send => :error },
            :crit => { :name => 'critical', :send => :error },
            :err => { :name => 'error', :send => :error },
            :warning => { :name => 'warning', :send => :warn },
            :notice => { :name => 'notice', :send => :success },
            :info => { :name => 'info', :send => :info },
            :debug => { :name => 'debug', :send => :info }
          }
          str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
          str = msg.source == "Puppet" ? str : "#{CORL.blue(msg.source)}: #{str}"
          level = levels[msg.level]

          if [ :error ].include?(level[:send])
            ::CORL::Provisioner::Puppetnode.status[name] = 111
          end

          CORL.ui_group("puppetnode::#{name}(#{CORL.yellow(level[:name])})", :cyan) do |ui|
            ui.send(level[:send], str)
          end
          puts caller if level[:send] == :error && [ :warn, :error ].include?(CORL.log_level)
        end
      end
    end
  end
end

#provision(node, profiles, options = {}) ⇒ Object 



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
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 219

def provision(node, profiles, options = {})
  super do |processed_profiles, config|
    locations = build_locations(node)
    success   = true

    include_location = lambda do |type, parameters = {}, add_search_path = false|
      classes = {}

      locations[:package].keys.reverse.each do |name|
        package_directory = locations[:package][name]
        type_gateway      = File.join(network.directory, package_directory, "#{type}.pp")
        resource_name     = resource([ name, type ])

        add_search_path(type, resource_name) if add_search_path

        if File.exists?(type_gateway)
          import(type_gateway)
          classes[resource_name] = parameters
        end

        type_directory = File.join(network.directory, package_directory, type.to_s)
        Dir.glob(File.join(type_directory, '*.pp')).each do |file|
          resource_name = resource([ name, type, File.basename(file).gsub('.pp', '') ])
          import(file)
          classes[resource_name] = parameters
        end
      end

      type_gateway = File.join(directory, "#{type}.pp")
      resource_name = resource([ plugin_name, type ])

      add_search_path(type, resource_name) if add_search_path

      if File.exists?(type_gateway)
        import(type_gateway)
        classes[resource_name] = parameters
      end

      type_directory = File.join(directory, type.to_s)

      if File.directory?(type_directory)
        Dir.glob(File.join(type_directory, '*.pp')).each do |file|
          resource_name = resource([ plugin_name, type, File.basename(file).gsub('.pp', '') ])
          import(file)
          classes[resource_name] = parameters
        end
      end
      classes
    end

    @@puppet_lock.synchronize do
      begin
        info("Starting catalog generation at #{Time.now.to_s}", { :i18n => false })

        @@status[id] = code.success
        @@network    = network
        @@node       = node

        start_time        = Time.now
        apply_environment = init_puppet(node, processed_profiles)

        if apply_environment.nil?
          success = false
        else
          Puppet.override(:environments => Puppet::Environments::Static.new(apply_environment)) do
            puppet_node = get_puppet_node(apply_environment.name)
            @compiler   = Puppet::Parser::Compiler.new(puppet_node)

            # Register Puppet module plugins
            register

            # Include defaults
            classes = include_location.call(:default, {}, true)

            # Import needed profiles
            include_location.call(:profiles, {}, false)

            processed_profiles.each do |profile|
              classes[profile.to_s] = { :require => 'Anchor[profile_start]' }
            end

            puppet_node.classes = classes

            # Compile catalog
            compiler.compile

            catalog = compiler.catalog.to_ral
            catalog.finalize
            catalog.retrieval_duration = Time.now - start_time

            unless config.get(:dry_run, false)
              info("\n", { :prefix => false, :i18n => false })
              info("Starting configuration run at #{Time.now.to_s}", { :i18n => false })

              # Configure the machine
              Puppet.push_context({ :current_environment => apply_environment }, "CORL environment for configurer transaction")

              configurer = Puppet::Configurer.new
              if ! configurer.run(:catalog => catalog, :pluginsync => false)
                success = false
              end
            end
          end
        end

      rescue Exception => error
        if [ :debug, :info, :warn, :error ].include? CORL.log_level
          logger.error("Puppetnode provisioner experienced an error:")
          logger.error(error.inspect)
          logger.error(error.message)
          logger.error(Util::Data.to_yaml(error.backtrace))
        end
        Puppet.log_exception(error)
        success = false
      end
    end

    success = false if @@status[id] != code.success
    success
  end
end

#register(options = {}) ⇒ Object 



67
68
69
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 67

def register(options = {})
  Util::Puppet.register_plugins(Config.ensure(options).defaults({ :puppet_scope => scope }))
end

#scope ⇒ Object 



80
81
82
83
 
# File 'lib/CORL/provisioner/puppetnode.rb', line 80

def scope
  return compiler.topscope if compiler
  nil
end