puppet 0.24.9 → 0.25.0

data/lib/puppet/rails/database/001_add_created_at_to_all_tables.rb

@@ -2,16 +2,16 @@ class AddCreatedAtToAllTables < ActiveRecord::Migration
     def self.up
         ActiveRecord::Base.connection.tables.each do |t|
             unless ActiveRecord::Base.connection.columns(t).collect {|c| c.name}.include?("created_at")
-                add_column t.to_s, :created_at, :datetime 
-            end    
-        end 
+                add_column t.to_s, :created_at, :datetime
+            end
+        end
     end
 
     def self.down
         ActiveRecord::Base.connection.tables.each do |t|
             unless ActiveRecord::Base.connection.columns(t).collect {|c| c.name}.include?("created_at")
                 remove_column t.to_s, :created_at
-            end    
-        end    
+            end
+        end
     end
 end

data/lib/puppet/rails/database/002_remove_duplicated_index_on_all_tables.rb

@@ -4,7 +4,7 @@ class RemoveDuplicatedIndexOnAllTables < ActiveRecord::Migration
             if ActiveRecord::Base.connection.indexes(t).collect {|c| c.columns}.include?("id")
                 remove_index t.to_s, :id
             end
-        end 
+        end
     end
 
     def self.down
@@ -12,6 +12,6 @@ class RemoveDuplicatedIndexOnAllTables < ActiveRecord::Migration
             unless ActiveRecord::Base.connection.indexes(t).collect {|c| c.columns}.include?("id")
                 add_index t.to_s, :id, :integer => true
             end
-        end    
+        end
     end
 end

data/lib/puppet/rails/database/003_add_environment_to_host.rb

@@ -4,7 +4,7 @@ class AddEnvironmentToHost < ActiveRecord::Migration
             add_column :hosts, :environment, :string
         end
     end
-    
+
     def self.down
         if ActiveRecord::Base.connection.columns(:hosts).collect {|c| c.name}.include?("environment")
             remove_column :hosts, :environment

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

@@ -27,7 +27,7 @@ class Puppet::Rails::Schema
                     add_index :resources, [:title, :restype]
                 end
 
-                create_table :source_files do |t| 
+                create_table :source_files do |t|
                     t.column :filename, :string
                     t.column :path, :string
                     t.column :updated_at, :datetime
@@ -44,7 +44,7 @@ class Puppet::Rails::Schema
                 add_index :resource_tags, :resource_id, :integer => true
                 add_index :resource_tags, :puppet_tag_id, :integer => true
 
-                create_table :puppet_tags do |t| 
+                create_table :puppet_tags do |t|
                     t.column :name, :string
                     t.column :updated_at, :datetime
                     t.column :created_at, :datetime
@@ -66,20 +66,20 @@ class Puppet::Rails::Schema
                 add_index :hosts, :source_file_id, :integer => true
                 add_index :hosts, :name
 
-                create_table :fact_names do |t| 
+                create_table :fact_names do |t|
                     t.column :name, :string, :null => false
                     t.column :updated_at, :datetime
                     t.column :created_at, :datetime
                 end
                 add_index :fact_names, :name
 
-                create_table :fact_values do |t| 
+                create_table :fact_values do |t|
                     t.column :value, :text, :null => false
                     t.column :fact_name_id, :integer, :null => false
                     t.column :host_id, :integer, :null => false
                     t.column :updated_at, :datetime
                     t.column :created_at, :datetime
-                end 
+                end
                 add_index :fact_values, :fact_name_id, :integer => true
                 add_index :fact_values, :host_id, :integer => true
 
@@ -93,14 +93,14 @@ class Puppet::Rails::Schema
                 end
                 add_index :param_values, :param_name_id, :integer => true
                 add_index :param_values, :resource_id, :integer => true
-         
-                create_table :param_names do |t| 
+
+                create_table :param_names do |t|
                     t.column :name, :string, :null => false
                     t.column :updated_at, :datetime
                     t.column :created_at, :datetime
                 end
                 add_index :param_names, :name
-            end 
+            end
         end
     ensure
         $stdout.close

data/lib/puppet/rails/fact_value.rb

