puppet 0.24.6 → 0.24.7

data/lib/puppet/rails/database/schema.rb

@@ -54,6 +54,7 @@ class Puppet::Rails::Schema
                 create_table :hosts do |t|
                     t.column :name, :string, :null => false
                     t.column :ip, :string
+                    t.column :environment, :string
                     t.column :last_compile, :datetime
                     t.column :last_freshcheck, :datetime
                     t.column :last_report, :datetime

data/lib/puppet/rails/host.rb

@@ -43,6 +43,10 @@ class Puppet::Rails::Host < ActiveRecord::Base
                 host.ip = ip
             end
 
+            if env = node.environment
+                host.environment = env
+            end
+
             # Store the facts into the database.
             host.setfacts node.parameters
 

data/lib/puppet/reference/configuration.rb

@@ -133,7 +133,7 @@ Signals
 -------
 The ``puppetd`` and ``puppetmasterd`` executables catch some signals for special 
 handling.  Both daemons catch (``SIGHUP``), which forces the server to restart 
-tself.  Predictably, interrupt and terminate (``SIGINT`` and ``SIGHUP``) will shut 
+tself.  Predictably, interrupt and terminate (``SIGINT`` and ``SIGTERM``) will shut 
 down the server, whether it be an instance of ``puppetd`` or ``puppetmasterd``.
 
 Sending the ``SIGUSR1`` signal to an instance of ``puppetd`` will cause it to 

data/lib/puppet/reports/tagmail.rb

@@ -151,12 +151,14 @@ Puppet::Reports.register_report(:tagmail) do
                     reports.each do |emails, messages|
                         Puppet.info "Sending report to %s" % emails.join(", ")
                         # We need to open a separate process for every set of email addresses
-                        IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
-                            p.puts "From: #{Puppet[:reportfrom]}"
-                            p.puts "Subject: Puppet Report for %s" % self.host
-                            p.puts "To: " + emails.join(", ")
-
-                            p.puts messages
+                        sync.synchronize do
+                            IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
+                                p.puts "From: #{Puppet[:reportfrom]}"
+                                p.puts "Subject: Puppet Report for %s" % self.host
+                                p.puts "To: " + emails.join(", ")
+
+                                p.puts messages
+                            end
                         end
                     end
                 rescue => detail
@@ -174,5 +176,12 @@ Puppet::Reports.register_report(:tagmail) do
         # Don't bother waiting for the pid to return.
         Process.detach(pid)
     end
+
+    def sync
+        unless defined?(@sync)
+            @sync = Sync.new
+        end
+        @sync
+    end
 end
 

data/lib/puppet/transaction/change.rb

@@ -53,12 +53,10 @@ class Puppet::Transaction::Change
         # The transaction catches any exceptions here.
         events = @property.sync
         if events.nil?
-            return nil
-        end
-
-        if events.is_a?(Array)
+            events = [(@property.name.to_s + "_changed").to_sym]
+        elsif events.is_a?(Array)
             if events.empty?
-                return nil
+                events = [(@property.name.to_s + "_changed").to_sym]
             end
         else
             events = [events]

data/lib/puppet/transportable.rb

@@ -53,6 +53,7 @@ module Puppet
                 Puppet.debug "Defining %s on %s" % [param, ref]
                 trans[param] = value
             }
+            trans.catalog = self.catalog
             Puppet::Type::Component.create(trans)
         end
 

data/lib/puppet/type/augeas.rb

