Class: Puppet::Util::Autoload

Inherits:
Object
  • Object
show all
Includes:
MethodHelper
Defined in:
lib/puppet/util/autoload.rb

Overview

Autoload paths, either based on names or all at once.

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from MethodHelper

#requiredopts, #set_options, #symbolize_options

Constructor Details

#initialize(obj, path, options = {}) ⇒ Autoload

Returns a new instance of Autoload.

Raises:

  • (ArgumentError) 


186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/puppet/util/autoload.rb', line 186

def initialize(obj, path, options = {})
  @path = path.to_s
  raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
  @object = obj

  self.class[obj] = self

  set_options(options)

  @wrap = true unless defined?(@wrap)
end

Class Attribute Details

.autoloaders ⇒ Object (readonly) 



14
15
16
 
# File 'lib/puppet/util/autoload.rb', line 14

def autoloaders
  @autoloaders
end

.loaded ⇒ Object 



15
16
17
 
# File 'lib/puppet/util/autoload.rb', line 15

def loaded
  @loaded
end

Instance Attribute Details

#object ⇒ Object 



184
185
186
 
# File 'lib/puppet/util/autoload.rb', line 184

def object
  @object
end

#objwarn ⇒ Object 



184
185
186
 
# File 'lib/puppet/util/autoload.rb', line 184

def objwarn
  @objwarn
end

#path ⇒ Object 



184
185
186
 
# File 'lib/puppet/util/autoload.rb', line 184

def path
  @path
end

#wrap ⇒ Object 



184
185
186
 
# File 'lib/puppet/util/autoload.rb', line 184

def wrap
  @wrap
end

Class Method Details

.changed?(name) ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/puppet/util/autoload.rb', line 42

def changed?(name)
  name = cleanpath(name).chomp('.rb')
  return true unless loaded.include?(name)
  file, old_mtime = loaded[name]
  environment = Puppet.lookup(:current_environment)
  return true unless file == get_file(name, environment)
  begin
    old_mtime.to_i != File.mtime(file).to_i
  rescue Errno::ENOENT
    true
  end
end

.cleanpath(path) ⇒ Object

Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows and eliminates unnecessary parts of a path.



169
170
171
172
173
174
175
176
177
178
 
# File 'lib/puppet/util/autoload.rb', line 169

def cleanpath(path)
  # There are two cases here because cleanpath does not handle absolute
  # paths correctly on windows (c:\ and c:/ are treated as distinct) but
  # we don't want to convert relative paths to absolute
  if Puppet::Util.absolute_path?(path)
    File.expand_path(path)
  else
    Pathname.new(path).cleanpath.to_s
  end
end

.files_in_dir(dir, path) ⇒ Object 



97
98
99
100
101
102
 
# File 'lib/puppet/util/autoload.rb', line 97

def files_in_dir(dir, path)
  dir = Pathname.new(File.expand_path(dir))
  Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
    Pathname.new(file).relative_path_from(dir).to_s
  end
end

.files_to_load(path) ⇒ Object 



93
94
95
 
# File 'lib/puppet/util/autoload.rb', line 93

def files_to_load(path)
  search_directories(nil).map {|dir| files_in_dir(dir, path) }.flatten.uniq
end

.gem_directories ⇒ Object 



159
160
161
 
# File 'lib/puppet/util/autoload.rb', line 159

def gem_directories
  gem_source.directories
end

.gem_source ⇒ Object 



18
19
20
 
# File 'lib/puppet/util/autoload.rb', line 18

def gem_source
  @gem_source ||= Puppet::Util::RubyGems::Source.new
end

.get_file(name, env) ⇒ Object

Get the correct file to load for a given path returns nil if no file is found



87
88
89
90
91
 
# File 'lib/puppet/util/autoload.rb', line 87

def get_file(name, env)
  name = name + '.rb' unless name =~ /\.rb$/
  path = search_directories(env).find { |dir| Puppet::FileSystem.exist?(File.join(dir, name)) }
  path and File.join(path, name)
end

.libdirs ⇒ Object 



149
150
151
152
153
154
155
156
157
 
# File 'lib/puppet/util/autoload.rb', line 149

def libdirs()
  # See the comments in #module_directories above.  Basically, we need to be careful not to try to access the
  # libdir before we know for sure that all of the settings have been initialized (e.g., during bootstrapping).
  if (Puppet.settings.app_defaults_initialized?)
    Puppet[:libdir].split(File::PATH_SEPARATOR)
  else
    []
  end
end

.load_file(name, env) ⇒ Object

Load a single plugin by name. We use ‘load’ here so we can reload a given plugin.



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/puppet/util/autoload.rb', line 57

def load_file(name, env)
  file = get_file(name.to_s, env)
  return false unless file
  begin
    mark_loaded(name, file)
    Kernel.load file, @wrap
    return true
  rescue SystemExit,NoMemoryError
    raise
  rescue Exception => detail
    message = "Could not autoload #{name}: #{detail}"
    Puppet.log_exception(detail, message)
    raise Puppet::Error, message, detail.backtrace
  end
end

.loadall(path) ⇒ Object 



