puppet 0.13.6 → 0.16.0

data/lib/puppet/config.rb

@@ -95,6 +95,11 @@ class Config
         @used = []
     end
 
+    # This is mostly just used for testing.
+    def clearused
+        @used = []
+    end
+
     def symbolize(param)
         case param
         when String: return param.intern
@@ -174,6 +179,23 @@ class Config
         @created = []
     end
 
+    # Make a directory with the appropriate user, group, and mode
+    def mkdir(default)
+        obj = nil
+        unless obj = @config[default]
+            raise ArgumentError, "Unknown default %s" % default
+        end
+
+        unless obj.is_a? CFile
+            raise ArgumentError, "Default %s is not a file" % default
+        end
+
+        Puppet::Util.asuser(obj.owner, obj.group) do
+            mode = obj.mode || 0750
+            Dir.mkdir(obj.value, mode)
+        end
+    end
+
     # Return all of the parameters associated with a given section.
     def params(section)
         section = section.intern if section.is_a? String
@@ -222,6 +244,14 @@ class Config
                         values[section] = {}
                     end
                     values[section][var.to_s] = value
+
+                    # Do some annoying skullduggery here.  This is so that
+                    # the group can be set in the config file.  The problem
+                    # is that we're using the word 'group' twice, which is
+                    # confusing.
+                    if var == :group and section == Puppet.name and @config.include?(:group)
+                        @config[:group].value = value
+                    end
                     next
                 end
 
@@ -263,7 +293,7 @@ class Config
         when String, Integer, Float: # nothing
             klass = CElement
         else
-            raise Puppet::Error, "Invalid value '%s' for %s" % [value, hash[:name]]
+            raise Puppet::Error, "Invalid value '%s' for %s" % [value.inspect, hash[:name]]
         end
         element = klass.new(hash)
         element.parent = self
@@ -504,6 +534,74 @@ Generated on #{Time.now}.
         @config.has_key?(param)
     end
 
+    # Open a file with the appropriate user, group, and mode
+    def write(default, *args)
+        obj = nil
+        unless obj = @config[default]
+            raise ArgumentError, "Unknown default %s" % default
+        end
+
+        unless obj.is_a? CFile
+            raise ArgumentError, "Default %s is not a file" % default
+        end
+
+        chown = nil
+        if Process.uid == 0
+            chown = [obj.owner, obj.group]
+        else
+            chown = [nil, nil]
+        end
+        Puppet::Util.asuser(*chown) do
+            mode = obj.mode || 0640
+
+            if args.empty?
+                args << "w"
+            end
+
+            args << mode
+
+            File.open(obj.value, *args) do |file|
+                yield file
+            end
+        end
+    end
+
+    # Open a non-default file under a default dir with the appropriate user,
+    # group, and mode
+    def writesub(default, file, *args)
+        obj = nil
+        unless obj = @config[default]
+            raise ArgumentError, "Unknown default %s" % default
+        end
+
+        unless obj.is_a? CFile
+            raise ArgumentError, "Default %s is not a file" % default
+        end
+
+        chown = nil
+        if Process.uid == 0
+            chown = [obj.owner, obj.group]
+        else
+            chown = [nil, nil]
+        end
+
+        Puppet::Util.asuser(*chown) do
+            mode = obj.mode || 0640
+            if args.empty?
+                args << "w"
+            end
+
+            args << mode
+
+            # Update the umask to make non-executable files
+            Puppet::Util.withumask(File.umask ^ 0111) do
+                File.open(file, *args) do |file|
+                    yield file
+                end
+            end
+        end
+    end
+
     # The base element type.
     class CElement
         attr_accessor :name, :section, :default, :parent, :setbycli
@@ -685,15 +783,24 @@ Generated on #{Time.now}.
             if type == :directory or self.create
                 obj[:ensure] = type
             end
