puppet 0.24.9 → 0.25.0

data/lib/puppet/rails/param_name.rb

@@ -1,9 +1,13 @@
 require 'puppet/util/rails/collection_merger'
 require 'puppet/rails/param_value'
+require 'puppet/util/rails/cache_accumulator'
 
 class Puppet::Rails::ParamName < ActiveRecord::Base
     include Puppet::Util::CollectionMerger
-    has_many :param_values, :dependent => :destroy 
+    has_many :param_values, :dependent => :destroy
+
+    include Puppet::Util::CacheAccumulator
+    accumulates :name
 
     def to_resourceparam(resource, source)
         hash = {}

data/lib/puppet/rails/param_value.rb

@@ -7,6 +7,31 @@ class Puppet::Rails::ParamValue < ActiveRecord::Base
     belongs_to :param_name
     belongs_to :resource
 
+    # Store a new parameter in a Rails db.
+    def self.from_parser_param(param, values)
+        values = munge_parser_values(values)
+
+        param_name = Puppet::Rails::ParamName.find_or_create_by_name(param.to_s)
+        return values.collect do |v|
+            {:value => v, :param_name => param_name}
+        end
+    end
+
+    # Make sure an array (or possibly not an array) of values is correctly
+    # set up for Rails.  The main thing is that Resource::Reference objects
+    # should stay objects, so they just get serialized.
+    def self.munge_parser_values(value)
+        values = value.is_a?(Array) ? value : [value]
+        values.map do |v|
+            if v.is_a?(Puppet::Resource::Reference)
+                v
+            else
+                v.to_s
+            end
+        end
+    end
+
+
     def value
         unserialize_value(self[:value])
     end
@@ -18,7 +43,7 @@ class Puppet::Rails::ParamValue < ActiveRecord::Base
     end
 
     def to_label
-      "#{self.param_name.name}"
+        "#{self.param_name.name}"
     end
 
     # returns an array of hash containing all the parameters of a given resource
@@ -43,5 +68,7 @@ class Puppet::Rails::ParamValue < ActiveRecord::Base
         params
     end
 
+    def to_s
+        "%s => %s" % [self.name, self.value]
+    end
 end
-

data/lib/puppet/rails/puppet_tag.rb

@@ -1,5 +1,10 @@
 require 'puppet/rails/resource_tag'
+require 'puppet/util/rails/cache_accumulator'
+
 class Puppet::Rails::PuppetTag < ActiveRecord::Base
     has_many :resource_tags, :dependent => :destroy
     has_many :resources, :through => :resource_tags
+
+    include Puppet::Util::CacheAccumulator
+    accumulates :name
 end

data/lib/puppet/rails/resource.rb

@@ -2,11 +2,13 @@ require 'puppet'
 require 'puppet/rails/param_name'
 require 'puppet/rails/param_value'
 require 'puppet/rails/puppet_tag'
+require 'puppet/rails/benchmark'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Resource < ActiveRecord::Base
     include Puppet::Util::CollectionMerger
     include Puppet::Util::ReferenceSerializer
+    include Puppet::Rails::Benchmark
 
     has_many :param_values, :dependent => :destroy, :class_name => "Puppet::Rails::ParamValue"
     has_many :param_names, :through => :param_values, :class_name => "Puppet::Rails::ParamName"
@@ -17,9 +19,32 @@ class Puppet::Rails::Resource < ActiveRecord::Base
     belongs_to :source_file
     belongs_to :host
 
+    @tags = {}
+    def self.tags
+        @tags
+    end
+
+    # Determine the basic details on the resource.
+    def self.rails_resource_initial_args(resource)
+        result = [:type, :title, :line].inject({}) do |hash, param|
+            # 'type' isn't a valid column name, so we have to use another name.
+            to = (param == :type) ? :restype : param
+            if value = resource.send(param)
+                hash[to] = value
+            end
+            hash
+        end
+
+        # We always want a value here, regardless of what the resource has,
+        # so we break it out separately.
+        result[:exported] = resource.exported || false
+
+        result
+    end
+
     def add_resource_tag(tag)
