puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/fileparsing.rb

@@ -0,0 +1,373 @@
+# A mini-language for parsing files.  This is only used file the ParsedFile
+# provider, but it makes more sense to split it out so it's easy to maintain
+# in one place.
+#
+# You can use this module to create simple parser/generator classes.  For instance,
+# the following parser should go most of the way to parsing /etc/passwd:
+#
+#   class Parser
+#       include Puppet::Util::FileParsing
+#       record_line :user, :fields => %w{name password uid gid gecos home shell},
+#           :separator => ":"
+#   end
+#
+# You would use it like this:
+#
+#   parser = Parser.new
+#   lines = parser.parse(File.read("/etc/passwd"))
+#
+#   lines.each do |type, hash| # type will always be :user, since we only have one
+#       p hash
+#   end
+#
+# Each line in this case would be a hash, with each field set appropriately.
+# You could then call 'parser.to_line(hash)' on any of those hashes to generate
+# the text line again.
+
+require 'puppet/util/methodhelper'
+
+module Puppet::Util::FileParsing
+  include Puppet::Util
+  attr_writer :line_separator, :trailing_separator
+
+  class FileRecord
+    include Puppet::Util
+    include Puppet::Util::MethodHelper
+    attr_accessor :absent, :joiner, :rts, :separator, :rollup, :name, :match, :block_eval
+
+    attr_reader :fields, :optional, :type
+
+    INVALID_FIELDS = [:record_type, :target, :on_disk]
+
+    # Customize this so we can do a bit of validation.
+    def fields=(fields)
+      @fields = fields.collect do |field|
+        r = field.intern
+        raise ArgumentError.new("Cannot have fields named #{r}") if INVALID_FIELDS.include?(r)
+        r
+      end
+    end
+
+    def initialize(type, options = {}, &block)
+      @type = type.intern
+      raise ArgumentError, "Invalid record type #{@type}" unless [:record, :text].include?(@type)
+
+      set_options(options)
+
+      if self.type == :record
+        # Now set defaults.
+        self.absent ||= ""
+        self.separator ||= /\s+/
+        self.joiner ||= " "
+        self.optional ||= []
+        @rollup = true unless defined?(@rollup)
+      end
+
+      if block_given?
+        @block_eval ||= :process
+
+        # Allow the developer to specify that a block should be instance-eval'ed.
+        if @block_eval == :instance
+          instance_eval(&block)
+        else
+          meta_def(@block_eval, &block)
+        end
+      end
+    end
+
+    # Convert a record into a line by joining the fields together appropriately.
+    # This is pulled into a separate method so it can be called by the hooks.
+    def join(details)
+      joinchar = self.joiner
+
+      fields.collect { |field|
+        # If the field is marked absent, use the appropriate replacement
+        if details[field] == :absent or details[field] == [:absent] or details[field].nil?
+          if self.optional.include?(field)
+            self.absent
+          else
+            raise ArgumentError, "Field '#{field}' is required"
+          end
+        else
+          details[field].to_s
+        end
+      }.reject { |c| c.nil?}.join(joinchar)
+    end
+
+    # Customize this so we can do a bit of validation.
+    def optional=(optional)
+      @optional = optional.collect do |field|
+        field.intern
+      end
+    end
+
+    # Create a hook that modifies the hash resulting from parsing.
+    def post_parse=(block)
+      meta_def(:post_parse, &block)
+    end
+
+    # Create a hook that modifies the hash just prior to generation.
+    def pre_gen=(block)
+      meta_def(:pre_gen, &block)
+    end
+
+    # Are we a text type?
+    def text?
+      type == :text
+    end
+
+    def to_line=(block)
+      meta_def(:to_line, &block)
+    end
+  end
+
+  # Clear all existing record definitions.  Only used for testing.
+  def clear_records
+    @record_types.clear
+    @record_order.clear
+  end
+
+  def fields(type)
+    if record = record_type(type)
+      record.fields.dup
+    else
+      nil
+    end
+  end
+
+  # Try to match a specific text line.
+  def handle_text_line(line, record)
+    line =~ record.match ? {:record_type => record.name, :line => line} : nil
+  end
+
+  # Try to match a record.
+  def handle_record_line(line, record)
+    ret = nil
+    if record.respond_to?(:process)
+      if ret = record.send(:process, line.dup)
+        unless ret.is_a?(Hash)
+          raise Puppet::DevError,
+            "Process record type #{record.name} returned non-hash"
+        end
+      else
+        return nil
+      end
+    elsif regex = record.match
+      # In this case, we try to match the whole line and then use the
+      # match captures to get our fields.
+      if match = regex.match(line)
+        fields = []
+        ret = {}
+        record.fields.zip(match.captures).each do |field, value|
+          if value == record.absent
+            ret[field] = :absent
+          else
+            ret[field] = value
+          end
+        end
+      else
+        nil
+      end
+    else
+      ret = {}
+      sep = record.separator
+
+      # String "helpfully" replaces ' ' with /\s+/ in splitting, so we
+      # have to work around it.
+      if sep == " "
+        sep = / /
+      end
+      line_fields = line.split(sep)
+      record.fields.each do |param|
+        value = line_fields.shift
+        if value and value != record.absent
+          ret[param] = value
+        else
+          ret[param] = :absent
+        end
+      end
+
+      if record.rollup and ! line_fields.empty?
+        last_field = record.fields[-1]
+        val = ([ret[last_field]] + line_fields).join(record.joiner)
+        ret[last_field] = val
+      end
+    end
+
+    if ret
+      ret[:record_type] = record.name
+      return ret
+    else
+      return nil
+    end
+  end
+
+  def line_separator
+    @line_separator ||= "\n"
+
+    @line_separator
+  end
+
+  # Split text into separate lines using the record separator.
+  def lines(text)
+    # Remove any trailing separators, and then split based on them
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = text.sub(/#{self.line_separator}\Q/,'').split(self.line_separator)
+  end
+
+  # Split a bunch of text into lines and then parse them individually.
+  def parse(text)
+    count = 1
+    lines(text).collect do |line|
+      count += 1
+      if val = parse_line(line)
+        val
+      else
+        error = Puppet::Error.new("Could not parse line #{line.inspect}")
+        error.line = count
+        raise error
+      end
+    end
+  end
+
+  # Handle parsing a single line.
+  def parse_line(line)
+    raise Puppet::DevError, "No record types defined; cannot parse lines" unless records?
+
+    @record_order.each do |record|
+      # These are basically either text or record lines.
+      method = "handle_#{record.type}_line"
+      if respond_to?(method)
+        if result = send(method, line, record)
+          record.send(:post_parse, result) if record.respond_to?(:post_parse)
+          return result
+        end
+      else
+        raise Puppet::DevError,
+          "Somehow got invalid line type #{record.type}"
+      end
+    end
+
+    nil
+  end
+
+  # Define a new type of record.  These lines get split into hashes.  Valid
+  # options are:
+  # * <tt>:absent</tt>: What to use as value within a line, when a field is
+  #   absent.  Note that in the record object, the literal :absent symbol is
+  #   used, and not this value.  Defaults to "".
+  # * <tt>:fields</tt>: The list of fields, as an array.  By default, all
+  #   fields are considered required.
+  # * <tt>:joiner</tt>: How to join fields together.  Defaults to '\t'.
+  # * <tt>:optional</tt>: Which fields are optional.  If these are missing,
+  #   you'll just get the 'absent' value instead of an ArgumentError.
+  # * <tt>:rts</tt>: Whether to remove trailing whitespace.  Defaults to false.
+  #   If true, whitespace will be removed; if a regex, then whatever matches
+  #   the regex will be removed.
+  # * <tt>:separator</tt>: The record separator.  Defaults to /\s+/.
+  def record_line(name, options, &block)
+    raise ArgumentError, "Must include a list of fields" unless options.include?(:fields)
+
+    record = FileRecord.new(:record, options, &block)
+    record.name = name.intern
+
+    new_line_type(record)
+  end
+
+  # Are there any record types defined?
+  def records?
+    defined?(@record_types) and ! @record_types.empty?
+  end
+
+  # Define a new type of text record.
+  def text_line(name, options, &block)
+    raise ArgumentError, "You must provide a :match regex for text lines" unless options.include?(:match)
+
+    record = FileRecord.new(:text, options, &block)
+    record.name = name.intern
+
+    new_line_type(record)
+  end
+
+  # Generate a file from a bunch of hash records.
+  def to_file(records)
+    text = records.collect { |record| to_line(record) }.join(line_separator)
+
+    text += line_separator if trailing_separator
+
+    text
+  end
+
+  # Convert our parsed record into a text record.
+  def to_line(details)
+    unless record = record_type(details[:record_type])
+      raise ArgumentError, "Invalid record type #{details[:record_type].inspect}"
+    end
+
+    if record.respond_to?(:pre_gen)
+      details = details.dup
+      record.send(:pre_gen, details)
+    end
+
+    case record.type
+    when :text; return details[:line]
+    else
+      return record.to_line(details) if record.respond_to?(:to_line)
+
+      line = record.join(details)
+
+      if regex = record.rts
+        # If they say true, then use whitespace; else, use their regex.
+        if regex == true
+          regex = /\s+$/
+        end
+        return line.sub(regex,'')
+      else
+        return line
+      end
+    end
+  end
+
+  # Whether to add a trailing separator to the file.  Defaults to true
+  def trailing_separator
+    if defined?(@trailing_separator)
+      return @trailing_separator
+    else
+      return true
+    end
+  end
+
+  def valid_attr?(type, attr)
+    type = type.intern
+    if record = record_type(type) and record.fields.include?(attr.intern)
+      return true
+    else
+      if attr.intern == :ensure
+        return true
+      else
+        false
+      end
+    end
+  end
+
+  private
+
+  # Define a new type of record.
+  def new_line_type(record)
+    @record_types ||= {}
+    @record_order ||= []
+
+    raise ArgumentError, "Line type #{record.name} is already defined" if @record_types.include?(record.name)
+
+    @record_types[record.name] = record
+    @record_order << record
+
+    record
+  end
+
+  # Retrieve the record object.
+  def record_type(type)
+    @record_types[type.intern]
+  end
+end
+

data/lib/vendor/puppet/util/filetype.rb

@@ -0,0 +1,296 @@
+# Basic classes for reading, writing, and emptying files.  Not much
+# to see here.
+
+require 'puppet/util/selinux'
+require 'tempfile'
+require 'fileutils'
+
+class Puppet::Util::FileType
+  attr_accessor :loaded, :path, :synced
+
+  include Puppet::Util::SELinux
+
+  class << self
+    attr_accessor :name
+    include Puppet::Util::ClassGen
+  end
+
+  # Create a new filetype.
+  def self.newfiletype(name, &block)
+    @filetypes ||= {}
+
+    klass = genclass(
+      name,
+      :block => block,
+      :prefix => "FileType",
+      :hash => @filetypes
+    )
+
+    # Rename the read and write methods, so that we're sure they
+    # maintain the stats.
+    klass.class_eval do
+      # Rename the read method
+      define_method(:real_read, instance_method(:read))
+      define_method(:read) do
+        begin
+          val = real_read
+          @loaded = Time.now
+          if val
+            return val.gsub(/# HEADER.*\n/,'')
+          else
+            return ""
+          end
+        rescue Puppet::Error => detail
+          raise
+        rescue => detail
+          puts detail.backtrace if Puppet[:trace]
+          raise Puppet::Error, "#{self.class} could not read #{@path}: #{detail}"
+        end
+      end
+
+      # And then the write method
+      define_method(:real_write, instance_method(:write))
+      define_method(:write) do |text|
+        begin
+          val = real_write(text)
+          @synced = Time.now
+          return val
+        rescue Puppet::Error => detail
+          raise
+        rescue => detail
+          puts detail.backtrace if Puppet[:debug]
+          raise Puppet::Error, "#{self.class} could not write #{@path}: #{detail}"
+        end
+      end
+    end
+  end
+
+  def self.filetype(type)
+    @filetypes[type]
+  end
+
+  # Pick or create a filebucket to use.
+  def bucket
+    @bucket ||= Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
+  end
+
+  def initialize(path)
+    raise ArgumentError.new("Path is nil") if path.nil?
+    @path = path
+  end
+
+  # Arguments that will be passed to the execute method. Will set the uid
+  # to the target user if the target user and the current user are not
+  # the same
+  def cronargs
+    if uid = Puppet::Util.uid(@path) and uid == Puppet::Util::SUIDManager.uid
+      {:failonfail => true, :combine => true}
+    else
+      {:failonfail => true, :combine => true, :uid => @path}
+    end
+  end
+
+  # Operate on plain files.
+  newfiletype(:flat) do
+    # Back the file up before replacing it.
+    def backup
+      bucket.backup(@path) if File.exists?(@path)
+    end
+
+    # Read the file.
+    def read
+      if File.exist?(@path)
+        File.read(@path)
+      else
+        return nil
+      end
+    end
+
+    # Remove the file.
+    def remove
+      File.unlink(@path) if File.exist?(@path)
+    end
+
+    # Overwrite the file.
+    def write(text)
+      tf = Tempfile.new("puppet")
+      tf.print text; tf.flush
+      FileUtils.cp(tf.path, @path)
+      tf.close
+      # If SELinux is present, we need to ensure the file has its expected context
+      set_selinux_default_context(@path)
+    end
+  end
+
+  # Operate on plain files.
+  newfiletype(:ram) do
+    @@tabs = {}
+
+    def self.clear
+      @@tabs.clear
+    end
+
+    def initialize(path)
+      super
+      @@tabs[@path] ||= ""
+    end
+
+    # Read the file.
+    def read
+      Puppet.info "Reading #{@path} from RAM"
+      @@tabs[@path]
+    end
+
+    # Remove the file.
+    def remove
+      Puppet.info "Removing #{@path} from RAM"
+      @@tabs[@path] = ""
+    end
+
+    # Overwrite the file.
+    def write(text)
+      Puppet.info "Writing #{@path} to RAM"
+      @@tabs[@path] = text
+    end
+  end
+
+  # Handle Linux-style cron tabs.
+  newfiletype(:crontab) do
+    def initialize(user)
+      self.path = user
+    end
+
+    def path=(user)
+      begin
+        @uid = Puppet::Util.uid(user)
+      rescue Puppet::Error => detail
+        raise Puppet::Error, "Could not retrieve user #{user}: #{detail}", detail.backtrace
+      end
+
+      # XXX We have to have the user name, not the uid, because some
+      # systems *cough*linux*cough* require it that way
+      @path = user
+    end
+
+    # Read a specific @path's cron tab.
+    def read
+      %x{#{cmdbase} -l 2>/dev/null}
+    end
+
+    # Remove a specific @path's cron tab.
+    def remove
+      if %w{Darwin FreeBSD}.include?(Facter.value("operatingsystem"))
+        %x{/bin/echo yes | #{cmdbase} -r 2>/dev/null}
+      else
+        %x{#{cmdbase} -r 2>/dev/null}
+      end
+    end
+
+    # Overwrite a specific @path's cron tab; must be passed the @path name
+    # and the text with which to create the cron tab.
+    def write(text)
+      IO.popen("#{cmdbase()} -", "w") { |p|
+        p.print text
+      }
+    end
+
+    private
+
+    # Only add the -u flag when the @path is different.  Fedora apparently
+    # does not think I should be allowed to set the @path to my own user name
+    def cmdbase
+      cmd = nil
+      if @uid == Puppet::Util::SUIDManager.uid || Facter.value(:operatingsystem) == "HP-UX"
+        return "crontab"
+      else
+        return "crontab -u #{@path}"
+      end
+    end
+  end
+
+  # SunOS has completely different cron commands; this class implements
+  # its versions.
+  newfiletype(:suntab) do
+    # Read a specific @path's cron tab.
+    def read
+      Puppet::Util.execute(%w{crontab -l}, cronargs)
+    rescue => detail
+      case detail.to_s
+      when /can't open your crontab/
+        return ""
+      when /you are not authorized to use cron/
+        raise Puppet::Error, "User #{@path} not authorized to use cron", detail.backtrace
+      else
+        raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}", detail.backtrace
+      end
+    end
+
+    # Remove a specific @path's cron tab.
+    def remove
+      Puppet::Util.execute(%w{crontab -r}, cronargs)
+    rescue => detail
+      raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
+    end
+
+    # Overwrite a specific @path's cron tab; must be passed the @path name
+    # and the text with which to create the cron tab.
+    def write(text)
+      output_file = Tempfile.new("puppet_suntab")
+      begin
+        output_file.print text
+        output_file.close
+        # We have to chown the stupid file to the user.
+        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
+        Puppet::Util.execute(["crontab", output_file.path], cronargs)
+      rescue => detail
+        raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
+      ensure
+        output_file.close
+        output_file.unlink
+      end
+    end
+  end
+
+  #  Support for AIX crontab with output different than suntab's crontab command.
+  newfiletype(:aixtab) do
+    # Read a specific @path's cron tab.
+    def read
+      Puppet::Util.execute(%w{crontab -l}, cronargs)
+    rescue => detail
+      case detail.to_s
+      when /Cannot open a file in the .* directory/
+        return ""
+      when /You are not authorized to use the cron command/
+        raise Puppet::Error, "User #{@path} not authorized to use cron", detail.backtrace
+      else
+        raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}", detail.backtrace
+      end
+    end
+
+    # Remove a specific @path's cron tab.
+    def remove
+      Puppet::Util.execute(%w{crontab -r}, cronargs)
+    rescue => detail
+      raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
+    end
+
+    # Overwrite a specific @path's cron tab; must be passed the @path name
+    # and the text with which to create the cron tab.
+    def write(text)
+      output_file = Tempfile.new("puppet_aixtab")
+
+      begin
+        output_file.print text
+        output_file.close
+        # We have to chown the stupid file to the user.
+        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
+        Puppet::Util.execute(["crontab", output_file.path], cronargs)
+      rescue => detail
+        raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
+      ensure
+        output_file.close
+        output_file.unlink
+      end
+    end
+  end
+end

data/lib/vendor/puppet/util/graph.rb

@@ -0,0 +1,27 @@
+require 'puppet'
+require 'puppet/simple_graph'
+
+# A module that handles the small amount of graph stuff in Puppet.
+module Puppet::Util::Graph
+  # Make a graph where each of our children gets converted to
+  # the receiving end of an edge.  Call the same thing on all
+  # of our children, optionally using a block
+  def to_graph(graph = nil, &block)
+    # Allow our calling function to send in a graph, so that we
+    # can call this recursively with one graph.
+    graph ||= Puppet::SimpleGraph.new
+
+    self.each do |child|
+      unless block_given? and ! yield(child)
+        graph.add_edge(self, child)
+
+        child.to_graph(graph, &block) if child.respond_to?(:to_graph)
+      end
+    end
+
+    # Do a topsort, which will throw an exception if the graph is cyclic.
+
+    graph
+  end
+end
+