Class: Onceover::Controlrepo

Inherits:
Object
  • Object
show all
Defined in:
lib/onceover/controlrepo.rb

Constant Summary collapse

@@existing_controlrepo =

This exists for caching. Each time a new one of these objects is created it gets dumped in here so that it’s values can be called without reference to the initial object itself

nil

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Controlrepo

End class methods



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
 
# File 'lib/onceover/controlrepo.rb', line 90

def initialize(opts = {})
  # When we initialize the object it is going to set some instance vars

  # We want people to be able to run this from anywhere within the repo
  # so traverse up until we think we are in a controlrepo.
  if opts[:path]
    @root = opts[:path]
  else
    @root = Dir.pwd
    until File.exist?(File.expand_path('./environment.conf', @root)) do
      # Throw an exception if we can't go any further up
      throw "Could not file root of the controlrepo anywhere above #{Dir.pwd}" if @root == File.expand_path('../', @root)

      # Step up and try again
      @root = File.expand_path('../', @root)
    end
  end

  @onceover_yaml = ENV['ONCEOVER_YAML'] || opts[:onceover_yaml] || File.expand_path("#{@root}/spec/onceover.yaml")

  if File.exist?(@onceover_yaml) && _data = YAML.load_file(@onceover_yaml)
    opts.merge!(_data.fetch('opts',{})||{})
  end
  opts.fetch(:facts_dir,'').sub!(%r{^[^/.].+} ){|path| File.expand_path(path, @root)}
  opts.fetch(:facts_files,[]).map!{|path| path =~ %r{^[/.]} ? path : File.expand_path(path, @root)}

  @environmentpath  = opts[:environmentpath]  || 'etc/puppetlabs/code/environments'
  @puppetfile       = opts[:puppetfile]       || File.expand_path('./Puppetfile', @root)
  @environment_conf = opts[:environment_conf] || File.expand_path('./environment.conf', @root)
  @spec_dir         = opts[:spec_dir]         || File.expand_path('./spec', @root)
  @facts_dir        = opts[:facts_dir]        || File.expand_path('factsets', @spec_dir)
  _facts_dirs       = [@facts_dir, File.expand_path('../../factsets', __dir__)]
  _facts_files      = opts[:facts_files] || _facts_dirs.map{|d| File.join(d, '*.json')}
  @facts_files      = _facts_files.map{|_path| Dir[_path]}.flatten

  @nodeset_file     = opts[:nodeset_file]     || File.expand_path('./spec/acceptance/nodesets/onceover-nodes.yml', @root)
  @role_regex       = opts[:role_regex]       ?  Regexp.new(opts[:role_regex]) : /role[s]?:{2}/
  @profile_regex    = opts[:profile_regex]    ?  Regexp.new(opts[:profile_regex]) : /profile[s]?:{2}/
  @tempdir          = opts[:tempdir]          || File.expand_path('./.onceover', @root)
  $temp_modulepath  = nil
  @opts             = opts
  logger.level = :debug if @opts[:debug]
  @@existing_controlrepo = self

  # Set the manifest option to the fully expanded path if it's used,
  # default to nil
  manifest = opts[:manifest] || config['manifest'] || nil
  if manifest
    @manifest = File.expand_path(manifest, @root)
  end
end

Instance Attribute Details

#environmentpath ⇒ Object

Returns the value of attribute environmentpath.



21
22
23
 
# File 'lib/onceover/controlrepo.rb', line 21

def environmentpath
  @environmentpath
end

#facts_files ⇒ Object

Returns the value of attribute facts_files.



20
21
22
 
# File 'lib/onceover/controlrepo.rb', line 20

def facts_files
  @facts_files
end

#manifest ⇒ Object

Returns the value of attribute manifest.



27
28
29
 
# File 'lib/onceover/controlrepo.rb', line 27

def manifest
  @manifest
end

#nodeset_file ⇒ Object

Returns the value of attribute nodeset_file.



26
27
28
 
# File 'lib/onceover/controlrepo.rb', line 26