-        pt = Puppet::Rails::PuppetTag.find_or_create_by_name(tag, :include => :puppet_tag)
-        resource_tags.create(:puppet_tag => pt)
+        pt = Puppet::Rails::PuppetTag.accumulate_by_name(tag)
+        resource_tags.build(:puppet_tag => pt)
     end
 
     def file
@@ -56,30 +81,96 @@ class Puppet::Rails::Resource < ActiveRecord::Base
         @tags_hash = hash
     end
 
-    # returns a hash of param_names.name => [param_values]
-    def get_params_hash(values = nil)
-        values ||= @params_hash || Puppet::Rails::ParamValue.find_all_params_from_resource(self)
-        if values.size == 0
-            return {}
+    def [](param)
+        return super || parameter(param)
+    end
+
+    # Make sure this resource is equivalent to the provided Parser resource.
+    def merge_parser_resource(resource)
+        accumulate_benchmark("Individual resource merger", :attributes) { merge_attributes(resource) }
+        accumulate_benchmark("Individual resource merger", :parameters) { merge_parameters(resource) }
+        accumulate_benchmark("Individual resource merger", :tags) { merge_tags(resource) }
+        save()
+    end
+
+    def merge_attributes(resource)
+        args = self.class.rails_resource_initial_args(resource)
+        args.each do |param, value|
+            unless resource[param] == value
+                self[param] = value
+            end
         end
-        values.inject({}) do |hash, value|
-            hash[value['name']] ||= []
-            hash[value['name']] << value
-            hash
+
+        # Handle file specially
+        if (resource.file and  (!resource.file or self.file != resource.file))
+            self.file = resource.file
         end
     end
 
-    def get_tag_hash(tags = nil)
-        tags ||= @tags_hash || Puppet::Rails::ResourceTag.find_all_tags_from_resource(self)
-        return tags.inject({}) do |hash, tag|
-            # We have to store the tag object, not just the tag name.
-            hash[tag['name']] = tag
-            hash
+    def merge_parameters(resource)
+        catalog_params = {}
+        resource.each do |param, value|
+            catalog_params[param.to_s] = value
+        end
+
+        db_params = {}
+
+        deletions = []
+        @params_hash.each do |value|
+            # First remove any parameters our catalog resource doesn't have at all.
+            deletions << value['id'] and next unless catalog_params.include?(value['name'])
+
+            # Now store them for later testing.
+            db_params[value['name']] ||= []
+            db_params[value['name']] << value
+        end
+
+        # Now get rid of any parameters whose value list is different.
+        # This might be extra work in cases where an array has added or lost
+        # a single value, but in the most common case (a single value has changed)
+        # this makes sense.
+        db_params.each do |name, value_hashes|
+            values = value_hashes.collect { |v| v['value'] }
+
+            unless value_compare(catalog_params[name], values)
+                value_hashes.each { |v| deletions << v['id'] }
+            end
+        end
+
+        # Perform our deletions.
+        Puppet::Rails::ParamValue.delete(deletions) unless deletions.empty?
+
+        # Lastly, add any new parameters.
+        catalog_params.each do |name, value|
+            next if db_params.include?(name)
+            values = value.is_a?(Array) ? value : [value]
+
+            values.each do |v|
+                param_values.build(:value => serialize_value(v), :line => resource.line, :param_name => Puppet::Rails::ParamName.accumulate_by_name(name))
+            end
         end
     end
 
-    def [](param)
-        return super || parameter(param)
+    # Make sure the tag list is correct.
+    def merge_tags(resource)
+        in_db = []
+        deletions = []
+        resource_tags = resource.tags
+        @tags_hash.each do |tag|
+            deletions << tag['id'] and next unless resource_tags.include?(tag['name'])
+            in_db << tag['name']
+        end
+        Puppet::Rails::ResourceTag.delete(deletions) unless deletions.empty?
+
+        (resource_tags - in_db).each do |tag|
+            add_resource_tag(tag)
+        end
+    end
+
+    def value_compare(v,db_value)
+        v = [v] unless v.is_a?(Array)
+
+        v == db_value
     end
 
     def name
