← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/puppet/oneiric-security

« back to all changes in this revision

Viewing changes to lib/puppet/provider/nameservice.rb

  • Committer: Bazaar Package Importer
  • Author(s): Micah Anderson
  • Date: 2008-07-26 15:43:45 UTC
  • mto: (3.1.1 lenny) (1.3.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20080726154345-1fmgo76b4l72ulvc
Import upstream version 0.24.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/puppet/provider/nameservice.rb
5
5
# provides a way for them all to be as similar as possible.
6
6
class Puppet::Provider::NameService < Puppet::Provider
7
7
    class << self
8
 
 
9
 
        def list
 
8
        def autogen_default(param)
 
9
            if defined? @autogen_defaults
 
10
                return @autogen_defaults[symbolize(param)]
 
11
            else
 
12
                return nil
 
13
            end
 
14
        end
 
15
 
 
16
        def autogen_defaults(hash)
 
17
            @autogen_defaults ||= {}
 
18
            hash.each do |param, value|
 
19
                @autogen_defaults[symbolize(param)] = value
 
20
            end
 
21
        end
 
22
 
 
23
        def initvars
 
24
            @checks = {}
 
25
            super
 
26
        end
 
27
 
 
28
        def instances
10
29
            objects = []
11
30
            listbyname do |name|
12
 
                obj = nil
13
 
                check = model.validstates
14
 
                if obj = model[name]
15
 
                    obj[:check] = check
16
 
                else
17
 
                    # unless it exists, create it as an unmanaged object
18
 
                    obj = model.create(:name => name, :check => check)
19
 
                end
20
 
 
21
 
                next unless obj # In case there was an error somewhere
22
 
                
23
 
                objects << obj
24
 
                yield obj if block_given?
 
31
                objects << new(:name => name, :ensure => :present)
25
32
            end
26
33
 
27
34
            objects
37
44
        end
38
45
 
39
46
        def options(name, hash)
40
 
            unless model.validattr?(name)
 
47
            unless resource_type.validattr?(name)
41
48
                raise Puppet::DevError, "%s is not a valid attribute for %s" %
42
 
                    [name, model.name]
 
49
                    [name, resource_type.name]
43
50
            end
44
51
            @options ||= {}
45
52
            @options[name] ||= {}
70
77
            return names
71
78
        end
72
79
 
 
80
        def resource_type=(resource_type)
 
81
            super
 
82
            @resource_type.validproperties.each do |prop|
 
83
                next if prop == :ensure
 
84
                unless public_method_defined?(prop)
 
85
                    define_method(prop) { get(prop) || :absent}
 
86
                end
 
87
                unless public_method_defined?(prop.to_s + "=")
 
88
                    define_method(prop.to_s + "=") { |*vals| set(prop, *vals) }
 
89
                end
 
90
            end
 
91
        end
 
92
 
73
93
        # This is annoying, but there really aren't that many options,
74
94
        # and this *is* built into Ruby.
75
95
        def section
76
 
            unless defined? @model
 
96
            unless defined? @resource_type
77
97
                raise Puppet::DevError,
78
 
                    "Cannot determine Etc section without a model"
 
98
                    "Cannot determine Etc section without a resource type"
79
99
 
80
100
            end
81
101
 
82
 
            if @model.name == :group
 
102
            if @resource_type.name == :group
83
103
                "gr"
84
104
            else
85
105
                "pw"
86
106
            end
87
107
        end
88
108
 
89
 
        def disabled_validate(name, value)
 
109
        def validate(name, value)
90
110
            name = name.intern if name.is_a? String
91
111
            if @checks.include? name
92
112
                block = @checks[name][:block]
99
119
 
100
120
        def verify(name, error, &block)
101
121
            name = name.intern if name.is_a? String
102
 
            @checks ||= {}
103
122
            @checks[name] = {:error => error, :block => block}
104
123
        end
105
124
 
106
125
        private
107
126
 
108
 
        def op(state)
109
 
            @ops[state.name] || ("-" + state.name)
 
127
        def op(property)
 
128
            @ops[property.name] || ("-" + property.name)
 
129
        end
 
130
    end
 
131
    
 
132
    # Autogenerate a value.  Mostly used for uid/gid, but also used heavily
 
133
    # with netinfo, because netinfo is stupid.
 
134
    def autogen(field)
 
135
        field = symbolize(field)
 
136
        id_generators = {:user => :uid, :group => :gid}
 
137
        if id_generators[@resource.class.name] == field
 
138
            return autogen_id(field)
 
139
        else
 
140
            if value = self.class.autogen_default(field)
 
141
                return value
 
142
            elsif respond_to?("autogen_%s" % [field])
 
143
                return send("autogen_%s" % field)
 
144
            else
 
145
                return nil
 
146
            end
110
147
        end
111
148
    end
112
149
 
113
150
    # Autogenerate either a uid or a gid.  This is hard-coded: we can only
114
151
    # generate one field type per class.
115
 
    def autogen
 
152
    def autogen_id(field)
116
153
        highest = 0
117
154
 
118
155
        group = method = nil
119
 
        case @model.class.name
 
156
        case @resource.class.name
120
157
        when :user: group = :passwd; method = :uid
121
158
        when :group: group = :group; method = :gid
122
159
        else
123
 
            raise Puppet::DevError, "Invalid model name %s" % model
 
160
            raise Puppet::DevError, "Invalid resource name %s" % resource
124
161
        end
125
162
        
126
163
        # Make sure we don't use the same value multiple times
141
178
        return @@prevauto
142
179
    end
143
180
 
144
 
    def autogen_gid
145
 
        autogen(@model.class.name)
146
 
    end
147
 
 
148
 
    def autogen_uid
149
 
        autogen(@model.class.name)
150
 
    end
151
 
 
152
181
    def create
153
182
        self.ensure = :present
154
183
    end
178
207
                return nil
179
208
            end
180
209
 
181
 
            # again, needs to be set by the ind. state or its
 
210
            # again, needs to be set by the ind. property or its
182
211
            # parent
183
212
            cmd = self.deletecmd
184
213
            type = "delete"
198
227
            execute(cmd)
199
228
        rescue Puppet::ExecutionFailure => detail
200
229
            raise Puppet::Error, "Could not %s %s %s: %s" %
201
 
                [type, @model.class.name, @model.name, detail]
 
230
                [type, @resource.class.name, @resource.name, detail]
202
231
        end
203
232
    end
204
233
 
225
254
        if @objectinfo.nil? or refresh == true
226
255
            @etcmethod ||= ("get" + self.class.section().to_s + "nam").intern
227
256
            begin
228
 
                @objectinfo = Etc.send(@etcmethod, @model[:name])
 
257
                @objectinfo = Etc.send(@etcmethod, @resource[:name])
229
258
            rescue ArgumentError => detail
230
259
                @objectinfo = nil
231
260
            end
247
276
        # Reset our group list
248
277
        Etc.setgrent
249
278
 
250
 
        user = @model[:name]
 
279
        user = @resource[:name]
251
280
 
252
281
        # Now iterate across all of the groups, adding each one our
253
282
        # user is a member of
269
298
    # Convert the Etc struct into a hash.
270
299
    def info2hash(info)
271
300
        hash = {}
272
 
        self.class.model.validstates.each do |param|
 
301
        self.class.resource_type.validproperties.each do |param|
273
302
            method = posixmethod(param)
274
303
            if info.respond_to? method
275
304
                hash[param] = info.send(posixmethod(param))
279
308
        return hash
280
309
    end
281
310
 
282
 
    def initialize(model)
 
311
    def initialize(resource)
283
312
        super
284
313
 
285
314
        @objectinfo = nil
286
315
    end
287
316
 
288
 
    # 
289
 
    def method_missing(name, *args)
290
 
        name = name.to_s
291
 
 
292
 
        # Make sure it's a valid state.  We go up our class structure instead of
293
 
        # our model's because the model is fake during testing.
294
 
        unless self.class.model.validstate?(name.sub("=",''))
295
 
            raise Puppet::DevError, "%s is not a valid %s state" %
296
 
                [name, @model.class.name]
297
 
        end
298
 
 
299
 
        # Each class has to override this manually
300
 
        if name =~ /=/
301
 
            set(name.to_s.sub("=", ''), *args)
302
 
        else
303
 
            return get(name.intern) || :absent
304
 
        end
305
 
    end
306
 
 
307
317
    def set(param, value)
308
 
        #self.class.validate(param, value)
 
318
        self.class.validate(param, value)
309
319
        cmd = modifycmd(param, value)
 
320
        unless cmd.is_a?(Array)
 
321
            raise Puppet::DevError, "Nameservice command must be an array"
 
322
        end
310
323
        begin
311
324
            execute(cmd)
312
325
        rescue Puppet::ExecutionFailure => detail
313
 
            raise Puppet::Error, "Could not set %s on %s[%s]: %s" %
314
 
                [param, @model.class.name, @model.name, detail]
 
326
            raise Puppet::Error, "Could not set %s on %s[%s]: %s" % [param, @resource.class.name, @resource.name, detail]
315
327
        end
316
328
    end
317
329
end
318
330
 
319
 
# $Id: nameservice.rb 1860 2006-11-12 21:25:13Z luke $