diff --git a/lib/puppet/indirector/request.rb b/lib/puppet/indirector/request.rb
index 3f7d1c554..5c577a05d 100644
--- a/lib/puppet/indirector/request.rb
+++ b/lib/puppet/indirector/request.rb
@@ -1,162 +1,168 @@
 require 'uri'
 require 'puppet/indirector'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
     attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
     attr_accessor :server, :port, :uri, :protocol
 
     attr_reader :indirection_name
 
     # Is this an authenticated request?
     def authenticated?
         # Double negative, so we just get true or false
         ! ! authenticated
     end
 
     def environment
         unless defined?(@environment) and @environment
             @environment = Puppet::Node::Environment.new()
         end
         @environment
     end
 
     def environment=(env)
         @environment = if env.is_a?(Puppet::Node::Environment)
             env
         else
             Puppet::Node::Environment.new(env)
         end
     end
 
     def escaped_key
         URI.escape(key)
     end
 
-    def indirection_name=(name)
-        @indirection_name = name.to_sym
-    end
-
     # LAK:NOTE This is a messy interface to the cache, and it's only
     # used by the Configurer class.  I decided it was better to implement
     # it now and refactor later, when we have a better design, than
     # to spend another month coming up with a design now that might
     # not be any better.
     def ignore_cache?
         ignore_cache
     end
 
     def ignore_terminus?
         ignore_terminus
     end
 
     def initialize(indirection_name, method, key, options = {})
         options ||= {}
         raise ArgumentError, "Request options must be a hash, not %s" % options.class unless options.is_a?(Hash)
 
         self.indirection_name = indirection_name
         self.method = method
 
         @options = options.inject({}) do |result, ary|
             param, value = ary
             if respond_to?(param.to_s + "=")
                 send(param.to_s + "=", value)
             else
                 result[param] = value
             end
             result
         end
 
         if key.is_a?(String) or key.is_a?(Symbol)
             # If the request key is a URI, then we need to treat it specially,
             # because it rewrites the key.  We could otherwise strip server/port/etc
             # info out in the REST class, but it seemed bad design for the REST
             # class to rewrite the key.
             if key.to_s =~ /^\w+:\/\// # it's a URI
                 set_uri_key(key)
             else
                 @key = key
             end
         else
             @instance = key
             @key = @instance.name
         end
     end
 
     # Look up the indirection based on the name provided.
     def indirection
         Puppet::Indirector::Indirection.instance(indirection_name)
     end
 