def nodeset_file
  @nodeset_file
end

#onceover_yaml ⇒ Object

Returns the value of attribute onceover_yaml.



29
30
31
 
# File 'lib/onceover/controlrepo.rb', line 29

def onceover_yaml
  @onceover_yaml
end

#opts ⇒ Object

Returns the value of attribute opts.



30
31
32
 
# File 'lib/onceover/controlrepo.rb', line 30

def opts
  @opts
end

#profile_regex ⇒ Object

Returns the value of attribute profile_regex.



23
24
25
 
# File 'lib/onceover/controlrepo.rb', line 23

def profile_regex
  @profile_regex
end

#puppetfile ⇒ Object

Returns the value of attribute puppetfile.



19
20
21
 
# File 'lib/onceover/controlrepo.rb', line 19

def puppetfile
  @puppetfile
end

#role_regex ⇒ Object

Returns the value of attribute role_regex.



22
23
24
 
# File 'lib/onceover/controlrepo.rb', line 22

def role_regex
  @role_regex
end

#root ⇒ Object

Returns the value of attribute root.



18
19
20
 
# File 'lib/onceover/controlrepo.rb', line 18

def root
  @root
end

#spec_dir ⇒ Object

Returns the value of attribute spec_dir.



24
25
26
 
# File 'lib/onceover/controlrepo.rb', line 24

def spec_dir
  @spec_dir
end

#temp_modulepath ⇒ Object

Returns the value of attribute temp_modulepath.



25
26
27
 
# File 'lib/onceover/controlrepo.rb', line 25

def temp_modulepath
  @temp_modulepath
end

#tempdir ⇒ Object

Returns the value of attribute tempdir.



28
29
30
 
# File 'lib/onceover/controlrepo.rb', line 28

def tempdir
  @tempdir
end

Class Method Details

.classes ⇒ Object 



55
56
57
 
# File 'lib/onceover/controlrepo.rb', line 55

def self.classes
 @@existing_controlrepo.classes
end

.config ⇒ Object 



67
68
69
 
# File 'lib/onceover/controlrepo.rb', line 67

def self.config
  @@existing_controlrepo.config
end

.create_dirs_and_log(dir) ⇒ Object 



583
584
585
586
587
588
589
590
 
# File 'lib/onceover/controlrepo.rb', line 583

def self.create_dirs_and_log(dir)
  Pathname.new(dir).descend do |folder|
    unless folder.directory?
      FileUtils.mkdir(folder)
      puts "#{'created'.green} #{folder.relative_path_from(Pathname.new(Dir.pwd)).to_s}"
    end
  end
end

.evaluate_template(template_name, bind) ⇒ Object 



592
593
594
595
596
597
598
599
600
601
602
 
# File 'lib/onceover/controlrepo.rb', line 592

def self.evaluate_template(template_name, bind)
  logger.debug "Evaluating template #{template_name}"
  template_dir = File.expand_path('../../templates', File.dirname(__FILE__))
  if File.file?(File.expand_path("./spec/templates/#{template_name}", @root))
    puts "Using Custom #{template_name}"
    template = File.read(File.expand_path("./spec/templates/#{template_name}", @root))
  else
    template = File.read(File.expand_path("./#{template_name}", template_dir))
  end
  ERB.new(template, trim_mode: '-').result(bind)
end

.facts(filter = nil) ⇒ Object 



71
72
73
 
# File 'lib/onceover/controlrepo.rb', line 71

def self.facts(filter = nil)
  @@existing_controlrepo.facts(filter, 'values')
end

.facts_files ⇒ Object 



51
52
53
 
# File 'lib/onceover/controlrepo.rb', line 51

def self.facts_files
 @@existing_controlrepo.facts_files
end

.generate_nodesets(repo) ⇒ Object 



534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
 
# File 'lib/onceover/controlrepo.rb', line 534

