mcollective-client 2.2.4 → 2.4.0

data/spec/unit/rpc/actionrunner_spec.rb

@@ -151,7 +151,8 @@ module MCollective
           if Util.windows?
             @runner.canrun?(File.join(ENV['SystemRoot'], "explorer.exe")).should == true
           else
-            @runner.canrun?("/bin/true").should == true
+            true_exe = ENV["PATH"].split(File::PATH_SEPARATOR).map {|f| p = File.join(f, "true") ;p if File.exists?(p)}.compact.first
+            @runner.canrun?(true_exe).should == true
           end
         end
 

data/spec/unit/rpc/agent_spec.rb

@@ -8,6 +8,8 @@ module MCollective
       before do
         ddl = stub
         ddl.stubs(:meta).returns({})
+        ddl.stubs(:action).returns([])
+        ddl.stubs(:validate_rpc_request).returns(true)
         DDL.stubs(:new).returns(ddl)
 
         @agent = Agent.new
@@ -15,9 +17,136 @@ module MCollective
         @agent.request = {}
       end
 
+      describe "#handlemsg" do
+        before do
+          Reply.any_instance.stubs(:initialize_data)
+
+          @agent.stubs(:respond_to?).with("rspec_action_action").returns(true)
+          @agent.stubs(:respond_to?).with("authorization_hook").returns(false)
+          @agent.stubs(:rspec_action_action).returns(nil)
+
+          @msg = {:msgtime => 1356006671,
+                  :senderid => "example.com",
+                  :requestid => "55f8abe1442328321667877a08bdc586",
+                  :body => {:agent => "rspec_agent",
+                            :action => "rspec_action",
+                            :data => {}},
+                  :caller => "cert=rspec"}
+        end
+
+        it "should or validate the incoming request" do
+          Request.any_instance.expects(:validate!).raises(DDLValidationError, "Failed to validate")
+
+          reply = @agent.handlemsg(@msg, DDL.new)
+
+          reply[:statuscode].should == 4
+          reply[:statusmsg].should == "Failed to validate"
+        end
+
+        it "should call the authorization hook if set" do
+          @agent.expects(:respond_to?).with("authorization_hook").returns(true)
+          @agent.expects(:authorization_hook).raises("authorization denied")
+          Log.stubs(:error)
+
+          reply = @agent.handlemsg(@msg, DDL.new)
+
+          reply[:statuscode].should == 5
+          reply[:statusmsg].should == "authorization denied"
+        end
+
+        it "should audit the request" do
+          @agent.expects(:audit_request)
+
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 0
+        end
+
+        it "should call the before_processing_hook" do
+          @agent.expects(:before_processing_hook)
+
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 0
+        end
+
+        it "should fail if the action does not exist" do
+          @agent.expects(:respond_to?).with("rspec_action_action").returns(false)
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 2
+        end
+
+        it "should call the action correctly" do
+          @agent.expects(:rspec_action_action)
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 0
+        end
+
+        it "should handle RPC Aborted errors" do
+          @agent.expects(:rspec_action_action).raises(RPCAborted, "rspec test")
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 1
+          reply[:statusmsg].should == "rspec test"
+        end
+
+        it "should handle Unknown Action errors" do
+          @agent.stubs(:respond_to?).with("rspec_action_action").returns(false)
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 2
+          reply[:statusmsg].should == "Unknown action 'rspec_action' for agent 'rspec_agent'"
+        end
+
+        it "should handle Missing Data errors" do
+          @agent.expects(:rspec_action_action).raises(MissingRPCData, "rspec test")
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 3
+          reply[:statusmsg].should == "rspec test"
+        end
+
+        it "should handle Invalid Data errors" do
+          @agent.expects(:rspec_action_action).raises(InvalidRPCData, "rspec test")
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 4
+          reply[:statusmsg].should == "rspec test"
+        end
+
+        it "should handle unknown errors" do
+          @agent.expects(:rspec_action_action).raises(UnknownRPCError, "rspec test")
+          Log.expects(:error).twice
+
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 5
+          reply[:statusmsg].should == "rspec test"
+        end
+
+        it "should handle arbitrary exceptions" do
+          @agent.expects(:rspec_action_action).raises(Exception, "rspec test")
+          Log.expects(:error).twice
+
+          reply = @agent.handlemsg(@msg, DDL.new)
+          reply[:statuscode].should == 5
+          reply[:statusmsg].should == "rspec test"
+        end
+
+        it "should call the after_processing_hook" do
+          @agent.expects(:after_processing_hook)
+          reply = @agent.handlemsg(@msg, DDL.new)
+        end
+
+        it "should respond if required" do
+          Request.any_instance.expects(:should_respond?).returns(true)
+          Reply.any_instance.expects(:to_hash).returns({})
+          @agent.handlemsg(@msg, DDL.new).should == {}
+        end
+
+        it "should not respond when not required" do
+          Request.any_instance.expects(:should_respond?).returns(false)
+          Reply.any_instance.expects(:to_hash).never
+          @agent.handlemsg(@msg, DDL.new).should == nil
+        end
+      end
+
       describe "#meta" do
         it "should be deprecated" do
