puppet 0.18.4 → 0.22.4

data/lib/puppet/util/filetype.rb

@@ -0,0 +1,300 @@
+# Basic classes for reading, writing, and emptying files.  Not much
+# to see here.
+class Puppet::Util::FileType
+    attr_accessor :loaded, :path, :synced
+
+    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
+                    if Puppet[:trace]
+                        puts detail.backtrace
+                    end
+                    raise Puppet::Error, "%s could not read %s: %s" %
+                        [self.class, @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
+                    if Puppet[:debug]
+                        puts detail.backtrace
+                    end
+                    raise Puppet::Error, "%s could not write %s: %s" %
+                        [self.class, @path, detail]
+                end
+            end
+        end
+    end
+
+    def self.filetype(type)
+        @filetypes[type]
+    end
+
+    def initialize(path)
+        @path = path
+    end
+
+    # Operate on plain files.
+    newfiletype(:flat) do
+        # Read the file.
+        def read
+            if File.exists?(@path)
+                File.read(@path)
+            else
+                return nil
+            end
+        end
+
+        # Remove the file.
+        def remove
+            if File.exists?(@path)
+                File.unlink(@path)
+            end
+        end
+
+        # Overwrite the file.
+        def write(text)
+            File.open(@path, "w") { |f| f.print text; f.flush }
+        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 %s from RAM" % @path
+            @@tabs[@path]
+        end
+
+        # Remove the file.
+        def remove
+            Puppet.info "Removing %s from RAM" % @path
+            @@tabs[@path] = ""
+        end
+
+        # Overwrite the file.
+        def write(text)
+            Puppet.info "Writing %s to RAM" % @path
+            @@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 %s" % user
+            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 Facter.value("operatingsystem") == "FreeBSD"
+                %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
+                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::SUIDManager.asuser(@path) {
+                %x{crontab -l 2>/dev/null}
+            }
+        end
+
+        # Remove a specific @path's cron tab.
+        def remove
+            Puppet::Util::SUIDManager.asuser(@path) {
+                %x{crontab -r 2>/dev/null}
+            }
+        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)
+            Puppet::Util::SUIDManager.asuser(@path) {
+                IO.popen("crontab", "w") { |p|
+                    p.print text
+                }
+            }
+        end
+    end
+
+    # Treat netinfo tables as a single file, just for simplicity of certain
+    # types
+    newfiletype(:netinfo) do
+        class << self
+            attr_accessor :format
+        end
+        def read
+            %x{nidump -r /#{@path} /}
+        end
+
+        # This really only makes sense for cron tabs.
+        def remove
+            %x{nireport / /#{@path} name}.split("\n").each do |name|
+                newname = name.gsub(/\//, '\/').sub(/\s+$/, '')
+                output = %x{niutil -destroy / '/#{@path}/#{newname}'}
+
+                unless $? == 0
+                    raise Puppet::Error, "Could not remove %s from %s" %
+                        [name, @path]
+                end
+            end
+        end
+
+        # Convert our table to an array of hashes.  This only works for
+        # handling one table at a time.
+        def to_array(text = nil)
+            unless text
+                text = read
+            end
+
+            hash = nil
+
+            # Initialize it with the first record
+            records = []
+            text.split("\n").each do |line|
+                next if line =~ /^[{}]$/ # Skip the wrapping lines
+                next if line =~ /"name" = \( "#{@path}" \)/ # Skip the table name
+                next if line =~ /CHILDREN = \(/ # Skip this header
+                next if line =~ /^  \)/ # and its closer
+
+                # Now we should have nothing but records, wrapped in braces
+
+                case line
+                when /^\s+\{/: hash = {}
+                when /^\s+\}/: records << hash
+                when /\s+"(\w+)" = \( (.+) \)/
+                    field = $1
+                    values = $2
+
+                    # Always use an array
+                    hash[field] = []
+
+                    values.split(/, /).each do |value|
+                        if value =~ /^"(.*)"$/
+                            hash[field] << $1
+                        else
+                            raise ArgumentError, "Could not match value %s" % value
+                        end
+                    end
+                else    
+                    raise ArgumentError, "Could not match line %s" % line
+                end
+            end
+
+            records
+        end
+
+        def write(text)
+            text.gsub!(/^#.*\n/,'')
+            text.gsub!(/^$/,'')
+            if text == "" or text == "\n"
+                self.remove
+                return
+            end
+            unless format = self.class.format
+                raise Puppe::DevError, "You must define the NetInfo format to inport"
+            end
+            IO.popen("niload -d #{format} . 1>/dev/null 2>/dev/null", "w") { |p|
+                p.print text
+            }
+
+            unless $? == 0
+                raise ArgumentError, "Failed to write %s" % @path
+            end
+        end
+    end
+end
+
+# $Id: filetype.rb 2178 2007-02-07 23:56:59Z luke $

data/lib/puppet/util/graph.rb

@@ -0,0 +1,39 @@
+#  Created by Luke Kanies on 2006-11-16.
+#  Copyright (c) 2006. All rights reserved.
+
+require 'puppet'
+require 'puppet/pgraph'
+
+# 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::PGraph.new
+        
+        self.each do |child|
+            unless block_given? and ! yield(child)
+                graph.add_edge!(self, child)
+
+                if graph.cyclic?
+                    raise Puppet::Error, "%s created a cyclic graph" % self
+                end
+                
+                if child.respond_to?(:to_graph)
+                    child.to_graph(graph, &block)
+                end
+            end
+        end
+        
+        if graph.cyclic?
+            raise Puppet::Error, "%s created a cyclic graph" % self
+        end
+        
+        graph
+    end
+end
+
+# $Id: graph.rb 2009 2007-01-01 21:08:45Z luke $

data/lib/puppet/util/inifile.rb

@@ -0,0 +1,209 @@
+# Module Puppet::IniConfig
+# A generic way to parse .ini style files and manipulate them in memory
+# One 'file' can be made up of several physical files. Changes to sections
+# on the file are tracked so that only the physical files in which
+# something has changed are written back to disk
+# Great care is taken to preserve comments and blank lines from the original
+# files
+# 
+# The parsing tries to stay close to python's ConfigParser
+
+require 'puppet/util/filetype'
+
+module Puppet::Util::IniConfig
+    # A section in a .ini file
+    class Section
+        attr_reader :name, :file
+
+        def initialize(name, file)
+            @name = name
+            @file = file
+            @dirty = false
+            @entries = []
+        end
+
+        # Has this section been modified since it's been read in
+        # or written back to disk
+        def dirty?
+            @dirty
+        end
+
+        # Should only be used internally
+        def mark_clean
+            @dirty = false
+        end
+
+        # Add a line of text (e.g., a comment) Such lines
+        # will be written back out in exactly the same
+        # place they were read in
+        def add_line(line)
+            @entries << line
+        end
+
+        # Set the entry 'key=value'. If no entry with the
+        # given key exists, one is appended to teh end of the section
+        def []=(key, value)
+            entry = find_entry(key)
+            @dirty = true
+            if entry.nil?
+                @entries << [key, value]
+            else
+                entry[1] = value
+            end
+        end
+
+        # Return the value associated with KEY. If no such entry
+        # exists, return nil
+        def [](key)
+            entry = find_entry(key)
+            if entry.nil?
+                return nil
+            end
+            return entry[1]
+        end
+
+        # Format the section as text in the way it should be
+        # written to file
+        def format
+            text = "[#{name}]\n"
+            @entries.each do |entry|
+                if entry.is_a?(Array)
+                    key, value = entry
+                    unless value.nil?
+                        text << "#{key}=#{value}\n"
+                    end
+                else
+                    text << entry
+                end
+            end
+            return text
+        end
+
+        private 
+        def find_entry(key)
+            @entries.each do |entry|
+                if entry.is_a?(Array) && entry[0] == key
+                    return entry
+                end
+            end
+            return nil
+        end
+        
+    end
+
+    # A logical .ini-file that can be spread across several physical
+    # files. For each physical file, call #read with the filename
+    class File
+        def initialize
+            @files = {}
+        end
+
+        # Add the contents of the file with name FILE to the
+        # already existing sections
+        def read(file)
+            text = Puppet::Util::FileType.filetype(:flat).new(file).read
+            if text.nil?
+                raise "Could not find #{file}"
+            end
+
+            section = nil   # The name of the current section
+            optname = nil   # The name of the last option in section
+            line = 0
+            @files[file] = []
+            text.each_line do |l|
+                line += 1
+                if l.strip.empty? || "#;".include?(l[0,1]) ||
+                        (l.split(nil, 2)[0].downcase == "rem" && 
+                         l[0,1].downcase == "r")
+                    # Whitespace or comment
+                    if section.nil?
+                        @files[file] << l
+                    else
+                        section.add_line(l)
+                    end
+                elsif " \t\r\n\f".include?(l[0,1]) && section && optname
+                    # continuation line
+                    section[optname] += "\n" + l.chomp
+                elsif l =~ /^\[([^\]]+)\]/
+                    # section heading
+                    section.mark_clean unless section.nil?
+                    section = add_section($1, file)
+                    optname = nil
+                elsif l =~ /^\s*([^\s=]+)\s*\=(.*)$/
+                    # We allow space around the keys, but not the values
+                    # For the values, we don't know if space is significant
+                    if section.nil?
+                        raise "#{file}:#{line}:Key/value pair outside of a section for key #{$1}"
+                    else
+                        section[$1] = $2
+                        optname = $1
+                    end
+                else
+                    raise "#{file}:#{line}: Can't parse '#{l.chomp}'"
+                end
+            end
+            section.mark_clean unless section.nil?
+        end
+
+        # Store all modifications made to sections in this file back
+        # to the physical files. If no modifications were made to 
+        # a physical file, nothing is written
+        def store
+            @files.each do |file, lines|
+                text = ""
+                dirty = false
+                lines.each do |l|
+                    if l.is_a?(Section)
+                        dirty ||= l.dirty?
+                        text << l.format
+                        l.mark_clean
+                    else
+                        text << l
+                    end
+                end
+                if dirty
+                    Puppet::Util::FileType.filetype(:flat).new(file).write(text)
+                end
+            end
+        end
+
+        # Execute BLOCK, passing each section in this file
+        # as an argument
+        def each_section(&block)
+            @files.each do |file, list|
+                list.each do |entry|
+                    if entry.is_a?(Section)
+                        yield(entry)
+                    end
+                end
+            end
+        end
+
+        # Return the Section with the given name or nil
+        def [](name)
+            name = name.to_s
+            each_section do |section|
+                return section if section.name == name
+            end
+            return nil
+        end
+
+        # Return true if the file contains a section with name NAME
+        def include?(name)
+            return ! self[name].nil?
+        end
+
+        # Add a section to be stored in FILE when store is called
+        def add_section(name, file)
+            if include?(name)
+                raise "A section with name #{name} already exists"
+            end
+            result = Section.new(name, file)
+            @files[file] ||= []
+            @files[file] << result
+            return result
+        end
+    end
+end
+
+# $Id: inifile.rb 2218 2007-02-21 17:14:26Z lutter $