diff --git a/lib/puppet/indirector/exec.rb b/lib/puppet/indirector/exec.rb
index 4683eda0f..8ea13ff95 100644
--- a/lib/puppet/indirector/exec.rb
+++ b/lib/puppet/indirector/exec.rb
@@ -1,48 +1,48 @@
 require 'puppet/indirector/terminus'
 require 'puppet/util'
 
 class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
   # Look for external node definitions.
   def find(request)
     # Run the command.
     unless output = query(request.key)
       return nil
     end
 
     # Translate the output to ruby.
     output
   end
 
   private
 
   # Proxy the execution, so it's easier to test.
-  def execute(command)
-    Puppet::Util.execute(command)
+  def execute(command, arguments)
+    Puppet::Util.execute(command,arguments)
   end
 
   # Call the external command and see if it returns our output.
   def query(name)
     external_command = command
 
     # Make sure it's an arry
     raise Puppet::DevError, "Exec commands must be an array" unless external_command.is_a?(Array)
 
     # Make sure it's fully qualified.
     raise ArgumentError, "You must set the exec parameter to a fully qualified command" unless external_command[0][0] == File::SEPARATOR[0]
 
     # Add our name to it.
     external_command << name
     begin
-      output = execute(external_command)
+      output = execute(external_command, :combine => false)
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error, "Failed to find #{name} via exec: #{detail}"
     end
 
     if output =~ /\A\s*\Z/ # all whitespace
       Puppet.debug "Empty response for #{name} from exec #{self.name} terminus"
       return nil
     else
       return output
     end
   end
 end
diff --git a/spec/unit/indirector/exec_spec.rb b/spec/unit/indirector/exec_spec.rb
index de37f2775..89d91a3ee 100755
--- a/spec/unit/indirector/exec_spec.rb
+++ b/spec/unit/indirector/exec_spec.rb
@@ -1,55 +1,55 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/indirector/exec'
 
 describe Puppet::Indirector::Exec do
   before do
     @indirection = stub 'indirection', :name => :testing
     Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
     @exec_class = Class.new(Puppet::Indirector::Exec) do
       def self.to_s
         "Testing::Mytype"
       end
 
       attr_accessor :command
     end
 
     @searcher = @exec_class.new
     @searcher.command = ["/echo"]
 
     @request = stub 'request', :key => "foo"
   end
 
   it "should throw an exception if the command is not an array" do
     @searcher.command = "/usr/bin/echo"
     proc { @searcher.find(@request) }.should raise_error(Puppet::DevError)
   end
 
   it "should throw an exception if the command is not fully qualified" do
     @searcher.command = ["mycommand"]
     proc { @searcher.find(@request) }.should raise_error(ArgumentError)
   end
 
   it "should execute the command with the object name as the only argument" do
-    @searcher.expects(:execute).with(%w{/echo foo})
+    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false)
     @searcher.find(@request)
   end
 
   it "should return the output of the script" do
-    @searcher.expects(:execute).with(%w{/echo foo}).returns("whatever")
+    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns("whatever")
     @searcher.find(@request).should == "whatever"
   end
 
   it "should return nil when the command produces no output" do
-    @searcher.expects(:execute).with(%w{/echo foo}).returns(nil)
+    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns(nil)
     @searcher.find(@request).should be_nil
   end
 
   it "should raise an exception if there's an execution failure" do
-    @searcher.expects(:execute).with(%w{/echo foo}).raises(Puppet::ExecutionFailure.new("message"))
+    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).raises(Puppet::ExecutionFailure.new("message"))
 
     lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end
 end
diff --git a/spec/unit/indirector/node/exec_spec.rb b/spec/unit/indirector/node/exec_spec.rb
index d214a5ef6..ebf28bd9a 100755
--- a/spec/unit/indirector/node/exec_spec.rb
+++ b/spec/unit/indirector/node/exec_spec.rb
@@ -1,70 +1,70 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/indirector/node/exec'
 
 describe Puppet::Node::Exec do
   before do
     @indirection = mock 'indirection'
     Puppet.settings.stubs(:value).with(:external_nodes).returns("/echo")
     @searcher = Puppet::Node::Exec.new
   end
 
   describe "when constructing the command to run" do
     it "should use the external_node script as the command" do
       Puppet.expects(:[]).with(:external_nodes).returns("/bin/echo")
       @searcher.command.should == %w{/bin/echo}
     end
 
     it "should throw an exception if no external node command is set" do
       Puppet.expects(:[]).with(:external_nodes).returns("none")
       proc { @searcher.find(stub('request', :key => "foo")) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when handling the results of the command" do
     before do
       @name = "yay"
       @node = Puppet::Node.new(@name)
       @node.stubs(:fact_merge)
       Puppet::Node.expects(:new).with(@name).returns(@node)
       @result = {}
       # Use a local variable so the reference is usable in the execute definition.
       result = @result
-      @searcher.meta_def(:execute) do |command|
+      @searcher.meta_def(:execute) do |command, arguments|
         return YAML.dump(result)
       end
 
       @request = stub 'request', :key => @name
     end
 
     it "should translate the YAML into a Node instance" do
       # Use an empty hash
       @searcher.find(@request).should equal(@node)
     end
 
     it "should set the resulting parameters as the node parameters" do
       @result[:parameters] = {"a" => "b", "c" => "d"}
       @searcher.find(@request)
       @node.parameters.should == {"a" => "b", "c" => "d"}
     end
 
     it "should set the resulting classes as the node classes" do
       @result[:classes] = %w{one two}
       @searcher.find(@request)
       @node.classes.should == [ 'one', 'two' ]
     end
 
     it "should merge the node's facts with its parameters" do
       @node.expects(:fact_merge)
       @searcher.find(@request)
     end
 
     it "should set the node's environment if one is provided" do
       @result[:environment] = "yay"
       @searcher.find(@request)
       @node.environment.to_s.should == 'yay'
     end
   end
 end