diff --git a/lib/puppet/rails/host.rb b/lib/puppet/rails/host.rb
index b5831671b..8f4c7375c 100644
--- a/lib/puppet/rails/host.rb
+++ b/lib/puppet/rails/host.rb
@@ -1,319 +1,311 @@
 require 'puppet/rails/resource'
 require 'puppet/rails/fact_name'
 require 'puppet/rails/source_file'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Host < ActiveRecord::Base
     include Puppet::Util
     include Puppet::Util::CollectionMerger
 
     has_many :fact_values, :dependent => :destroy
     has_many :fact_names, :through => :fact_values
     belongs_to :source_file
     has_many :resources, :dependent => :destroy
 
     # If the host already exists, get rid of its objects
     def self.clean(host)
         if obj = self.find_by_name(host)
             obj.rails_objects.clear
             return obj
         else
             return nil
         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)
                 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
 
             # Store the facts into the database.
             host.merge_facts(node.parameters)
 
             seconds = Benchmark.realtime {
                 host.merge_resources(resources)
             }
             Puppet.debug("Handled resources in %0.2f seconds" % seconds)
 
             host.last_compile = Time.now
 
             seconds = Benchmark.realtime {
                 host.save
             }
             Puppet.debug("Saved host in %0.2f seconds" % seconds)
         end
 
         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}'") 
             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 |
             hash[value.fact_name.name] ||= []
             hash[value.fact_name.name] << value
             hash
         end
     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 merge_resources(list)
         resources_by_id = nil
         seconds = Benchmark.realtime {
             resources_by_id = find_resources()
         }
         Puppet.debug("Searched for resources in %0.2f seconds" % seconds)
 
         seconds = Benchmark.realtime {
             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(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 |
             hash[resource.id] = resource
             hash
         end
     end
 
     def find_resources_parameters_tags(resources)
         # initialize all resource parameters
         resources.each do |key,resource|
             resource.params_hash = []
         end
 
         find_resources_parameters(resources)
         find_resources_tags(resources)
     end
 
     def compare_to_catalog(existing, list)
         compiled = list.inject({}) do |hash, resource|
             hash[resource.ref] = resource
             hash
         end
 
         resources = nil
         seconds = Benchmark.realtime {
             resources = remove_unneeded_resources(compiled, existing)
         }
         Puppet.debug("Resource removal took %0.2f seconds" % seconds)
 
         # Now for all resources in the catalog but not in the db, we're pretty easy.
         additions = nil
         seconds = Benchmark.realtime {
             additions = perform_resource_merger(compiled, resources)
         }
         Puppet.debug("Resource merger took %0.2f seconds" % seconds)
 
         seconds = Benchmark.realtime {
             additions.each do |resource|
                 build_rails_resource_from_parser_resource(resource)
             end
         }
         Puppet.debug("Resource addition took %0.2f seconds" % seconds)
     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)
         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
 
         resource.eachparam do |param|
             Puppet::Rails::ParamValue.from_parser_param(param).each do |value_hash|
                 db_resource.param_values.build(value_hash)
             end
         end
 
         resource.tags.each { |tag| db_resource.add_resource_tag(tag) }
 
         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.
         times = Hash.new(0)
         additions = []
         compiled.each do |ref, resource|
             if db_resource = resources[ref]
                 db_resource.merge_parser_resource(resource).each do |name, time|
                     times[name] += time
                 end
             else
                 additions << resource
             end
         end
         times.each do |name, time|
             Puppet.debug("Resource merger(%s) took %0.2f seconds" % [name, time])
         end
 
         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
 
             # 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?
 
-        # Now for all resources in the catalog but not in the db, we're pretty easy.
-        compiled.each do |ref, resource|
-            if db_resource = resources[ref]
-                db_resource.merge_parser_resource(resource)
-            else
-                self.resources << Puppet::Rails::Resource.from_parser_resource(resource)
-            end
-        end
+        return resources
     end
 
     def find_resources_parameters(resources)
         params = Puppet::Rails::ParamValue.find_all_params_from_host(self)
 
         # assign each loaded parameters/tags to the resource it belongs to
         params.each do |param|
             resources[param['resource_id']].add_param_to_hash(param) if resources.include?(param['resource_id'])
         end
     end
 
     def find_resources_tags(resources)
         tags = Puppet::Rails::ResourceTag.find_all_tags_from_host(self)
 
         tags.each do |tag|
             resources[tag['resource_id']].add_tag_to_hash(tag) if resources.include?(tag['resource_id'])
         end
     end
 
     def update_connect_time
         self.last_connect = Time.now
         save
     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
diff --git a/lib/puppet/rails/resource.rb b/lib/puppet/rails/resource.rb
index 27bf96783..0c8c9aa52 100644
--- a/lib/puppet/rails/resource.rb
+++ b/lib/puppet/rails/resource.rb
@@ -1,257 +1,245 @@
 require 'puppet'
 require 'puppet/rails/param_name'
 require 'puppet/rails/param_value'
 require 'puppet/rails/puppet_tag'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Resource < ActiveRecord::Base
     include Puppet::Util::CollectionMerger
     include Puppet::Util::ReferenceSerializer
 
     has_many :param_values, :dependent => :destroy, :class_name => "Puppet::Rails::ParamValue"
     has_many :param_names, :through => :param_values, :class_name => "Puppet::Rails::ParamName"
 
     has_many :resource_tags, :dependent => :destroy, :class_name => "Puppet::Rails::ResourceTag"
     has_many :puppet_tags, :through => :resource_tags, :class_name => "Puppet::Rails::PuppetTag"
 
     belongs_to :source_file
     belongs_to :host
 
-    # Turn a parser resource into a Rails resource.  
-    def self.from_parser_resource(resource)
-        args = rails_resource_initial_args(resource)
-
-        db_resource = create(args)
-
-        # Our file= method does the name to id conversion.
-        db_resource.file = resource.file
-
-        resource.eachparam do |param|
-            Puppet::Rails::ParamValue.from_parser_param(param).each do |value_hash|
-                db_resource.param_values.build(value_hash)
-            end
-        end
-
-        resource.tags.each { |tag| db_resource.add_resource_tag(tag) }
-
-        return db_resource
+    @tags = {}
+    def self.tags
+        @tags
     end
 
     # Determine the basic details on the resource.
     def self.rails_resource_initial_args(resource)
         return [:type, :title, :line, :exported].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
     end
 
     def add_resource_tag(tag)
         pt = Puppet::Rails::PuppetTag.find_or_create_by_name(tag)
         resource_tags.build(:puppet_tag => pt)
     end
 
     def file
         if f = self.source_file
             return f.filename
         else
             return nil
         end
     end
 
     def file=(file)
         self.source_file = Puppet::Rails::SourceFile.find_or_create_by_filename(file)
     end
 
     def title
         unserialize_value(self[:title])
     end
 
     def add_param_to_hash(param)
         @params_hash ||= []
         @params_hash << param
     end
 
     def add_tag_to_hash(tag)
         @tags_hash ||= []
         @tags_hash << tag
     end
 
     def params_hash=(hash)
         @params_hash = hash
     end
 
     def tags_hash=(hash)
         @tags_hash = hash
     end
 
     def [](param)
         return super || parameter(param)
     end
 
     # Make sure this resource is equivalent to the provided Parser resource.
     def merge_parser_resource(resource)
-        merge_attributes(resource)
-        merge_parameters(resource)
-        merge_tags(resource)
+        times = {}
+        times[:attributes] = Benchmark.realtime { merge_attributes(resource) }
+        times[:parameters] = Benchmark.realtime { merge_parameters(resource) }
+        times[:tags] = Benchmark.realtime { merge_tags(resource) }
+
+        times
     end
 
     def merge_attributes(resource)
         args = self.class.rails_resource_initial_args(resource)
         args.each do |param, value|
             self[param] = value unless resource[param] == value
         end
 
         # Handle file specially
         if (resource.file and  (!resource.file or self.file != resource.file))
             self.file = resource.file
         end
     end
 
     def merge_parameters(resource)
         catalog_params = {}
         resource.eachparam do |param|
             catalog_params[param.name.to_s] = param
         end
 
         db_params = {}
 
         deletions = []
         #Puppet::Rails::ParamValue.find_all_params_from_resource(self).each do |value|
         @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].value, 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, param|
             next if db_params.include?(name)
             values = param.value.is_a?(Array) ? param.value : [param.value]
 
             values.each do |v|
                 param_values.build(:value => serialize_value(v), :line => param.line, :param_name => Puppet::Rails::ParamName.find_or_create_by_name(name))
             end
         end
     end
         
     # Make sure the tag list is correct.
     def merge_tags(resource)
         in_db = []
         deletions = []
         resource_tags = resource.tags
         #Puppet::Rails::ResourceTag.find_all_tags_from_resource(self).each do |tag|
         @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
         ref()
     end
 
     def parameter(param)
         if pn = param_names.find_by_name(param)
             if pv = param_values.find(:first, :conditions => [ 'param_name_id = ?', pn])
                 return pv.value
             else
                 return nil
             end
         end
     end
 
     def parameters
         result = get_params_hash
         result.each do |param, value|
             if value.is_a?(Array)
                 result[param] = value.collect { |v| v['value'] }
             else
                 result[param] = value.value
             end
         end
         result
     end
 
     def ref
         "%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.
     def to_resource(scope)
         hash = self.attributes
         hash["type"] = hash["restype"]
         hash.delete("restype")
 
         # FIXME At some point, we're going to want to retain this information
         # for logging and auditing.
         hash.delete("host_id")
         hash.delete("updated_at")
         hash.delete("source_file_id")
         hash.delete("created_at")
         hash.delete("id")
         hash.each do |p, v|
             hash.delete(p) if v.nil?
         end
         hash[:scope] = scope
         hash[:source] = scope.source
         hash[:params] = []
         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
             hash[:params] << pname.to_resourceparam(self, scope.source)
         end
         obj = Puppet::Parser::Resource.new(hash)
 
         # Store the ID, so we can check if we're re-collecting the same resource.
         obj.rails_id = self.id
 
         return obj
     end
 end