mcollective-client 2.6.1 → 2.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c24db8c899fd482feae76bea713511b792381c2
+  data.tar.gz: f5d522ecc91fa9f26758a1c6cd0cb42cb729d191
+SHA512:
+  metadata.gz: f0d0d69945a17275b37071b4f81d77782f17fa7a011d4142c51ccff5419945fd03d91102533dbe9edc311b5bec8b81f28b5385e33c44c9ddf39908d0f56e822e
+  data.tar.gz: 6493eb3a377883e6d9c788cef263fd2bfdb4ae3b6c029f00b333f4518fd41f5125d2c2677287beb83e52de5c784143f90d80de2c0552a6427f1824083e63643e

data/lib/mcollective.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'json'
 require 'stomp'
 require 'timeout'
 require 'digest/md5'
@@ -59,7 +60,7 @@ module MCollective
 
   MCollective::Vendor.load_vendored
 
-  VERSION="@DEVELOPMENT_VERSION@"
+  VERSION="2.7.0"
 
   def self.version
     VERSION

data/lib/mcollective/client.rb

@@ -1,21 +1,44 @@
 module MCollective
   # Helpers for writing clients that can talk to agents, do discovery and so forth
   class Client
-    attr_accessor :options, :stats, :discoverer
+    attr_accessor :options, :stats, :discoverer, :connection_timeout
 
-    def initialize(configfile)
+    def initialize(options)
       @config = Config.instance
-      @config.loadconfig(configfile) unless @config.configured
+      @options = nil
+
+      if options.is_a?(String)
+        # String is the path to a config file
+        @config.loadconfig(options) unless @config.configured
+      elsif options.is_a?(Hash)
+        @config.loadconfig(options[:config]) unless @config.configured
+        @options = options
+        @connection_timeout = options[:connection_timeout]
+      else
+        raise "Invalid parameter passed to Client constructor. Valid types are Hash or String"
+      end
+
+      @connection_timeout ||= @config.connection_timeout
 
       @connection = PluginManager["connector_plugin"]
       @security = PluginManager["security_plugin"]
 
       @security.initiated_by = :client
-      @options = nil
       @subscriptions = {}
 
       @discoverer = Discovery.new(self)
-      @connection.connect
+
+      # Time box the connection if a timeout has been specified
+      # connection_timeout defaults to nil which means it will try forever if
+      # not specified
+      begin
+        Timeout::timeout(@connection_timeout, ClientTimeoutError) do
+          @connection.connect
+        end
+      rescue ClientTimeoutError => e
+        Log.error("Timeout occured while trying to connect to middleware")
+        raise e
+      end
     end
 
     @@request_sequence = 0
@@ -101,9 +124,12 @@ module MCollective
         reply.expected_msgid = requestid
 
         reply.decode!
+
         unless reply.requestid == requestid
           raise(MsgDoesNotMatchRequestID, "Message reqid #{reply.requestid} does not match our reqid #{requestid}")
         end
+
+        Log.debug("Received reply to #{reply.requestid} from #{reply.payload[:senderid]}")
       rescue SecurityValidationFailed => e
         Log.warn("Ignoring a message that did not pass security validations")
         retry
@@ -122,7 +148,7 @@ module MCollective
     # of the discovery being cancelled soon as it reached the
     # requested limit of hosts
     def discover(filter, timeout, limit=0)
-      discovered = @discoverer.discover(filter, timeout, limit)
+      @discoverer.discover(filter.merge({'collective' => collective}), timeout, limit)
     end
 
     # Send a request, performs the passed block for each response

data/lib/mcollective/config.rb

@@ -17,6 +17,7 @@ module MCollective
     attr_reader :default_discovery_method, :default_discovery_options
     attr_reader :publish_timeout, :threaded, :soft_shutdown, :activate_agents
     attr_reader :registration_splay, :discovery_timeout, :soft_shutdown_timeout
+    attr_reader :connection_timeout
 
     def initialize
       @configured = false
@@ -94,6 +95,8 @@ module MCollective
                   @discovery_timeout = Integer(val)
                 when "publish_timeout"
                   @publish_timeout = Integer(val)
+                when "connection_timeout"
+                  @connection_timeout = Integer(val)
                 when "rpcaudit"
                   @rpcaudit = Util.str_to_bool(val)
                 when "rpcauditprovider"
@@ -205,6 +208,7 @@ module MCollective
       @soft_shutdown = false
       @soft_shutdown_timeout = nil
       @activate_agents = true