@@ -88,7 +179,7 @@ class Puppet::Rails::Resource < ActiveRecord::Base
 
     def parameter(param)
         if pn = param_names.find_by_name(param)
-            if pv = param_values.find(:first, :conditions => [ 'param_name_id = ?', pn]                                                            )
+            if pv = param_values.find(:first, :conditions => [ 'param_name_id = ?', pn])
                 return pv.value
             else
                 return nil
@@ -112,6 +203,15 @@ class Puppet::Rails::Resource < ActiveRecord::Base
         "%s[%s]" % [self[:restype].split("::").collect { |s| s.capitalize }.join("::"), self.title.to_s]
     end
 
+    # Returns a hash of parameter names and values, no ActiveRecord instances.
+    def to_hash
+        Puppet::Rails::ParamValue.find_all_params_from_resource(self).inject({}) do |hash, value|
+            hash[value['name']] ||= []
+            hash[value['name']] << value.value
+            hash
+        end
+    end
+
     # Convert our object to a resource.  Do not retain whether the object
     # is exported, though, since that would cause it to get stripped
     # from the configuration.

data/lib/puppet/rails/resource_tag.rb

@@ -4,7 +4,7 @@ class Puppet::Rails::ResourceTag < ActiveRecord::Base
 
     def to_label
       "#{self.puppet_tag.name}"
-    end  
+    end
 
     # returns an array of hash containing tags of resource
     def self.find_all_tags_from_resource(db_resource)

data/lib/puppet/rails/source_file.rb

@@ -4,5 +4,5 @@ class Puppet::Rails::SourceFile < ActiveRecord::Base
 
     def to_label
       "#{self.filename}"
-    end  
+    end
 end

data/lib/puppet/reference/configuration.rb

@@ -53,20 +53,20 @@ the parameters below, but not all of the arguments make sense for every executab
 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 parameters can be supplied to the executables either as command-line 
+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::
 
     $ puppetd --storeconfigs
-      
+
     $ puppetd --no-storeconfigs
 
-The invocations above will enable and disable, respectively, the storage of 
+The invocations above will enable and disable, respectively, the storage of
 the client configuration.
 
 Configuration Files
@@ -95,7 +95,7 @@ The file follows INI-style formatting.  Here is an example of a very simple
     [main]
         confdir = /private/puppet
         storeconfigs = true
-    
+
 Note that boolean parameters must be explicitly specified as `true` or
 `false` as seen above.
 
@@ -112,13 +112,13 @@ will print a template configuration to standard output, which can be
 redirected to a file like so::
 
     $ puppetd --genconfig > /etc/puppet/puppet.conf
-  
+
 Note that this invocation will replace the contents of any pre-existing
 `puppet.conf` file, so make a backup of your present config if it contains
 valuable information.
 
 Like the `--genconfig` argument, the executables also accept a `--genmanifest`
-argument, which will generate a manifest that can be used to manage all of 
+argument, which will generate a manifest that can be used to manage all of
 Puppet's directories and files and prints it to standard output.  This can
 likewise be redirected to a file::
 
@@ -128,16 +128,16 @@ Puppet can also create user and group accounts for itself (one `puppet` group
 and one `puppet` user) if it is invoked as `root` with the `--mkusers` argument::
 
     $ puppetd --mkusers
-  
+
 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 ``SIGTERM``) will shut 
+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 ``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 
-immediately begin a new configuration transaction with the server.  This 
+Sending the ``SIGUSR1`` signal to an instance of ``puppetd`` will cause it to
+immediately begin a new configuration transaction with the server.  This
 signal has no effect on ``puppetmasterd``.
 
 Configuration Parameter Reference

data/lib/puppet/reference/function.rb

@@ -6,7 +6,7 @@ There are two types of functions in Puppet: Statements and rvalues.
 Statements stand on their own and do not return arguments; they are used for
 performing stand-alone work like importing.  Rvalues return values and can
 only be used in a statement requiring a value, such as an assignment or a case
-statement. 
+statement.
 
 Here are the functions available in Puppet:
 

