Class: Puppet::Provider::ParsedFile

Inherits:
Puppet::Provider show all
Extended by:
Util::FileParsing
Defined in:
lib/vendor/puppet/provider/parsedfile.rb

Overview

This provider can be used as the parent class for a provider that parses and generates files. Its content must be loaded via the ‘prefetch’ method, and the file will be written when ‘flush’ is called on the provider instance. At this point, the file is written once for every provider instance.

Once the provider prefetches the data, it’s the resource’s job to copy that data over to the @is variables.

Direct Known Subclasses

Naginator

Constant Summary

Constants included from Util

Util::AbsolutePathPosix, Util::AbsolutePathWindows

Constants included from Util::Docs

Util::Docs::HEADER_LEVELS

Class Attribute Summary collapse

Instance Attribute Summary collapse

Attributes included from Util::FileParsing

#line_separator, #trailing_separator

Attributes inherited from Puppet::Provider

#model, #resource

Attributes included from Util::Docs

#doc, #nodoc

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Util::FileParsing

clear_records, fields, handle_record_line, handle_text_line, lines, parse, parse_line, record_line, records?, text_line, to_file, to_line, valid_attr?

Methods included from Util

absolute_path?, activerecord_version, benchmark, binread, chuser, classproxy, #execfail, #execpipe, execute, execute_posix, execute_windows, logmethods, memory, path_to_uri, proxy, replace_file, safe_posix_fork, symbolize, symbolizehash, symbolizehash!, synchronize_on, thinmark, #threadlock, uri_to_path, wait_for_output, which, withumask

Methods included from Util::POSIX

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

Methods inherited from Puppet::Provider

#<=>, #clear, command, #command, commands, declared_feature?, default?, defaultfor, #get, make_command_methods, mkmodelmethods, #name, optional_commands, #set, specificity, supports_parameter?, #to_s

Methods included from Util::Logging

#clear_deprecation_warnings, #deprecation_warning, #send_log

Methods included from Util::Docs

#desc, #dochook, #doctable, #markdown_definitionlist, #markdown_header, #nodoc?, #pad, scrub

Methods included from Util::Warnings

clear_warnings, notice_once, warnonce

Methods included from Confiner

#confine, #confine_collection, #suitable?

Methods included from Util::Errors

#adderrorcontext, #devfail, #error_context, #exceptwrap, #fail

Constructor Details

#initialize(record) ⇒ ParsedFile

Returns a new instance of ParsedFile.



346
347
348
349
350
351
352
353
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 346

def initialize(record)
  super

  # The 'record' could be a resource or a record, depending on how the provider
  # is initialized.  If we got an empty property hash (probably because the resource
  # is just being initialized), then we want to set up some defualts.
  @property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent} if @property_hash.empty?
end

Class Attribute Details

.default_target ⇒ Object

Returns the value of attribute default_target.



17
18
19
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 17

def default_target
  @default_target
end

.target ⇒ Object

Returns the value of attribute target.



17
18
19
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 17

def target
  @target
end

Instance Attribute Details

#property_hash ⇒ Object

Returns the value of attribute property_hash.



20
21
22
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 20

def property_hash
  @property_hash
end

Class Method Details

.backup_target(target) ⇒ Object

Make sure our file is backed up, but only back it up once per transaction. We cheat and rely on the fact that @records is created on each prefetch.



78
79
80
81
82
83
84
85
86
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 78

def self.backup_target(target)
  return nil unless target_object(target).respond_to?(:backup)

  @backup_stats ||= {}
  return nil if @backup_stats[target] == @records.object_id

  target_object(target).backup
  @backup_stats[target] = @records.object_id
end

.clean(hash) ⇒ Object 



22
23
24
25
26
27
28
29
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 22

def self.clean(hash)
  newhash = hash.dup
  [:record_type, :on_disk].each do |p|
    newhash.delete(p) if newhash.include?(p)
  end

  newhash
end

.clear ⇒ Object 



31
32
33
34
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 31

def self.clear
  @target_objects.clear
  @records.clear
end

.filetype ⇒ Object 



36
37
38
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 36

def self.filetype
  @filetype ||= Puppet::Util::FileType.filetype(:flat)
end

.filetype=(type) ⇒ Object 



40
41
42
43
44
45
46
47
48
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 40

def self.filetype=(type)
  if type.is_a?(Class)
    @filetype = type
  elsif klass = Puppet::Util::FileType.filetype(type)
    @filetype = klass
  else
    raise ArgumentError, "Invalid filetype #{type}"
  end