@@ -4,7 +4,7 @@ class Puppet::Rails::FactValue < ActiveRecord::Base
 
     def to_label
       "#{self.fact_name.name}"
-    end  
+    end
 end
 
 # $Id: fact_value.rb 1952 2006-12-19 05:47:57Z luke $

data/lib/puppet/rails/host.rb

@@ -1,16 +1,19 @@
 require 'puppet/rails/resource'
 require 'puppet/rails/fact_name'
 require 'puppet/rails/source_file'
+require 'puppet/rails/benchmark'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Host < ActiveRecord::Base
+    include Puppet::Rails::Benchmark
+    extend Puppet::Rails::Benchmark
     include Puppet::Util
     include Puppet::Util::CollectionMerger
 
-    has_many :fact_values, :dependent => :destroy
-    has_many :fact_names, :through => :fact_values
+    has_many :fact_values, :dependent => :destroy, :class_name => "Puppet::Rails::FactValue"
+    has_many :fact_names, :through => :fact_values, :class_name => "Puppet::Rails::FactName"
     belongs_to :source_file
-    has_many :resources, :dependent => :destroy
+    has_many :resources, :dependent => :destroy, :class_name => "Puppet::Rails::Resource"
 
     # If the host already exists, get rid of its objects
     def self.clean(host)
@@ -22,54 +25,75 @@ class Puppet::Rails::Host < ActiveRecord::Base
         end
     end
 
+    def self.from_puppet(node)
+        host = find_by_name(node.name) || new(:name => node.name)
+
+        {"ipaddress" => "ip", "environment" => "environment"}.each do |myparam, itsparam|
+            if value = node.send(myparam)
+                host.send(itsparam + "=", value)
+            end
+        end
+
+        host
+    end
+
     # Store our host in the database.
     def self.store(node, resources)
         args = {}
 
         host = nil
-        transaction do
-            #unless host = find_by_name(name)
-            seconds = Benchmark.realtime {
-                unless host = find_by_name(node.name)
-                    host = new(:name => node.name)
+        railsmark "Stored node" do
+            transaction do
+                #unless host = find_by_name(name)
+
+                debug_benchmark("Searched for host")do
+                    unless host = find_by_name(node.name)
+                        host = new(:name => node.name)
+                    end
+                end
+                if ip = node.parameters["ipaddress"]
+                    host.ip = ip
                 end
-            }
-            Puppet.debug("Searched for host in %0.2f seconds" % seconds)
-            if ip = node.parameters["ipaddress"]
-                host.ip = ip
-            end
 
-            if env = node.environment
-                host.environment = env
-            end
+                if env = node.environment
+                    host.environment = env
+                end
+
+                # Store the facts into the database.
+                host.merge_facts(node.parameters)
 
-            # Store the facts into the database.
-            host.setfacts node.parameters
+                debug_benchmark("Handled resources") {
+                    host.merge_resources(resources)
+                }
 
-            seconds = Benchmark.realtime {
-                host.setresources(resources)
-            }
-            Puppet.debug("Handled resources in %0.2f seconds" % seconds)
+                host.last_compile = Time.now
 
-            host.last_compile = Time.now
+                debug_benchmark("Saved host") {
+                    host.save
+                }
+            end
 
-            host.save
         end
 
+        # This only runs if time debugging is enabled.
+        write_benchmarks
+
         return host
     end
 
     # Return the value of a fact.
     def fact(name)
         if fv = self.fact_values.find(:all, :include => :fact_name,
-                                      :conditions => "fact_names.name = '#{name}'") 
+                                      :conditions => "fact_names.name = '#{name}'")
             return fv
         else
             return nil
         end
     end
-    
+
     # returns a hash of fact_names.name => [ fact_values ] for this host.
+    # Note that 'fact_values' is actually a list of the value instances, not
+    # just actual values.
     def get_facts_hash
         fact_values = self.fact_values.find(:all, :include => :fact_name)
         return fact_values.inject({}) do | hash, value |
@@ -78,60 +102,70 @@ class Puppet::Rails::Host < ActiveRecord::Base
             hash
         end
     end