data/lib/puppet/reference/metaparameter.rb

@@ -0,0 +1,48 @@
+metaparameter = Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
+    types = {}
+    Puppet::Type.loadall
+
+    Puppet::Type.eachtype { |type|
+        next if type.name == :puppet
+        next if type.name == :component
+        types[type.name] = type
+    }
+
+   str = %{
+Metaparameters
+--------------
+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.
+
+Available Metaparameters
+++++++++++++++++++++++++
+}
+    begin
+        params = []
+        Puppet::Type.eachmetaparam { |param|
+            params << param
+        }
+
+        params.sort { |a,b|
+            a.to_s <=> b.to_s
+        }.each { |param|
+            str += paramwrap(param.to_s, scrub(Puppet::Type.metaparamdoc(param)), :level => 4)
+            #puts "<dt>" + param.to_s + "</dt>"
+            #puts tab(1) + Puppet::Type.metaparamdoc(param).scrub.indent($tab)gsub(/\n\s*/,' ')
+            #puts "<dd>"
+            #puts indent(scrub(Puppet::Type.metaparamdoc(param)), $tab)
+            #puts scrub(Puppet::Type.metaparamdoc(param))
+            #puts "</dd>"
+
+            #puts ""
+        }
+    rescue => detail
+        puts detail.backtrace
+        puts "incorrect metaparams: %s" % detail
+        exit(1)
+    end
+
+    str
+end

data/lib/puppet/reference/providers.rb

@@ -61,9 +61,9 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
                 details = ".. [%s]\n" % count
                 missing.each do |test, values|
                     case test
-                    when :exists:
+                    when :exists
                         details += "  - Missing files %s\n" % values.join(", ")
-                    when :variable:
+                    when :variable
                         values.each do |name, facts|
                             if Puppet.settings.valid?(name)
                                 details += "  - Setting %s (currently %s) not in list %s\n" % [name, Puppet.settings.value(name).inspect, facts.join(", ")]
@@ -71,16 +71,16 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
                                 details += "  - Fact %s (currently %s) not in list %s\n" % [name, Facter.value(name).inspect, facts.join(", ")]
                             end
                         end
-                    when :true:
+                    when :true
                         details += "  - Got %s true tests that should have been false\n" % values
-                    when :false:
+                    when :false
                         details += "  - Got %s false tests that should have been true\n" % values
-                    when :feature:
+                    when :feature
                         details += "  - Missing features %s\n" % values.collect { |f| f.to_s }.join(",")
                     end
                 end
                 notes << details
-                
+
                 count += 1
             end
 

data/lib/puppet/reference/type.rb

@@ -9,42 +9,6 @@ type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource
     }
 
     str = %{
-Metaparameters
---------------
-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.
-
-Available Metaparameters
-++++++++++++++++++++++++
-}
-    begin
-        params = []
-        Puppet::Type.eachmetaparam { |param|
-            params << param
-        }
-
-        params.sort { |a,b|
-            a.to_s <=> b.to_s
-        }.each { |param|
-            str += paramwrap(param.to_s, scrub(Puppet::Type.metaparamdoc(param)), :level => 4)
-            #puts "<dt>" + param.to_s + "</dt>"
-            #puts tab(1) + Puppet::Type.metaparamdoc(param).scrub.indent($tab)gsub(/\n\s*/,' ')
-            #puts "<dd>"
-            #puts indent(scrub(Puppet::Type.metaparamdoc(param)), $tab)
-            #puts scrub(Puppet::Type.metaparamdoc(param))
-            #puts "</dd>"
-
-            #puts ""
-        }
-    rescue => detail
-        puts detail.backtrace
-        puts "incorrect metaparams: %s" % detail
-        exit(1)
-    end
-
-    str += %{
 
 Resource Types
 --------------
@@ -53,7 +17,7 @@ Resource Types
   This is the parameter that gets assigned when a string is provided before
   the colon in a type declaration.  In general, only developers will need to
   worry about which parameter is the ``namevar``.
-  
+
   In the following code::
 
       file { "/etc/passwd":