Class: Onceover::Controlrepo

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Controlrepo

End class methods



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

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

  @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)
  @facts_dir        = opts[:facts_dir] || File.expand_path('./spec/factsets',@root)
  @spec_dir         = opts[:spec_dir] || File.expand_path('./spec',@root)
  @facts_files      = opts[:facts_files] || [Dir["#{@facts_dir}/*.json"],Dir["#{File.expand_path('../../../factsets',__FILE__)}/*.json"]].flatten
  @nodeset_file     = opts[:nodeset_file] || File.expand_path('./spec/acceptance/nodesets/onceover-nodes.yml',@root)
  @role_regex       = /role[s]?:{2}/
  @profile_regex    = /profile[s]?:{2}/
  @tempdir          = opts[:tempdir] || File.expand_path('./.onceover',@root)
  $temp_modulepath  = nil
  @manifest         = opts[:manifest] || config['manifest'] ? File.expand_path(config['manifest'],@root) : nil
  @onceover_yaml    = opts[:onceover_yaml] || "#{@spec_dir}/onceover.yaml"
  @opts             = opts
  logger.level = :debug if @opts[:debug]
end

Instance Attribute Details

#environmentpath ⇒ Object

Returns the value of attribute environmentpath.



16
17
18
 
# File 'lib/onceover/controlrepo.rb', line 16

def environmentpath
  @environmentpath
end

#facts_files ⇒ Object

Returns the value of attribute facts_files.



15
16
17
 
# File 'lib/onceover/controlrepo.rb', line 15

def facts_files
  @facts_files
end

#manifest ⇒ Object

Returns the value of attribute manifest.



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

def manifest
  @manifest
end

#nodeset_file ⇒ Object

Returns the value of attribute nodeset_file.



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

def nodeset_file
  @nodeset_file
end

#onceover_yaml ⇒ Object

Returns the value of attribute onceover_yaml.



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

def onceover_yaml
  @onceover_yaml
end

#opts ⇒ Object

Returns the value of attribute opts.



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

def opts
  @opts
end

#profile_regex ⇒ Object

Returns the value of attribute profile_regex.



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

def profile_regex
  @profile_regex
end

#puppetfile ⇒ Object

Returns the value of attribute puppetfile.



14
15
16
 
# File 'lib/onceover/controlrepo.rb', line 14

def puppetfile
  @puppetfile
end

#role_regex ⇒ Object

Returns the value of attribute role_regex.



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

def role_regex
  @role_regex
end

#root ⇒ Object

Returns the value of attribute root.



13
14
15
 
# File 'lib/onceover/controlrepo.rb', line 13

def root
  @root
end

#spec_dir ⇒ Object

Returns the value of attribute spec_dir.



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

def spec_dir
  @spec_dir
end

#temp_modulepath ⇒ Object

Returns the value of attribute temp_modulepath.



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

def temp_modulepath
  @temp_modulepath
end

#tempdir ⇒ Object

Returns the value of attribute tempdir.



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

def tempdir
  @tempdir
end

Class Method Details

.classes ⇒ Object 



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

def self.classes
 Onceover::Controlrepo.new.classes
end

.config ⇒ Object 



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

def self.config
  Onceover::Controlrepo.new.config
end

.create_dirs_and_log(dir) ⇒ Object 



459
460
461
462
463
464
465
466
 
# File 'lib/onceover/controlrepo.rb', line 459

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 



468
469
470
471
472
473
 
# File 'lib/onceover/controlrepo.rb', line 468

def self.evaluate_template(template_name,bind)
  logger.debug "Evaluating template #{template_name}"
  template_dir = File.expand_path('../../templates',File.dirname(__FILE__))
  template = File.read(File.expand_path("./#{template_name}",template_dir))
  ERB.new(template, nil, '-').result(bind)
end

.facts(filter = nil) ⇒ Object 



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

def self.facts(filter = nil)
  Onceover::Controlrepo.new.facts(filter)
end

.facts_files ⇒ Object 



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

def self.facts_files
 Onceover::Controlrepo.new.facts_files
