puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/provider/parsedfile.rb

@@ -0,0 +1,374 @@
+require 'puppet'
+require 'puppet/util/filetype'
+require 'puppet/util/fileparsing'
+
+# 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.
+class Puppet::Provider::ParsedFile < Puppet::Provider
+  extend Puppet::Util::FileParsing
+
+  class << self
+    attr_accessor :default_target, :target
+  end
+
+  attr_accessor :property_hash
+
+  def self.clean(hash)
+    newhash = hash.dup
+    [:record_type, :on_disk].each do |p|
+      newhash.delete(p) if newhash.include?(p)
+    end
+
+    newhash
+  end
+
+  def self.clear
+    @target_objects.clear
+    @records.clear
+  end
+
+  def self.filetype
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+  end
+
+  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 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'.
+  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
+
+  # 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.
+  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
+
+  # Flush all of the records relating to a specific target.
+  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
+
+  # Return the header placed at the top of each generated file, warning
+  # users that modifying this file manually is probably a bad idea.
+  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
+
+  # Add another type var.
+  def self.initvars
+    @records = []
+    @target_objects = {}
+
+    @target = nil
+
+    # Default to flat files
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+    super
+  end
+
+  # Return a list of all of the records we can find.
+  def self.instances
+    targets.collect do |target|
+      prefetch_target(target)
+    end.flatten.reject { |r| skip_record?(r) }.collect do |record|
+      new(record)
+    end
+  end
+
+  # Override the default method with a lot more functionality.
+  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
+
+  # Always make the resource methods.
+  def self.resource_type=(resource)
+    super
+    mk_resource_methods
+  end
+
+  # Mark a target as modified so we know to flush it.  This only gets
+  # used within the attr= methods.
+  def self.modified(target)
+    @modified ||= []
+    @modified << target unless @modified.include?(target)
+  end
+
+  # 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.
+  def self.prefetch(resources = nil)
+    # Reset the record list.
+    @records = prefetch_all_targets(resources)
+
+    match_providers_with_resources(resources)
+  end
+
+  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
+
+  def self.prefetch_all_targets(resources)
+    records = []
+    targets(resources).each do |target|
+      records += prefetch_target(target)
+    end
+    records
+  end
+
+  # Prefetch an individual target.
+  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
+
+  # Is there an existing record with this name?
+  def self.record?(name)
+    return nil unless @records
+    @records.find { |r| r[:name] == name }
+  end
+
+  # Retrieve the text for the file. Returns nil in the unlikely
+  # event that it doesn't exist.
+  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
+
+  # Should we skip the record?  Basically, we skip text records.
+  # This is only here so subclasses can override it.
+  def self.skip_record?(record)
+    record_type(record[:record_type]).text?
+  end
+
+  # Initialize the object if necessary.
+  def self.target_object(target)
+    @target_objects[target] ||= filetype.new(target)
+
+    @target_objects[target]
+  end
+
+  # Find all of the records for a given target
+  def self.target_records(target)
+    @records.find_all { |r| r[:target] == target }
+  end
+
+  # 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.
+  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
+
+  def self.to_file(records)
+    text = super
+    header + text
+  end
+
+  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
+
+  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
+
+  def exists?
+    !(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
+  end
+
+  # Write our data to disk.
+  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
+
+  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
+
+  # Retrieve the current state from disk.
+  def prefetch
+    raise Puppet::DevError, "Somehow got told to prefetch with no resource set" unless @resource
+    self.class.prefetch(@resource[:name] => @resource)
+  end
+
+  def record_type
+    @property_hash[:record_type]
+  end
+
+  private
+
+  # Mark both the resource and provider target as modified.
+  def mark_target_modified
+    if defined?(@resource) and restarget = @resource.should(:target) and restarget != @property_hash[:target]
+      self.class.modified(restarget)
+    end
+    self.class.modified(@property_hash[:target]) if @property_hash[:target] != :absent and @property_hash[:target]
+  end
+end

data/lib/vendor/puppet/provider/port/parsed.rb

@@ -0,0 +1,173 @@
+require 'puppet/provider/parsedfile'
+
+#services = nil
+#case Facter.value(:operatingsystem)
+#when "Solaris"; services = "/etc/inet/services"
+#else
+#    services = "/etc/services"
+#end
+#
+#Puppet::Type.type(:port).provide(:parsed,
+#    :parent => Puppet::Provider::ParsedFile,
+#    :default_target => services,
+#    :filetype => :flat
+#) do
+#    text_line :comment, :match => /^\s*#/
+#    text_line :blank, :match => /^\s*$/
+#
+#    # We're cheating horribly here -- we don't support ddp, because it assigns
+#    # the same number to already-used names, and the same name to different
+#    # numbers.
+#    text_line :ddp, :match => /^\S+\s+\d+\/ddp/
+#
+#    # Also, just ignore the lines on OS X that don't have service names.
+#    text_line :funky_darwin, :match => /^\s+\d+\//
+#
+#    # We have to manually parse the line, since it's so darn complicated.
+#    record_line :parsed, :fields => %w{name port protocols alias description},
+#        :optional => %w{alias description} do |line|
+#        if line =~ /\/ddp/
+#            raise "missed ddp in #{line}"
+#        end
+#        # The record might contain multiple port lines separated by \n.
+#        hashes = line.split("\n").collect { |l| parse_port(l) }
+#
+#        # It's easy if there's just one hash.
+#        if hashes.length == 1
+#            return hashes.shift
+#        end
+#
+#        # Else, merge the two records into one.
+#        return port_merge(*hashes)
+#    end
+#
+#    # Override how we split into lines, so that we always treat both protocol
+#    # lines as a single line.  This drastically simplifies merging the two lines
+#    # into one record.
+#    def self.lines(text)
+#        names = {}
+#        lines = []
+#
+#        # We organize by number, because that's apparently how the ports work.
+#        # You'll never be able to use Puppet to manage multiple entries
+#        # with the same name but different numbers, though.
+#        text.split("\n").each do |line|
+#            if line =~ /^([-\w]+)\s+(\d+)\/[^d]/ # We want to skip ddp proto stuff
+#                names[$1] ||= []
+#                names[$1] << line
+#                lines << [:special, $1]
+#            else
+#                lines << line
+#            end
+#        end
+#
+#        # Now, return each line in order, but join the ones with the same name
+#        lines.collect do |line|
+#            if line.is_a?(Array)
+#                name = line[1]
+#                if names[name]
+#                    t = names[name].join("\n")
+#                    names.delete(name)
+#                    t
+#                end
+#            else
+#                line
+#            end
+#        end.reject { |l| l.nil? }
+#    end
+#
+#    # Parse a single port line, returning a hash.
+#    def self.parse_port(line)
+#        hash = {}
+#        if line.sub!(/^(\S+)\s+(\d+)\/(\w+)\s*/, '')
+#            hash[:name] = $1
+#            hash[:number] = $2
+#            hash[:protocols] = [$3]
+#
+#            unless line == ""
+#                line.sub!(/^([^#]+)\s*/) do |value|
+#                    aliases = $1
+#
+#                    # Remove any trailing whitespace
+#                    aliases.strip!
+#                    unless aliases =~ /^\s*$/
+#                        hash[:alias] = aliases.split(/\s+/)
+#                    end
+#
+#                    ""
+#                end
+#
+#                line.sub!(/^\s*#\s*(.+)$/) do |value|
+#                    desc = $1
+#                    unless desc =~ /^\s*$/
+#                        hash[:description] = desc.sub(/\s*$/, '')
+#                    end
+#
+#                    ""
+#                end
+#            end
+#        else
+#            if line =~ /^\s+\d+/ and
+#                Facter["operatingsystem"].value == "Darwin"
+#                    #Puppet.notice "Skipping wonky OS X port entry %s" %
+#                    #    line.inspect
+#                    next
+#            end
+#            Puppet.notice "Ignoring unparseable line '#{line}' in #{self.target}"
+#        end
+#
+#        if hash.empty?
+#            return nil
+#        else
+#            return hash
+#        end
+#    end
+#
+#    # Merge two records into one.
+#    def self.port_merge(one, two)
+#        keys = [one.keys, two.keys].flatten.uniq
+#
+#        # We'll be returning the 'one' hash. so make any necessary modifications
+#        # to it.
+#        keys.each do |key|
+#            # The easy case
+#            if one[key] == two[key]
+#                next
+#            elsif one[key] and ! two[key]
+#                next
+#            elsif ! one[key] and two[key]
+#                one[key] = two[key]
+#            elsif one[key].is_a?(Array) and two[key].is_a?(Array)
+#                one[key] = [one[key], two[key]].flatten.uniq
+#            else
+#                # Keep the info from the first hash, so don't do anything
+#                #Puppet.notice "Cannot merge %s in %s with %s" %
+#                #    [key, one.inspect, two.inspect]
+#            end
+#        end
+#
+#        return one
+#    end
+#
+#    # Convert the current object into one or more services entry.
+#    def self.to_line(hash)
+#        unless hash[:record_type] == :parsed
+#            return super
+#        end
+#
+#        # Strangely, most sites seem to use tabs as separators.
+#        hash[:protocols].collect { |proto|
+#            str = "#{hash[:name]}\t\t#{hash[:number]}/#{proto}"
+#
+#            if value = hash[:alias] and value != :absent
+#                str += "\t\t#{value.join(" ")}"
+#            end
+#
+#            if value = hash[:description] and value != :absent
+#                str += "\t# #{value}"
+#            end
+#            str
+#        }.join("\n")
+#    end
+#end
+