73
74
75
76
77
78
79
 
# File 'lib/puppet/util/autoload.rb', line 73

def loadall(path)
  # Load every instance of everything we can find.
  files_to_load(path).each do |file|
    name = file.chomp(".rb")
    load_file(name, nil) unless loaded?(name)
  end
end

.loaded?(path) ⇒ Boolean

Has a given path been loaded? This is used for testing whether a changed file should be loaded or just ignored. This is only used in network/client/master, when downloading plugins, to see if a given plugin is currently loaded and thus should be reloaded.

Returns:

  • (Boolean) 


27
28
29
30
 
# File 'lib/puppet/util/autoload.rb', line 27

def loaded?(path)
  path = cleanpath(path).chomp('.rb')
  loaded.include?(path)
end

.mark_loaded(name, file) ⇒ Object

Save the fact that a given path has been loaded. This is so we can load downloaded plugins if they’ve already been loaded into memory.



35
36
37
38
39
40
 
# File 'lib/puppet/util/autoload.rb', line 35

def mark_loaded(name, file)
  name = cleanpath(name).chomp('.rb')
  ruby_file = name + ".rb"
  $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
  loaded[name] = [file, File.mtime(file)]
end

.module_directories(env) ⇒ Object 



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
 
# File 'lib/puppet/util/autoload.rb', line 104

def module_directories(env)
  # We're using a per-thread cache of module directories so that we don't
  # scan the filesystem each time we try to load something. This is reset
  # at the beginning of compilation and at the end of an agent run.
  $env_module_directories ||= {}


  # This is a little bit of a hack.  Basically, the autoloader is being
  # called indirectly during application bootstrapping when we do things
  # such as check "features".  However, during bootstrapping, we haven't
  # yet parsed all of the command line parameters nor the config files,
  # and thus we don't yet know with certainty what the module path is.
  # This should be irrelevant during bootstrapping, because anything that
  # we are attempting to load during bootstrapping should be something
  # that we ship with puppet, and thus the module path is irrelevant.
  #
  # In the long term, I think the way that we want to handle this is to
  # have the autoloader ignore the module path in all cases where it is
  # not specifically requested (e.g., by a constructor param or
  # something)... because there are very few cases where we should
  # actually be loading code from the module path.  However, until that
  # happens, we at least need a way to prevent the autoloader from
  # attempting to access the module path before it is initialized.  For
  # now we are accomplishing that by calling the
  # "app_defaults_initialized?" method on the main puppet Settings object.
  # --cprice 2012-03-16
  if Puppet.settings.app_defaults_initialized?
    env ||= Puppet.lookup(:environments).get(Puppet[:environment])

    if env
      # if the app defaults have been initialized then it should be safe to access the module path setting.
      $env_module_directories[env] ||= env.modulepath.collect do |dir|
        Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
      end.flatten.find_all do |d|
        FileTest.directory?(d)
      end
    else
      []
    end
  else
    # if we get here, the app defaults have not been initialized, so we basically use an empty module path.
    []
  end
end

.reload_changed ⇒ Object 



81
82
83
 
# File 'lib/puppet/util/autoload.rb', line 81

def reload_changed
  loaded.keys.each { |file| load_file(file, nil) if changed?(file) }
end

.search_directories(env) ⇒ Object 



163
164
165
 
# File 'lib/puppet/util/autoload.rb', line 163

def search_directories(env)
  [gem_directories, module_directories(env), libdirs(), $LOAD_PATH].flatten
end

Instance Method Details

#changed?(name) ⇒ Boolean

Returns:

  • (Boolean) 


220
221
222
 
# File 'lib/puppet/util/autoload.rb', line 220

def changed?(name)
  self.class.changed?(expand(name))
end

#expand(name) ⇒ Object 



228
229
230
 
# File 'lib/puppet/util/autoload.rb', line 228

def expand(name)
  ::File.join(@path, name.to_s)
end

#files_to_load ⇒ Object 



224
225
226
 
# File 'lib/puppet/util/autoload.rb', line 224

def files_to_load
  self.class.files_to_load(@path)
end

#load(name, env = nil) ⇒ Object 



198
199
200
 
# File 'lib/puppet/util/autoload.rb', line 198

def load(name, env = nil)
  self.class.load_file(expand(name), env)
end

#loadall ⇒ Object

Load all instances from a path of Autoload.search_directories matching the relative path this Autoloader was initialized with. For example, if we have created a Puppet::Util::Autoload for Puppet::Type::User with a path of ‘puppet/provider/user’, the search_directories path will be searched for all ruby files matching puppet/provider/user/*.rb and they will then be loaded from the first directory in the search path providing them. So earlier entries in the search path may shadow later entries.

This uses require, rather than load, so that already-loaded files don’t get reloaded unnecessarily.



212
213
214
 
# File 'lib/puppet/util/autoload.rb', line 212

def loadall
  self.class.loadall(@path)
end

#loaded?(name) ⇒ Boolean

Returns:

  • (Boolean) 


216
217
218
 
# File 'lib/puppet/util/autoload.rb', line 216

def loaded?(name)
  self.class.loaded?(expand(name))
end