+    def indirection_name=(name)
+        @indirection_name = name.to_sym
+    end
+
+
+    def model
+        raise ArgumentError, "Could not find indirection '%s'" % indirection_name unless i = indirection
+        i.model
+    end
+
     # Should we allow use of the cached object?
     def use_cache?
         if defined?(@use_cache)
             ! ! use_cache
         else
             true
         end
     end
 
     # Are we trying to interact with multiple resources, or just one?
     def plural?
         method == :search
     end
 
     # Create the query string, if options are present.
     def query_string
         return "" unless options and ! options.empty?
         "?" + options.collect do |key, value|
             case value
             when nil; next
             when true, false; value = value.to_s
             when Fixnum, Bignum, Float; value = value # nothing
             when String; value = URI.escape(value)
             when Symbol; value = URI.escape(value.to_s)
             when Array; value = URI.escape(YAML.dump(value))
             else
                 raise ArgumentError, "HTTP REST queries cannot handle values of type '%s'" % value.class
             end
 
             "%s=%s" % [key, value]
         end.join("&")
     end
 
     def to_s
         return uri if uri
         return "/%s/%s" % [indirection_name, key]
     end
 
     private
 
     # Parse the key as a URI, setting attributes appropriately.
     def set_uri_key(key)
         @uri = key
         begin
             uri = URI.parse(URI.escape(key))
         rescue => detail
             raise ArgumentError, "Could not understand URL %s: %s" % [source, detail.to_s]
         end
 
         # Just short-circuit these to full paths
         if uri.scheme == "file"
             @key = URI.unescape(uri.path)
             return
         end
 
         @server = uri.host if uri.host
 
         # If the URI class can look up the scheme, it will provide a port,
         # otherwise it will default to '0'.
         if uri.port.to_i == 0 and uri.scheme == "puppet"
             @port = Puppet.settings[:masterport].to_i
         else
             @port = uri.port.to_i
         end
 
         @protocol = uri.scheme
         @key = URI.unescape(uri.path.sub(/^\//, ''))
     end
 end
diff --git a/spec/unit/indirector/request.rb b/spec/unit/indirector/request.rb
index 241f5f9fc..e2a871a5f 100755
--- a/spec/unit/indirector/request.rb
+++ b/spec/unit/indirector/request.rb
@@ -1,275 +1,292 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/indirector/request'
 
 describe Puppet::Indirector::Request do
     describe "when initializing" do
         it "should require an indirection name, a key, and a method" do
             lambda { Puppet::Indirector::Request.new }.should raise_error(ArgumentError)
         end
 
         it "should always convert the indirection name to a symbol" do
             Puppet::Indirector::Request.new("ind", :method, "mykey").indirection_name.should == :ind
         end
 
         it "should use provided value as the key if it is a string" do
             Puppet::Indirector::Request.new(:ind, :method, "mykey").key.should == "mykey"
         end
 
         it "should use provided value as the key if it is a symbol" do
             Puppet::Indirector::Request.new(:ind, :method, :mykey).key.should == :mykey
         end
 
         it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
             instance = mock 'instance', :name => "mykey"
             request = Puppet::Indirector::Request.new(:ind, :method, instance)
             request.key.should == "mykey"
             request.instance.should equal(instance)
         end
 
         it "should support options specified as a hash" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key, :one => :two) }.should_not raise_error(ArgumentError)
         end
 
         it "should support nil options" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.should_not raise_error(ArgumentError)
         end
 
         it "should support unspecified options" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key) }.should_not raise_error(ArgumentError)
         end
 
         it "should fail if options are specified as anything other than nil or a hash" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key, [:one, :two]) }.should raise_error(ArgumentError)
         end
 
         it "should use an empty options hash if nil was provided" do
             Puppet::Indirector::Request.new(:ind, :method, :key, nil).options.should == {}
         end
 
         it "should default to a nil node" do
             Puppet::Indirector::Request.new(:ind, :method, :key, nil).node.should be_nil
         end
 
         it "should set its node attribute if provided in the options" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :node => "foo.com").node.should == "foo.com"
         end
 
         it "should default to a nil ip" do
             Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip.should be_nil
         end
 
         it "should set its ip attribute if provided in the options" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :ip => "192.168.0.1").ip.should == "192.168.0.1"
         end
 
         it "should default to being unauthenticated" do
             Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_authenticated
         end
 
         it "should set be marked authenticated if configured in the options" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :authenticated => "eh").should be_authenticated
         end
 
         it "should keep its options as a hash even if a node is specified" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :node => "eh").options.should be_instance_of(Hash)
         end
 
         it "should keep its options as a hash even if another option is specified" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :foo => "bar").options.should be_instance_of(Hash)
         end
 
         describe "and the request key is a URI" do
             describe "and the URI is a 'file' URI" do
                 before do
                     @request = Puppet::Indirector::Request.new(:ind, :method, "file:///my/file with spaces")
                 end
 
                 it "should set the request key to the unescaped full file path" do
                     @request.key.should == "/my/file with spaces"
                 end
 
                 it "should not set the protocol" do
                     @request.protocol.should be_nil
                 end
 
                 it "should not set the port" do
                     @request.port.should be_nil
                 end
 
                 it "should not set the server" do
                     @request.server.should be_nil
                 end
             end
 
             it "should set the protocol to the URI scheme" do
                 Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").protocol.should == "http"
             end
 
             it "should set the server if a server is provided" do
                 Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").server.should == "host"
             end
 
             it "should set the server and port if both are provided" do
                 Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff").port.should == 543
             end
 
             it "should default to the masterport if the URI scheme is 'puppet'" do
                 Puppet.settings.expects(:value).with(:masterport).returns "321"
                 Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff").port.should == 321
             end
 
             it "should use the provided port if the URI scheme is not 'puppet'" do
                 Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").port.should == 80
             end
 
             it "should set the request key to the unescaped unqualified path from the URI" do
                 Puppet::Indirector::Request.new(:ind, :method, "http:///stuff with spaces").key.should == "stuff with spaces"
             end
 
             it "should set the :uri attribute to the full URI" do
                 Puppet::Indirector::Request.new(:ind, :method, "http:///stuff").uri.should == "http:///stuff"
             end
         end
 
         it "should allow indication that it should not read a cached instance" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_cache => true).should be_ignore_cache
         end
 
         it "should default to not ignoring the cache" do
             Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_cache
         end
 
         it "should allow indication that it should not not read an instance from the terminus" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_terminus => true).should be_ignore_terminus
         end
 
         it "should default to not ignoring the terminus" do
             Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_terminus
         end
     end
 
     it "should look use the Indirection class to return the appropriate indirection" do
         ind = mock 'indirection'
         Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
         request = Puppet::Indirector::Request.new(:myind, :method, :key)
 
         request.indirection.should equal(ind)
     end
 