+      @connection_timeout = nil
     end
 
     def read_plugin_config_dir(dir)

data/lib/mcollective/exceptions.rb

@@ -2,8 +2,9 @@ module MCollective
 # Exceptions for the RPC system
   class DDLValidationError<RuntimeError;end
   class ValidatorError<RuntimeError; end
+  class ClientTimeoutError<RuntimeError; end
   class MsgDoesNotMatchRequestID < RuntimeError; end
-  class MsgTTLExpired<RuntimeError;end   
+  class MsgTTLExpired<RuntimeError;end
   class NotTargettedAtUs<RuntimeError;end
   class RPCError<StandardError;end
   class SecurityValidationFailed<RuntimeError;end

data/lib/mcollective/message.rb

@@ -175,7 +175,21 @@ module MCollective
     def decode!
       raise "Cannot decode message type #{type}" unless [:request, :reply].include?(type)
 
-      @payload = PluginManager["security_plugin"].decodemsg(self)
+      begin
+        @payload = PluginManager["security_plugin"].decodemsg(self)
+      rescue Exception => e
+        if type == :request
+          # If we're a server receiving a request, reraise
+          raise(e)
+        else
+          # We're in the client, log and carry on as best we can
+
+          # Note: mc_sender is unverified.  The verified identity is in the
+          # payload we just failed to decode
+          Log.warn("Failed to decode a message from '#{headers["mc_sender"]}': #{e}")
+          return
+        end
+      end
 
       if type == :request
         raise 'callerid in request is not valid, surpressing reply to potentially forged request' unless PluginManager["security_plugin"].valid_callerid?(payload[:callerid])
@@ -203,7 +217,6 @@ module MCollective
           raise(MsgTTLExpired, "message #{requestid} from #{cid} created at #{msgtime} is #{msg_age} seconds old, TTL is #{ttl}.  Rejecting message.")
         end
       end
-
       raise(NotTargettedAtUs, "Received message is not targetted to us") unless PluginManager["security_plugin"].validate_filter?(payload[:filter])
 
       @validated = true

data/lib/mcollective/monkey_patches.rb

@@ -2,7 +2,7 @@
 # 1.8.5 and 1.8.6
 class String
   def start_with?(str)
-    return self[0 .. (str.length-1)] == str
+    return self[0..(str.length-1)] == str
   end unless method_defined?("start_with?")
 end
 

data/lib/mcollective/optionparser.rb

@@ -181,6 +181,10 @@ module MCollective
       @parser.on("--sort", "Sort the output of an RPC call before processing.") do |v|
         @options[:sort] = true
       end
+
+      @parser.on("--connection-timeout TIMEOUT", Integer, "Set the timeout for establishing a connection to the middleware") do |v|
+        @options[:connection_timeout] = Integer(v)
+      end
     end
 
     private

data/lib/mcollective/pluginpackager.rb

@@ -85,5 +85,14 @@ module MCollective
         end
       end.reject{ |dependency| dependency == nil }
     end
+
+    # Return the path to a plugin's core directories
+    def self.get_plugin_path(target)
+      if (File.exists?(File.join(target, "lib", "mcollective")))
+        return File.join(target, "lib", "mcollective")
+      end
+
+      return target
+    end
   end
 end

data/lib/mcollective/pluginpackager/agent_definition.rb

@@ -7,7 +7,7 @@ module MCollective
 
       def initialize(configuration, mcdependency, plugintype)
         @plugintype = plugintype
-        @path = configuration[:target]
+        @path = PluginPackager.get_plugin_path(configuration[:target])
         @packagedata = {}
         @revision = configuration[:revision] || 1
         @preinstall = configuration[:preinstall]
@@ -42,9 +42,9 @@ module MCollective
 
         agentdir = File.join(@path, "agent")
 
-        if PluginPackager.check_dir_present agentdir
+        if (PluginPackager.check_dir_present(agentdir))
           ddls = Dir.glob(File.join(agentdir, "*.ddl"))
-          agent[:files] = (Dir.glob(File.join(agentdir, "*")) - ddls)
+          agent[:files] = (Dir.glob(File.join(agentdir, "**", "**")) - ddls)
         else
           return nil
         end

data/lib/mcollective/pluginpackager/standard_definition.rb

@@ -6,7 +6,7 @@ module MCollective
 
       def initialize(configuration, mcdependency, plugintype)
         @plugintype = plugintype
-        @path = configuration[:target]
+        @path = PluginPackager.get_plugin_path(configuration[:target])
         @packagedata = {}
         @revision = configuration[:revision] || 1
         @preinstall = configuration[:preinstall]

