diff --git a/lib/puppet/rails/host.rb b/lib/puppet/rails/host.rb
index 6c008bccf..986cebd0a 100644
--- a/lib/puppet/rails/host.rb
+++ b/lib/puppet/rails/host.rb
@@ -1,322 +1,323 @@
+require 'puppet/rails'
 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, :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, :class_name => "Puppet::Rails::Resource"
 
   # 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
     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
 
         if env = node.environment
           host.environment = env
         end
 
         # Store the facts into the database.
         host.merge_facts(node.parameters)
 
         debug_benchmark("Handled resources") {
           host.merge_resources(resources)
         }
 
         host.last_compile = Time.now
 
         debug_benchmark("Saved host") {
           host.save
         }
       end
 
     end
 
     # This only runs if time debugging is enabled.
     write_benchmarks
 
     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)
     # 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
     }
 
     debug_benchmark("Searched for resource params and tags") {
       find_resources_parameters_tags(resources_by_id)
     } if id
 
     debug_benchmark("Performed resource comparison") {
       compare_to_catalog(resources_by_id, list)
     }
   end
 
   def find_resources
     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
   end
 
   def find_resources_parameters_tags(resources)
     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
     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
 
     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"
 
     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?
 
     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_list(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_list(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/reference/network.rb b/lib/puppet/reference/network.rb
index a3bff656b..15e4f6769 100644
--- a/lib/puppet/reference/network.rb
+++ b/lib/puppet/reference/network.rb
@@ -1,37 +1,39 @@
+require 'puppet/network/handler'
+
 network = Puppet::Util::Reference.newreference :network, :depth => 2, :doc => "Available network handlers and clients" do
   ret = ""
   Puppet::Network::Handler.subclasses.sort { |a,b| a.to_s <=> b.to_s }.each do |name|
     handler = Puppet::Network::Handler.handler(name)
 
     next if ! handler.doc or handler.doc == ""
 
     interface = handler.interface
 
     ret += h(name, 2)
 
     ret += scrub(handler.doc)
     ret += "\n\n"
     ret += option(:prefix, interface.prefix)
     ret += option(:side, handler.side.to_s.capitalize)
     ret += option(:methods, interface.methods.collect { |ary| ary[0] }.join(", ") )
     ret += "\n\n"
   end
 
   ret
 end
 
 network.header = "
 This is a list of all Puppet network interfaces.  Each interface is
 implemented in the form of a client and a handler; the handler is loaded
 on the server, and the client knows how to call the handler's methods
 appropriately.
 
 Most handlers are meant to be started on the server, usually within
 ``puppet master``, and the clients are mostly started on the client,
 usually within ``puppet agent``.
 
 You can find the server-side handler for each interface at
 ``puppet/network/handler/<name>.rb`` and the client class at
 ``puppet/network/client/<name>.rb``.
 
 "