+    it "should use its indirection to look up the appropriate model" do
+        ind = mock 'indirection'
+        Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
+        request = Puppet::Indirector::Request.new(:myind, :method, :key)
+
+        ind.expects(:model).returns "mymodel"
+
+        request.model.should == "mymodel"
+    end
+
+    it "should fail intelligently when asked to find a model but the indirection cannot be found" do
+        Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
+        request = Puppet::Indirector::Request.new(:myind, :method, :key)
+
+        lambda { request.model }.should raise_error(ArgumentError)
+    end
+
     it "should have a method for determining if the request is plural or singular" do
         Puppet::Indirector::Request.new(:myind, :method, :key).should respond_to(:plural?)
     end
 
     it "should be considered plural if the method is 'search'" do
         Puppet::Indirector::Request.new(:myind, :search, :key).should be_plural
     end
 
     it "should not be considered plural if the method is not 'search'" do
         Puppet::Indirector::Request.new(:myind, :find, :key).should_not be_plural
     end
 
     it "should use its uri, if it has one, as its string representation" do
         Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz").to_s.should == "foo://bar/baz"
     end
 
     it "should use its indirection name and key, if it has no uri, as its string representation" do
         Puppet::Indirector::Request.new(:myind, :find, "key") == "/myind/key"
     end
 
     it "should be able to return the URI-escaped key" do
         Puppet::Indirector::Request.new(:myind, :find, "my key").escaped_key.should == URI.escape("my key")
     end
 
     it "should have an environment accessor" do
         Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").should respond_to(:environment)
     end
 
     it "should set its environment to an environment instance when a string is specified as its environment" do
         Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
     end
 
     it "should use any passed in environment instances as its environment" do
         env = Puppet::Node::Environment.new("foo")
         Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => env).environment.should equal(env)
     end
 
     it "should use the default environment when none is provided" do
         Puppet::Indirector::Request.new(:myind, :find, "my key" ).environment.should equal(Puppet::Node::Environment.new)
     end
 
     describe "when building a query string from its options" do
         before do
             @request = Puppet::Indirector::Request.new(:myind, :find, "my key")
         end
 
         it "should return an empty query string if there are no options" do
             @request.stubs(:options).returns nil
             @request.query_string.should == ""
         end
 
         it "should return an empty query string if the options are empty" do
             @request.stubs(:options).returns({})
             @request.query_string.should == ""
         end
 
         it "should prefix the query string with '?'" do
             @request.stubs(:options).returns(:one => "two")
             @request.query_string.should =~ /^\?/
         end
 
         it "should include all options in the query string, separated by '&'" do
             @request.stubs(:options).returns(:one => "two", :three => "four")
             @request.query_string.sub(/^\?/, '').split("&").sort.should == %w{one=two three=four}.sort
         end
 
         it "should ignore nil options" do
             @request.stubs(:options).returns(:one => "two", :three => nil)
             @request.query_string.should_not be_include("three")
         end
 
         it "should convert 'true' option values into strings" do
             @request.stubs(:options).returns(:one => true)
             @request.query_string.should == "?one=true"
         end
 
         it "should convert 'false' option values into strings" do
             @request.stubs(:options).returns(:one => false)
             @request.query_string.should == "?one=false"
         end
 
         it "should convert to a string all option values that are integers" do
             @request.stubs(:options).returns(:one => 50)
             @request.query_string.should == "?one=50"
         end
 
         it "should convert to a string all option values that are floating point numbers" do
             @request.stubs(:options).returns(:one => 1.2)
             @request.query_string.should == "?one=1.2"
         end
 
         it "should URI-escape all option values that are strings" do
             escaping = URI.escape("one two")
             @request.stubs(:options).returns(:one => "one two")
             @request.query_string.should == "?one=#{escaping}"
         end
 
         it "should YAML-dump and URI-escape arrays" do
             escaping = URI.escape(YAML.dump(%w{one two}))
             @request.stubs(:options).returns(:one => %w{one two})
             @request.query_string.should == "?one=#{escaping}"
         end
 
         it "should convert to a string and URI-escape all option values that are symbols" do
             escaping = URI.escape("sym bol")
             @request.stubs(:options).returns(:one => :"sym bol")
             @request.query_string.should == "?one=#{escaping}"
         end
 
         it "should fail if options other than booleans or strings are provided" do
             @request.stubs(:options).returns(:one => {:one => :two})
             lambda { @request.query_string }.should raise_error(ArgumentError)
         end
     end
 end