puppet 0.23.0 → 0.23.1

data/lib/puppet/rails.rb

@@ -12,6 +12,13 @@ module Puppet::Rails
             Puppet.config.use(:main, :rails, :puppetmasterd)
 
             ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
+            begin
+                loglevel = Logger.const_get(Puppet[:rails_loglevel].upcase)
+                ActiveRecord::Base.logger.level = loglevel
+            rescue => detail
+                Puppet.warning "'%s' is not a valid Rails log level; using debug" % Puppet[:rails_loglevel]
+                ActiveRecord::Base.logger.level = Logger::DEBUG
+            end
             ActiveRecord::Base.allow_concurrency = true
             ActiveRecord::Base.verify_active_connections!
 
@@ -28,7 +35,7 @@ module Puppet::Rails
 
     # The arguments for initializing the database connection.
     def self.database_arguments
-        args = {:adapter => Puppet[:dbadapter]}
+        args = {:adapter => Puppet[:dbadapter], :log_level => Puppet[:rails_loglevel]}
 
         case Puppet[:dbadapter]
         when "sqlite3":
@@ -117,4 +124,4 @@ if Puppet.features.rails?
     require 'puppet/rails/host'
 end
 
-# $Id: rails.rb 2609 2007-06-18 18:46:00Z luke $
+# $Id: rails.rb 2667 2007-07-09 23:15:01Z luke $

data/lib/puppet/rails/param_name.rb

@@ -12,12 +12,11 @@ class Puppet::Rails::ParamName < ActiveRecord::Base
         hash[:value] = resource.param_values.find(:all, :conditions => [ "param_name_id = ?", self]).collect { |v| v.value }
         if hash[:value].length == 1
             hash[:value] = hash[:value].shift
-        end
-        if hash[:value].empty?
+        elsif hash[:value].empty?
             hash[:value] = nil
         end
         Puppet::Parser::Resource::Param.new hash
     end
 end
 
-# $Id: param_name.rb 2565 2007-06-12 00:31:16Z ballman $
+# $Id: param_name.rb 2706 2007-07-18 19:47:09Z luke $

data/lib/puppet/rails/param_value.rb

@@ -1,6 +1,25 @@
 class Puppet::Rails::ParamValue < ActiveRecord::Base
     belongs_to :param_name
     belongs_to :resource
+
+    def value
+        val = self[:value]
+        if val =~ /^--- \!/
+            YAML.load(val)
+        else
+            val
+        end
+    end
+
+    # I could not find a cleaner way to handle making sure that resource references
+    # were consistently serialized and deserialized.
+    def value=(val)
+        if val.is_a?(Puppet::Parser::Resource::Reference)
+            self[:value] = YAML.dump(val)
+        else
+            self[:value] = val
+        end
+    end
 end
 
-# $Id: param_value.rb 2565 2007-06-12 00:31:16Z ballman $
+# $Id: param_value.rb 2706 2007-07-18 19:47:09Z luke $

data/lib/puppet/rails/resource.rb

@@ -45,7 +45,8 @@ class Puppet::Rails::Resource < ActiveRecord::Base
     def get_tag_hash(tags = nil)
         tags ||= resource_tags.find(:all, :include => :puppet_tag)
         return tags.inject({}) do |hash, tag|
-            hash[tag.puppet_tag.name] = tag.puppet_tag.name
+            # We have to store the tag object, not just the tag name.
+            hash[tag.puppet_tag.name] = tag
             hash
         end
     end
@@ -105,7 +106,12 @@ class Puppet::Rails::Resource < ActiveRecord::Base
         hash[:source] = scope.source
         obj = Puppet::Parser::Resource.new(hash)
 
+        names = []
         self.param_names.each do |pname|
+            # We can get the same name multiple times because of how the
+            # db layout works.
+            next if names.include?(pname.name)
+            names << pname.name
             obj.set(pname.to_resourceparam(self, scope.source))
         end
 
@@ -116,4 +122,4 @@ class Puppet::Rails::Resource < ActiveRecord::Base
     end
 end
 
-# $Id: resource.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: resource.rb 2705 2007-07-18 17:32:46Z luke $

data/lib/puppet/reference/configuration.rb

@@ -46,25 +46,23 @@ Specifying Configuration Parameters
 On The Command-Line
 +++++++++++++++++++
 Every Puppet executable (with the exception of ``puppetdoc``) accepts all of