def self.generate_nodesets(repo)
  warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"

  require 'onceover/beaker'
  require 'multi_json'
  require 'net/http'

  hosts_hash = {}

  repo.facts.each do |fact_set|
    node_name = File.basename(repo.facts_files[repo.facts.index(fact_set)], '.json')
    boxname   = Onceover::Beaker.facts_to_vagrant_box(fact_set)
    platform  = Onceover::Beaker.facts_to_platform(fact_set)

    logger.debug "Querying hashicorp API for Vagrant box that matches #{boxname}"

    uri = URI("https://atlas.hashicorp.com:443/api/v1/box/#{boxname}")
    request = Net::HTTP.new(uri.host, uri.port)
    request.use_ssl = true
    response = request.get(uri)

    url = 'URL goes here'

    if response.code == "404"
      comment_out = true
    else
      comment_out = false
      box_info = MultiJson.load(response.body)
      box_info['current_version']['providers'].each do |provider|
        if provider['name'] == 'virtualbox'
          url = provider['original_url']
        end
      end
    end

    # Add the resulting info to the hosts hash. This is what the
    # template will output
    hosts_hash[node_name] = {
      :platform => platform,
      :boxname => boxname,
      :url => url,
      :comment_out => comment_out
    }
  end

  # Use an ERB template
  evaluate_template('nodeset.yaml.erb', binding)
end

.generate_onceover_yaml(repo) ⇒ Object 



529
530
531
532
 
# File 'lib/onceover/controlrepo.rb', line 529

def self.generate_onceover_yaml(repo)
  # This will return a controlrepo.yaml that can be written to a file
  evaluate_template('controlrepo.yaml.erb', binding)
end

.hiera_config_file ⇒ Object 



83
84
85
 
# File 'lib/onceover/controlrepo.rb', line 83

def self.hiera_config_file
  @@existing_controlrepo.hiera_config_file
end

.init(repo) ⇒ Object 



486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
 
# File 'lib/onceover/controlrepo.rb', line 486

def self.init(repo)
  # This code will initialise a controlrepo with all of the config
  # that it needs
  require 'pathname'
  require 'colored'

  Onceover::Controlrepo.init_write_file(generate_onceover_yaml(repo), repo.onceover_yaml)
  # [DEPRECATION] Writing nodesets is deprecated due to the removal of Beaker"
  #Onceover::Controlrepo.init_write_file(generate_nodesets(repo),repo.nodeset_file)
  init_write_file(
    evaluate_template('pre_conditions_README.md.erb', binding),
    File.expand_path('./pre_conditions/README.md', repo.spec_dir)
  )
  init_write_file(
    evaluate_template('factsets_README.md.erb', binding),
    File.expand_path('./factsets/README.md', repo.spec_dir)
  )
  init_write_file(
    evaluate_template('Rakefile.erb', binding),
    File.expand_path('./Rakefile', repo.root)
  )
  init_write_file(
    evaluate_template('Gemfile.erb', binding),
    File.expand_path('./Gemfile', repo.root)
  )

  # Add .onceover to Gitignore
  gitignore_path = File.expand_path('.gitignore', repo.root)
  if File.exist? gitignore_path
    gitignore_content = (File.read(gitignore_path)).split("\n")
    message = "#{'changed'.green}"
  else
    message = "#{'created'.green}"
    gitignore_content = []
  end

  unless gitignore_content.include?(".onceover")
    gitignore_content << ".onceover\n"
    File.write(gitignore_path, gitignore_content.join("\n"))
    puts "#{message} #{Pathname.new(gitignore_path).relative_path_from(Pathname.new(Dir.pwd)).to_s}"
  end
end

.init_write_file(contents, out_file) ⇒ Object 



604
605
606
607
608
609
610
611
612
 
# File 'lib/onceover/controlrepo.rb', line 604

def self.init_write_file(contents, out_file)
  create_dirs_and_log(File.dirname(out_file))
  if File.exist?(out_file)
    puts "#{'skipped'.yellow} #{Pathname.new(out_file).relative_path_from(Pathname.new(Dir.pwd)).to_s} #{'(exists)'.yellow}"
  else
    File.write(out_file, contents)
    puts "#{'created'.green} #{Pathname.new(out_file).relative_path_from(Pathname.new(Dir.pwd)).to_s}"
  end