end

.generate_nodesets(repo) ⇒ Object 



412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
 
# File 'lib/onceover/controlrepo.rb', line 412

def self.generate_nodesets(repo)
  require 'onceover/beaker'
  require 'net/http'
  require 'json'

  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 = JSON.parse(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
  Onceover::Controlrepo.evaluate_template('nodeset.yaml.erb',binding)
end

.generate_onceover_yaml(repo) ⇒ Object 



407
408
409
410
 
# File 'lib/onceover/controlrepo.rb', line 407

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

.hiera_config_file ⇒ Object 



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

def self.hiera_config_file
  Onceover::Controlrepo.new.hiera_config_file
end

.init(repo) ⇒ Object 



377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
 
# File 'lib/onceover/controlrepo.rb', line 377

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)
  Onceover::Controlrepo.init_write_file(generate_nodesets(repo),repo.nodeset_file)
  Onceover::Controlrepo.init_write_file(Onceover::Controlrepo.evaluate_template('pre_conditions_README.md.erb',binding),File.expand_path('./pre_conditions/README.md',repo.spec_dir))
  Onceover::Controlrepo.init_write_file(Onceover::Controlrepo.evaluate_template('factsets_README.md.erb',binding),File.expand_path('./factsets/README.md',repo.spec_dir))
  Onceover::Controlrepo.init_write_file(Onceover::Controlrepo.evaluate_template('Rakefile.erb',binding),File.expand_path('./Rakefile',repo.root))
  Onceover::Controlrepo.init_write_file(Onceover::Controlrepo.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.exists? gitignore_path
    gitignore_content = (File.open(gitignore_path,'r') {|f| f.read }).split("\n")
    message = "#{'changed'.green}"
  else
    message = "#{'created'.green}"
    gitignore_content = []
  end

  unless gitignore_content.include?(".onceover")
    gitignore_content << ".onceover\n"
    File.open(gitignore_path,'w') {|f| f.write(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 



475
476
477
478
479
480
481
482
483
 
# File 'lib/onceover/controlrepo.rb', line 475

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

.profiles ⇒ Object 



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

def self.profiles
  Onceover::Controlrepo.new.profiles
end

.puppetfile ⇒ Object 



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

def self.puppetfile
 Onceover::Controlrepo.new.puppetfile
end

.roles ⇒ Object 



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

def self.roles
  Onceover::Controlrepo.new.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



38
39
40
 
# File 'lib/onceover/controlrepo.rb', line 38

def self.root
 Onceover::Controlrepo.new.root
end

Instance Method Details

#classes ⇒ Object 



136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/onceover/controlrepo.rb', line 136

def classes
  # 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] == '$'}

  # 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.each do |dir|
    classes << get_classes(dir)
  end
  classes.flatten
end

#config ⇒ Object 



335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/onceover/controlrepo.rb', line 335

def config
  # Parse the file
  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|
    environment_config.merge!(Hash[*line.split('=').map { |s| s.strip}])
  end

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

#facts(filter = nil) ⇒ Object 



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/onceover/controlrepo.rb', line 155

def facts(filter = nil)
  # Returns an array facts hashes
  all_facts = []
  logger.debug "Reading factsets"
  @facts_files.each do |file|
    all_facts << read_facts(file)['values']
  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.each do |filter_fact,value|
        matches << keypair_is_in_hash(hash,filter_fact,value)
      end
      if matches.include? false
        false
      else
        true
      end
    end
  end
  return all_facts
end

#fixtures ⇒ Object 



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

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 firge 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 



313
314
315
316
317
318
319
320
 
# File 'lib/onceover/controlrepo.rb', line 313

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 



322
323
324
 
# File 'lib/onceover/controlrepo.rb', line 322

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

#hiera_config_file ⇒ Object 



306
307
308
309
310
311
 
# File 'lib/onceover/controlrepo.rb', line 306

def hiera_config_file
  # try to find the hiera.iyaml file
  hiera_config_file = File.expand_path('./hiera.yaml',@spec_dir) if File.exist?(File.expand_path('./hiera.yaml',@spec_dir))
  hiera_config_file = File.expand_path('./hiera.yaml',@root) if File.exist?(File.expand_path('./hiera.yaml',@root))
  hiera_config_file
end

#hiera_data ⇒ Object 



326
327
328
329
330
331
332
333
 
# File 'lib/onceover/controlrepo.rb', line 326

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 



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

def print_puppetfile_table
  require 'table_print'
  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 = []
  puppetfile.modules.each do |mod|
    return_hash = {}
    logger.debug "Loading data for #{mod.full_name}"
    return_hash[:full_name] = mod.full_name
    if mod.is_a?(R10K::Module::Forge)
      return_hash[:current_version] = mod.expected_version
      return_hash[:latest_version] = mod.v3_module.current_release.version
      current = Versionomy.parse(return_hash[:current_version])
      latest = Versionomy.parse(return_hash[:latest_version])
      if current.major < latest.major
        return_hash[:out_of_date] = "Major".red
      elsif current.minor < latest.minor
        return_hash[:out_of_date] = "Minor".yellow
      elsif current.tiny < latest.tiny
        return_hash[:out_of_date] = "Tiny".green
      else
        return_hash[:out_of_date] = "No".green
      end
    else
      return_hash[:current_version] = "N/A"
      return_hash[:latest_version] = "N/A"
      return_hash[:out_of_date] = "N/A"
    end
    output_array << return_hash
  end

  tp output_array, \
    {:full_name => {:display_name => "Full Name"}}, \
    {:current_version => {:display_name => "Current Version"}}, \
    {:latest_version => {:display_name => "Latest Version"}}, \
    {:out_of_date => {:display_name => "Out of Date?"}}
end

#profiles ⇒ Object 



132
133
134
 
# File 'lib/onceover/controlrepo.rb', line 132

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

#r10k_config ⇒ Object 



365
366
367
 
# File 'lib/onceover/controlrepo.rb', line 365

def r10k_config
  YAML.load_file(r10k_config_file)
end

#r10k_config=(data) ⇒ Object 



369
370
371
 
# File 'lib/onceover/controlrepo.rb', line 369

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

#r10k_config_file ⇒ Object 



359
360
361
362
363
 
# File 'lib/onceover/controlrepo.rb', line 359

def r10k_config_file
  r10k_config_file = File.expand_path('./r10k.yaml',@spec_dir) if File.exist?(File.expand_path('./r10k.yaml',@spec_dir))
  r10k_config_file = File.expand_path('./r10k.yaml',@root) if File.exist?(File.expand_path('./r10k.yaml',@root))
  r10k_config_file
end

#roles ⇒ Object 



128
129
130
 
# File 'lib/onceover/controlrepo.rb', line 128

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



487
488
489
490
491
492
493
494
495
496
497
498
499
 
# File 'lib/onceover/controlrepo.rb', line 487

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,testconfig.pre_condition)
  end
end

#temp_manifest ⇒ Object 



373
374
375
 
# File 'lib/onceover/controlrepo.rb', line 373

def temp_manifest
  config['manifest'] ? File.expand_path(config['manifest'],@tempdir) : nil
end

#to_s ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/onceover/controlrepo.rb', line 112

def to_s
  require 'colored'

  <<-END.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}
  END
end

#update_puppetfile ⇒ Object 



226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/onceover/controlrepo.rb', line 226

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

  puppetfile.modules.keep_if {|m| m.is_a?(R10K::Module::Forge)}
  puppetfile.modules.each do |mod|
    line_index = puppetfile_string.index {|l| l =~ /^\s*[^#]*#{mod.owner}[\/-]#{mod.name}/}
    logger.debug "Getting latest version of #{mod.full_name}"
    puppetfile_string[line_index].gsub!(mod.expected_version,mod.v3_module.current_release.version)
  end
  File.open(@puppetfile, 'w') {|f| f.write(puppetfile_string.join("\n")) }
  puts "#{'changed'.yellow} #{@puppetfile}"
end