-          Log.expects(:warn).with(regexp_matches(/setting meta data in agents have been deprecated/))
+          Log.expects(:warn).with(regexp_matches(/Setting metadata in agents has been deprecated/))
           Agent.metadata("foo")
         end
       end

data/spec/unit/rpc/client_spec.rb

@@ -62,6 +62,19 @@ module MCollective
         end
       end
 
+      describe "#validate_request" do
+        it "should fail when a DDL isn't present" do
+          @client.instance_variable_set("@ddl", nil)
+          expect { @client.validate_request("rspec", {}) }.to raise_error("No DDL found for agent foo cannot validate inputs")
+        end
+
+        it "should validate the input arguments" do
+          @client.ddl.expects(:set_default_input_arguments).with("rspec", {})
+          @client.ddl.expects(:validate_rpc_request).with("rspec", {})
+          @client.validate_request("rspec", {})
+        end
+      end
+
       describe "#process_results_with_block" do
         it "should inform the stats object correctly for passed requests" do
           response = {:senderid => "rspec", :body => {:statuscode => 0}}
@@ -215,7 +228,9 @@ module MCollective
 
       describe "#discovery_method=" do
         it "should set the method" do
+          @client.default_discovery_method.should == true
           @client.discovery_method = "rspec"
+          @client.default_discovery_method.should == false
           @client.discovery_method.should == "rspec"
         end
 
@@ -224,6 +239,7 @@ module MCollective
           client.discovery_method = "rspec"
           client.discovery_method.should == "rspec"
           client.discovery_options.should == ["rspec"]
+          client.default_discovery_method.should == false
         end
 
         it "should clear the options if none are given initially" do
@@ -263,6 +279,77 @@ module MCollective
         end
       end
 
+      describe "#class_filter" do
+        it "should add a class to the filter" do
+          @client.class_filter("rspec")
+          @client.filter["cf_class"].should == ["rspec"]
+        end
+
+        it "should be idempotent" do
+          @client.class_filter("rspec")
+          @client.class_filter("rspec")
+          @client.filter["cf_class"].should == ["rspec"]
+        end
+      end
+
+      describe "#fact_filter" do
+        before do
+          Util.stubs(:parse_fact_string).with("rspec=present").returns({:value => "present", :fact => "rspec", :operator => "=="})
+        end
+
+        it "should add a fact to the filter" do
+          @client.fact_filter("rspec", "present", "=")
+          @client.filter["fact"].should == [{:value=>"present", :fact=>"rspec", :operator=>"=="}]
+        end
+
+        it "should be idempotent" do
+          @client.fact_filter("rspec", "present", "=")
+          @client.fact_filter("rspec", "present", "=")
+          @client.filter["fact"].should == [{:value=>"present", :fact=>"rspec", :operator=>"=="}]
+        end
+      end
+
+      describe "#agent_filter" do
+        it "should add an agent to the filter" do
+          @client.filter["agent"].should == ["foo"]
+        end
+
+        it "should be idempotent" do
+          @client.agent_filter("foo")
+          @client.filter["agent"].should == ["foo"]
+        end
+      end
+
+      describe "#identity_filter" do
+        it "should add a node to the filter" do
+          @client.identity_filter("rspec_node")
+          @client.filter["identity"].should == ["rspec_node"]
+        end
+
+        it "should be idempotent" do
+          @client.identity_filter("rspec_node")
+          @client.identity_filter("rspec_node")
+          @client.filter["identity"].should == ["rspec_node"]
+        end
+      end
+
+      describe "#compound_filter" do
+        before do
+          Matcher.stubs(:create_compound_callstack).with("filter").returns("filter")
+        end
+
+        it "should add a compound filter" do
+          @client.compound_filter("filter")
+          @client.filter["compound"].should == ["filter"]
+        end
+
+        it "should be idempotent" do
+          @client.compound_filter("filter")
+          @client.compound_filter("filter")
+          @client.filter["compound"].should == ["filter"]
+        end
+      end
+
       describe "#discovery_timeout" do
         it "should favour the initial options supplied timeout" do
           client = Client.new("rspec", {:options => {:disctimeout => 3, :filter => Util.empty_filter, :config => "/nonexisting"}})
