mcollective-client 2.2.4 → 2.4.0

data/lib/mcollective/windows_daemon.rb

@@ -11,15 +11,26 @@ module MCollective
 
     def service_main
       Log.debug("Starting Windows Service Daemon")
+      while running?
+        return if state != RUNNING
+        @runner = Runner.new(nil)
+        @runner.run
+      end
 
-      runner = Runner.new(nil)
-      runner.run
+      # Right now we don't have a way to let the connection and windows sleeper threads
+      # run to conclusion. Until that is possible we iterate the list of living threads
+      # and kill everything that isn't the main thread. This lets us exit cleanly.
+      Thread.list.each do |t|
+        if t != Thread.current
+          t.kill
+        end
+      end
     end
 
     def service_stop
       Log.info("Windows service stopping")
+      @runner.stop
       PluginManager["connector_plugin"].disconnect
-      exit! 0
     end
   end
 end

data/spec/spec_helper.rb

@@ -15,11 +15,13 @@ require 'ostruct'
 require 'tmpdir'
 require 'tempfile'
 require 'fileutils'
+require 'mcollective/test'
 
 require 'monkey_patches/instance_variable_defined'
 
 RSpec.configure do |config|
   config.mock_with :mocha
+  config.include(MCollective::Test::Matchers)
 
   config.before :each do
     MCollective::Config.instance.set_config_defaults("")

data/spec/unit/application_spec.rb

@@ -174,6 +174,25 @@ module MCollective
         @argv_backup.each{|a| ARGV << a}
       end
 
+      it "should support unsetting boolean options" do
+        Application.any_instance.stubs("main").returns(true)
+
+        Application.option :foo,
+                           :description => "meh",
+                           :arguments => "--[no-]foo",
+                           :type => :boolean
+
+        ARGV.clear
+        ARGV << "--no-foo"
+
+        a = Application.new
+        a.run
+        a.configuration.should == {:foo=>false}
+
+        ARGV.clear
+        @argv_backup.each{|a| ARGV << a}
+      end
+
       it "should set the application description as head" do
         OptionParser.any_instance.stubs(:define_head).with("meh")
 
@@ -395,7 +414,7 @@ module MCollective
 
     describe "#halt" do
       before do
-        @stats = {:discoverytime => 0, :discovered => 0, :failcount => 0, :responses => 0}
+        @stats = {:discoverytime => 0, :discovered => 0, :failcount => 0, :responses => 0, :okcount => 0}
       end
 
       it "should exit with code 0 if discovery was done and all responses passed" do
@@ -404,28 +423,25 @@ module MCollective
         @stats[:discoverytime] = 2
         @stats[:discovered] = 2
         @stats[:responses] = 2
+        @stats[:okcount] = 2
 
-        app.expects(:exit).with(0)
-
-        app.halt(@stats)
+        app.halt_code(@stats).should == 0
       end
 
       it "should exit with code 0 if no discovery were done but responses were received" do
         app = Application.new
 
         @stats[:responses] = 1
+        @stats[:okcount] = 1
+        @stats[:discovered] = 1
 
-        app.expects(:exit).with(0)
-
-        app.halt(@stats)
+        app.halt_code(@stats).should == 0
       end
 
-      it "should exit with code 0 if discovery info is missing" do
+      it "should exit with code 1 if discovery info is missing" do
         app = Application.new
 
-        app.expects(:exit).with(0)
-
-        app.halt({})
+        app.halt_code({}).should == 1
       end
 
       it "should exit with code 1 if no nodes were discovered and discovery was done" do
@@ -433,22 +449,29 @@ module MCollective
 
         @stats[:discoverytime] = 2
 
-        app.expects(:exit).with(1)
-
-        app.halt(@stats)
+        app.halt_code(@stats).should == 1
       end
 
       it "should exit with code 2 if a request failed for some nodes" do
         app = Application.new
 
-        @stats[:discovered] = 1
+        @stats[:discovered] = 2
         @stats[:failcount] = 1
         @stats[:discoverytime] = 2
-        @stats[:responses] = 1
+        @stats[:responses] = 2
+
+        app.halt_code(@stats).should == 2
+      end
+
+      it "should exit with code 2 when no discovery were done and there were failure results" do
+        app = Application.new
 
-        app.expects(:exit).with(2)
+        @stats[:discovered] = 1
+        @stats[:failcount] = 1
+        @stats[:discoverytime] = 0
+        @stats[:responses] = 1
 
-        app.halt(@stats)
+        app.halt_code(@stats).should == 2
       end
 
       it "should exit with code 3 if no responses were received after discovery" do
@@ -457,17 +480,13 @@ module MCollective
         @stats[:discovered] = 1
         @stats[:discoverytime] = 2
 