-    
-
-    def setfacts(facts)
-        facts = facts.dup
-        
-        ar_hash_merge(get_facts_hash(), facts, 
-                      :create => Proc.new { |name, values|
-                          fact_name = Puppet::Rails::FactName.find_or_create_by_name(name)
-                          values = [values] unless values.is_a?(Array)
-                          values.each do |value|
-                              fact_values.build(:value => value,
-                                                :fact_name => fact_name)
-                          end
-                      }, :delete => Proc.new { |values|
-                          values.each { |value| self.fact_values.delete(value) }
-                      }, :modify => Proc.new { |db, mem|
-                          mem = [mem].flatten
-                          fact_name = db[0].fact_name
-                          db_values = db.collect { |fact_value| fact_value.value }
-                          (db_values - (db_values & mem)).each do |value|
-                              db.find_all { |fact_value| 
-                                  fact_value.value == value 
-                              }.each { |fact_value|
-                                  fact_values.delete(fact_value)
-                              }
-                          end
-                          (mem - (db_values & mem)).each do |value|
-                              fact_values.build(:value => value, 
-                                                :fact_name => fact_name)
-                          end
-                      })
+
+
+    # This is *very* similar to the merge_parameters method
+    # of Puppet::Rails::Resource.
+    def merge_facts(facts)
+        db_facts = {}
+
+        deletions = []
+        self.fact_values.find(:all, :include => :fact_name).each do |value|
+            deletions << value['id'] and next unless facts.include?(value['name'])
+            # Now store them for later testing.
+            db_facts[value['name']] ||= []
+            db_facts[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_facts.each do |name, value_hashes|
+            values = value_hashes.collect { |v| v['value'] }
+
+            unless values == facts[name]
+                value_hashes.each { |v| deletions << v['id'] }
+            end
+        end
+
+        # Perform our deletions.
+        Puppet::Rails::FactValue.delete(deletions) unless deletions.empty?
+
+        # Lastly, add any new parameters.
+        facts.each do |name, value|
+            next if db_facts.include?(name)
+            values = value.is_a?(Array) ? value : [value]
+
+            values.each do |v|
+                fact_values.build(:value => v, :fact_name => Puppet::Rails::FactName.find_or_create_by_name(name))
+            end
+        end
     end
 
     # Set our resources.
-    def setresources(list)
-        resource_by_id = nil
-        seconds = Benchmark.realtime {
-            resource_by_id = find_resources()
+    def merge_resources(list)
+        # keep only exported resources in thin_storeconfig mode
+        list = list.select { |r| r.exported? } if Puppet.settings[:thin_storeconfigs]
+
+        resources_by_id = nil
+        debug_benchmark("Searched for resources") {
+            resources_by_id = find_resources()
         }
-        Puppet.debug("Searched for resources in %0.2f seconds" % seconds)
 
-        seconds = Benchmark.realtime {
-            find_resources_parameters_tags(resource_by_id)
+        debug_benchmark("Searched for resource params and tags") {
+            find_resources_parameters_tags(resources_by_id)
         } if id
-        Puppet.debug("Searched for resource params and tags in %0.2f seconds" % seconds)
 
-        seconds = Benchmark.realtime {
-            compare_to_catalog(resource_by_id, list)
+        debug_benchmark("Performed resource comparison") {
+            compare_to_catalog(resources_by_id, list)
         }
-        Puppet.debug("Resource comparison took %0.2f seconds" % seconds)
     end
 
     def find_resources
-        resources.find(:all, :include => :source_file).inject({}) do | hash, resource |
+        condition = { :exported => true } if Puppet.settings[:thin_storeconfigs]
+
+        resources.find(:all, :include => :source_file, :conditions => condition || {}).inject({}) do | hash, resource |
             hash[resource.id] = resource
             hash
         end
@@ -147,38 +181,112 @@ class Puppet::Rails::Host < ActiveRecord::Base
         find_resources_tags(resources)
     end
 
-    # it seems that it can happen (see bug #2010) some resources are duplicated in the
-    # database (ie logically corrupted database), in which case we remove the extraneous
-    # entries.
     def compare_to_catalog(existing, list)
-        extra_db_resources = []
-        resources = existing.inject({}) do |hash, res|
-            resource = res[1]
-            if hash.include?(resource.ref)
-                extra_db_resources << hash[resource.ref]
-            end
+        compiled = list.inject({}) do |hash, resource|
             hash[resource.ref] = resource
             hash
         end
 
-        compiled = list.inject({}) do |hash, resource|
-            hash[resource.ref] = resource
-            hash
+        resources = nil
+        debug_benchmark("Resource removal") {
+            resources = remove_unneeded_resources(compiled, existing)
+        }
+
+        # Now for all resources in the catalog but not in the db, we're pretty easy.
+        additions = nil
+        debug_benchmark("Resource merger") {
+            additions = perform_resource_merger(compiled, resources)
+        }
+
+        debug_benchmark("Resource addition") {
+            additions.each do |resource|
+                build_rails_resource_from_parser_resource(resource)
+            end
+
+            log_accumulated_marks "Added resources"
+        }
+    end
+
+    def add_new_resources(additions)
+        additions.each do |resource|
+            Puppet::Rails::Resource.from_parser_resource(self, resource)
+        end
+    end
+
+    # Turn a parser resource into a Rails resource.
+    def build_rails_resource_from_parser_resource(resource)
+        db_resource = nil
+        accumulate_benchmark("Added resources", :initialization) {
+            args = Puppet::Rails::Resource.rails_resource_initial_args(resource)
+
+            db_resource = self.resources.build(args)
+
+            # Our file= method does the name to id conversion.
+            db_resource.file = resource.file
+        }
+
+
+        accumulate_benchmark("Added resources", :parameters) {
+            resource.each do |param, value|
+                Puppet::Rails::ParamValue.from_parser_param(param, value).each do |value_hash|
+                    db_resource.param_values.build(value_hash)
+                end
+            end
+        }
+
+        accumulate_benchmark("Added resources", :tags) {
+            resource.tags.each { |tag| db_resource.add_resource_tag(tag) }
+        }
+
+        db_resource.save
+
+        return db_resource
+    end
+
+
+    def perform_resource_merger(compiled, resources)
+        return compiled.values if resources.empty?
+
+        # Now for all resources in the catalog but not in the db, we're pretty easy.
+        additions = []
+        compiled.each do |ref, resource|
+            if db_resource = resources[ref]
+                db_resource.merge_parser_resource(resource)
+            else
+                additions << resource
+            end
         end
+        log_accumulated_marks "Resource merger"
 
-        ar_hash_merge(resources, compiled,
-                      :create => Proc.new { |ref, resource|
-                          resource.to_rails(self)
-                      }, :delete => Proc.new { |resource|
-                          self.resources.delete(resource)
-                      }, :modify => Proc.new { |db, mem|
-                          mem.modify_rails(db)
-                      })
+        return additions
+    end
+
+    def remove_unneeded_resources(compiled, existing)
+        deletions = []
+        resources = {}
+        existing.each do |id, resource|
+            # it seems that it can happen (see bug #2010) some resources are duplicated in the
+            # database (ie logically corrupted database), in which case we remove the extraneous
+            # entries.
+            if resources.include?(resource.ref)
+                deletions << id
+                next
+            end
 
-        # fix-up extraneous resources
-        extra_db_resources.each do |resource|
-            self.resources.delete(resource)
+            # If the resource is in the db but not in the catalog, mark it
+            # for removal.
+            unless compiled.include?(resource.ref)
+                deletions << id
+                next
+            end
+
+            resources[resource.ref] = resource
         end
+        # We need to use 'destroy' here, not 'delete', so that all
+        # dependent objects get removed, too.
+        Puppet::Rails::Resource.destroy(deletions) unless deletions.empty?
+
+        return resources
     end
 
     def find_resources_parameters(resources)
@@ -202,5 +310,15 @@ class Puppet::Rails::Host < ActiveRecord::Base
         self.last_connect = Time.now
         save
     end
-end
 
+    def to_puppet
+        node = Puppet::Node.new(self.name)
+        {"ip" => "ipaddress", "environment" => "environment"}.each do |myparam, itsparam|
+            if value = send(myparam)
+                node.send(itsparam + "=", value)
+            end
+        end
+
+        node
+    end
+end