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



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

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.



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

def environmentpath
  @environmentpath
end

#facts_files ⇒ Object

Returns the value of attribute facts_files.



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

def facts_files
  @facts_files
end

#manifest ⇒ Object

Returns the value of attribute manifest.



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

def manifest
  @manifest
end

#nodeset_file ⇒ Object

Returns the value of attribute nodeset_file.



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

def nodeset_file
  @nodeset_file
end

#onceover_yaml ⇒ Object

Returns the value of attribute onceover_yaml.



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

def onceover_yaml
  @onceover_yaml
end

#opts ⇒ Object

Returns the value of attribute opts.



32
33
34
 
# File 'lib/onceover/controlrepo.rb', line 32

def opts
  @opts
end

#profile_regex ⇒ Object

Returns the value of attribute profile_regex.



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

def profile_regex
  @profile_regex
end

#puppetfile ⇒ Object

Returns the value of attribute puppetfile.



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

def puppetfile
  @puppetfile
end

#role_regex ⇒ Object

Returns the value of attribute role_regex.



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

def role_regex
  @role_regex
end

#root ⇒ Object

Returns the value of attribute root.



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

def root
  @root
end

#spec_dir ⇒ Object

Returns the value of attribute spec_dir.



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

def spec_dir
  @spec_dir
end

#temp_modulepath ⇒ Object

Returns the value of attribute temp_modulepath.



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

def temp_modulepath
  @temp_modulepath
end

#tempdir ⇒ Object

Returns the value of attribute tempdir.



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

def tempdir
  @tempdir
end

Class Method Details

.classes ⇒ Object 



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

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

.config ⇒ Object 



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

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

.create_dirs_and_log(dir) ⇒ Object 



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

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 



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

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 



73
74
75
 
# File 'lib/onceover/controlrepo.rb', line 73

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

.facts_files ⇒ Object 



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

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

.generate_nodesets(repo) ⇒ Object 



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

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}"
    response = Net::HTTP.get(URI.parse("https://atlas.hashicorp.com/api/v1/box/#{boxname}"))
    url = 'URL goes here'

    if response =~ /Not Found/i
      comment_out = true
    else
      comment_out = false
      box_info = JSON.parse(response)
      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 



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

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 



77
78
79
 
# File 'lib/onceover/controlrepo.rb', line 77

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

.init(repo) ⇒ Object 



383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
 
# File 'lib/onceover/controlrepo.rb', line 383

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

  # 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 



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

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 



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

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

.puppetfile ⇒ Object 



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

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

.roles ⇒ Object 



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

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



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

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

Instance Method Details

#classes ⇒ Object 



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

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 



341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
 
# File 'lib/onceover/controlrepo.rb', line 341

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 



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

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 



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

def fixtures
  # Load up the Puppetfile using R10k
  puppetfile = R10K::Puppetfile.new(@root)
  modules = puppetfile.load

  # 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 



319
320
321
322
323
324
325
326
 
# File 'lib/onceover/controlrepo.rb', line 319

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 



328
329
330
 
# File 'lib/onceover/controlrepo.rb', line 328

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

#hiera_config_file ⇒ Object 



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

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 



332
333
334
335
336
337
338
339
 
# File 'lib/onceover/controlrepo.rb', line 332

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 



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

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 



139
140
141
 
# File 'lib/onceover/controlrepo.rb', line 139

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

#r10k_config ⇒ Object 



371
372
373
 
# File 'lib/onceover/controlrepo.rb', line 371

def r10k_config
  YAML.load_file(r10k_config_file)
end

#r10k_config=(data) ⇒ Object 



375
376
377
 
# File 'lib/onceover/controlrepo.rb', line 375

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

#r10k_config_file ⇒ Object 



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

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 



135
136
137
 
# File 'lib/onceover/controlrepo.rb', line 135

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



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

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 



379
380
381
 
# File 'lib/onceover/controlrepo.rb', line 379

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

#to_s ⇒ Object 



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/onceover/controlrepo.rb', line 119

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 



233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/onceover/controlrepo.rb', line 233

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