Module: FacterDB

Defined in:
lib/facterdb.rb,
lib/facterdb/bin.rb,
lib/facterdb/version.rb

Defined Under Namespace

Modules: Errors, Version Classes: Bin

Class Method Summary collapse

Class Method Details

.cleanup ⇒ Object

Note:

Call this method at the end of test suite, for example via after(:suite), to reclaim back the memory required to hold json data and filter cache



15
16
17
18
19
 
# File 'lib/facterdb.rb', line 15

def self.cleanup
  @database = nil
  Thread.current[:facterdb_last_filter_seen] = nil
  Thread.current[:facterdb_last_facts_seen] = nil
end

.database ⇒ String

Returns a giant incomprehensible string of concatenated json data

Returns:

  • (String) —

    returns a giant incomprehensible string of concatenated json data



10
11
12
 
# File 'lib/facterdb.rb', line 10

def self.database
  @database ||= "[#{facterdb_fact_files.map { |f| read_json_file(f) }.join(',')}]\n"
end

.default_fact_files ⇒ Array[String]

Returns list of all files found in the default facterdb facts path.

Returns:

  • (Array[String]) —

    list of all files found in the default facterdb facts path



50
51
52
53
54
55
56
 
# File 'lib/facterdb.rb', line 50

def self.default_fact_files
  return [] unless use_defaultdb?

  proj_root = File.join(File.dirname(File.dirname(__FILE__)))
  facts_dir = File.expand_path(File.join(proj_root, 'facts'))
  Dir.glob(File.join(facts_dir, '**', '*.facts'))
end

.external_fact_files(fact_paths = ENV.fetch('FACTERDB_SEARCH_PATHS', nil)) ⇒ Array[String]

Returns list of all files found in the user supplied facterdb facts path.

Parameters:

  • fact_paths (String) (defaults to: ENV.fetch('FACTERDB_SEARCH_PATHS', nil)) —

    a comma separated list of paths to search for fact files

Returns:

  • (Array[String]) —

    list of all files found in the user supplied facterdb facts path



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

def self.external_fact_files(fact_paths = ENV.fetch('FACTERDB_SEARCH_PATHS', nil))
  fact_paths ||= ''
  return [] if fact_paths.empty?

  paths = fact_paths.split(File::PATH_SEPARATOR).map do |fact_path|
    unless File.directory?(fact_path)
      warn("[FACTERDB] Ignoring external facts path #{fact_path} as it is not a directory")
      next nil
    end
    fact_path = fact_path.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
    File.join(fact_path.strip, '**', '*.facts')
  end.compact
  Dir.glob(paths)
end

.facterdb_fact_files ⇒ Array[String]

Note:

external fact files supplied by the user will take precedence over default fact files found in this gem

Returns list of all files found in the default facterdb facts path and user supplied path.

Returns:

  • (Array[String]) —

    list of all files found in the default facterdb facts path and user supplied path



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

def self.facterdb_fact_files
  (external_fact_files + default_fact_files).uniq
end

.generate_filter_str(filter = nil) ⇒ String

Returns the string filter.

Parameters:

  • filter (Object) (defaults to: nil) —

    The filter to convert to jgrep string

Returns:

  • (String) —

    the string filter



114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/facterdb.rb', line 114

def self.generate_filter_str(filter = nil)
  case filter
  when ::Array
    '(' + filter.map { |f| f.map { |k, v| "#{k}=#{v}" }.join(' and ') }.join(') or (') + ')'
  when ::Hash
    filter.map { |k, v| "#{k}=#{v}" }.join(' and ')
  when ::String
    filter
  when ::NilClass
    ''
  else
    raise Errors::InvalidFilter, "filter must be either an Array a Hash, String, or nil, received #{filter.class}"
  end
end

.get_facts(filter = nil, cache = true) ⇒ Array[Hash[Symbol, Any]]

Returns array of hashes of facts.

Parameters:

  • filter (Object) (defaults to: nil) —

    The filter to convert to jgrep string

Returns:

  • (Array[Hash[Symbol, Any]]) —

    array of hashes of facts



140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/facterdb.rb', line 140

def self.get_facts(filter = nil, cache = true)
  if cache && filter && filter == Thread.current[:facterdb_last_filter_seen]
    return Thread.current[:facterdb_last_facts_seen]
  end

  filter_str = generate_filter_str(filter)
  result = JGrep.jgrep(database, filter_str).map { |hash| hash.map { |k, v| [k.to_sym, v] }.to_h }
  if cache
    Thread.current[:facterdb_last_filter_seen] = filter
    Thread.current[:facterdb_last_facts_seen] = result
  end
  result
end

.get_os_facts(facter_version = '*', filter = []) ⇒ Object

Deprecated.

Use get_facts instead.



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/facterdb.rb', line 82

def self.get_os_facts(facter_version = '*', filter = [])
  if facter_version == '*'
    if filter.is_a?(Array)
      filter_str = filter.map { |f| f.map { |k, v| "#{k}=#{v}" }.join(' and ') }.join(' or ')
    elsif filter.is_a?(Hash)
      filter_str = filter.map { |k, v| "#{k}=#{v}" }.join(' and ')
    elsif filter.is_a?(String)
      filter_str = filter
    else
      raise 'filter must be either an Array a Hash or a String'
    end
  elsif filter.is_a?(Array)
    filter_str = "facterversion=/^#{facter_version}/ and (#{filter.map do |f|
                                                              f.map do |k, v|
                                                                "#{k}=#{v}"
                                                              end.join(' and ')
                                                            end.join(' or ')})"
  elsif filter.is_a?(Hash)
    filter_str = "facterversion=/^#{facter_version}/ and (#{filter.map { |k, v| "#{k}=#{v}" }.join(' and ')})"
  elsif filter.is_a?(String)
    filter_str = "facterversion=/^#{facter_version}/ and (#{filter})"
  else
    raise 'filter must be either an Array a Hash or a String'
  end

  warn "[DEPRECATION] `get_os_facts` is deprecated. Please use `get_facts(#{filter_str})` instead."

  get_facts(filter_str)
end

.inject_source? ⇒ Boolean

The default is false.

Returns:

  • (Boolean) —

    returns true if we should inject the source file name and file path into the json factsets.



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

def self.inject_source?
  !ENV['FACTERDB_INJECT_SOURCE'].nil?
end

.use_defaultdb? ⇒ Boolean

Note:

If the user passes anything to the FACTERDB_SKIP_DEFAULTDB environment variable we assume

they want to skip the default db

Returns:

  • (Boolean) —

    returns true if we should use the default facterdb database, false otherwise



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

def self.use_defaultdb?
  ENV['FACTERDB_SKIP_DEFAULTDB'].nil?
end

.valid_filters?(filters) ⇒ Boolean

Returns true if the filter is valid against the jgrep filter validator.

Parameters:

  • filters (Object) —

    The filter to convert to jgrep string

Returns:

  • (Boolean) —

    true if the filter is valid against the jgrep filter validator



131
132
133
134
135
136
 
# File 'lib/facterdb.rb', line 131

def self.valid_filters?(filters)
  filter_str = generate_filter_str(filters)
  JGrep.validate_filters(filter_str).nil?
rescue RuntimeError
  false
end