Class: Facter::Util::DotD

Inherits:
Object
  • Object
show all
Defined in:
lib/facter/facter_dot_d.rb

Overview

A Facter plugin that loads facts from /etc/facts.d.

Facts can be in the form of JSON, YAML or Text files and any executable that returns key=value pairs.

In the case of scripts you can also create a file that contains a cache TTL. For foo.sh store the ttl as just a number in foo.sh.ttl

The cache is stored in /tmp/facts_cache.yaml as a mode 600 file and will have the end result of not calling your fact scripts more often than is needed

To test from the cli “export RUBYLIB=/var/lib/puppet/lib”, then run facter

Instance Method Summary collapse

Constructor Details

#initialize(dir = "/etc/facts.d", cache_file = "/tmp/facts_cache.yml") ⇒ DotD

Returns a new instance of DotD.



20
21
22
23
24
25
 
# File 'lib/facter/facter_dot_d.rb', line 20

def initialize(dir="/etc/facts.d", cache_file="/tmp/facts_cache.yml")
    @dir = dir
    @cache_file = cache_file
    @cache = nil
    @types = {".txt" => :txt, ".json" => :json, ".yaml" => :yaml}
end

Instance Method Details

#cache_lookup(file) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/facter/facter_dot_d.rb', line 137

def cache_lookup(file)
    cache = load_cache

    return nil if cache.empty?

    ttl = cache_time(file)

    if cache[file]
        now = Time.now.to_i

        return cache[file][:data] if ttl == -1
        return cache[file][:data] if (now - cache[file][:stored]) <= ttl
        return nil
    else
        return nil
    end
rescue
    return nil
end

#cache_save! ⇒ Object 



124
125
126
127
128
 
# File 'lib/facter/facter_dot_d.rb', line 124

def cache_save!
    cache = load_cache
    File.open(@cache_file, "w", 0600) {|f| f.write(YAML.dump(cache)) }
rescue
end

#cache_store(file, data) ⇒ Object 



130
131
132
133
134
135
 
# File 'lib/facter/facter_dot_d.rb', line 130

def cache_store(file, data)
    load_cache

    @cache[file] = {:data => data, :stored => Time.now.to_i}
rescue
end

#cache_time(file) ⇒ Object 



157
158
159
160
161
162
163
 
# File 'lib/facter/facter_dot_d.rb', line 157

def cache_time(file)
    meta = file + ".ttl"

    return File.read(meta).chomp.to_i
rescue
    return 0
end

#create ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/facter/facter_dot_d.rb', line 180

def create
    entries.each do |fact|
        type = fact_type(fact)
        parser = "#{type}_parser"

        if respond_to?("#{type}_parser")
            Facter.debug("Parsing #{fact} using #{parser}")

            send(parser, fact)
        end
    end
end

#entries ⇒ Object 



27
28
29
30
31
 
# File 'lib/facter/facter_dot_d.rb', line 27

def entries
    Dir.entries(@dir).reject{|f| f =~ /^\.|\.ttl$/}.sort.map {|f| File.join(@dir, f) }
rescue
    []
end

#fact_type(file) ⇒ Object 



33
34
35
36
37
38
39
40
41
 
# File 'lib/facter/facter_dot_d.rb', line 33

def fact_type(file)
    extension = File.extname(file)

    type = @types[extension] || :unknown

    type = :script if type == :unknown && File.executable?(file)

    return type
end

#json_parser(file) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/facter/facter_dot_d.rb', line 57

def json_parser(file)
    try_count = 0

    begin
        try_count += 1

        require 'json'
    rescue LoadError
        if try_count == 1
            require 'rubygems'
            retry
        else
            raise
        end
    end

    JSON.load(File.read(file)).each_pair do |f, v|
        Facter.add(f) do
            setcode { v }
        end
    end
rescue Exception => e
    Facter.warn("Failed to handle #{file} as json facts: #{e.class}: #{e}")
end

#load_cache ⇒ Object 



165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/facter/facter_dot_d.rb', line 165

def load_cache
    unless @cache
        if File.exist?(@cache_file)
            @cache = YAML.load_file(@cache_file)
        else
            @cache = {}
        end
    end

    return @cache
rescue
    @cache = {}
    return @cache
end

#script_parser(file) ⇒ Object 



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
 
# File 'lib/facter/facter_dot_d.rb', line 94

def script_parser(file)
    result = cache_lookup(file)
    ttl = cache_time(file)

    unless result
        result = Facter::Util::Resolution.exec(file)

        if ttl > 0
            Facter.debug("Updating cache for #{file}")
            cache_store(file, result)
            cache_save!
        end
    else
        Facter.debug("Using cached data for #{file}")
    end

    result.split("\n").each do |line|
        if line =~ /^(.+)=(.+)$/
            var = $1; val = $2

            Facter.add(var) do
                setcode { val }
            end
        end
    end
rescue Exception => e
    Facter.warn("Failed to handle #{file} as script facts: #{e.class}: #{e}")
    Facter.debug(e.backtrace.join("\n\t"))
end

#txt_parser(file) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/facter/facter_dot_d.rb', line 43

def txt_parser(file)
    File.readlines(file).each do |line|
        if line =~ /^(.+)=(.+)$/
            var = $1; val = $2

            Facter.add(var) do
                setcode { val }
            end
        end
    end
rescue Exception => e
    Facter.warn("Failed to handle #{file} as text facts: #{e.class}: #{e}")
end

#yaml_parser(file) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/facter/facter_dot_d.rb', line 82

def yaml_parser(file)
    require 'yaml'

    YAML.load_file(file).each_pair do |f, v|
        Facter.add(f) do
            setcode { v }
        end
    end
rescue Exception => e
    Facter.warn("Failed to handle #{file} as yaml facts: #{e.class}: #{e}")
end