Class: Puppet::Parser::TypeLoader

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Node::Environment::Helper
Defined in:
lib/puppet/parser/type_loader.rb

Instance Method Summary collapse

Methods included from Node::Environment::Helper

#environment, #environment=

Constructor Details

#initialize(env) ⇒ TypeLoader

Returns a new instance of TypeLoader.



49
50
51
 
# File 'lib/puppet/parser/type_loader.rb', line 49

def initialize(env)
  self.environment = env
end

Instance Method Details

#import(pattern, dir) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Import manifest files that match a given file glob pattern.

Parameters:

  • pattern (String) —

    the file glob to apply when determining which files to load

  • dir (String) —

    base directory to use when the file is not found in a module



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/puppet/parser/type_loader.rb', line 17

def import(pattern, dir)
  return if Puppet[:ignoreimport]

  modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
  if files.empty?
    abspat = File.expand_path(pattern, dir)
    file_pattern = abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )

    files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
    modname = nil

    if files.empty?
      raise_no_files_found(pattern)
    end
  end

  load_files(modname, files)
end

#import_all ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Load all of the manifest files in all known modules.



38
39
40
41
42
43
44
45
 
# File 'lib/puppet/parser/type_loader.rb', line 38

def import_all
  # And then load all files from each module, but (relying on system
  # behavior) only load files from the first module of a given name.  E.g.,
  # given first/foo and second/foo, only files from first/foo will be loaded.
  environment.modules.each do |mod|
    load_files(mod.name, mod.all_manifests)
  end
end

#parse_file(file) ⇒ Object 



72
73
74
75
76
77
 
# File 'lib/puppet/parser/type_loader.rb', line 72

def parse_file(file)
  Puppet.debug("importing '#{file}' in environment #{environment}")
  parser = Puppet::Parser::ParserFactory.parser(environment)
  parser.file = file
  return parser.parse
end

#try_load_fqname(type, fqname) ⇒ Object

Try to load the object with the given fully qualified name.



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/puppet/parser/type_loader.rb', line 54

def try_load_fqname(type, fqname)
  return nil if fqname == "" # special-case main.
  files_to_try_for(fqname).each do |filename|
    begin
      imported_types = import_from_modules(filename)
      if result = imported_types.find { |t| t.type == type and t.name == fqname }
        Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
        return result
      end
    rescue Puppet::ImportError => detail
      # I'm not convienced we should just drop these errors, but this
      # preserves existing behaviours.
    end
  end
  # Nothing found.
  return nil
end