puppet 0.24.6 → 0.24.7

data/lib/puppet/type/user.rb

@@ -1,6 +1,7 @@
 require 'etc'
 require 'facter'
 require 'puppet/property/list'
+require 'puppet/property/ordered_list'
 require 'puppet/property/keyvalue'
 
 module Puppet
@@ -98,6 +99,16 @@ module Puppet
                 end
             end
 
+            def insync?(is)
+                # We know the 'is' is a number, so we need to convert the 'should' to a number,
+                # too.
+                @should.each do |value|
+                    return true if number = Puppet::Util.gid(value) and is == number
+                end
+
+                return false
+            end
+
             def sync
                 found = false
                 @should.each do |value|
@@ -109,6 +120,8 @@ module Puppet
                 end
 
                 fail "Could not find group(s) %s" % @should.join(",") unless found
+
+                # Use the default event.
             end
         end
 
@@ -266,6 +279,17 @@ module Puppet
             end
         end
 
+        #autorequire the roles that the user has
+        autorequire(:user) do
+            reqs = []
+
+            if roles_property = @parameters[:roles] and roles = roles_property.should
+                reqs += roles.split(',')
+            end
+
+            reqs
+        end
+
         newparam(:role_membership) do
             desc "Whether specified roles should be treated as the only roles
                 of which the user is a member or whether they should merely
@@ -304,7 +328,7 @@ module Puppet
             defaultto :minimum
         end
 
-        newproperty(:profiles, :parent => Puppet::Property::List, :required_features => :manages_solaris_rbac) do
+        newproperty(:profiles, :parent => Puppet::Property::OrderedList, :required_features => :manages_solaris_rbac) do
             desc "The profiles the user has.  Multiple profiles should be
                 specified as an array."
 

data/lib/puppet/type/zfs.rb

@@ -0,0 +1,51 @@
+module Puppet
+    newtype(:zfs) do
+        @doc = "Manage zfs. Create destroy and set properties on zfs instances."
+
+        ensurable
+
+        newparam(:name) do
+            desc "The full name for this filesystem. (including the zpool)"
+        end
+
+        newproperty(:mountpoint) do
+            desc "The mountpoint property."
+        end
+
+        newproperty(:compression) do
+            desc "The compression property."
+        end
+
+        newproperty(:copies) do
+            desc "The copies property."
+        end
+
+        newproperty(:quota) do
+            desc "The quota property."
+        end
+
+        newproperty(:reservation) do
+            desc "The reservation property."
+        end
+
+        newproperty(:sharenfs) do
+            desc "The sharenfs property."
+        end
+
+        newproperty(:snapdir) do
+            desc "The sharenfs property."
+        end
+
+        autorequire(:zpool) do
+            #strip the zpool off the zfs name and autorequire it
+            [@parameters[:name].value.split('/')[0]]
+        end
+
+        autorequire(:zfs) do
+            #slice and dice, we want all the zfs before this one
+            names = @parameters[:name].value.split('/')
+            names.slice(1..-2).inject([]) { |a,v| a << "#{a.last}/#{v}" }.collect { |fs| names[0] + fs }
+        end
+    end
+end
+

data/lib/puppet/type/zone.rb

@@ -357,6 +357,14 @@ end
         end
     end
 
+    newparam(:create_args) do
+        desc "Arguments to the zonecfg create command.  This can be used to create branded zones."
+    end
+    
+    newparam(:install_args) do
+        desc "Arguments to the zoneadm install command.  This can be used to create branded zones."
+    end
+
     newparam(:realhostname) do
         desc "The actual hostname of the zone."
     end

data/lib/puppet/type/zpool.rb

