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


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

def initialize(env)
  self.environment = env
end

Instance Method Details

#environmentObject


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.


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_allObject

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


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

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
81
# 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)
      result = imported_types.find { |t| t.type == type and t.name == fqname }
      if result
        Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
        return result
      end
    rescue TypeLoaderError
      # I'm not convinced we should just drop these errors, but this
      # preserves existing behaviours.
    end
  end
  # Nothing found.
  return nil
end