-
Notifications
You must be signed in to change notification settings - Fork 2.2k
/
environment.rb
632 lines (570 loc) · 21.2 KB
/
environment.rb
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
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
require 'puppet/util'
require 'puppet/util/cacher'
require 'monitor'
require 'puppet/parser/parser_factory'
# Just define it, so this class has fewer load dependencies.
class Puppet::Node
end
# Puppet::Node::Environment acts as a container for all configuration
# that is expected to vary between environments.
#
# ## The root environment
#
# In addition to normal environments that are defined by the user,there is a
# special 'root' environment. It is defined as an instance variable on the
# Puppet::Node::Environment metaclass. The environment name is `*root*` and can
# be accessed by looking up the `:root_environment` using {Puppet.lookup}.
#
# The primary purpose of the root environment is to contain parser functions
# that are not bound to a specific environment. The main case for this is for
# logging functions. Logging functions are attached to the 'root' environment
# when {Puppet::Parser::Functions.reset} is called.
class Puppet::Node::Environment
include Puppet::Util::Cacher
NO_MANIFEST = :no_manifest
# @api private
def self.seen
@seen ||= {}
end
# Create a new environment with the given name, or return an existing one
#
# The environment class memoizes instances so that attempts to instantiate an
# environment with the same name with an existing environment will return the
# existing environment.
#
# @overload self.new(environment)
# @param environment [Puppet::Node::Environment]
# @return [Puppet::Node::Environment] the environment passed as the param,
# this is implemented so that a calling class can use strings or
# environments interchangeably.
#
# @overload self.new(string)
# @param string [String, Symbol]
# @return [Puppet::Node::Environment] An existing environment if it exists,
# else a new environment with that name
#
# @overload self.new()
# @return [Puppet::Node::Environment] The environment as set by
# Puppet.settings[:environment]
#
# @api public
def self.new(name = nil)
return name if name.is_a?(self)
name ||= Puppet.settings.value(:environment)
raise ArgumentError, "Environment name must be specified" unless name
symbol = name.to_sym
return seen[symbol] if seen[symbol]
obj = self.create(symbol,
split_path(Puppet.settings.value(:modulepath, symbol)),
Puppet.settings.value(:manifest, symbol),
Puppet.settings.value(:config_version, symbol))
seen[symbol] = obj
end
# Create a new environment with the given name
#
# @param name [Symbol] the name of the
# @param modulepath [Array<String>] the list of paths from which to load modules
# @param manifest [String] the path to the manifest for the environment or
# the constant Puppet::Node::Environment::NO_MANIFEST if there is none.
# @param config_version [String] path to a script whose output will be added
# to report logs (optional)
# @return [Puppet::Node::Environment]
#
# @api public
def self.create(name, modulepath, manifest = NO_MANIFEST, config_version = nil)
obj = self.allocate
obj.send(:initialize,
name,
expand_dirs(extralibs() + modulepath),
manifest == NO_MANIFEST ? manifest : File.expand_path(manifest),
config_version)
obj
end
# A "reference" to a remote environment. The created environment instance
# isn't expected to exist on the local system, but is instead a reference to
# environment information on a remote system. For instance when a catalog is
# being applied, this will be used on the agent.
#
# @note This does not provide access to the information of the remote
# environment's modules, manifest, or anything else. It is simply a value
# object to pass around and use as an environment.
#
# @param name [Symbol] The name of the remote environment
#
def self.remote(name)
create(name, [], NO_MANIFEST)
end
# Instantiate a new environment
#
# @note {Puppet::Node::Environment.new} is overridden to return memoized
# objects, so this will not be invoked with the normal Ruby initialization
# semantics.
#
# @param name [Symbol] The environment name
def initialize(name, modulepath, manifest, config_version)
@name = name
@modulepath = modulepath
@manifest = manifest
@config_version = config_version
# set watching to true for legacy environments - the directory based environment loaders will set this to
# false for directory based environments after the environment has been created.
@watching = true
end
# Returns if files are being watched or not.
# @api private
#
def watching?
@watching
end
# Turns watching of files on or off
# @param flag [TrueClass, FalseClass] if files should be watched or not
# @ api private
def watching=(flag)
@watching = flag
end
# Creates a new Puppet::Node::Environment instance, overriding any of the passed
# parameters.
#
# @param env_params [Hash<{Symbol => String,Array<String>}>] new environment
# parameters (:modulepath, :manifest, :config_version)
# @return [Puppet::Node::Environment]
def override_with(env_params)
return self.class.create(name,
env_params[:modulepath] || modulepath,
env_params[:manifest] || manifest,
env_params[:config_version] || config_version)
end
# Creates a new Puppet::Node::Environment instance, overriding manfiest
# modulepath, or :config_version from the passed settings if they were
# originally set from the commandline, or returns self if there is nothing to
# override.
#
# @param settings [Puppet::Settings] an initialized puppet settings instance
# @return [Puppet::Node::Environment] new overridden environment or self if
# there are no commandline changes from settings.
def override_from_commandline(settings)
overrides = {}
if settings.set_by_cli?(:modulepath)
overrides[:modulepath] = self.class.split_path(settings.value(:modulepath))
end
if settings.set_by_cli?(:config_version)
overrides[:config_version] = settings.value(:config_version)
end
if settings.set_by_cli?(:manifest) ||
(settings.set_by_cli?(:manifestdir) && settings.value(:manifest).start_with?(settings.value(:manifestdir)))
overrides[:manifest] = settings.value(:manifest)
end
overrides.empty? ?
self :
self.override_with(overrides)
end
# Retrieve the environment for the current process.
#
# @note This should only used when a catalog is being compiled.
#
# @api private
#
# @return [Puppet::Node::Environment] the currently set environment if one
# has been explicitly set, else it will return the '*root*' environment
def self.current
Puppet.deprecation_warning("Puppet::Node::Environment.current has been replaced by Puppet.lookup(:current_environment), see http://links.puppetlabs.com/current-env-deprecation")
Puppet.lookup(:current_environment)
end
# @param [String] name Environment name to check for valid syntax.
# @return [Boolean] true if name is valid
# @api public
def self.valid_name?(name)
!!name.match(/\A\w+\Z/)
end
# Clear all memoized environments and the 'current' environment
#
# @api private
def self.clear
seen.clear
end
# @!attribute [r] name
# @api public
# @return [Symbol] the human readable environment name that serves as the
# environment identifier
attr_reader :name
# @api public
# @return [Array<String>] All directories present on disk in the modulepath
def modulepath
@modulepath.find_all do |p|
Puppet::FileSystem.directory?(p)
end
end
# @api public
# @return [Array<String>] All directories in the modulepath (even if they are not present on disk)
def full_modulepath
@modulepath
end
# @!attribute [r] manifest
# @api public
# @return [String] path to the manifest file or directory.
attr_reader :manifest
# @!attribute [r] config_version
# @api public
# @return [String] path to a script whose output will be added to report logs
# (optional)
attr_reader :config_version
# Checks to make sure that this environment did not have a manifest set in
# its original environment.conf if Puppet is configured with
# +disable_per_environment_manifest+ set true. If it did, the environment's
# modules may not function as intended by the original authors, and we may
# seek to halt a puppet compilation for a node in this environment.
#
# The only exception to this would be if the environment.conf manifest is an exact,
# uninterpolated match for the current +default_manifest+ setting.
#
# @return [Boolean] true if using directory environments, and
# Puppet[:disable_per_environment_manifest] is true, and this environment's
# original environment.conf had a manifest setting that is not the
# Puppet[:default_manifest].
# @api public
def conflicting_manifest_settings?
return false if Puppet[:environmentpath].empty? || !Puppet[:disable_per_environment_manifest]
environment_conf = Puppet.lookup(:environments).get_conf(name)
original_manifest = environment_conf.raw_setting(:manifest)
!original_manifest.nil? && !original_manifest.empty? && original_manifest != Puppet[:default_manifest]
end
# Test to see if $environment is in the environmentpath or basemodulepath.
# If $environment is found in either of the settings then return false, otherwise
# return true.
# @api public
def unsafe_manifest_interpolation?
return true if /\$environment/ =~ Puppet.settings.value(:environmentpath, name, true)
return true if /\$environment/ =~ Puppet.settings.value(:basemodulepath, name, true)
end
# Validates a manifest for this environment. If the manifest cannot be
# validated for the environment then an error is raised. The possible errors
# that can be raised are
# @api public
def validate
if conflicting_manifest_settings?
errmsg = [
"The 'disable_per_environment_manifest' setting is true, and this '#{name}'",
"has an environment.conf manifest that conflicts with the 'default_manifest' setting.",
"Compilation has been halted in order to avoid running a catalog which may be using",
"unexpected manifests. For more information, see",
"http://docs.puppetlabs.com/puppet/latest/reference/environments.html",
]
raise(Puppet::Error, errmsg.join(' '))
end
if unsafe_manifest_interpolation?
errmsg = [
"While using directory environments '$environment' may not be interpolated in the",
"'environmentpath' or 'basemodulepath' settings.",
"Compilation has been halted in order to avoid an environments final configuration",
"from being invalid after interpolation. For more information, see",
"https://docs.puppetlabs.com/puppet/latest/reference/environments.html",
]
raise(Puppet::Error, errmsg.join(' '))
end
end
# Return an environment-specific Puppet setting.
#
# @api public
#
# @param param [String, Symbol] The environment setting to look up
# @return [Object] The resolved setting value
def [](param)
Puppet.settings.value(param, self.name)
end
# @api public
# @return [Puppet::Resource::TypeCollection] The current global TypeCollection
def known_resource_types
if @known_resource_types.nil?
@known_resource_types = Puppet::Resource::TypeCollection.new(self)
@known_resource_types.import_ast(perform_initial_import(), '')
end
@known_resource_types
end
# Yields each modules' plugin directory if the plugin directory (modulename/lib)
# is present on the filesystem.
#
# @yield [String] Yields the plugin directory from each module to the block.
# @api public
def each_plugin_directory(&block)
modules.map(&:plugin_directory).each do |lib|
lib = Puppet::Util::Autoload.cleanpath(lib)
yield lib if File.directory?(lib)
end
end
# Locate a module instance by the module name alone.
#
# @api public
#
# @param name [String] The module name
# @return [Puppet::Module, nil] The module if found, else nil
def module(name)
modules.find {|mod| mod.name == name}
end
# Locate a module instance by the full forge name (EG authorname/module)
#
# @api public
#
# @param forge_name [String] The module name
# @return [Puppet::Module, nil] The module if found, else nil
def module_by_forge_name(forge_name)
author, modname = forge_name.split('/')
found_mod = self.module(modname)
found_mod and found_mod.forge_name == forge_name ?
found_mod :
nil
end
# @!attribute [r] modules
# Return all modules for this environment in the order they appear in the
# modulepath.
# @note If multiple modules with the same name are present they will
# both be added, but methods like {#module} and {#module_by_forge_name}
# will return the first matching entry in this list.
# @note This value is cached so that the filesystem doesn't have to be
# re-enumerated every time this method is invoked, since that
# enumeration could be a costly operation and this method is called
# frequently. The cache expiry is determined by `Puppet[:filetimeout]`.
# @see Puppet::Util::Cacher.cached_attr
# @api public
# @return [Array<Puppet::Module>] All modules for this environment
cached_attr(:modules, Puppet[:filetimeout]) do
module_references = []
seen_modules = {}
modulepath.each do |path|
Dir.entries(path).each do |name|
warn_about_mistaken_path(path, name)
next if module_references.include?(name)
if not seen_modules[name]
module_references << {:name => name, :path => File.join(path, name)}
seen_modules[name] = true
end
end
end
module_references.collect do |reference|
begin
Puppet::Module.new(reference[:name], reference[:path], self)
rescue Puppet::Module::Error
nil
end
end.compact
end
# Generate a warning if the given directory in a module path entry is named `lib`.
#
# @api private
#
# @param path [String] The module directory containing the given directory
# @param name [String] The directory name
def warn_about_mistaken_path(path, name)
if name == "lib"
Puppet.debug("Warning: Found directory named 'lib' in module path ('#{path}/lib'); unless " +
"you are expecting to load a module named 'lib', your module path may be set " +
"incorrectly.")
end
end
# Modules broken out by directory in the modulepath
#
# @note This method _changes_ the current working directory while enumerating
# the modules. This seems rather dangerous.
#
# @api public
#
# @return [Hash<String, Array<Puppet::Module>>] A hash whose keys are file
# paths, and whose values is an array of Puppet Modules for that path
def modules_by_path
modules_by_path = {}
modulepath.each do |path|
Dir.chdir(path) do
module_names = Dir.glob('*').select do |d|
FileTest.directory?(d) && (File.basename(d) =~ /\A\w+(-\w+)*\Z/)
end
modules_by_path[path] = module_names.sort.map do |name|
Puppet::Module.new(name, File.join(path, name), self)
end
end
end
modules_by_path
end
# All module requirements for all modules in the environment modulepath
#
# @api public
#
# @comment This has nothing to do with an environment. It seems like it was
# stuffed into the first convenient class that vaguely involved modules.
#
# @example
# environment.module_requirements
# # => {
# # 'username/amodule' => [
# # {
# # 'name' => 'username/moduledep',
# # 'version' => '1.2.3',
# # 'version_requirement' => '>= 1.0.0',
# # },
# # {
# # 'name' => 'username/anotherdep',
# # 'version' => '4.5.6',
# # 'version_requirement' => '>= 3.0.0',
# # }
# # ]
# # }
# #
#
# @return [Hash<String, Array<Hash<String, String>>>] See the method example
# for an explanation of the return value.
def module_requirements
deps = {}
modules.each do |mod|
next unless mod.forge_name
deps[mod.forge_name] ||= []
mod.dependencies and mod.dependencies.each do |mod_dep|
dep_name = mod_dep['name'].tr('-', '/')
(deps[dep_name] ||= []) << {
'name' => mod.forge_name,
'version' => mod.version,
'version_requirement' => mod_dep['version_requirement']
}
end
end
deps.each do |mod, mod_deps|
deps[mod] = mod_deps.sort_by { |d| d['name'] }
end
deps
end
# Set a periodic watcher on the file, so we can tell if it has changed.
# If watching has been turned off, this call has no effect.
# @param file[File,String] File instance or filename
# @api private
def watch_file(file)
if watching?
known_resource_types.watch_file(file.to_s)
end
end
# Checks if a reparse is required (cache of files is stale).
# This call does nothing unless files are being watched.
#
def check_for_reparse
if (Puppet[:code] != @parsed_code) || (watching? && @known_resource_types && @known_resource_types.require_reparse?)
@parsed_code = nil
@known_resource_types = nil
end
end
# @return [String] The stringified value of the `name` instance variable
# @api public
def to_s
name.to_s
end
# @return [Symbol] The `name` value, cast to a string, then cast to a symbol.
#
# @api public
#
# @note the `name` instance variable is a Symbol, but this casts the value
# to a String and then converts it back into a Symbol which will needlessly
# create an object that needs to be garbage collected
def to_sym
to_s.to_sym
end
# Return only the environment name when serializing.
#
# The only thing we care about when serializing an environment is its
# identity; everything else is ephemeral and should not be stored or
# transmitted.
#
# @api public
def to_zaml(z)
self.to_s.to_zaml(z)
end
def self.split_path(path_string)
path_string.split(File::PATH_SEPARATOR)
end
def ==(other)
return true if other.kind_of?(Puppet::Node::Environment) &&
self.name == other.name &&
self.full_modulepath == other.full_modulepath &&
self.manifest == other.manifest
end
alias eql? ==
def hash
[self.class, name, full_modulepath, manifest].hash
end
private
def self.extralibs()
if ENV["PUPPETLIB"]
split_path(ENV["PUPPETLIB"])
else
[]
end
end
def self.expand_dirs(dirs)
dirs.collect do |dir|
File.expand_path(dir)
end
end
# Reparse the manifests for the given environment
#
# There are two sources that can be used for the initial parse:
#
# 1. The value of `Puppet.settings[:code]`: Puppet can take a string from
# its settings and parse that as a manifest. This is used by various
# Puppet applications to read in a manifest and pass it to the
# environment as a side effect. This is attempted first.
# 2. The contents of `Puppet.settings[:manifest]`: Puppet will try to load
# the environment manifest. By default this is `$manifestdir/site.pp`
#
# @note This method will return an empty hostclass if
# `Puppet.settings[:ignoreimport]` is set to true.
#
# @return [Puppet::Parser::AST::Hostclass] The AST hostclass object
# representing the 'main' hostclass
def perform_initial_import
return empty_parse_result if Puppet[:ignoreimport]
parser = Puppet::Parser::ParserFactory.parser(self)
@parsed_code = Puppet[:code]
if @parsed_code != ""
parser.string = @parsed_code
parser.parse
else
file = self.manifest
# if the manifest file is a reference to a directory, parse and combine all .pp files in that
# directory
if file == NO_MANIFEST
Puppet::Parser::AST::Hostclass.new('')
elsif File.directory?(file)
if Puppet[:parser] == 'future'
parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*.pp')).glob.sort.map do | file_to_parse |
parser.file = file_to_parse
parser.parse
end
else
parse_results = Dir.entries(file).find_all { |f| f =~ /\.pp$/ }.sort.map do |file_to_parse|
parser.file = File.join(file, file_to_parse)
parser.parse
end
end
# Use a parser type specific merger to concatenate the results
Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))
else
parser.file = file
parser.parse
end
end
rescue => detail
@known_resource_types.parse_failed = true
msg = "Could not parse for environment #{self}: #{detail}"
error = Puppet::Error.new(msg)
error.set_backtrace(detail.backtrace)
raise error
end
# Return an empty toplevel hostclass to indicate that no file was loaded
#
# This is used as the return value of {#perform_initial_import} when
# `Puppet.settings[:ignoreimport]` is true.
#
# @return [Puppet::Parser::AST::Hostclass]
def empty_parse_result
return Puppet::Parser::AST::Hostclass.new('')
end
# A special "null" environment
#
# This environment should be used when there is no specific environment in
# effect.
NONE = create(:none, [])
end