puppet 0.18.4 → 0.22.4

data/lib/puppet/client/runner.rb

@@ -1,17 +0,0 @@
-class Puppet::Client::Runner < Puppet::Client::ProxyClient
-    @drivername = :Runner
-
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::Runner
-    self.mkmethods
-
-    def initialize(hash = {})
-        if hash.include?(:Runner)
-            hash[:Runner] = Puppet::Server::Runner.new()
-        end
-
-        super(hash)
-    end
-end
-
-# $Id: runner.rb 1212 2006-05-18 20:41:54Z luke $

data/lib/puppet/client/status.rb

@@ -1,7 +0,0 @@
-class Puppet::Client::StatusClient < Puppet::Client::ProxyClient
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::ServerStatus
-    self.mkmethods
-end
-
-# $Id: status.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/event-loop.rb

@@ -1 +0,0 @@
-require "puppet/event-loop/event-loop"

data/lib/puppet/filetype.rb

@@ -1,308 +0,0 @@
-module Puppet
-    # Basic classes for reading, writing, and emptying files.  Not much
-    # to see here.
-    class FileType
-        attr_accessor :loaded, :path, :synced
-
-        class << self
-            attr_accessor :name
-        end
-
-        def self.inspect
-            "SvcType(#{self.name})"
-        end
-
-        def self.to_s
-            "SvcType(#{self.name})"
-        end
-
-        def svctype
-            self.class.name
-        end
-
-        def self.newfiletype(name, &block)
-            @filetypes ||= {}
-
-            klass = Class.new(self)
-
-            klass.name = name
-
-            klass.class_eval(&block)
-
-            const_set(name.to_s.capitalize, klass)
-
-            # 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[:debug]
-                            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
-
-            @filetypes[name] = klass
-        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)
-                begin
-                    uid = Puppet::Util.uid(user)
-                rescue Puppet::Error => detail
-                    raise Puppet::Error, "Could not retrieve user %s" % user
-                end
-
-                # 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
-                %x{#{cmdbase()} -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)
-                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
-            def cmdbase
-                cmd = nil
-                if @path == Process.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.asuser(@path) {
-                    %x{crontab -l 2>/dev/null}
-                }
-            end
-
-            # Remove a specific @path's cron tab.
-            def remove
-                Puppet::Util.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.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
-end
-
-# $Id: filetype.rb 1402 2006-07-18 15:35:15Z luke $

data/lib/puppet/inifile.rb

@@ -1,201 +0,0 @@
-# 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
-module Puppet
-    module 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::FileType.filetype(:flat).new(file).read
-                if text.nil?
-                    raise "Could not find #{file}"
-                end
-
-                section = nil
-                line = 0
-                @files[file] = []
-                text.each_line do |l|
-                    line += 1
-                    if l =~ /^\[(.+)\]$/
-                        section.mark_clean unless section.nil?
-                        section = add_section($1, file)
-                    elsif l =~ /^(\s*\#|\s*$)/
-                        if section.nil?
-                            @files[file] << l
-                        else
-                            section.add_line(l)
-                        end
-                    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
-                        end
-                    else
-                        # FIXME: We can't deal with continuation lines
-                        # that at least yum allows (lines that start with
-                        # whitespace, and that should really be appended
-                        # to the value of the previous key)
-                        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::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
-end