data/lib/mcollective/rpc/actionrunner.rb

@@ -127,15 +127,31 @@ module MCollective
       end
 
       def path_to_command(command)
-        unless command[0,1] == File::SEPARATOR
-          Config.instance.libdir.each do |libdir|
-            command_file = File.join(libdir, "agent", agent, command)
+        if Util.absolute_path?(command)
+          return command
+        end
 
-            return command_file if File.exist?(command_file)
+        Config.instance.libdir.each do |libdir|
+          command_file_old = File.join(libdir, "agent", agent, command)
+          command_file_new = File.join(libdir, "mcollective", "agent", agent, command)
+          command_file_old_exists = File.exists?(command_file_old)
+          command_file_new_exists = File.exists?(command_file_new)
+
+          if command_file_new_exists && command_file_old_exists
+            Log.debug("Found 'implemented_by' scripts found in two locations #{command_file_old} and #{command_file_new}")
+            Log.debug("Running script: #{command_file_new}")
+            return command_file_new
+          elsif command_file_old_exists
+            Log.debug("Running script: #{command_file_old}")
+            return command_file_old
+          elsif command_file_new_exists
+            Log.debug("Running script: #{command_file_new}")
+            return command_file_new
           end
         end
 
-        return command
+        Log.warn("No script found for: #{command}")
+        command
       end
     end
   end

data/lib/mcollective/rpc/client.rb

@@ -25,11 +25,11 @@ module MCollective
           initial_options = Marshal.load(@@initial_options)
 
         else