end

.profiles ⇒ Object 



63
64
65
 
# File 'lib/onceover/controlrepo.rb', line 63

def self.profiles
  @@existing_controlrepo.profiles
end

.puppetfile ⇒ Object 



47
48
49
 
# File 'lib/onceover/controlrepo.rb', line 47

def self.puppetfile
 @@existing_controlrepo.puppetfile
end

.roles ⇒ Object 



59
60
61
 
# File 'lib/onceover/controlrepo.rb', line 59

def self.roles
  @@existing_controlrepo.roles
end

.root ⇒ Object

Create methods on self so that we can access these basic things without having to actually instantiate the class, I’m debating how much stuff I should be putting in here, we don’t reeeally need to instantiate the object unless we want to modify it’s parameters, so maybe everything. We shall see…

And yeah I know this makes little sense, but it will look nicer to type, promise

Also it’s probably pretty memory hungry, but let’s be honest, how many times would be be calling this? If we call it over and over you can just instantiate it anyway



43
44
45
 
# File 'lib/onceover/controlrepo.rb', line 43

def self.root
 @@existing_controlrepo.root
end

.trusted_external_facts(filter = nil) ⇒ Object 



79
80
81
 
# File 'lib/onceover/controlrepo.rb', line 79

def self.trusted_external_facts(filter = nil)
  @@existing_controlrepo.facts(filter, 'trusted_external')
end

.trusted_facts(filter = nil) ⇒ Object 



75
76
77
 
# File 'lib/onceover/controlrepo.rb', line 75

def self.trusted_facts(filter = nil)
  @@existing_controlrepo.facts(filter, 'trusted')
end

Instance Method Details

#classes ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/onceover/controlrepo.rb', line 166

def classes
  logger.debug('scanning for classes specified in onceover.yaml')

  # Get all of the possible places for puppet code and look for classes
  code_dirs = self.config['modulepath']
  # Remove interpolated references
  code_dirs.delete_if { |dir| dir[0] == '$'}

  # Include all r10k-downloaded modules to support vendored and/or separate
  # role and profile classes
  code_dirs << "#{@tempdir}/#{@environmentpath}/production/modules"

  # Make sure that the paths are relative to the controlrepo root
  code_dirs.map! do |dir|
    File.expand_path(dir, @root)
  end

  # Get all the classes from all of the manifests
  classes = code_dirs.map do |dir|
    get_classes(dir)
  end
  classes.flatten
end

#config ⇒ Object 



437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
 
# File 'lib/onceover/controlrepo.rb', line 437