-        app.expects(:exit).with(3)
-
-        app.halt(@stats)
+        app.halt_code(@stats).should == 3
       end
 
       it "should exit with code 4 if no discovery was done and no responses were received" do
         app = Application.new
 
-        app.expects(:exit).with(4)
-
-        app.halt(@stats)
+        app.halt_code(@stats).should == 4
       end
     end
 
@@ -573,8 +592,8 @@ module MCollective
         e.stubs(:backtrace).returns(["rspec"])
         e.stubs(:to_s).returns("rspec")
 
-        @app.expects(:options).returns({:verbose => true}).twice
-        out.expects(:puts).with(regexp_matches(/ application failed to run, use -v for full error details/))
+        @app.expects(:options).returns({:verbose => true}).times(3)
+        out.expects(:puts).with(regexp_matches(/ application failed to run/))
         out.expects(:puts).with(regexp_matches(/from rspec  <---/))
         out.expects(:puts).with(regexp_matches(/rspec.+Mocha::Mock/))
 

data/spec/unit/cache_spec.rb

@@ -76,14 +76,14 @@ module MCollective
       end
     end
 
-    describe "#valid?" do
-      it "should return >0 for valid" do
+    describe "#ttl" do
+      it "should return a positive value for an unexpired item" do
         Cache.setup("rspec", 300)
         Cache.write("rspec", :key, :val)
         Cache.ttl("rspec", :key).should >= 0
       end
 
-      it "should return <0 for invalid" do
+      it "should return <0 for an expired item" do
         Cache.setup("rspec", 300)
         Cache.write("rspec", :key, :val)
 

data/spec/unit/client_spec.rb

@@ -27,44 +27,122 @@ module MCollective
 
     describe "#sendreq" do
       it "should send the supplied message" do
+        request = mock
+        request.stubs(:agent)
+        request.stubs(:ttl)
+        request.stubs(:collective)
+        @client.expects(:createreq).with(request, "rspec", {}).returns(request)
+        request.expects(:publish)
+        request.expects(:requestid).returns("13fegbcw").twice
+        result = @client.sendreq(request, "rspec")
+        result.should == "13fegbcw"
+      end
+    end
+
+    describe "#createreq" do
+      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)
+        message.stubs(:reply_to)
+        result = @client.createreq(message, "rspec")
+        result.should == message
+      end
 
-        message.expects(:encode!)
-        @client.expects(:subscribe).with("rspec", :reply)
-        message.expects(:publish)
-        message.expects(:requestid).twice
-        @client.sendreq(message, "rspec")
+      it "should create a new request if the message if not of type Message" do
+        message = mock
+        message.stubs(:encode!)
+        @client.stubs(:subscribe)
+        message.stubs(:reply_to)
+        Message.expects(:new).returns(message)
+        result = @client.createreq("message", "rspec")
+        result.should == message
       end
 
-      it "should not subscribe to a reply queue for a message with a reply-to" do
+      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.reply_to = "rspec"
+        message.stubs(:encode!)
+        @client.expects(:subscribe).with("rspec", :reply)
+        message.stubs(:reply_to).returns(nil)
+        @client.createreq(message, "rspec")
+      end
 
-        message.expects(:encode!)
+      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
-        message.expects(:publish)
-        message.expects(:requestid).twice
-        @client.sendreq(message, "rspec")
+        message.stubs(:reply_to).returns(:reply)
+        @client.createreq(message, "rspec")
       end
     end
-    describe "#req" do
-      it "should record the requestid" do
-        message = Message.new("rspec", nil, {:agent => "rspec", :type => :request, :collective => "mcollective", :filter => Util.empty_filter, :options => Util.default_options})
-        message.discovered_hosts = ["rspec"]
 
-        reply = mock
-        reply.stubs("payload").returns("rspec payload")
+    describe "#subscribe" do
+      it "should subscribe to a destination if it hasn't already" do
+        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}
+      end
 
-        @client.expects(:sendreq).returns("823a3419a0975c3facbde121f72ab61f")
-        @client.expects(:receive).returns(reply)
+      it "should not subscribe to a destination if it already has" do
+        @client.instance_variable_get(:@subscriptions)["rspec"] = 1
+        Util.expects(:make_subscription).never
+        @client.subscribe("rspec", :queue)
+      end
+    end
 
-        @discoverer.expects(:discovery_timeout).with(message.options[:timeout], message.options[:filter]).returns(0)
+    describe "#unsubscribe" do
+      it "should unsubscribe if a subscription has been made" do
+        subscription = mock
+        @client.instance_variable_get(:@subscriptions)["rspec"] = 1
+        Util.expects(:make_subscriptions).returns(subscription)
+        Util.expects(:unsubscribe).with(subscription)
+        @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)
+      end
+    end
 