@@ -321,9 +408,7 @@ module MCollective
 
           client.stubs(:call_agent)
 
-          ddl = mock
-          ddl.expects(:validate_rpc_request).with("rspec", {:arg => :val}).raises("validation failed")
-          client.instance_variable_set("@ddl", ddl)
+          client.expects(:validate_request).with("rspec", {:arg => :val}).raises("validation failed")
 
           expect { client.rspec(:arg => :val) }.to raise_error("validation failed")
         end
@@ -482,6 +567,87 @@ module MCollective
         end
       end
 
+      describe "#fire_and_forget_request" do
+        before do
+          @client = stub
+          @discoverer = stub
+          @ddl = stub
+
+          @ddl.stubs(:meta).returns({:timeout => 2})
+
+          @discoverer.stubs(:force_direct_mode?).returns(false)
+          @discoverer.stubs(:ddl).returns(@ddl)
+          @discoverer.stubs(:discovery_method).returns("mc")
+
+          @client.stubs("options=")
+          @client.stubs(:collective).returns("mcollective")
+          @client.stubs(:discoverer).returns(@discoverer)
+          @client.stubs(:sendreq)
+
+          Config.instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          MCollective::Client.expects(:new).returns(@client)
+          Config.instance.stubs(:direct_addressing).returns(true)
+
+          @rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          @rpcclient.stubs(:validate_request)
+          @request = stub
+          @rpcclient.stubs(:new_request).returns(@request)
+        end
+
+        it "should validate the request" do
+          @rpcclient.expects(:validate_request).with("rspec", {:rspec => "test"}).raises("rspec")
+
+          expect {
+            @rpcclient.fire_and_forget_request("rspec", {:rspec => "test"})
+          }.to raise_error("rspec")
+        end
+
+        it "should set the filter if it was specifically supplied" do
+          message = mock
+          Message.expects(:new).with(@request, nil, {:agent => "foo", :type => :request, :collective => "mcollective", :filter => "filter", :options => @rpcclient.options}).returns(message)
+
+          @rpcclient.expects(:identity_filter_discovery_optimization)
+          @rpcclient.fire_and_forget_request("rspec", {:rspec => "test"}, "filter")
+        end
+
+        it "should set reply_to if set" do
+          message = mock
+          Message.expects(:new).with(@request, nil, {:agent => "foo", :type => :request, :collective => "mcollective", :filter => @rpcclient.filter, :options => @rpcclient.options}).returns(message)
+
+          @rpcclient.reply_to = "/reply/to"
+          message.expects(:reply_to=).with("/reply/to")
+
+          @rpcclient.expects(:identity_filter_discovery_optimization)
+          @rpcclient.fire_and_forget_request("rspec", {:rspec => "test"})
+        end
+
+        it "should support direct_requests with discovery data supplied" do
+          message = mock
+          Message.expects(:new).with(@request, nil, {:agent => "foo", :type => :request, :collective => "mcollective", :filter => @rpcclient.filter, :options => @rpcclient.options}).returns(message)
+
+          @rpcclient.discover :nodes => "rspec"
+          message.expects(:discovered_hosts=).with(["rspec"])
+          message.expects(:type=).with(:direct_request)
+
+          @rpcclient.expects(:identity_filter_discovery_optimization)
+          @rpcclient.fire_and_forget_request("rspec", {:rspec => "test"})
+        end
+
+        it "should support direct_requests with discoverers that force direct mode" do
+          message = mock
+          Message.expects(:new).with(@request, nil, {:agent => "foo", :type => :request, :collective => "mcollective", :filter => @rpcclient.filter, :options => @rpcclient.options}).returns(message)
+
+          @discoverer.stubs(:force_direct_mode?).returns(true)
+          @rpcclient.stubs(:discover).returns(["rspec"])
+
+          message.expects(:discovered_hosts=).with(["rspec"])
+          message.expects(:type=).with(:direct_request)
+
+          @rpcclient.expects(:identity_filter_discovery_optimization)
+          @rpcclient.fire_and_forget_request("rspec", {:rspec => "test"})
+        end
+      end
+
       describe "#call_agent_batched" do
         before do
           @client = stub

data/spec/unit/security/base_spec.rb

@@ -10,7 +10,6 @@ module MCollective
         @config.stubs(:identity).returns("test")
         @config.stubs(:configured).returns(true)
         @config.stubs(:topicsep).returns(".")
