Module: Puppet::MetaType::Manager

Includes:
Util::ClassGen
Included in:
Type
Defined in:
lib/puppet/metatype/manager.rb

Instance Method Summary collapse

Methods included from Util::ClassGen

#genclass, #genmodule, #rmclass

Methods included from Util

activerecord_version, benchmark, chuser, classproxy, #execfail, #execpipe, execute, logmethods, memory, proxy, recmkdir, secure_open, symbolize, symbolizehash, symbolizehash!, synchronize_on, thinmark, #threadlock, which, withumask

Methods included from Util::POSIX

#get_posix_field, #gid, #idfield, #methodbyid, #methodbyname, #search_posix_field, #uid

Methods included from Util::MethodHelper

#requiredopts, #set_options, #symbolize_options

Instance Method Details

#allclear ⇒ Object

remove all type instances; this is mostly only useful for testing



11
12
13
14
15
 
# File 'lib/puppet/metatype/manager.rb', line 11

def allclear
  @types.each { |name, type|
    type.clear
  }
end

#eachtype ⇒ Object

iterate across all of the subclasses of Type



18
19
20
21
22
23
24
25
 
# File 'lib/puppet/metatype/manager.rb', line 18

def eachtype
  @types.each do |name, type|
    # Only consider types that have names
    #if ! type.parameters.empty? or ! type.validproperties.empty?
      yield type
    #end
  end
end

#loadall ⇒ Object

Load all types. Only currently used for documentation.



28
29
30
 
# File 'lib/puppet/metatype/manager.rb', line 28

def loadall
  typeloader.loadall
end

#newtype(name, options = {}, &block) ⇒ Object

Define a new type.



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
 
# File 'lib/puppet/metatype/manager.rb', line 33

def newtype(name, options = {}, &block)
  # Handle backward compatibility
  unless options.is_a?(Hash)
    Puppet.warning "Puppet::Type.newtype(#{name}) now expects a hash as the second argument, not #{options.inspect}"
    options = {:parent => options}
  end

  # First make sure we don't have a method sitting around
  name = symbolize(name)
  newmethod = "new#{name.to_s}"

  # Used for method manipulation.
  selfobj = singleton_class

  @types ||= {}

  if @types.include?(name)
    if self.respond_to?(newmethod)
      # Remove the old newmethod
      selfobj.send(:remove_method,newmethod)
    end
  end

  options = symbolize_options(options)

  if parent = options[:parent]
    options.delete(:parent)
  end

  # Then create the class.

  klass = genclass(
    name,
    :parent => (parent || Puppet::Type),
    :overwrite => true,
    :hash => @types,
    :attributes => options,
    &block
  )

  # Now define a "new<type>" method for convenience.
  if self.respond_to? newmethod
    # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
    Puppet.warning "'new#{name.to_s}' method already exists; skipping"
  else
    selfobj.send(:define_method, newmethod) do |*args|
      klass.new(*args)
    end
  end

  # If they've got all the necessary methods defined and they haven't
  # already added the property, then do so now.
  klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)

  # Now set up autoload any providers that might exist for this type.

  klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")

  # We have to load everything so that we can figure out the default provider.
  klass.providerloader.loadall
  klass.providify unless klass.providers.empty?

  klass
end

#rmtype(name) ⇒ Object

Remove an existing defined type. Largely used for testing.



99
100
101
102
103
104
105
 
# File 'lib/puppet/metatype/manager.rb', line 99

def rmtype(name)
  # Then create the class.

  klass = rmclass(name, :hash => @types)

  singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
end

#type(name) ⇒ Object

Return a Type instance by name.



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/puppet/metatype/manager.rb', line 108

def type(name)
  @types ||= {}

  name = name.to_s.downcase.to_sym

  if t = @types[name]
    return t
  else
    if typeloader.load(name)
      Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
    end

    return @types[name]
  end
end

#typeloader ⇒ Object

Create a loader for Puppet types.



125
126
127
128
129
130
131
 
# File 'lib/puppet/metatype/manager.rb', line 125

def typeloader
  unless defined?(@typeloader)
    @typeloader = Puppet::Util::Autoload.new(self, "puppet/type", :wrap => false)
  end

  @typeloader
end