1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
require 'puppet/indirector'
# A class for managing nodes, including their facts and environment.
class Puppet::Node
require 'puppet/node/facts'
require 'puppet/node/environment'
# Set up indirection, so that nodes can be looked for in
# the node sources.
extend Puppet::Indirector
# Use the node source as the indirection terminus.
indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
A node is composed of its name, its facts, and its environment."
# Retrieve a node from the node source, with some additional munging
# thrown in for kicks.
def self.find_by_any_name(key)
return nil unless key
node = nil
names = node_names(key)
names.each do |name|
name = name.to_s if name.is_a?(Symbol)
break if node = find(name)
end
# If they made it this far, we haven't found anything, so look for a
# default node.
unless node or names.include?("default")
if node = find("default")
Puppet.notice "Using default node for %s" % key
end
end
return nil unless node
node.names = names
# This is critical, because it forces our node's name to always
# be the key, which is nearly always the node's certificate.
# This is how the node instance is linked to the Facts instance,
# so it quite matters.
node.name = key
return node
end
private
# Look up the node facts so we can generate the node names to use.
def self.node_facts(key)
if facts = Puppet::Node::Facts.find(key)
facts.values
else
{}
end
end
# Calculate the list of node names we should use for looking
# up our node.
def self.node_names(key, facts = nil)
facts ||= node_facts(key)
names = []
# First, get the fqdn
unless fqdn = facts["fqdn"]
if domain = facts["domain"]
fqdn = facts["hostname"] + "." + facts["domain"]
end
end
# Now that we (might) have the fqdn, add each piece to the name
# list to search, in order of longest to shortest.
if fqdn
list = fqdn.split(".")
tmp = []
list.each_with_index do |short, i|
tmp << list[0..i].join(".")
end
names += tmp.reverse
end
# And make sure the key is first, since that's the most
# likely usage.
# The key is usually the Certificate CN, but it can be
# set to the 'facter' hostname instead.
if Puppet[:node_name] == 'cert'
names.unshift key
else
names.unshift facts["hostname"]
end
names.uniq
end
public
attr_accessor :name, :classes, :parameters, :source, :ipaddress, :names
attr_reader :time
# Set the environment, making sure that it's valid.
def environment=(value)
raise(ArgumentError, "Invalid environment %s" % value) unless Puppet::Node::Environment.valid?(value)
@environment = value
end
# Do not return environments that are the empty string, and use
# explicitly set environments, then facts, then a central env
# value.
def environment
unless @environment
if env = parameters["environment"]
raise(ArgumentError, "Invalid environment %s from parameters" % env) unless Puppet::Node::Environment.valid?(env)
@environment = env
else
@environment = Puppet::Node::Environment.new.name.to_s
end
end
@environment
end
def initialize(name, options = {})
unless name
raise ArgumentError, "Node names cannot be nil"
end
@name = name
# Provide a default value.
if names = options[:names]
if names.is_a?(String)
@names = [names]
else
@names = names
end
else
@names = [name]
end
if classes = options[:classes]
if classes.is_a?(String)
@classes = [classes]
else
@classes = classes
end
else
@classes = []
end
@parameters = options[:parameters] || {}
self.environment = options[:environment] if options[:environment]
@time = Time.now
end
# Merge the node facts with parameters from the node source.
def fact_merge
if facts = Puppet::Node::Facts.find(name)
merge(facts.values)
end
end
# Merge any random parameters into our parameter list.
def merge(params)
params.each do |name, value|
@parameters[name] = value unless @parameters.include?(name)
end
end
end
|
