Class: Puppet::Parser::TypeLoader

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

Defined Under Namespace

Classes: TypeLoaderError

Instance Method Summary collapse

Constructor Details

#initialize(env) ⇒ TypeLoader

Returns a new instance of TypeLoader.



47
48
49
 
# File 'lib/puppet/parser/type_loader.rb', line 47

def initialize(env)
  self.environment = env
end

Instance Method Details

#environment ⇒ Object 



51
52
53
 
# File 'lib/puppet/parser/type_loader.rb', line 51

def environment
  @environment
end

#environment=(env) ⇒ Object 



55
56
57
58
59
60
61
 
# File 'lib/puppet/parser/type_loader.rb', line 55

def environment=(env)
  if env.is_a?(String) or env.is_a?(Symbol)
    @environment = Puppet.lookup(:environments).get!(env)
  else
    @environment = env
  end
end

#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
 
# File 'lib/puppet/parser/type_loader.rb', line 17

def import(pattern, dir)
  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' : '' )

    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.



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

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 



82
83
84
85
86
87
 
# File 'lib/puppet/parser/type_loader.rb', line 82

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

#try_load_fqname(type, fqname) ⇒ Object

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



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/puppet/parser/type_loader.rb', line 64

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 TypeLoaderError => detail
      # I'm not convinced we should just drop these errors, but this
      # preserves existing behaviours.
    end
  end
  # Nothing found.
  return nil
end