-        Time.stubs(:now).returns(Time.at(1340621250), Time.at(1340621251))
+    describe "receive" do
+      let(:message) do
+        m = mock
+        m.stubs(:type=)
+        m.stubs(:expected_msgid=)
+        m.stubs(:decode!)
+        m.stubs(:requestid).returns("erfs123")
+        m
+      end
+
+      let(:badmessage) do
+        m = mock
+        m.stubs(:type=)
+        m.stubs(:expected_msgid=)
+        m.stubs(:decode!)
+        m.stubs(:requestid).returns("badmessage")
+        m
+      end
+
+      it "should receive a message" do
+        @connector.stubs(:receive).returns(message)
+        result = @client.receive("erfs123")
+        result.should == message
+      end
+
+      it "log and retry if the message reqid does not match the expected msgid" do
+        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")
+      end
 
-        @client.req(message){}.should == {:blocktime => 1.0, :discoverytime => 0, :noresponsefrom => [],
-                                          :requestid => "823a3419a0975c3facbde121f72ab61f", :responses => 1,
-                                          :starttime => 1340621250.0, :totaltime => 1.0}
+      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")
       end
     end
 
@@ -74,5 +152,172 @@ module MCollective
         @client.discover({}, 1).should == []
       end
     end
+
+    describe "#req" do
+      let(:message) do
+        m = Message.new("rspec", nil, {:agent => "rspec",
+                                       :type => :request,
+                                       :collective => "mcollective",
+                                       :filter => Util.empty_filter,
+                                       :options => Util.default_options})
+        m.discovered_hosts = ["rspec"]
+        m
+      end
+
+      let(:request) do
+        r = mock
+        r.stubs(:requestid).returns("erfs123")
+        r
+      end
+
+      before :each do
+        @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)
+      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)
+        message.options[:threaded] = true
+        @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)
+      end
+    end
+
+    describe "#unthreaded_req" do
+      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)
+      end
+    end
+
+    describe "#threaded_req" do
+      it "should start a publisher thread and a receiver thread" do
+        request = mock
+        request.stubs(:requestid).returns("erfs123")
+        p_thread = mock
+        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)
+        p_thread.expects(:join)
+        result = @client.threaded_req(request, 5, 10, 2)
+        result.should == 2
+      end
+    end
+
+    describe "#start_publisher" do
+      let(:message) do
+        m = mock
+        m.stubs(:requestid)
+        m.stubs(:agent)
+        m.stubs(:ttl)
+        m.stubs(:collective)
+        m
+      end
+
+      it "should publish the message" do
+        Timeout.stubs(:timeout).with(2).yields
+        message.expects(:publish)
+        @client.start_publisher(message, 2)
+      end
+
+      it "should log a warning on a timeout" do
+        Timeout.stubs(:timeout).raises(Timeout::Error)
+        Log.expects(:warn).with("Could not publish all messages. Publishing timed out.")
+        @client.start_publisher(message,2)
+      end
+    end
+
+    describe "#start_receiver" do
+      it "should go into a receive loop and receive until it reaches waitfor" do
+        results = []
+        Timeout.stubs(:timeout).yields
+        message = mock
+        @client.stubs(:receive).with("erfs123").returns(message)
+        message.stubs(:payload).returns("msg1", "msg2", "msg3")
+        @client.start_receiver("erfs123", 3, 5) do |msg|
+          results << msg
+        end
+        results.should == ["msg1", "msg2", "msg3"]
+      end
+
+      it "should log a warning if a timeout occurs" do
+        results = []
+        Timeout.stubs(:timeout).yields
+        message = mock
+        @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|
+          if msg == "timeout"
+            raise Timeout::Error
+          end
+          results << msg
+        end
+        results.should == ["msg1", "msg2"]
+        responded.should == 2
+      end
+
+      it "should not log a warning if a the response count is larger or equal to the expected number of responses" do
+        results = []
+        Timeout.stubs(:timeout).yields
+        message = mock
+        @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|
+          if msg == "timeout"
+            raise Timeout::Error
+          end
+          results << msg
+        end
+        results.should == ["msg1", "msg2"]
+        responded.should == 2
+      end
+    end
+
+    describe "#update_stat" do
+      let(:before) do
+        { :starttime     => Time.now.to_f,
+          :discoverytime => 0, 
+          :blocktime     => 0,
+          :totaltime     => 0 }
+      end
+
+      let(:after) do
+        { :starttime     => 10.0,
+          :discoverytime => 0,
+          :blocktime     => 10.0,
+          :totaltime     => 10.0,
+          :responses     => 5,
+          :requestid     => "erfs123",
+          :noresponsefrom  => [] }
+      end
+
+      it "should update stats and return the stats hash" do
+        Time.stubs(:now).returns(10, 20)
+        @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)
+          }.to raise_error("Client#discovered_req has been removed, please port your agent and client to the SimpleRPC framework")
+      end
+    end
   end
 end