-the arguments below, but not all of the arguments make sense for every executable.
-Each argument has a section listed with it in parentheses; often, that section
+the parameters below, but not all of the arguments make sense for every executable.
+Each parameter has a section listed with it in parentheses; often, that section
 will map to an executable (e.g., ``puppetd``), in which case it probably only
-makes sense for that one executable.  If ``puppet`` is listed as the section,
+makes sense for that one executable.  If ``main`` is listed as the section,
 it is most likely an option that is valid for everyone.
 
-This will not always be the case.  I have tried to be as thorough as possible
-in the descriptions of the arguments, so it should be obvious whether an
-argument is appropriate or not.
+I have tried to be as thorough as possible in the descriptions of the
+arguments, so it should be obvious whether an argument is appropriate or not.
 
-These arguments can be supplied to the executables either as command-line 
-arugments or in the configuration file for the appropriate executable.  For 
-instance, the command-line invocation below would set the configuration directory
-to ``/private/puppet``::
+These parameters can be supplied to the executables either as command-line 
+options or in the configuration file.  For instance, the command-line
+invocation below would set the configuration directory to ``/private/puppet``::
   
     $ puppetd --confdir=/private/puppet
   
-Note that boolean options are turned on and off with a slightly different syntax
-on the command line::
+Note that boolean options are turned on and off with a slightly different
+syntax on the command line::
 
     $ puppetd --storeconfigs
       
@@ -76,14 +74,14 @@ the client configuration.
 Configuration Files
 +++++++++++++++++++
 As mentioned above, the configuration parameters can also be stored in a 
-configuration file located in the configuration directory (`/etc/puppet` 
-by default).  All executables look for ``puppet.conf`` in their
-configuration directory (although they used to each look to separate files).
+configuration file, located in the configuration directory (`/etc/puppet` 
+by default).  As of 0.23.0, all executables look for ``puppet.conf`` in their
+configuration directory (although they previously looked for separate files).
 
 All executables will set any parameters set within the ``main`` section,
 while each executable will also look for a section named for the executable
 and load those parameters.  For example, ``puppetd`` will look for a
