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
|
# Support for modules
class Puppet::Module
TEMPLATES = "templates"
FILES = "files"
MANIFESTS = "manifests"
# Return an array of paths by splitting the +modulepath+ config
# parameter. Only consider paths that are absolute and existing
# directories
def self.modulepath(environment = nil)
dirs = Puppet.config.value(:modulepath, environment).split(":")
if ENV["PUPPETLIB"]
dirs = ENV["PUPPETLIB"].split(":") + dirs
else
end
dirs.select do |p|
p =~ /^#{File::SEPARATOR}/ && File::directory?(p)
end
end
# Find and return the +module+ that +path+ belongs to. If +path+ is
# absolute, or if there is no module whose name is the first component
# of +path+, return +nil+
def self.find(modname, environment = nil)
if modname =~ %r/^#{File::SEPARATOR}/
return nil
end
modpath = modulepath(environment).collect { |p|
File::join(p, modname)
}.find { |f| File::directory?(f) }
return nil unless modpath
return self.new(modname, modpath)
end
# Instance methods
# Find the concrete file denoted by +file+. If +file+ is absolute,
# return it directly. Otherwise try to find it as a template in a
# module. If that fails, return it relative to the +templatedir+ config
# param.
# In all cases, an absolute path is returned, which does not
# necessarily refer to an existing file
def self.find_template(template, environment = nil)
if template =~ /^#{File::SEPARATOR}/
return template
end
path, file = split_path(template)
# Because templates don't have an assumed template name, like manifests do,
# we treat templates with no name as being templates in the main template
# directory.
if file.nil?
mod = nil
else
mod = find(path, environment)
end
if mod
return mod.template(file)
else
return File.join(Puppet.config.value(:templatedir, environment), template)
end
end
# Return a list of manifests (as absolute filenames) that match +pat+
# with the current directory set to +cwd+. If the first component of
# +pat+ does not contain any wildcards and is an existing module, return
# a list of manifests in that module matching the rest of +pat+
# Otherwise, try to find manifests matching +pat+ relative to +cwd+
def self.find_manifests(start, options = {})
cwd = options[:cwd] || Dir.getwd
path, pat = split_path(start)
mod = find(path, options[:environment])
if mod
return mod.manifests(pat)
else
abspat = File::expand_path(start, cwd)
files = Dir.glob(abspat).reject { |f| FileTest.directory?(f) }
if files.size == 0
files = Dir.glob(abspat + ".pp").reject { |f| FileTest.directory?(f) }
end
return files
end
end
# Split the path into the module and the rest of the path.
def self.split_path(path)
if path =~ %r/^#{File::SEPARATOR}/
return nil
end
modname, rest = path.split(File::SEPARATOR, 2)
return nil if modname.nil? || modname.empty?
return modname, rest
end
attr_reader :name, :path
def initialize(name, path)
@name = name
@path = path
end
def template(file)
return File::join(path, TEMPLATES, file)
end
def files
return File::join(path, FILES)
end
# Return the list of manifests matching the given glob pattern,
# defaulting to 'init.pp' for empty modules.
def manifests(rest)
rest ||= "init.pp"
p = File::join(path, MANIFESTS, rest)
files = Dir.glob(p)
if files.size == 0
files = Dir.glob(p + ".pp")
end
return files
end
private :initialize
end
|