def config
  logger.debug "Reading #{@environment_conf}"
  env_conf = File.read(@environment_conf)
  env_conf = env_conf.split("\n")

  # Delete commented out lines
  env_conf.delete_if { |l| l =~ /^\s*#/}

  # Map the lines into a hash
  environment_config = {}
  env_conf.each do |line|
    if matches = line.match(/^(\S+)\s*=(.*)$/)
      environment_config[matches[1]] = matches[2].strip
    end
  end

  # Finally, split the modulepath values and return
  begin
    environment_config['modulepath'] = environment_config['modulepath'].split(':')
  rescue StandardError
    raise "modulepath was not found in environment.conf, don't know where to look for roles & profiles"
  end

  environment_config
end

#facts(filter = nil, key = 'values') ⇒ Object 



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
 
# File 'lib/onceover/controlrepo.rb', line 190

def facts(filter = nil, key = 'values')
  # Returns an array facts hashes
  all_facts = []
  logger.debug "Reading factsets"
  @facts_files.each do |file|
    facts_from_file = read_facts(file)
    # Facter 4 removed the top level key 'values' and, instead, puts facts
    # at the top level. The conditional below accounts for this.
    if (key.eql?('values') and facts_from_file.has_key?('values')) or !key.eql?('values')
      all_facts << facts_from_file[key]
    else
      all_facts << facts_from_file
    end
  end
  if filter
    # Allow us to pass a hash of facts to filter by
    raise "Filter param must be a hash" unless filter.is_a?(Hash)

    all_facts.keep_if do |hash|
      matches = filter.map do |filter_fact,value|
        keypair_is_in_hash(hash,filter_fact,value)
      end
      !matches.include? false
    end
  end
  return all_facts
end

#fixtures ⇒ Object 



338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
 
# File 'lib/onceover/controlrepo.rb', line 338

def fixtures
  # Load up the Puppetfile using R10k
  puppetfile = R10K::Puppetfile.new(@root)
  fail 'Could not load Puppetfile' unless puppetfile.load

  modules = puppetfile.modules

  # Iterate over everything and seperate it out for the sake of readability
  symlinks      = []
  forge_modules = []
  repositories  = []

  modules.each do |mod|
    logger.debug "Converting #{mod.to_s} to .fixtures.yml format"
    # This logic could probably be cleaned up. A lot.
    if mod.is_a? R10K::Module::Forge
      if mod.expected_version.is_a?(Hash)
        # Set it up as a symlink, because we are using local files in the Puppetfile
        symlinks << {
          'name' => mod.name,
          'dir' => mod.expected_version[:path]
        }
      elsif mod.expected_version.is_a?(String)
        # Set it up as a normal forge module
        forge_modules << {
          'name' => mod.name,
          'repo' => mod.title,
          'ref' => mod.expected_version
        }
      end
    elsif mod.is_a? R10K::Module::Git
      # Set it up as a git repo
      repositories << {
          'name' => mod.name,
          # I know I shouldn't be doing this, but trust me, there are no methods
          # anywhere that expose this value, I looked.
          'repo' => mod.instance_variable_get(:@remote),
          'ref' => mod.version
        }
    end
  end

  # also add synlinks for anything that is in environment.conf
  code_dirs = self.config['modulepath']
  code_dirs.delete_if { |dir| dir[0] == '$'}
  code_dirs.each do |dir|
    # We need to traverse down into these directories and create a symlink for each
    # module we find because fixtures.yml is expecting the module's root not the
    # root of modulepath
    Dir["#{dir}/*"].each do |mod|
      symlinks << {
        'name' => File.basename(mod),
        'dir' => Pathname.new(File.expand_path(mod)).relative_path_from(Pathname.new(@root))#File.expand_path(mod)
      }
    end
  end

  # Use an ERB template to write the files
  Onceover::Controlrepo.evaluate_template('.fixtures.yml.erb', binding)
end

#hiera_config ⇒ Object 



414
415
416
417
418
419
420
421
 
# File 'lib/onceover/controlrepo.rb', line 414

def hiera_config
  begin
    YAML.load_file(hiera_config_file)
  rescue TypeError
    puts "WARNING: Could not find hiera config file, continuing"
    nil
  end
end

#hiera_config=(data) ⇒ Object 



423
424
425
 
# File 'lib/onceover/controlrepo.rb', line 423

def hiera_config=(data)
  File.write(hiera_config_file,data.to_yaml)
end

#hiera_config_file ⇒ Object 



399
400
401
402
403
404
405
406
407
408
 
# File 'lib/onceover/controlrepo.rb', line 399

def hiera_config_file
  case
  when File.exist?(File.expand_path('./hiera.yaml', @spec_dir))
    File.expand_path('./hiera.yaml', @spec_dir)
  when File.exist?(File.expand_path('./hiera.yaml', @root))
    File.expand_path('./hiera.yaml', @root)
  else
    nil
  end
end

#hiera_config_file_relative_path ⇒ Object 



410
411
412
 
# File 'lib/onceover/controlrepo.rb', line 410

def hiera_config_file_relative_path
  Pathname.new(hiera_config_file).relative_path_from(Pathname.new(root)).to_s if hiera_config_file
end

#hiera_data ⇒ Object 



427
428
429
430
431
432
433
434
435
 
# File 'lib/onceover/controlrepo.rb', line 427

def hiera_data
  # This is going to try to find your hiera data directory, if you have named it something
  # unexpected it won't work
  possibe_datadirs = Dir["#{@root}/*/"]
  possibe_datadirs.keep_if { |dir| dir =~ /hiera(?:.*data)?/i }
  raise "There were too many directories that looked like hiera data: #{possibe_datadirs}" if possibe_datadirs.count > 1

  File.expand_path(possibe_datadirs[0])
end

#print_puppetfile_table ⇒ Object 



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
294
295
296
297
298
299
 
# File 'lib/onceover/controlrepo.rb', line 218

def print_puppetfile_table
  require 'terminal-table'
  require 'versionomy'
  require 'colored'
  require 'r10k/puppetfile'

  # Load up the Puppetfile using R10k
  logger.debug "Reading puppetfile from #{@root}"
  puppetfile = R10K::Puppetfile.new(@root)
  logger.debug "Loading modules from Puppetfile"
  puppetfile.load!

  output_array = []
  error_array  = []
  threads = puppetfile.modules.map do |mod|
    Thread.new do
      begin
        row = []
        logger.debug "Loading data for #{mod.full_name}"
        row << mod.full_name
        if mod.is_a?(R10K::Module::Forge)
          row << mod.expected_version
          row << mod.v3_module.current_release.version

          # Configure a custom version format to support modern Puppet Forge versions.
          # (major.minor.tiny-patchlevel-patchlevel_minor)
          # e.g. 8.5.0-0-2
          puppetforge_format = Versionomy.default_format.modified_copy do
            field(:patchlevel_minor) do
              recognize_number(:default_value_optional => true,
                               :delimiter_regexp => '-',
                               :default_delimiter => '-')
            end
          end

          current = puppetforge_format.parse(mod.expected_version)
          latest = puppetforge_format.parse(mod.v3_module.current_release.version)
          row << if current.major < latest.major
                    "Major".red
                  elsif current.minor < latest.minor
                    "Minor".yellow
                  elsif current.tiny < latest.tiny
                    "Tiny".green
                  elsif current.patchlevel < latest.patchlevel
                    "PatchLevel".green
                  elsif current.patchlevel_minor < latest.patchlevel_minor
                    "PatchLevel_minor".green
                  else
                    "No".green
                 end

          row << mod.v3_module.endorsement
          superseded_by = mod.v3_module.superseded_by
          row << (superseded_by.nil? ? '' : superseded_by[:slug])
        else
          row << "N/A"
          row << "N/A"
          row << "N/A"
          row << "N/A"
          row << "N/A"
        end
        output_array << row
      rescue RuntimeError => e
        error = []
        error << mod.full_name
        error << mod.expected_version
        error << mod.v3_module.current_release.version
        error << e.message
        error_array << error
        logger.debug "Error loading module #{mod.full_name} - #{e.inspect}"
      end
    end
  end

  threads.map(&:join)

  output_array.sort_by! { |line| line[0] }
  error_array.sort_by! { |line| line[0] } unless error_array.empty?

  puts Terminal::Table.new(headings: ["Full Name", "Current Version", "Latest Version", "Out of Date?", "Endorsement", "Superseded by"], rows: output_array)
  puts Terminal::Table.new(headings: ["Issue assessing module", "Current", "Latest", "Error"], rows: error_array) unless error_array.empty?
end

#profiles ⇒ Object 



162
163
164
 
# File 'lib/onceover/controlrepo.rb', line 162

def profiles
  classes.keep_if { |c| c =~ @profile_regex }
end

#r10k_config ⇒ Object 



474
475
476
 
# File 'lib/onceover/controlrepo.rb', line 474

def r10k_config
  YAML.load_file(r10k_config_file)
end

#r10k_config=(data) ⇒ Object 



478
479
480
 
# File 'lib/onceover/controlrepo.rb', line 478

def r10k_config=(data)
  File.write(r10k_config_file, data.to_yaml)
end

#r10k_config_file ⇒ Object 



463
464
465
466
467
468
469
470
471
472
 
# File 'lib/onceover/controlrepo.rb', line 463

def r10k_config_file
  case
  when File.exist?(File.expand_path('./r10k.yaml', @spec_dir))
    File.expand_path('./r10k.yaml', @spec_dir)
  when File.exist?(File.expand_path('./r10k.yaml', @root))
    File.expand_path('./r10k.yaml', @root)
  else
    nil
  end
end

#roles ⇒ Object 



158
159
160
 
# File 'lib/onceover/controlrepo.rb', line 158

def roles
  classes.keep_if { |c| c =~ @role_regex }
end

#spec_tests(&block) ⇒ Object

Returns the deduplicted and verified output of testconfig.spec_tests for use in Rspec tests so that we don’t have to deal with more than one object



616
617
618
619
620
621
622
623
624
625
626
627
628
 
# File 'lib/onceover/controlrepo.rb', line 616

def spec_tests(&block)
  require 'onceover/testconfig'

  # Load up all of the tests and deduplicate them
  testconfig = Onceover::TestConfig.new(@onceover_yaml, @opts)
  testconfig.spec_tests.each { |tst| testconfig.verify_spec_test(self, tst) }
  tests = testconfig.run_filters(Onceover::Test.deduplicate(testconfig.spec_tests))

  # Loop over each test, executing the user's block on each
  tests.each do |tst|
    block.call(tst.classes[0].name, tst.nodes[0].name, tst.nodes[0].fact_set, tst.nodes[0].trusted_set, tst.nodes[0].trusted_external_set, testconfig.pre_condition)
  end
end

#temp_manifest ⇒ Object 



482
483
484
 
# File 'lib/onceover/controlrepo.rb', line 482

def temp_manifest
  @manifest
end

#to_s ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/onceover/controlrepo.rb', line 142

def to_s
  require 'colored'

  <<-REPO.gsub(/^\s{4}/,'')
  #{'puppetfile'.green}       #{@puppetfile}
  #{'environment_conf'.green} #{@environment_conf}
  #{'facts_dir'.green}        #{@facts_dir}
  #{'spec_dir'.green}         #{@spec_dir}
  #{'facts_files'.green}      #{@facts_files}
  #{'nodeset_file'.green}     #{@nodeset_file}
  #{'roles'.green}            #{roles}
  #{'profiles'.green}         #{profiles}
  #{'onceover.yaml'.green}    #{@onceover_yaml}
  REPO
end

#update_puppetfile ⇒ Object 



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
 
# File 'lib/onceover/controlrepo.rb', line 301

def update_puppetfile
  require 'r10k/puppetfile'

  # Read in the Puppetfile as a string and as an object
  puppetfile_string = File.read(@puppetfile).split("\n")
  puppetfile = R10K::Puppetfile.new(@root)
  puppetfile.load!

  # TODO: Make sure we can deal with :latest

  # Create threading resources
  queue = Queue.new
  queue.push(puppetfile_string)

  puppetfile.modules.keep_if {|m| m.is_a?(R10K::Module::Forge)}
  threads = puppetfile.modules.map do |mod|
    Thread.new do
      logger.debug "Getting latest version of #{mod.full_name}"
      latest_version = mod.v3_module.current_release.version

      # Get the data off the queue, or wait if something else is using it
      puppetfile_string_temp = queue.pop
      line_index = puppetfile_string_temp.index {|l| l =~ /^\s*[^#]*#{mod.owner}[\/-]#{mod.name}/}
      puppetfile_string_temp[line_index].gsub!(mod.expected_version,latest_version)

      # Put the data back into the queue once we are done with it
      queue.push(puppetfile_string_temp)
    end
  end

  threads.map(&:join)
  puppetfile_string = queue.pop

  File.open(@puppetfile, 'w') {|f| f.puts(puppetfile_string.join("\n")) }
  puts "#{'changed'.yellow} #{@puppetfile}"
end