end

.flush(record) ⇒ Object

Flush all of the targets for which there are modified records. The only reason we pass a record here is so that we can add it to the stack if necessary – it’s passed from the instance calling ‘flush’.



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 53

def self.flush(record)
  # Make sure this record is on the list to be flushed.
  unless record[:on_disk]
    record[:on_disk] = true
    @records << record

    # If we've just added the record, then make sure our
    # target will get flushed.
    modified(record[:target] || default_target)
  end

  return unless defined?(@modified) and ! @modified.empty?

  flushed = []
  @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
    Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
    flush_target(target)
    flushed << target
  end

  @modified.reject! { |t| flushed.include?(t) }
end

.flush_target(target) ⇒ Object

Flush all of the records relating to a specific target.



89
90
91
92
93
94
95
96
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 89

def self.flush_target(target)
  backup_target(target)

  records = target_records(target).reject { |r|
    r[:ensure] == :absent
  }
  target_object(target).write(to_file(records))
end

.header ⇒ Object

Return the header placed at the top of each generated file, warning users that modifying this file manually is probably a bad idea.



100
101
102
103
104
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 100

def self.header
%{# HEADER: This file was autogenerated at #{Time.now}
# HEADER: by puppet.  While it can still be managed manually, it
# HEADER: is definitely not recommended.\n}
end

.initvars ⇒ Object

Add another type var.



107
108
109
110
111
112
113
114
115
116
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 107

def self.initvars
  @records = []
  @target_objects = {}

  @target = nil

  # Default to flat files
  @filetype ||= Puppet::Util::FileType.filetype(:flat)
  super
end

.instances ⇒ Object

Return a list of all of the records we can find.



119
120
121
122
123
124
125
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 119

def self.instances
  targets.collect do |target|
    prefetch_target(target)
  end.flatten.reject { |r| skip_record?(r) }.collect do |record|
    new(record)
  end
end

.match_providers_with_resources(resources) ⇒ Object 



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 189

def self.match_providers_with_resources(resources)
  return unless resources
  matchers = resources.dup
  @records.each do |record|
    # Skip things like comments and blank lines
    next if skip_record?(record)

    if name = record[:name] and resource = resources[name]
      resource.provider = new(record)
    elsif respond_to?(:match)
      if resource = match(record, matchers)
        # Remove this resource from circulation so we don't unnecessarily try to match
        matchers.delete(resource.title)
        record[:name] = resource[:name]
        resource.provider = new(record)
      end
    end
  end
end

.mk_resource_methods ⇒ Object

Override the default method with a lot more functionality.



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 128

def self.mk_resource_methods
  [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
    attr = attr.intern
    define_method(attr) do
#                if @property_hash.empty?
#                    # Note that this swaps the provider out from under us.
#                    prefetch
#                    if @resource.provider == self
#                        return @property_hash[attr]
#                    else
#                        return @resource.provider.send(attr)
#                    end
#                end
      # If it's not a valid field for this record type (which can happen
      # when different platforms support different fields), then just
      # return the should value, so the resource shuts up.
      if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
        @property_hash[attr] || :absent
      else
        if defined?(@resource)
          @resource.should(attr)
        else
          nil
        end
      end
    end

    define_method(attr.to_s + "=") do |val|
      mark_target_modified
      @property_hash[attr] = val
    end
  end
end

.modified(target) ⇒ Object

Mark a target as modified so we know to flush it. This only gets used within the attr= methods.



170
171
172
173
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 170

def self.modified(target)
  @modified ||= []
  @modified << target unless @modified.include?(target)
end

.prefetch(resources = nil) ⇒ Object

Retrieve all of the data from disk. There are three ways to know which files to retrieve: We might have a list of file objects already set up, there might be instances of our associated resource and they will have a path parameter set, and we will have a default path set. We need to turn those three locations into a list of files, prefetch each one, and make sure they’re associated with each appropriate resource instance.



182
183
184
185
186
187
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 182

def self.prefetch(resources = nil)
  # Reset the record list.
  @records = prefetch_all_targets(resources)

  match_providers_with_resources(resources)
end

.prefetch_all_targets(resources) ⇒ Object 



209
210
211
212
213
214
215
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 209

def self.prefetch_all_targets(resources)
  records = []
  targets(resources).each do |target|
    records += prefetch_target(target)
  end
  records
end

.prefetch_target(target) ⇒ Object

Prefetch an individual target.

Raises:



218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 218

def self.prefetch_target(target)
  target_records = retrieve(target).each do |r|
    r[:on_disk] = true
    r[:target] = target
    r[:ensure] = :present
  end

  target_records = prefetch_hook(target_records) if respond_to?(:prefetch_hook)

  raise Puppet::DevError, "Prefetching #{target} for provider #{self.name} returned nil" unless target_records

  target_records
end

.record?(name) ⇒ Boolean

Is there an existing record with this name?

Returns:

  • (Boolean) 


233
234
235
236
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 233

def self.record?(name)
  return nil unless @records
  @records.find { |r| r[:name] == name }
end

.resource_type=(resource) ⇒ Object

Always make the resource methods.



163
164
165
166
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 163

def self.resource_type=(resource)
  super
  mk_resource_methods
end

.retrieve(path) ⇒ Object

Retrieve the text for the file. Returns nil in the unlikely event that it doesn’t exist.



240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 240

def self.retrieve(path)
  # XXX We need to be doing something special here in case of failure.
  text = target_object(path).read
  if text.nil? or text == ""
    # there is no file
    return []
  else
    # Set the target, for logging.
    old = @target
    begin
      @target = path
      return self.parse(text)
    rescue Puppet::Error => detail
      detail.file = @target
      raise detail
    ensure
      @target = old
    end
  end
end

.skip_record?(record) ⇒ Boolean

Should we skip the record? Basically, we skip text records. This is only here so subclasses can override it.

Returns:

  • (Boolean) 


263
264
265
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 263

def self.skip_record?(record)
  record_type(record[:record_type]).text?
end

.target_object(target) ⇒ Object

Initialize the object if necessary.



268
269
270
271
272
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 268

def self.target_object(target)
  @target_objects[target] ||= filetype.new(target)

  @target_objects[target]
end

.target_records(target) ⇒ Object

Find all of the records for a given target



275
276
277
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 275

def self.target_records(target)
  @records.find_all { |r| r[:target] == target }
end

.targets(resources = nil) ⇒ Object

Find a list of all of the targets that we should be reading. This is used to figure out what targets we need to prefetch.

Raises:



281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 281

def self.targets(resources = nil)
  targets = []
  # First get the default target
  raise Puppet::DevError, "Parsed Providers must define a default target" unless self.default_target
  targets << self.default_target

  # Then get each of the file objects
  targets += @target_objects.keys

  # Lastly, check the file from any resource instances
  if resources
    resources.each do |name, resource|
      if value = resource.should(:target)
        targets << value
      end
    end
  end

  targets.uniq.compact
end

.to_file(records) ⇒ Object 



302
303
304
305
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 302

def self.to_file(records)
  text = super
  header + text
end

Instance Method Details

#create ⇒ Object 



307
308
309
310
311
312
313
314
315
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 307

def create
  @resource.class.validproperties.each do |property|
    if value = @resource.should(property)
      @property_hash[property] = value
    end
  end
  mark_target_modified
  (@resource.class.name.to_s + "_created").intern
end

#destroy ⇒ Object 



317
318
319
320
321
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 317

def destroy
  # We use the method here so it marks the target as modified.
  self.ensure = :absent
  (@resource.class.name.to_s + "_deleted").intern
end

#exists? ⇒ Boolean

Returns:

  • (Boolean) 


323
324
325
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 323

def exists?
  !(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
end

#flush ⇒ Object

Write our data to disk.



328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 328

def flush
  # Make sure we've got a target and name set.

  # If the target isn't set, then this is our first modification, so
  # mark it for flushing.
  unless @property_hash[:target]
    @property_hash[:target] = @resource.should(:target) || self.class.default_target
    self.class.modified(@property_hash[:target])
  end
  @resource.class.key_attributes.each do |attr|
    @property_hash[attr] ||= @resource[attr]
  end

  self.class.flush(@property_hash)

  #@property_hash = {}
end

#prefetch ⇒ Object

Retrieve the current state from disk.

Raises:



356
357
358
359
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 356

def prefetch
  raise Puppet::DevError, "Somehow got told to prefetch with no resource set" unless @resource
  self.class.prefetch(@resource[:name] => @resource)
end

#record_type ⇒ Object 



361
362
363
 
# File 'lib/vendor/puppet/provider/parsedfile.rb', line 361

def record_type
  @property_hash[:record_type]
end