Module: AbideDevUtils::Ppt::FacterUtils

Defined in:
lib/abide_dev_utils/ppt/facter_utils.rb

Overview

Methods relating to Facter

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.current_version ⇒ Object 



13
14
15
16
17
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 13

def current_version
  return latest_version unless defined?(@current_version)

  @current_version
end

Class Method Details

.all_versions ⇒ Object 



53
54
55
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 53

def all_versions
  @all_versions ||= fact_files.keys.sort
end

.fact_files ⇒ Object 



34
35
36
37
38
39
40
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 34

def fact_files
  @fact_files ||= FacterDB.facterdb_fact_files.each_with_object({}) do |f, h|
    facter_version = file_facter_version(f)
    h[facter_version] = [] unless h.key?(facter_version)
    h[facter_version] << f
  end
end

.fact_sets(facter_version: current_version) ⇒ Object 



42
43
44
45
46
47
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 42

def fact_sets(facter_version: current_version)
  @fact_sets ||= fact_files[facter_version].each_with_object({}) do |fp, h|
    h[facter_version] = [] unless h.key?(facter_version)
    h[facter_version] << JSON.parse(File.read(fp))
  end
end

.facts_for_os(os_name, os_release_major = nil, os_hardware: 'x86_64', facter_version: current_version) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 101

def facts_for_os(os_name, os_release_major = nil, os_hardware: 'x86_64', facter_version: current_version)
  cache_key = "#{os_name.downcase}_#{os_release_major}_#{os_hardware}"
  return @facts_for_os[cache_key] if @facts_for_os&.key?(cache_key)

  fact_file = fact_files[facter_version].find do |f|
    name_parts = File.basename(f, '.facts').split('-')
    name = name_parts[0]
    relmaj = name_parts.length >= 3 ? name_parts[1] : nil
    hardware = name_parts[-1]
    name == os_name.downcase && relmaj == os_release_major && hardware == os_hardware
  end
  return if fact_file.nil? || fact_file.empty?

  @facts_for_os = {} unless defined?(@facts_for_os)
  @facts_for_os[cache_key] = JSON.parse(File.read(fact_file))
  @facts_for_os[cache_key]
end

.file_facter_version(path) ⇒ Object 



49
50
51
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 49

def file_facter_version(path)
  File.basename(File.dirname(path))
end

.latest_version ⇒ Object 



57
58
59
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 57

def latest_version
  @latest_version ||= all_versions[-1]
end

.previous_major_version(facter_version = current_version) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 61

def previous_major_version(facter_version = current_version)
  @previous_major_version_map ||= {}

  majver = facter_version.split('.')[0]
  return @previous_major_version_map[majver] if @previous_major_version_map.key?(majver)

  prev_majver = (majver.to_i - 1).to_s
  prev_ver = all_versions.select { |v| v.start_with?(prev_majver) }.max
  return nil if prev_ver.to_i < 1

  @previous_major_version_map[majver] = prev_ver
  @previous_major_version_map[majver]
end

.recurse_versions(version = current_version, &block) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 75

def recurse_versions(version = current_version, &block)
  use_version(version)
  output = yield
  return output unless output.nil? || output.empty?

  prev_ver = previous_major_version(version).dup
  return nil if prev_ver.nil?

  recurse_versions(prev_ver, &block)
rescue SystemStackError
  locals = {
    prev_ver_map: @previous_major_version_map,
    current_version: current_version,
  }
  raise "Failed to find output while recursing versions. Locals: #{locals}"
end

.recursive_facts_for_os(os_name, os_release_major = nil, os_hardware: 'x86_64') ⇒ Object 



92
93
94
95
96
97
98
99
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 92

def recursive_facts_for_os(os_name, os_release_major = nil, os_hardware: 'x86_64')
  saved_ver = current_version.dup
  output = recurse_versions do
    facts_for_os(os_name, os_release_major, os_hardware: os_hardware)
  end
  use_version(saved_ver)
  output
end

.resolve_dot_path(dot_path, facter_version: latest_version) ⇒ Object 



119
120
121
122
123
124
125
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 119

def resolve_dot_path(dot_path, facter_version: latest_version)
  path_array = dot_path.delete_prefix('facts.').split('.')
  resolved = fact_sets[facter_version].map do |fs|
    fs.dig(*path_array)
  end
  resolved.compact.uniq
end

.resolve_related_dot_paths(*dot_paths, facter_version: current_version) ⇒ Object 



127
128
129
130
131
132
133
134
135
136
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 127

def resolve_related_dot_paths(*dot_paths, facter_version: current_version)
  resolved = []
  fact_sets[facter_version].map do |fs|
    resolved << dot_paths.map do |p|
      path_array = p.delete_prefix('facts.').split('.')
      fs.dig(*path_array)
    end
  end
  resolved
end

.use_version(version) ⇒ Object 



19
20
21
22
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 19

def use_version(version)
  self.current_version = version
  current_version
end

.with_version(version, reset: true) ⇒ Object 



24
25
26
27
28
29
30
31
32
 
# File 'lib/abide_dev_utils/ppt/facter_utils.rb', line 24

def with_version(version, reset: true)
  return unless block_given?

  old_ver = current_version.dup
  use_version(version)
  output = yield
  use_version(old_ver) if reset
  output
end