-          oparser = MCollective::Optionparser.new({ :verbose => false, 
-                                                    :progress_bar => true, 
-                                                    :mcollective_limit_targets => false, 
-                                                    :batch_size => nil, 
-                                                    :batch_sleep_time => 1 }, 
+          oparser = MCollective::Optionparser.new({ :verbose => false,
+                                                    :progress_bar => true,
+                                                    :mcollective_limit_targets => false,
+                                                    :batch_size => nil,
+                                                    :batch_sleep_time => 1 },
                                                   "filter")
 
           initial_options = oparser.parse do |parser, opts|
@@ -46,8 +46,7 @@ module MCollective
         @initial_options = initial_options
 
         @config = initial_options[:config]
-        @client = MCollective::Client.new(@config)
-        @client.options = initial_options
+        @client = MCollective::Client.new(@initial_options)
 
         @stats = Stats.new
         @agent = agent
@@ -247,7 +246,7 @@ module MCollective
         # TODO(ploubser): The logic here seems poor. It implies that it is valid to
         # pass arguments where batch_mode is set to false and batch_mode > 0.
         # If this is the case we completely ignore the supplied value of batch_mode
-        # and do our own thing. 
+        # and do our own thing.
 
         # if a global batch size is set just use that else set it
         # in the case that it was passed as an argument
@@ -542,10 +541,11 @@ module MCollective
           # and if we're configured to use the first found hosts as the
           # limit method then pass in the limit thus minimizing the amount
           # of work we do in the discover phase and speeding it up significantly
+          filter = @filter.merge({'collective' => @collective})
           if @limit_method == :first and @limit_targets.is_a?(Fixnum)
-            @discovered_agents = @client.discover(@filter, discovery_timeout, @limit_targets)
+            @discovered_agents = @client.discover(filter, discovery_timeout, @limit_targets)
           else
-            @discovered_agents = @client.discover(@filter, discovery_timeout)
+            @discovered_agents = @client.discover(filter, discovery_timeout)
           end
 
           @stderr.puts(@discovered_agents.size) if verbose
@@ -625,7 +625,7 @@ module MCollective
         unless Config.instance.direct_addressing
           raise "Can only set batch size if direct addressing is supported"
         end
-        
+
         validate_batch_size(limit)
 
         @batch_size = limit
@@ -813,10 +813,10 @@ module MCollective
           processed_nodes = 0
 
           discovered.in_groups_of(batch_size) do |hosts|
-            message = Message.new(req, nil, {:agent => @agent, 
-                                             :type => :direct_request, 
-                                             :collective => @collective, 
-                                             :filter => opts[:filter], 
+            message = Message.new(req, nil, {:agent => @agent,
+                                             :type => :direct_request,
+                                             :collective => @collective,
+                                             :filter => opts[:filter],
                                              :options => opts})
 
             # first time round we let the Message object create a request id
@@ -1007,7 +1007,7 @@ module MCollective
       end
 
       private
-      
+
       def determine_batch_mode(batch_size)
         if (batch_size != 0 && batch_size != "0")
           return true

data/lib/mcollective/vendor/require_vendored.rb

@@ -1,2 +1 @@
 require 'systemu'
-require 'json'

data/spec/unit/client_spec.rb

@@ -4,7 +4,13 @@ require 'spec_helper'
 
 module MCollective
   describe Client do
-    before do
+    let(:client) do
+      c = Client.new("/nonexisting")
+      c.options = Util.default_options
+      c
+    end
+
+    before :each do
       @security = mock
       @security.stubs(:initiated_by=)
       @connector = mock
@@ -20,9 +26,19 @@ module MCollective
       Config.instance.instance_variable_set("@configured", true)
       PluginManager.expects("[]").with("connector_plugin").returns(@connector)
       PluginManager.expects("[]").with("security_plugin").returns(@security)
+      Timeout.stubs(:timeout).with(nil, MCollective::ClientTimeoutError)
+    end
 
-      @client = Client.new("/nonexisting")
-      @client.options = Util.default_options
+    describe "#initialize" do
+      it "should set a timeout if a timeout has been specified" do
+        Timeout.expects(:timeout).with(1, MCollective::ClientTimeoutError)
+        Client.new({:config => "/nonexisting", :connection_timeout => 1})
+      end
+
+      it "should try forever if no timeout has been set" do
+        Timeout.expects(:timeout).with(nil, MCollective::ClientTimeoutError)
+        Client.new({:config => "/nonexisting"})
+      end
     end
 
     describe "#sendreq" do
@@ -31,10 +47,10 @@ module MCollective
         request.stubs(:agent)
         request.stubs(:ttl)
         request.stubs(:collective)
-        @client.expects(:createreq).with(request, "rspec", {}).returns(request)
+        client.expects(:createreq).with(request, "rspec", {}).returns(request)
         request.expects(:publish)
         request.expects(:requestid).returns("13fegbcw").twice
-        result = @client.sendreq(request, "rspec")
+        result = client.sendreq(request, "rspec")
         result.should == "13fegbcw"
       end
     end
@@ -43,36 +59,36 @@ module MCollective
       it "should create a request" do
         message = Message.new("rspec", nil, {:agent => "rspec", :type => :request, :collective => "mcollective", :filter => Util.empty_filter, :options => Util.default_options})
         message.stubs(:encode!)
-        @client.stubs(:subscribe)
+        client.stubs(:subscribe)
         message.stubs(:reply_to)
-        result = @client.createreq(message, "rspec")
+        result = client.createreq(message, "rspec")
         result.should == message
       end
 
       it "should create a new request if the message if not of type Message" do
         message = mock
         message.stubs(:encode!)
-        @client.stubs(:subscribe)
+        client.stubs(:subscribe)
         message.stubs(:reply_to)
         Message.expects(:new).returns(message)
-        result = @client.createreq("message", "rspec")
+        result = client.createreq("message", "rspec")
         result.should == message
       end
 
       it "should subscripe to the reply queue unless has been specified" do
         message = Message.new("rspec", nil, {:agent => "rspec", :type => :request, :collective => "mcollective", :filter => Util.empty_filter, :options => Util.default_options})
         message.stubs(:encode!)
-        @client.expects(:subscribe).with("rspec", :reply)
+        client.expects(:subscribe).with("rspec", :reply)
         message.stubs(:reply_to).returns(nil)
-        @client.createreq(message, "rspec")
+        client.createreq(message, "rspec")
       end
 
       it "should not subscribe to the reply queue if one has been specified" do
         message = Message.new("rspec", nil, {:agent => "rspec", :type => :request, :collective => "mcollective", :filter => Util.empty_filter, :options => Util.default_options})
         message.stubs(:encode!)
-        @client.expects(:subscribe).never
+        client.expects(:subscribe).never
         message.stubs(:reply_to).returns(:reply)
-        @client.createreq(message, "rspec")
+        client.createreq(message, "rspec")
       end
     end
 
@@ -81,75 +97,85 @@ module MCollective
         subscription = mock
         Util.stubs(:make_subscriptions).returns(subscription)
         Util.expects(:subscribe).with(subscription)
-        @client.subscribe("rspec", :queue)
-        @client.instance_variable_get(:@subscriptions).should == {"rspec" => 1}
+        client.subscribe("rspec", :queue)
+        client.instance_variable_get(:@subscriptions).should == {"rspec" => 1}
       end
 
       it "should not subscribe to a destination if it already has" do
-        @client.instance_variable_get(:@subscriptions)["rspec"] = 1
+        client.instance_variable_get(:@subscriptions)["rspec"] = 1
         Util.expects(:make_subscription).never
-        @client.subscribe("rspec", :queue)
+        client.subscribe("rspec", :queue)
       end
     end
 
     describe "#unsubscribe" do
       it "should unsubscribe if a subscription has been made" do
         subscription = mock
-        @client.instance_variable_get(:@subscriptions)["rspec"] = 1
+        client.instance_variable_get(:@subscriptions)["rspec"] = 1
         Util.expects(:make_subscriptions).returns(subscription)
         Util.expects(:unsubscribe).with(subscription)
-        @client.unsubscribe("rspec", :queue)
+        client.unsubscribe("rspec", :queue)
       end
 
       it "should no unsubscribe if a subscription hasn't been made" do
         Util.expects(:make_subscription).never
-        @client.unsubscribe("rspec", :queue)
+        client.unsubscribe("rspec", :queue)
       end
     end
 
     describe "receive" do
       let(:message) do
-        m = mock
+        m = mock('message')
         m.stubs(:type=)
         m.stubs(:expected_msgid=)
         m.stubs(:decode!)
         m.stubs(:requestid).returns("erfs123")
+        m.stubs(:payload).returns({:senderid => 'test-sender'})
         m
       end
 
       let(:badmessage) do
-        m = mock
+        m = mock('badmessage')
         m.stubs(:type=)
         m.stubs(:expected_msgid=)
         m.stubs(:decode!)
         m.stubs(:requestid).returns("badmessage")
+        m.stubs(:payload).returns({})
         m
       end
 
       it "should receive a message" do
         @connector.stubs(:receive).returns(message)
-        result = @client.receive("erfs123")
+        result = client.receive("erfs123")
         result.should == message
       end
 
-      it "log and retry if the message reqid does not match the expected msgid" do
+      it 'should log who the message was from' do
+        @connector.stubs(:receive).returns(message)
+        Log.expects(:debug).with("Received reply to erfs123 from test-sender")
+
+        client.receive("erfs123")
+      end
+
+      it "should log and retry if the message reqid does not match the expected msgid" do
+        Log.stubs(:debug)
         Log.expects(:debug).with("Ignoring a message for some other client : Message reqid badmessage does not match our reqid erfs123")
         @connector.stubs(:receive).returns(badmessage, message)
-        @client.receive("erfs123")
+        client.receive("erfs123")
       end
 
       it "should log and retry if a SecurityValidationFailed expection is raised" do
         Log.expects(:warn).with("Ignoring a message that did not pass security validations")
         badmessage.stubs(:decode!).raises(SecurityValidationFailed)
         @connector.stubs(:receive).returns(badmessage, message)
-        @client.receive("erfs123")
+        client.receive("erfs123")
       end
     end
 
     describe "#discover" do
       it "should delegate to the discovery plugins" do
-        @discoverer.expects(:discover).with({}, 1, 0).returns([])
-        @client.discover({}, 1).should == []
+        @discoverer.expects(:discover).with({'collective' => 'mcollective'}, 1, 0).returns([])
+        client.discover({}, 1).should == []
       end
     end
 
@@ -171,23 +197,23 @@ module MCollective
       end
 
       before :each do
-        @client.expects(:unsubscribe)
+        client.expects(:unsubscribe)
         @discoverer.expects(:discovery_timeout).with(message.options[:timeout], message.options[:filter]).returns(0)
-        @client.stubs(:createreq).returns(request)
-        @client.expects(:update_stat)
+        client.stubs(:createreq).returns(request)
+        client.expects(:update_stat)
       end
 
       it "should thread the publisher and receiver if configured" do
-        @client.instance_variable_get(:@options)[:threaded] = true
-        @client.expects(:threaded_req).with(request, nil, 0, 1)
+        client.instance_variable_get(:@options)[:threaded] = true
+        client.expects(:threaded_req).with(request, nil, 0, 1)
         message.options[:threaded] = true
-        @client.req(message)
+        client.req(message)
       end
 
       it "should not thread the publisher and receiver if configured" do
-        @client.instance_variable_set(:@threaded, false)
-        @client.expects(:unthreaded_req).with(request, nil, 0, 1)
-        @client.req(message)
+        client.instance_variable_set(:@threaded, false)
+        client.expects(:unthreaded_req).with(request, nil, 0, 1)
+        client.req(message)
       end
     end
 
@@ -195,9 +221,9 @@ module MCollective
       it "should start a publisher and then start a receiver" do
         request = mock
         request.stubs(:requestid).returns("erfs123")
-        @client.expects(:start_publisher).with(request, 5)
-        @client.expects(:start_receiver).with("erfs123", 2, 10)
-        @client.unthreaded_req(request, 5, 10, 2)
+        client.expects(:start_publisher).with(request, 5)
+        client.expects(:start_receiver).with("erfs123", 2, 10)
+        client.unthreaded_req(request, 5, 10, 2)
       end
     end
 
@@ -209,10 +235,10 @@ module MCollective
         r_thread = mock
         Thread.expects(:new).yields.returns(p_thread)
         Thread.expects(:new).yields.returns(r_thread)
-        @client.expects(:start_publisher).with(request, 5)
-        @client.expects(:start_receiver).with("erfs123", 2, 15).returns(2)
+        client.expects(:start_publisher).with(request, 5)
+        client.expects(:start_receiver).with("erfs123", 2, 15).returns(2)
         p_thread.expects(:join)
-        result = @client.threaded_req(request, 5, 10, 2)
+        result = client.threaded_req(request, 5, 10, 2)
         result.should == 2
       end
     end
@@ -230,13 +256,13 @@ module MCollective
       it "should publish the message" do
         Timeout.stubs(:timeout).with(2).yields
         message.expects(:publish)
-        @client.start_publisher(message, 2)
+        client.start_publisher(message, 2)
       end
 
       it "should log a warning on a timeout" do
-        Timeout.stubs(:timeout).raises(Timeout::Error)
+        Timeout.stubs(:timeout).with(2).raises(Timeout::Error)
         Log.expects(:warn).with("Could not publish all messages. Publishing timed out.")
-        @client.start_publisher(message,2)
+        client.start_publisher(message,2)
       end
     end
 
@@ -245,9 +271,9 @@ module MCollective
         results = []
         Timeout.stubs(:timeout).yields
         message = mock
-        @client.stubs(:receive).with("erfs123").returns(message)
+        client.stubs(:receive).with("erfs123").returns(message)
         message.stubs(:payload).returns("msg1", "msg2", "msg3")
-        @client.start_receiver("erfs123", 3, 5) do |msg|
+        client.start_receiver("erfs123", 3, 5) do |msg|
           results << msg
         end
         results.should == ["msg1", "msg2", "msg3"]
@@ -257,10 +283,10 @@ module MCollective
         results = []
         Timeout.stubs(:timeout).yields
         message = mock
-        @client.stubs(:receive).with("erfs123").returns(message)
+        client.stubs(:receive).with("erfs123").returns(message)
         message.stubs(:payload).returns("msg1", "msg2", "timeout")
         Log.expects(:warn).with("Could not receive all responses. Expected : 3. Received : 2")
-        responded = @client.start_receiver("erfs123", 3, 5) do |msg|
+        responded = client.start_receiver("erfs123", 3, 5) do |msg|
           if msg == "timeout"
             raise Timeout::Error
           end
@@ -274,10 +300,10 @@ module MCollective
         results = []
         Timeout.stubs(:timeout).yields
         message = mock
-        @client.stubs(:receive).with("erfs123").returns(message)
+        client.stubs(:receive).with("erfs123").returns(message)
         message.stubs(:payload).returns("msg1", "msg2", "timeout")
         Log.expects(:warn).never
-        responded = @client.start_receiver("erfs123", 2, 5) do |msg|
+        responded = client.start_receiver("erfs123", 2, 5) do |msg|
           if msg == "timeout"
             raise Timeout::Error
           end
@@ -291,7 +317,7 @@ module MCollective
     describe "#update_stat" do
       let(:before) do
         { :starttime     => Time.now.to_f,
-          :discoverytime => 0, 
+          :discoverytime => 0,
           :blocktime     => 0,
           :totaltime     => 0 }
       end
@@ -308,14 +334,14 @@ module MCollective
 
       it "should update stats and return the stats hash" do
         Time.stubs(:now).returns(10, 20)
-        @client.update_stat(before, 5, "erfs123").should == after
+        client.update_stat(before, 5, "erfs123").should == after
       end
     end
 
     describe "#discovered_req" do
       it "should raise a deprecation exception" do
         expect{
-          @client.discovered_req(nil, nil)
+          client.discovered_req(nil, nil)
           }.to raise_error("Client#discovered_req has been removed, please port your agent and client to the SimpleRPC framework")
       end
     end