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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
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
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
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
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
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
410
411
412
413
414
415
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
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
|
# The client for interacting with the puppetmaster config server.
require 'sync'
require 'timeout'
require 'puppet/network/http_pool'
class Puppet::Network::Client::Master < Puppet::Network::Client
unless defined? @@sync
@@sync = Sync.new
end
attr_accessor :catalog
attr_reader :compile_time
class << self
# Puppetd should only have one instance running, and we need a way
# to retrieve it.
attr_accessor :instance
include Puppet::Util
end
def self.facts
# Retrieve the facts from the central server.
if Puppet[:factsync]
self.getfacts()
end
down = Puppet[:downcasefacts]
Facter.clear
# Reload everything.
if Facter.respond_to? :loadfacts
Facter.loadfacts
elsif Facter.respond_to? :load
Facter.load
else
Puppet.warning "You should upgrade your version of Facter to at least 1.3.8"
end
# This loads all existing facts and any new ones. We have to remove and
# reload because there's no way to unload specific facts.
loadfacts()
facts = Facter.to_hash.inject({}) do |newhash, array|
name, fact = array
if down
newhash[name] = fact.to_s.downcase
else
newhash[name] = fact.to_s
end
newhash
end
# Add our client version to the list of facts, so people can use it
# in their manifests
facts["clientversion"] = Puppet.version.to_s
# And add our environment as a fact.
unless facts.include?("environment")
facts["environment"] = Puppet[:environment]
end
facts
end
# Return the list of dynamic facts as an array of symbols
# NOTE:LAK(2008/04/10): This code is currently unused, since we now always
# recompile.
def self.dynamic_facts
# LAK:NOTE See http://snurl.com/21zf8 [groups_google_com]
x = Puppet.settings[:dynamicfacts].split(/\s*,\s*/).collect { |fact| fact.downcase }
end
# Cache the config
def cache(text)
Puppet.info "Caching catalog at %s" % self.cachefile
confdir = ::File.dirname(Puppet[:localconfig])
::File.open(self.cachefile + ".tmp", "w", 0660) { |f|
f.print text
}
::File.rename(self.cachefile + ".tmp", self.cachefile)
end
def cachefile
unless defined? @cachefile
@cachefile = Puppet[:localconfig] + ".yaml"
end
@cachefile
end
def clear
@catalog.clear(true) if @catalog
@catalog = nil
end
# Initialize and load storage
def dostorage
begin
Puppet::Util::Storage.load
@compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
rescue => detail
if Puppet[:trace]
puts detail.backtrace
end
Puppet.err "Corrupt state file %s: %s" % [Puppet[:statefile], detail]
begin
::File.unlink(Puppet[:statefile])
retry
rescue => detail
raise Puppet::Error.new("Cannot remove %s: %s" %
[Puppet[:statefile], detail])
end
end
end
# Let the daemon run again, freely in the filesystem. Frolick, little
# daemon!
def enable
lockfile.unlock(:anonymous => true)
end
# Stop the daemon from making any catalog runs.
def disable
lockfile.lock(:anonymous => true)
end
# Retrieve the config from a remote server. If this fails, then
# use the cached copy.
def getconfig
dostorage()
# Retrieve the plugins.
getplugins() if Puppet[:pluginsync]
facts = nil
Puppet::Util.benchmark(:debug, "Retrieved facts") do
facts = self.class.facts
end
raise Puppet::Network::ClientError.new("Could not retrieve any facts") unless facts.length > 0
Puppet.debug("Retrieving catalog")
# If we can't retrieve the catalog, just return, which will either
# fail, or use the in-memory catalog.
unless marshalled_objects = get_actual_config(facts)
use_cached_config(true)
return
end
begin
case Puppet[:catalog_format]
when "marshal": objects = Marshal.load(marshalled_objects)
when "yaml": objects = YAML.load(marshalled_objects)
else
raise "Invalid catalog format '%s'" % Puppet[:catalog_format]
end
rescue => detail
msg = "Configuration could not be translated from %s" % Puppet[:catalog_format]
msg += "; using cached catalog" if use_cached_config(true)
Puppet.warning msg
return
end
self.setclasses(objects.classes)
# Clear all existing objects, so we can recreate our stack.
clear() if self.catalog
# Now convert the objects to a puppet catalog graph.
begin
@catalog = objects.to_catalog
rescue => detail
clear()
puts detail.backtrace if Puppet[:trace]
msg = "Configuration could not be instantiated: %s" % detail
msg += "; using cached catalog" if use_cached_config(true)
Puppet.warning msg
return
end
if ! @catalog.from_cache
self.cache(marshalled_objects)
end
# Keep the state database up to date.
@catalog.host_config = true
end
# A simple proxy method, so it's easy to test.
def getplugins
self.class.getplugins
end
# Just so we can specify that we are "the" instance.
def initialize(*args)
Puppet.settings.use(:main, :ssl, :puppetd)
super
self.class.instance = self
@running = false
end
# Mark that we should restart. The Puppet module checks whether we're running,
# so this only gets called if we're in the middle of a run.
def restart
# If we're currently running, then just mark for later
Puppet.notice "Received signal to restart; waiting until run is complete"
@restart = true
end
# Should we restart?
def restart?
if defined? @restart
@restart
else
false
end
end
# Retrieve the cached config
def retrievecache
if FileTest.exists?(self.cachefile)
return ::File.read(self.cachefile)
else
return nil
end
end
# The code that actually runs the catalog.
# This just passes any options on to the catalog,
# which accepts :tags and :ignoreschedules.
def run(options = {})
got_lock = false
splay
Puppet::Util.sync(:puppetrun).synchronize(Sync::EX) do
if !lockfile.lock
Puppet.notice "Lock file %s exists; skipping catalog run" %
lockfile.lockfile
else
got_lock = true
begin
duration = thinmark do
self.getconfig
end
rescue => detail
puts detail.backtrace if Puppet[:trace]
Puppet.err "Could not retrieve catalog: %s" % detail
end
if self.catalog
@catalog.retrieval_duration = duration
Puppet.notice "Starting catalog run" unless @local
benchmark(:notice, "Finished catalog run") do
@catalog.apply(options)
end
end
# Now close all of our existing http connections, since there's no
# reason to leave them lying open.
Puppet::Network::HttpPool.clear_http_instances
end
lockfile.unlock
# Did we get HUPped during the run? If so, then restart now that we're
# done with the run.
if self.restart?
Process.kill(:HUP, $$)
end
end
ensure
# Just make sure we remove the lock file if we set it.
lockfile.unlock if got_lock and lockfile.locked?
clear()
end
def running?
lockfile.locked?
end
# Store the classes in the classfile, but only if we're not local.
def setclasses(ary)
if @local
return
end
unless ary and ary.length > 0
Puppet.info "No classes to store"
return
end
begin
::File.open(Puppet[:classfile], "w") { |f|
f.puts ary.join("\n")
}
rescue => detail
Puppet.err "Could not create class file %s: %s" %
[Puppet[:classfile], detail]
end
end
private
# Download files from the remote server, returning a list of all
# changed files.
def self.download(args)
hash = {
:path => args[:dest],
:recurse => true,
:source => args[:source],
:tag => "#{args[:name]}s",
:owner => Process.uid,
:group => Process.gid,
:purge => true,
:force => true,
:backup => false,
:noop => false
}
if args[:ignore]
hash[:ignore] = args[:ignore].split(/\s+/)
end
downconfig = Puppet::Node::Catalog.new("downloading")
downconfig.add_resource Puppet::Type.type(:file).create(hash)
Puppet.info "Retrieving #{args[:name]}s"
files = []
begin
Timeout::timeout(self.timeout) do
downconfig.apply do |trans|
trans.changed?.find_all do |resource|
yield resource if block_given?
files << resource[:path]
end
end
end
rescue Puppet::Error, Timeout::Error => detail
if Puppet[:debug]
puts detail.backtrace
end
Puppet.err "Could not retrieve %ss: %s" % [args[:name], detail]
end
# Now clean up after ourselves
downconfig.clear
return files
end
# Retrieve facts from the central server.
def self.getfacts
# Download the new facts
path = Puppet[:factpath].split(":")
files = []
download(:dest => Puppet[:factdest], :source => Puppet[:factsource],
:ignore => Puppet[:factsignore], :name => "fact") do |resource|
next unless path.include?(::File.dirname(resource[:path]))
files << resource[:path]
end
end
# Retrieve the plugins from the central server. We only have to load the
# changed plugins, because Puppet::Type loads plugins on demand.
def self.getplugins
download(:dest => Puppet[:plugindest], :source => Puppet[:pluginsource],
:ignore => Puppet[:pluginsignore], :name => "plugin") do |resource|
next if FileTest.directory?(resource[:path])
path = resource[:path].sub(Puppet[:plugindest], '').sub(/^\/+/, '')
unless Puppet::Util::Autoload.loaded?(path)
next
end
begin
Puppet.info "Reloading downloaded file %s" % path
load resource[:path]
rescue => detail
Puppet.warning "Could not reload downloaded file %s: %s" %
[resource[:path], detail]
end
end
end
def self.loaddir(dir, type)
return unless FileTest.directory?(dir)
Dir.entries(dir).find_all { |e| e =~ /\.rb$/ }.each do |file|
fqfile = ::File.join(dir, file)
begin
Puppet.info "Loading %s %s" %
[type, ::File.basename(file.sub(".rb",''))]
Timeout::timeout(self.timeout) do
load fqfile
end
rescue => detail
Puppet.warning "Could not load %s %s: %s" % [type, fqfile, detail]
end
end
end
def self.loadfacts
# LAK:NOTE See http://snurl.com/21zf8 [groups_google_com]
x = Puppet[:factpath].split(":").each do |dir|
loaddir(dir, "fact")
end
end
def self.timeout
timeout = Puppet[:configtimeout]
case timeout
when String:
if timeout =~ /^\d+$/
timeout = Integer(timeout)
else
raise ArgumentError, "Configuration timeout must be an integer"
end
when Integer: # nothing
else
raise ArgumentError, "Configuration timeout must be an integer"
end
return timeout
end
loadfacts()
# Actually retrieve the catalog, either from the server or from a
# local master.
def get_actual_config(facts)
begin
Timeout::timeout(self.class.timeout) do
return get_remote_config(facts)
end
rescue Timeout::Error
Puppet.err "Configuration retrieval timed out"
return nil
end
end
# Retrieve a config from a remote master.
def get_remote_config(facts)
textobjects = ""
textfacts = CGI.escape(YAML.dump(facts))
benchmark(:debug, "Retrieved catalog") do
# error handling for this is done in the network client
begin
textobjects = @driver.getconfig(textfacts, Puppet[:catalog_format])
begin
textobjects = CGI.unescape(textobjects)
rescue => detail
raise Puppet::Error, "Could not CGI.unescape catalog"
end
rescue => detail
Puppet.err "Could not retrieve catalog: %s" % detail
return nil
end
end
return nil if textobjects == ""
@compile_time = Time.now
Puppet::Util::Storage.cache(:configuration)[:facts] = facts
Puppet::Util::Storage.cache(:configuration)[:compile_time] = @compile_time
return textobjects
end
def lockfile
unless defined?(@lockfile)
@lockfile = Puppet::Util::Pidlock.new(Puppet[:puppetdlockfile])
end
@lockfile
end
# Sleep when splay is enabled; else just return.
def splay
return unless Puppet[:splay]
limit = Integer(Puppet[:splaylimit])
# Pick a splay time and then cache it.
unless time = Puppet::Util::Storage.cache(:configuration)[:splay_time]
time = rand(limit)
Puppet::Util::Storage.cache(:configuration)[:splay_time] = time
end
Puppet.info "Sleeping for %s seconds (splay is enabled)" % time
sleep(time)
end
private
# Use our cached config, optionally specifying whether this is
# necessary because of a failure.
def use_cached_config(because_of_failure = false)
return true if self.catalog
if because_of_failure and ! Puppet[:usecacheonfailure]
@catalog = nil
Puppet.warning "Not using cache on failed catalog"
return false
end
return false unless oldtext = self.retrievecache
begin
@catalog = YAML.load(oldtext).to_catalog
@catalog.from_cache = true
@catalog.host_config = true
rescue => detail
puts detail.backtrace if Puppet[:trace]
Puppet.warning "Could not load cached catalog: %s" % detail
clear
return false
end
return true
end
end
|