-            [:group, :mode].each { |var|
+            [:mode].each { |var|
                 if value = self.send(var)
-                    obj[var] = value
+                    obj[var] = "%o" % value
                 end
             }
 
-            if Process.uid == 0 and value = self.send(:owner)
-                obj[:owner] = value
+            # Only chown or chgrp when root
+            if Process.uid == 0
+                [:group, :owner].each { |var|
+                    if value = self.send(var)
+                        obj[var] = value
+                    end
+                }
             end
+
+            # And set the loglevel to debug for everything
+            obj[:loglevel] = "debug"
+
             if self.section
                 obj.tags = ["puppet", "configuration", self.section]
             end
@@ -728,4 +835,4 @@ Generated on #{Time.now}.
 end
 end
 
-# $Id: config.rb 967 2006-03-02 20:28:45Z luke $
+# $Id: config.rb 1111 2006-04-12 17:36:14Z luke $

data/lib/puppet/element.rb

@@ -52,8 +52,6 @@ class Puppet::Element
                 if self.name == "puppet[top]"
                     @path = ["/"]
                 else
-                    # We assume that if we don't have a parent that we should not
-                    # cache the path
                     if self.is_a?(Puppet.type(:component))
                         @path = [self.name]
                     else
@@ -68,4 +66,4 @@ class Puppet::Element
 
 end
 
-# $Id: element.rb 787 2006-01-08 00:02:23Z luke $
+# $Id: element.rb 980 2006-03-03 23:06:40Z luke $

data/lib/puppet/event.rb

@@ -77,12 +77,13 @@ module Puppet
 
             # Trigger the subscriptions related to an event, and then pass it up
             # as appropriate
-            def self.trigger(source, event, transaction)
+            def self.trigger(source, event)
                 type, name = self.split(source)
 
                 @subscriptions[type][name].each { |sub|
                     if sub.match?(event)
-                        sub.trigger(transaction)
+                        yield sub
+                        #sub.trigger(transaction)
                     end
                 }
             end
@@ -211,26 +212,14 @@ module Puppet
                     target = self.target
                     #Puppet.debug "'%s' matched '%s'; triggering '%s' on '%s'" %
                     #    [@source,@event,@method,target]
-                    begin
-                        if target.respond_to?(@callback)
-                            target.log "triggering %s" % @callback
-                            event = target.send(@callback)
-                        else
-                            Puppet.debug(   
-                                "'%s' of type '%s' does not respond to '%s'" %
-                                [target,target.class,@callback.inspect]
-                            )
-                        end
-                    rescue => detail
-                        # um, what the heck do i do when an object fails to
-                        # refresh?  shouldn't that result in the transaction
-                        # rolling back?  the 'onerror' metaparam will be used
-                        # to determine behaviour in that case
-                        Puppet.err "'%s' failed to %s: '%s'" %
-                            [target,@callback,detail]
-                        raise
-                        #raise "We need to roll '%s' transaction back" %
-                            #transaction
+                    if target.respond_to?(@callback)
+                        target.log "triggering %s" % @callback
+                        event = target.send(@callback)
+                    else
+                        Puppet.debug(   
+                            "'%s' of type '%s' does not respond to '%s'" %
+                            [target,target.class,@callback.inspect]
+                        )
                     end
                     transaction.triggered(target, @callback)
                 end
@@ -261,4 +250,4 @@ module Puppet
 	end
 end
 
-# $Id: event.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: event.rb 998 2006-03-09 20:46:55Z luke $

data/lib/puppet/filetype.rb

@@ -119,19 +119,19 @@ module Puppet
 
             # Read the file.
             def read
-                Puppet.info "Reading %s" % @path
+                Puppet.info "Reading %s from RAM" % @path
                 @text
             end
 
             # Remove the file.
             def remove
-                Puppet.info "Removing %s" % @path
+                Puppet.info "Removing %s from RAM" % @path
                 @text = ""
             end
 
             # Overwrite the file.
             def write(text)
-                Puppet.info "Writing %s" % @path
+                Puppet.info "Writing %s to RAM" % @path
                 @text = text
             end
         end
@@ -156,7 +156,9 @@ module Puppet
                     raise Puppet::Error, "Could not retrieve user %s" % user
                 end
 
-                @path = uid
+                # 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.
@@ -205,7 +207,93 @@ module Puppet
                 }
             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 910 2006-02-15 07:20:36Z luke $
+# $Id: filetype.rb 1125 2006-04-20 19:38:48Z luke $

data/lib/puppet/inifile.rb

@@ -0,0 +1,201 @@
+# 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