-section named ``puppetd`, and ``puppetmasterd`` looks for a section
+section named ``puppetd``, and ``puppetmasterd`` looks for a section
 named ``puppetmasterd``.  This allows you to use a single configuration file
 to customize the settings for all of your executables.
 

data/lib/puppet/reference/type.rb

@@ -11,7 +11,7 @@ type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource
     str = %{
 Metaparameters
 --------------
-Metaparameters are parameters that work with any element; they are part of the
+Metaparameters are parameters that work with any resource type; they are part of the
 Puppet framework itself rather than being part of the implementation of any
 given instance.  Thus, any defined metaparameter can be used with any instance
 in your manifest, including defined components.
@@ -66,9 +66,6 @@ Resource Types
   dependency handling), and because ``path`` is the namevar for ``file``, that
   string is assigned to the ``path`` parameter.
 
-- *Features* are abilities that some providers might not support.  You can use the list
-  of supported features to determine how a given provider can be used.
-
 - *Parameters* determine the specific configuration of the instance.  They either
   directly modify the system (internally, these are called properties) or they affect
   how the instance behaves (e.g., adding a search path for ``exec`` instances
@@ -82,6 +79,9 @@ Resource Types
   binaries indicate that Puppet will search for the binary using the shell
   path.
 
+- *Features* are abilities that some providers might not support.  You can use the list
+  of supported features to determine how a given provider can be used.
+
   Resource types define features they can use, and providers can be tested to see
   which features they provide.
 

data/lib/puppet/transaction.rb

@@ -68,7 +68,7 @@ class Transaction
         resourceevents = apply_changes(resource, changes)
 
         # If there were changes and the resource isn't in noop mode...
-        unless changes.empty? or changes.include?(:noop)
+        unless changes.empty? or resource.noop
             # Record when we last synced
             resource.cache(:synced, Time.now)
 
@@ -490,12 +490,12 @@ class Transaction
                 if Puppet[:trace]
                     puts detail.backtrace
                 end
-                Puppet.err "Could not prefetch % provider %s: %s" % [resources[0].class.name, provider.name, detail]
+                Puppet.err "Could not prefetch %s provider '%s': %s" % [provider.resource_type.name, provider.name, detail]
             end
         end
     end
     
-    # Prepare to evaluate the elements in a transaction.
+    # Prepare to evaluate the resources in a transaction.
     def prepare
         prefetch()
     
@@ -737,4 +737,4 @@ end
 
 require 'puppet/transaction/report'
 
-# $Id: transaction.rb 2621 2007-06-18 21:56:11Z luke $
+# $Id: transaction.rb 2678 2007-07-11 19:30:42Z luke $

data/lib/puppet/type.rb

@@ -1,18 +1,25 @@
 require 'puppet'
 require 'puppet/util/log'
-require 'puppet/element'
 require 'puppet/event'
 require 'puppet/util/metric'
-require 'puppet/type/property'
+require 'puppet/property'
 require 'puppet/parameter'
 require 'puppet/util'
 require 'puppet/util/autoload'
 require 'puppet/metatype/manager'
+require 'puppet/util/errors'
+require 'puppet/util/log_paths'
+require 'puppet/util/logging'
 
 # see the bottom of the file for the rest of the inclusions
 
 module Puppet
-class Type < Puppet::Element
+class Type
+    include Puppet::Util
+    include Puppet::Util::Errors
+    include Puppet::Util::LogPaths
+    include Puppet::Util::Logging
+
     # Nearly all of the code in this class is stored in files in the
     # metatype/ directory.  This is a temporary measure until I get a chance
     # to refactor this class entirely.  There's still more simplification to
@@ -28,7 +35,7 @@ class Type < Puppet::Element
     require 'puppet/metatype/schedules'
     require 'puppet/metatype/tags'
 
-    # Types (which map to elements in the languages) are entirely composed of
+    # Types (which map to resources in the languages) are entirely composed of
     # attribute value pairs.  Generally, Puppet calls any of these things an
     # 'attribute', but these attributes always take one of three specific
     # forms:  parameters, metaparams, or properties.
@@ -40,6 +47,7 @@ class Type < Puppet::Element
     attr_reader :parent
 
     attr_writer :title
+    attr_writer :noop
 
     include Enumerable
     
@@ -53,6 +61,9 @@ class Type < Puppet::Element
         attr_accessor :self_refresh
         include Enumerable, Puppet::Util::ClassGen
         include Puppet::MetaType::Manager
+
+        include Puppet::Util
+        include Puppet::Util::Logging
     end
 
     # all of the variables that must be initialized for each subclass
@@ -241,10 +252,12 @@ class Type < Puppet::Element
                 rescue ArgumentError, Puppet::Error, TypeError
                     raise
                 rescue => detail
-                    self.devfail(
+                    error = Puppet::DevError.new(
                         "Could not set %s on %s: %s" %
                             [attr, self.class.name, detail]
                     )
+                    error.set_backtrace(detail.backtrace)
+                    raise error
                 end
                 hash.delete attr
             end
@@ -381,4 +394,4 @@ require 'puppet/type/tidy'
 
 
 
-# $Id: type.rb 2577 2007-06-14 03:39:23Z luke $
+# $Id: type.rb 2684 2007-07-12 16:39:47Z luke $

data/lib/puppet/type/component.rb

@@ -95,6 +95,12 @@ Puppet::Type.newtype(:component) do
     def initialize(args)
         @children = []
         super(args)
+
+        # If the title isn't a full resource reference, assume
+        # we're a class and make an alias for that.
+        unless @title.to_s.include?("[")
+            self.class.alias("class[%s]" % @title, self)
+        end
     end
 
     def initvars
@@ -131,10 +137,10 @@ Puppet::Type.newtype(:component) do
             if parentof?(child)
                 devfail "Already the parent of %s[%s]" % [child.class.name, child.title]
             end
-            unless child.is_a?(Puppet::Element)
+            unless child.is_a?(Puppet::Type)
                 self.debug "Got object of type %s" % child.class
                 self.devfail(
-                    "Containers can only contain Puppet::Elements, not %s" %
+                    "Containers can only contain Puppet resources, not %s" %
                     child.class
                 )
             end
@@ -230,4 +236,4 @@ Puppet::Type.newtype(:component) do
     end
 end
 
-# $Id: component.rb 2499 2007-05-09 21:30:44Z luke $
+# $Id: component.rb 2715 2007-07-19 19:23:56Z luke $

data/lib/puppet/type/cron.rb

@@ -1,6 +1,5 @@
 require 'etc'
 require 'facter'
-require 'puppet/type/property'
 require 'puppet/util/filetype'
 
 Puppet::Type.newtype(:cron) do
@@ -92,6 +91,9 @@ Puppet::Type.newtype(:cron) do
 
         def should_to_s(newvalue = @should)
             if newvalue
+                unless newvalue.is_a?(Array)
+                    newvalue = [newvalue]
+                end
                 if self.name == :command or newvalue[0].is_a? Symbol
                     newvalue[0]
                 else
@@ -302,8 +304,12 @@ Puppet::Type.newtype(:cron) do
         end
 
         def is_to_s(newvalue)
-            if newvalue
-                newvalue.join(",")
+            if newvalue 
+                if newvalue.is_a?(Array)
+                    newvalue.join(",")
+                else
+                    newvalue
+                end
             else
                 nil
             end
@@ -402,5 +408,5 @@ Puppet::Type.newtype(:cron) do
 end
 
 
-# $Id: cron.rb 2621 2007-06-18 21:56:11Z luke $
+# $Id: cron.rb 2698 2007-07-14 21:18:36Z luke $
 

data/lib/puppet/type/exec.rb

@@ -6,7 +6,12 @@ module Puppet
         @doc = "Executes external commands.  It is critical that all commands
             executed using this mechanism can be run multiple times without
             harm, i.e., they are *idempotent*.  One useful way to create idempotent
-            commands is to use the *creates* parameter.
+            commands is to use the checks like ``creates`` to avoid running the
+            command unless some condition is met.
+
+            Note also that you can restrict an ``exec`` to only run when it receives
+            events by using the ``refreshonly`` parameter; this is a useful way to
+            have your configuration respond to events with arbitrary commands.
 
             It is worth noting that ``exec`` is special, in that it is not
             currently considered an error to have multiple ``exec`` instances
@@ -48,10 +53,9 @@ module Puppet
             to native Puppet types as quickly as possible.  If you find that
             you are doing a lot of work with ``exec``, please at least notify
             us at Reductive Labs what you are doing, and hopefully we can work with
-            you to get a native element type for the work you are doing."
+            you to get a native resource type for the work you are doing."
 
         require 'open3'
-        require 'puppet/type/property'
 
         # Create a new check mechanism.  It's basically just a parameter that
         # provides one extra 'check' method.
@@ -197,7 +201,7 @@ module Puppet
 
         newparam(:logoutput) do
             desc "Whether to log output.  Defaults to logging output at the
-                loglevel for the ``exec`` element.  Values are **true**, *false*,
+                loglevel for the ``exec`` resource.  Values are **true**, *false*,
                 and any legal log level."
 
             values = [:true, :false]
@@ -598,4 +602,4 @@ module Puppet
     end
 end
 
-# $Id: exec.rb 2551 2007-06-04 20:37:14Z luke $
+# $Id: exec.rb 2696 2007-07-14 20:26:31Z luke $

data/lib/puppet/type/group.rb

@@ -8,12 +8,11 @@
 
 require 'etc'
 require 'facter'
-require 'puppet/type/property'
 
 module Puppet
     newtype(:group) do
         @doc = "Manage groups.  This type can only create groups.  Group
-            membership must be managed on individual users.  This element type
+            membership must be managed on individual users.  This resource type
             uses the prescribed native tools for creating groups and generally
             uses POSIX APIs for retrieving information about them.  It does
             not directly modify ``/etc/group`` or anything.
@@ -130,4 +129,4 @@ module Puppet
     end
 end
 
-# $Id: group.rb 2551 2007-06-04 20:37:14Z luke $
+# $Id: group.rb 2665 2007-07-09 21:32:33Z luke $

data/lib/puppet/type/mailalias.rb

@@ -0,0 +1,50 @@
+module Puppet
+    newtype(:mailalias) do
+        @doc = "Creates an email alias in the local alias database."
+        
+        ensurable
+
+        newparam(:name, :namevar => true) do
+            desc "The alias name."
+        end
+
+        newproperty(:recipient, :array_matching => :all) do
+            desc "Where email should should be sent.  Multiple values
+                should be specified as an array."
+
+            def is_to_s(value)
+                if value.include?(:absent)
+                    super
+                else
+                    value.join(",")
+                end
+            end
+
+            def should
+                @should
+            end
+
+            def should_to_s(value)
+                if value.include?(:absent)
+                    super
+                else
+                    value.join(",")
+                end
+            end
+        end
+
+        newproperty(:target) do
+            desc "The file in which to store the aliases.  Only used by
+                those providers that write to disk (i.e., not NetInfo)."
+
+            defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
+                    @resource.class.defaultprovider.default_target
+                else
+                    nil
+                end
+            }
+        end
+    end
+end
+
+# $Id: mailalias.rb 2676 2007-07-10 23:24:34Z luke $