@@ -0,0 +1,155 @@
+#--
+#  Copyright (C) 2008 Red Hat Inc.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public
+#  License as published by the Free Software Foundation; either
+#  version 2 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#
+# Author: Bryan Kearney <bkearney@redhat.com>
+
+Puppet::Type.newtype(:augeas) do
+    include Puppet::Util
+    
+    feature :parse_commands, "Parse the command string"
+    feature :need_to_run?, "If the command should run"
+    feature :execute_changes, "Actually make the changes"    
+
+    @doc = "Apply the changes (single or array of changes) to the filesystem
+        via the augeas tool.
+
+         Requires:
+           - augeas to be installed (http://www.augeas.net)
+           - ruby-augeas bindings
+
+         Sample usage with a string::
+
+            augeas{\"test1\" :
+                   context => \"/files/etc/sysconfig/firstboot\",
+                   changes => \"set RUN_FIRSTBOOT YES\",
+                   onlyif  => \"match other_value size > 0\",
+             }
+
+         Sample usage with an array and custom lenses::
+
+            augeas{\"jboss_conf\":
+                context => \"/files\",
+                changes => [
+                    \"set /etc/jbossas/jbossas.conf/JBOSS_IP $ipaddress\",
+                    \"set /etc/jbossas/jbossas.conf/JAVA_HOME /usr\"
+                ],
+                load_path => \"$/usr/share/jbossas/lenses\",
+            }
+
+         "
+
+    newparam (:name) do
+        desc "The name of this task. Used for uniqueness"
+        isnamevar
+    end
+
+    newparam (:context) do
+        desc "Optional context path. This value is pre-pended to the paths of all changes"
+        defaultto ""        
+    end
+
+    newparam (:onlyif) do
+        desc "Optional augeas command and comparisons to control the execution of this type.
+             Supported onlyif syntax::
+
+               get [AUGEAS_PATH] [COMPARATOR] [STRING]
+               match [MATCH_PATH] size [COMPARATOR] [INT]
+               match [MATCH_PATH] include [STRING]
+               match [MATCH_PATH] == [AN_ARRAY]
+
+             where::
+
+               AUGEAS_PATH is a valid path scoped by the context
+               MATCH_PATH is a valid match synatx scoped by the context
+               COMPARATOR is in the set [> >= != == <= <]
+               STRING is a string
+               INT is a number
+               AN_ARRAY is in the form ['a string', 'another']"
+        defaultto ""
+    end
+    
+
+    newparam(:changes) do
+        desc "The changes which should be applied to the filesystem. This
+        can be either a string which contains a command or an array of commands.
+        Commands supported are::
+
+          set [PATH] [VALUE]     Sets the value VALUE at loction PATH
+          rm [PATH]              Removes the node at location PATH
+          remove [PATH]          Synonym for rm
+          clear [PATH]           Keeps the node at PATH, but removes the value.
+          ins [PATH]             Inserts an empty node at PATH.
+          insert [PATH]          Synonym for ins
+
+        If the parameter 'context' is set that that value is prepended to PATH"
+
+        munge do |value|    
+            provider.parse_commands(value)
+        end
+    end
+
+
+    newparam(:root) do
+        desc "A file system path; all files loaded by Augeas are loaded underneath ROOT"
+        defaultto "/"
+    end
+
+    newparam(:load_path) do
+        desc "Optional colon separated list of directories; these directories are searched for schema definitions"
+        defaultto ""
+    end
+
+
+    newparam(:type_check) do
+        desc "Set to true if augeas should perform typechecking. Optional, defaults to false"
+        newvalues(:true, :false)
+
+        defaultto :false
+    end
+    
+    # This is the acutal meat of the code. It forces
+    # augeas to be run and fails or not based on the augeas return
+    # code.
+    newproperty(:returns) do |property|
+        include Puppet::Util
+        desc "The expected return code from the augeas command. Should not be set"
+
+        defaultto 0
+        
+        # Make output a bit prettier
+        def change_to_s(currentvalue, newvalue)
+            return "executed successfully"
+        end        
+        
+        # if the onlyif resource is provided, then the value is parsed.
+        # a return value of 0 will stop exection becuase it matches the
+        # default value.
+        def retrieve
+            if @resource.provider.need_to_run?()
+                :need_to_run
+            else
+                0
+            end
+        end            
+
+        # Actually execute the command.
+        def sync
+            @resource.provider.execute_changes()
+        end
+    end    
+
+end

data/lib/puppet/type/computer.rb

@@ -0,0 +1,62 @@
+Puppet::Type.newtype(:computer) do
+    
+    @doc = "Computer object management using DirectoryService
+      on OS X.
+
+      Note that these are distinctly different kinds of objects to 'hosts',
+      as they require a MAC address and can have all sorts of policy attached to
+      them.
+
+      This provider only manages Computer objects in the local directory service
+      domain, not in remote directories.
+
+      If you wish to manage /etc/hosts on Mac OS X, then simply use the host
+      type as per other platforms.
+
+      This type primarily exists to create localhost Computer objects that MCX
+      policy can then be attached to."
+    
+    # ensurable
+    
+    # We autorequire the computer object in case it is being managed at the
+    # file level by Puppet.
+    
+    autorequire(:file) do
+        if self[:name]
+            "/var/db/dslocal/nodes/Default/computers/#{self[:name]}.plist"
+        else
+            nil
+        end
+    end
+    
+    newproperty(:ensure, :parent => Puppet::Property::Ensure) do
+        desc "Control the existences of this computer record. Set this attribute to
+            ``present`` to ensure the computer record exists.  Set it to ``absent``
+            to delete any computer records with this name"
+        newvalue(:present) do
+            provider.create
+        end
+
+        newvalue(:absent) do
+            provider.delete
+        end
+    end
+    
+    newparam(:name) do
+        desc "The authoritative 'short' name of the computer record."
+        isnamevar
+    end
+    
+    newparam(:realname) do
+        desc "The 'long' name of the computer record."
+    end
+        
+    newproperty(:en_address) do
+        desc "The MAC address of the primary network interface. Must match en0."
+    end
+    
+    newproperty(:ip_address) do
+        desc "The IP Address of the Computer object."
+    end
+    
+end

data/lib/puppet/type/exec.rb

@@ -391,7 +391,8 @@ module Puppet
                 Note that this command follows the same rules as the main command,
                 which is to say that it must be fully qualified if the path is not set.
 
-                Also note that onlyif can take an array as its value, eg:
+                Also note that onlyif can take an array as its value, eg::
+
                     onlyif => [\"test -f /tmp/file1\", \"test -f /tmp/file2\"]
 
                 This will only run the exec if /all/ conditions in the array return true.

data/lib/puppet/type/file.rb

@@ -1127,7 +1127,7 @@ module Puppet
         # file creation/modification, so we have to do some extra checking.
         def property_fix
             properties.each do |thing|
-                next unless [:mode, :owner, :group].include?(thing.name)
+                next unless [:mode, :owner, :group, :seluser, :selrole, :seltype, :selrange].include?(thing.name)
 
                 # Make sure we get a new stat objct
                 self.stat(true)

data/lib/puppet/type/file/ensure.rb

@@ -2,11 +2,10 @@ module Puppet
     Puppet.type(:file).ensurable do
         require 'etc'
         desc "Whether to create files that don't currently exist.
-            Possible values are *absent*, *present* (will match any form of
-            file existence, and if the file is missing will create an empty
-            file), *file*, and *directory*.  Specifying ``absent`` will delete
-            the file, although currently this will not recursively delete
-            directories.
+            Possible values are *absent*, *present*, *file*, and *directory*.
+            Specifying ``present`` will match any form of file existence, and
+            if the file is missing will create an empty file. Specifying
+            ``absent`` will delete the file (and directory if recurse => true).
 
             Anything other than those values will be considered to be a symlink.
             For instance, the following text creates a link::
@@ -138,6 +137,10 @@ module Puppet
         # We have to treat :present specially, because it works with any
         # type of file.
         def insync?(currentvalue)
+            unless currentvalue == :absent or resource.replace?
+                return true
+            end
+
             if self.should == :present
                 if currentvalue.nil? or currentvalue == :absent
                     return false

data/lib/puppet/type/file/mode.rb

@@ -103,22 +103,8 @@ module Puppet
         end
 
         def sync
-            unless @resource.stat(false)
-                stat = @resource.stat(true)
-
-                unless stat
-                    self.debug "File does not exist; cannot set mode"
-                    return nil
-                end
-            end
-
             mode = self.should
 
-            if mode == :absent
-                # This is really only valid for create states...
-                return nil
-            end
-
             begin
                 File.chmod(mode, @resource[:path])
             rescue => detail

data/lib/puppet/type/file/owner.rb

@@ -1,5 +1,8 @@
 module Puppet
     Puppet.type(:file).newproperty(:owner) do
+        include Puppet::Util::POSIX
+        include Puppet::Util::Warnings
+
         require 'etc'
         desc "To whom the file should belong.  Argument can be user name or
             user ID."
@@ -24,40 +27,32 @@ module Puppet
             end
         end
 
-        def name2id(value)
-            if value.is_a?(Symbol)
-                return value.to_s
+        def insync?(current)
+            unless Puppet::Util::SUIDManager.uid == 0
+                warning "Cannot manage ownership unless running as root"
+                return true
             end
-            begin
-                user = Etc.getpwnam(value)
-                if user.uid == ""
-                    return nil
+
+            @should.each do |value|
+                if value =~ /^\d+$/
+                    uid = Integer(value)
+                elsif value.is_a?(String)
+                    fail "Could not find user %s" % value unless uid = uid(value)
+                else
+                    uid = value
                 end
-                return user.uid
-            rescue ArgumentError => detail
-                return nil
+
+                return true if uid == current
             end
+            return false
         end
 
         # Determine if the user is valid, and if so, return the UID
         def validuser?(value)
-            if value =~ /^\d+$/
-                value = value.to_i
-            end
-
-            if value.is_a?(Integer)
-                # verify the user is a valid user
-                if tmp = id2name(value)
-                    return value
-                else
-                    return false
-                end
+            if number = uid(value)
+                return number
             else
-                if tmp = name2id(value)
-                    return tmp
-                else
-                    return false
-                end
+                return false
             end
         end
 
@@ -99,13 +94,6 @@ module Puppet
                 return :absent
             end
 
-            # Set our method appropriately, depending on links.
-            if stat.ftype == "link" and @resource[:links] != :follow
-                @method = :lchown
-            else
-                @method = :chown
-            end
-
             currentvalue = stat.uid
             
             # On OS X, files that are owned by -2 get returned as really
@@ -120,44 +108,24 @@ module Puppet
         end
 
         def sync
-            unless Puppet::Util::SUIDManager.uid == 0
-                unless defined? @@notifieduid
-                    self.notice "Cannot manage ownership unless running as root"
-                    #@resource.delete(self.name)
-                    @@notifieduid = true
-                end
-                return nil
+            # Set our method appropriately, depending on links.
+            if resource[:links] == :manage
+                method = :lchown
+            else
+                method = :chown
             end
 
-            user = nil
-            unless user = self.validuser?(self.should)
-                tmp = self.should
-                unless defined? @@usermissing
-                    @@usermissing = {}
-                end
-
-                if @@usermissing.include?(tmp)
-                    @@usermissing[tmp] += 1
-                else
-                    self.notice "user %s does not exist" % tmp
-                    @@usermissing[tmp] = 1
-                end
-                return nil
+            uid = nil
+            @should.each do |user|
+                break if uid = validuser?(user)
             end
 
-            unless @resource.stat(false)
-                unless @resource.stat(true)
-                    self.debug "File does not exist; cannot set owner"
-                    return nil
-                end
-                #self.debug "%s: after refresh, is '%s'" % [self.class.name,@is]
-            end
+            raise Puppet::Error, "Could not find user(s) %s" % @should.join(",") unless uid
 
             begin
-                File.send(@method, user, nil, @resource[:path])
+                File.send(method, uid, nil, @resource[:path])
             rescue => detail
-                raise Puppet::Error, "Failed to set owner to '%s': %s" %
-                    [user, detail]
+                raise Puppet::Error, "Failed to set owner to '%s': %s" % [uid, detail]
             end
 
             return :file_changed