@@ -0,0 +1,93 @@
+module Puppet
+    class Property
+
+        class VDev < Property
+
+            def flatten_and_sort(array)
+                array.collect { |a| a.split(' ') }.flatten.sort
+            end
+
+            def insync?(is)
+                return true unless self.should
+
+                return @should == [:absent] if is == :absent
+
+                flatten_and_sort(is) == flatten_and_sort(@should)
+            end
+        end
+
+        class MultiVDev < VDev
+            def insync?(is)
+                return true unless self.should
+
+                return @should == [:absent] if is == :absent
+
+                return false unless is.length == @should.length
+
+                is.each_with_index { |list, i| return false unless flatten_and_sort(list) == flatten_and_sort(@should[i]) }
+
+                #if we made it this far we are in sync
+                true
+            end
+        end
+    end
+
+    newtype(:zpool) do
+        @doc = "Manage zpools. Create and delete zpools. The provider WILL NOT SYNC, only report differences.
+
+                Supports vdevs with mirrors, raidz, logs and spares."
+
+        ensurable
+
+        newproperty(:disk, :array_matching => :all, :parent => Puppet::Property::VDev) do
+            desc "The disk(s) for this pool. Can be an array or space separated string"
+        end
+
+        newproperty(:mirror, :array_matching => :all, :parent => Puppet::Property::MultiVDev) do
+            desc "List of all the devices to mirror for this pool. Each mirror should be a space separated string.
+                  mirror => [\"disk1 disk2\", \"disk3 disk4\"]"
+
+            validate do |value|
+                if value.include?(",")
+                    raise ArgumentError, "mirror names must be provided as string separated, not a comma-separated list"
+                end
+            end
+        end
+
+        newproperty(:raidz, :array_matching => :all, :parent => Puppet::Property::MultiVDev) do
+            desc "List of all the devices to raid for this pool. Should be an array of space separated strings.
+                  raidz => [\"disk1 disk2\", \"disk3 disk4\"]"
+
+            validate do |value|
+                if value.include?(",")
+                    raise ArgumentError, "raid names must be provided as string separated, not a comma-separated list"
+                end
+            end
+        end
+
+        newproperty(:spare, :array_matching => :all, :parent => Puppet::Property::VDev) do
+            desc "Spare disk(s) for this pool."
+        end
+
+        newproperty(:log, :array_matching => :all, :parent => Puppet::Property::VDev) do
+            desc "Log disks for this pool. (doesn't support mirroring yet)"
+        end
+
+        newparam(:pool) do
+            desc "The name for this pool."
+            isnamevar
+       end
+
+        newparam(:raid_parity) do
+            desc "Determines parity when using raidz property."
+        end
+
+        validate do
+            has_should = [:disk, :mirror, :raidz].select { |prop| self.should(prop) }
+            if has_should.length > 1
+                self.fail "You cannot specify %s on this type (only one)" % has_should.join(" and ")
+            end
+        end
+    end
+end
+

data/lib/puppet/util.rb

@@ -10,6 +10,8 @@ module Puppet
 module Util
     require 'benchmark'
     
+    # These are all for backward compatibility -- these are methods that used
+    # to be in Puppet::Util but have been moved into external modules.
     require 'puppet/util/posix'
     extend Puppet::Util::POSIX
 
@@ -66,40 +68,6 @@ module Util
         end
     end
 
-    # Create a shared lock for reading
-    def self.readlock(file)
-        self.sync(file).synchronize(Sync::SH) do
-            File.open(file) { |f|
-                f.lock_shared { |lf| yield lf }
-            }
-        end
-    end
-
-    # Create an exclusive lock for writing, and do the writing in a
-    # tmp file.
-    def self.writelock(file, mode = 0600)
-        tmpfile = file + ".tmp"
-        unless FileTest.directory?(File.dirname(tmpfile))
-            raise Puppet::DevError, "Cannot create %s; directory %s does not exist" %
-                [file, File.dirname(file)]
-        end
-        self.sync(file).synchronize(Sync::EX) do
-            File.open(file, "w", mode) do |rf|
-                rf.lock_exclusive do |lrf|
-                    File.open(tmpfile, "w", mode) do |tf|
-                        yield tf
-                    end
-                    begin
-                        File.rename(tmpfile, file)
-                    rescue => detail
-                        Puppet.err "Could not rename %s to %s: %s" %
-                            [file, tmpfile, detail]
-                    end
-                end
-            end
-        end
-    end
-
     # Create instance methods for each of the log levels.  This allows
     # the messages to be a little richer.  Most classes will be calling this
     # method.
@@ -268,7 +236,10 @@ module Util
 
     # Execute the desired command, and return the status and output.
     # def execute(command, failonfail = true, uid = nil, gid = nil)
-    def execute(command, arguments = {:failonfail => true})
+    # :combine sets whether or not to combine stdout/stderr in the output
+    # :stdinfile sets a file that can be used for stdin. Passing a string
+    # for stdin is not currently supported.
+    def execute(command, arguments = {:failonfail => true, :combine => true})
         if command.is_a?(Array)
             command = command.flatten.collect { |i| i.to_s }
             str = command.join(" ")
@@ -301,9 +272,13 @@ module Util
 
         # The idea here is to avoid IO#read whenever possible.
         output_file="/dev/null"
+        error_file="/dev/null"
         if ! arguments[:squelch]
             require "tempfile"
             output_file = Tempfile.new("puppet")
+            if arguments[:combine]
+                error_file=output_file
+            end
         end
 
         oldverb = $VERBOSE
@@ -317,9 +292,14 @@ module Util
             # Child process executes this
             Process.setsid
             begin
-                $stdin.reopen("/dev/null")
+                if arguments[:stdinfile]
+                    $stdin.reopen(arguments[:stdinfile])
+                else
+                    $stdin.reopen("/dev/null")
+                end
                 $stdout.reopen(output_file)
-                $stderr.reopen(output_file)
+                $stderr.reopen(error_file)
+
                 3.upto(256){|fd| IO::new(fd).close rescue nil} 
                 if arguments[:gid]
                     Process.egid = arguments[:gid]
@@ -461,4 +441,3 @@ require 'puppet/util/execution'
 require 'puppet/util/logging'
 require 'puppet/util/package'
 require 'puppet/util/warnings'
-

data/lib/puppet/util/file_locking.rb

@@ -0,0 +1,44 @@
+require 'puppet/util'
+
+module Puppet::Util::FileLocking
+    module_function
+
+    # Create a shared lock for reading
+    def readlock(file)
+        Puppet::Util.sync(file).synchronize(Sync::SH) do
+            File.open(file) { |f|
+                f.lock_shared { |lf| yield lf }
+            }
+        end
+    end
+
+    # Create an exclusive lock for writing, and do the writing in a
+    # tmp file.
+    def writelock(file, mode = nil)
+        unless FileTest.directory?(File.dirname(file))
+            raise Puppet::DevError, "Cannot create %s; directory %s does not exist" % [file, File.dirname(file)]
+        end
+        tmpfile = file + ".tmp"
+
+        unless mode
+            # It's far more likely that the file will be there than not, so it's
+            # better to stat once to check for existence and mode.
+            # If we can't stat, it's most likely because the file's not there,
+            # but could also be because the directory isn't readable, in which case
+            # we won't be able to write anyway.
+            begin
+                mode = File.stat(file).mode
+            rescue
+                mode = 0600
+            end
+        end
+
+        Puppet::Util.sync(file).synchronize(Sync::EX) do
+            File.open(file, "w", mode) do |rf|
+                rf.lock_exclusive do |lrf|
+                    yield lrf
+                end
+            end
+        end
+    end
+end

data/lib/puppet/util/filetype.rb

@@ -213,10 +213,10 @@ class Puppet::Util::FileType
             begin
                 output = Puppet::Util.execute(%w{crontab -l}, :uid => @path)
                 return "" if output.include?("can't open your crontab")
+                raise Puppet::Error, "User %s not authorized to use cron" % @path if output.include?("you are not authorized to use cron")
                 return output
-            rescue
-                # If there's a failure, treat it like an empty file.
-                return ""
+            rescue => detail
+                raise Puppet::Error, "Could not read crontab for %s: %s" % [@path, detail] 
             end
         end
 

data/lib/puppet/util/log.rb

@@ -369,11 +369,7 @@ class Puppet::Util::Log
         end
 
         def handle(msg)
-            # Only add messages from objects, since anything else is
-            # probably unrelated to this run.
-            if msg.objectsource?
-                @report.newlog(msg)
-            end
+            @report.newlog(msg)
         end
     end
 
@@ -505,15 +501,6 @@ class Puppet::Util::Log
         Log.newmessage(self)
     end
 
-    # Was the source of this log a Puppet resource or parameter?
-    def objectsource?
-        if defined? @objectsource and @objectsource
-            @objectsource
-        else
-            false
-        end
-    end
-
     # If they pass a source in to us, we make sure it is a string, and
     # we retrieve any tags we can.
     def source=(source)
@@ -521,10 +508,8 @@ class Puppet::Util::Log
         # We can't just check for whether it responds to :path, because
         # plenty of providers respond to that in their normal function.
         if (source.is_a?(Puppet::Type) or source.is_a?(Puppet::Parameter)) and source.respond_to?(:path)
-            @objectsource = true
             @source = source.path
         else
-            @objectsource = false
             @source = source.to_s
         end
         if source.respond_to?(:tags)

data/lib/puppet/util/metric.rb

@@ -4,11 +4,6 @@ require 'puppet'
 # A class for handling metrics.  This is currently ridiculously hackish.
 class Puppet::Util::Metric
     
-    # Load the library as a feature, so we can test its presence.
-    # It's only used by this class, so there's no reason to move it
-    # to the main feature list.
-    Puppet.features.add :rrd, :libs => 'RRDtool'
-
     attr_accessor :type, :name, :value, :label
     attr_writer :values
 

data/lib/puppet/util/rdoc.rb

@@ -0,0 +1,85 @@
+
+module Puppet::Util::RDoc
+
+    module_function
+
+    # launch a rdoc documenation process
+    # with the files/dir passed in +files+
+    def rdoc(outputdir, files)
+        begin
+            Puppet[:ignoreimport] = true
+
+            # then rdoc
+            require 'rdoc/rdoc'
+
+            # load our parser
+            require 'puppet/util/rdoc/parser'
+
+            r = RDoc::RDoc.new
+            RDoc::RDoc::GENERATORS["puppet"] = RDoc::RDoc::Generator.new("puppet/util/rdoc/generators/puppet_generator.rb",
+                                                                       "PuppetGenerator".intern,
+                                                                       "puppet")
+            # specify our own format & where to output
+            options = [ "--fmt", "puppet",
+                        "--quiet",
+                        "--op", outputdir ]
+
+            options += files
+
+            # launch the documentation process
+            r.document(options)
+        rescue RDoc::RDocError => e
+            raise Puppet::ParseError.new("RDoc error %s" % e)
+        end
+    end
+
+    # launch a output to console manifest doc
+    def manifestdoc(files)
+        Puppet[:ignoreimport] = true
+        files.select { |f| FileTest.file?(f) }.each do |f|
+            parser = Puppet::Parser::Parser.new(:environment => Puppet[:environment])
+            parser.file = f
+            ast = parser.parse
+            output(f, ast)
+        end
+    end
+
+    # Ouputs to the console the documentation
+    # of a manifest
+    def output(file, ast)
+        astobj = []
+        ast[:nodes].each do |name, k|
+            astobj << k if k.file == file
+        end
+        ast[:classes].each do |name, k|
+            astobj << k if k.file == file
+        end
+        ast[:definitions].each do |name, k|
+            astobj << k if k.file == file
+        end
+        astobj.sort! {|a,b| a.line <=> b.line }.each do |k|
+            output_astnode_doc(k)
+        end
+    end
+
+    def output_astnode_doc(ast)
+        puts ast.doc if !ast.doc.nil? and !ast.doc.empty?
+        if Puppet.settings[:document_all]
+            # scan each underlying resources to produce documentation
+            code = ast.code.children if ast.code.is_a?(Puppet::Parser::AST::ASTArray)
+            code ||= ast.code
+            output_resource_doc(code) unless code.nil?
+        end
+    end
+
+    def output_resource_doc(code)
+        code.sort { |a,b| a.line <=> b.line }.each do |stmt|
+            output_resource_doc(stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
+
+            if stmt.is_a?(Puppet::Parser::AST::Resource)
+                puts stmt.doc if !stmt.doc.nil? and !stmt.doc.empty?
+            end
+        end
+    end
+
+end