-        @config.stubs(:topicprefix).returns("/topic/")
 
         @stats = mock("stats")
 

data/spec/unit/shell_spec.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env rspec
 
 require 'spec_helper'
+require 'pathname'
 
 module MCollective
   describe Shell do
@@ -79,8 +80,15 @@ module MCollective
         end
       end
 
+      before :each do
+        @systemu = mock
+        @thread = mock
+        @thread.stubs(:kill)
+        @systemu.stubs(:thread).returns(@thread)
+      end
+
       it "should run the command" do
-        Shell.any_instance.stubs("systemu").returns(true).once.with("date", "stdout" => '', "stderr" => '', "env" => {"LC_ALL" => "C"}, 'cwd' => Dir.tmpdir)
+        Shell.any_instance.stubs("systemu").returns(@systemu).once.with("date", "stdout" => '', "stderr" => '', "env" => {"LC_ALL" => "C"}, 'cwd' => Dir.tmpdir)
         s = Shell.new("date")
         s.runcommand
       end
@@ -127,11 +135,12 @@ module MCollective
       end
 
       it "should run in the correct cwd" do
-        s = Shell.new('ruby -e "puts Dir.pwd"', :cwd => Dir.tmpdir)
+        tmpdir = Pathname.new(Dir.tmpdir).realpath.to_s
+        s = Shell.new('ruby -e "puts Dir.pwd"', :cwd => tmpdir)
 
         s.runcommand
 
-        s.stdout.should == "#{Dir.tmpdir}#{nl}"
+        s.stdout.should == "#{tmpdir}#{nl}"
       end
 
       it "should send the stdin" do
@@ -147,6 +156,70 @@ module MCollective
 
         s.stdout.should == "first line#{nl}#{nl}2nd line#{nl}"
       end
+
+      it "should quietly catch Errno::ESRCH if the systemu process has completed" do
+        s = Shell.new("echo foo")
+        Thread.any_instance.stubs(:alive?).raises(Errno::ESRCH)
+        s.runcommand
+      end
+
+      describe "timeout has been set" do
+        before do
+          thread = mock
+          thread.stubs(:alive?).returns(false)
+          Thread.stubs(:current).returns(thread)
+          Util.stubs(:windows?).returns(false)
+          Thread.stubs(:alive?).returns(false)
+          Process.expects(:kill).with("TERM", 1234)
+          Process.expects(:waitpid).with(1234)
+        end
+
+        it "should terminate the systemu process after the specified timeout is exceeded" do
+          s = Shell.new(%{ruby -e 'sleep 5'}, :timeout => 1)
+          s.stubs(:systemu).yields(1234).returns(@systemu)
+          s.stubs(:sleep).with(2)
+          s.expects(:sleep).with(1)
+          Process.stubs(:kill).with(0, 1234).returns(1, nil)
+          s.runcommand
+        end
+
+        it "should kill an unresponsive systemu process on timeout" do
+          s = Shell.new(%{ruby -e 'sleep 5'}, :timeout => 1)
+          s.stubs(:systemu).yields(1234).returns(@systemu)
+          s.expects(:sleep).with(1)
+          s.stubs(:sleep).with(2)
+          Process.stubs(:kill).with(0, 1234).returns(1)
+          Process.expects(:kill).with("KILL", 1234)
+          s.runcommand
+        end
+
+        it "should kill the systemu process if the parent thread exits and :on_thread_exit is specified" do
+          s = Shell.new(%{ruby -e 'sleep 5'}, :timeout => :on_thread_exit)
+          s.stubs(:systemu).yields(1234).returns(@systemu)
+          s.stubs(:sleep).with(2)
+          Process.stubs(:kill).with(0, 1234).returns(1)
+          Process.expects(:kill).with("KILL", 1234)
+          s.runcommand
+        end
+      end
+
+      it "should log a warning if the child process cannot be reaped" do
+        s = Shell.new('ruby -e "sleep 2"', :timeout=> 1)
+        Thread.stubs(:current)
+        s.stubs(:systemu).yields(1234).returns(@systemu)
+        s.stubs(:sleep).with(1).raises(Errno::ECHILD)
+        Log.expects(:warn).with("Could not reap process '1234'.")
+        s.runcommand
+      end
+
+      it "should kill the guard thread when the process returns" do
+        s = Shell.new("echo hello world")
+        Thread.stubs(:current)
+        s.expects(:systemu).returns(@systemu)
+        @thread.expects(:kill)
+        result = s.runcommand
+        result.should == @systemu
+      end
     end
   end
 end