mcollective-client 2.2.4 → 2.4.0

data/spec/unit/plugins/mcollective/connector/rabbitmq_spec.rb

@@ -27,6 +27,7 @@ module MCollective
         @config.stubs(:configured).returns(true)
         @config.stubs(:identity).returns("rspec")
         @config.stubs(:collectives).returns(["mcollective"])
+        @config.stubs(:pluginconf).returns({})
 
         logger = mock
         logger.stubs(:log)
@@ -96,6 +97,8 @@ module MCollective
                         "rabbitmq.backup" => "true",
                         "rabbitmq.timeout" => "1",
                         "rabbitmq.vhost" => "mcollective",
+                        "rabbitmq.max_hbrlck_fails" => 3,
+                        "rabbitmq.max_hbread_fails" => 3,
                         "rabbitmq.connect_timeout" => "5"}
 
 
@@ -115,10 +118,12 @@ module MCollective
                                        :use_exponential_back_off => false,
                                        :max_reconnect_attempts => 5,
                                        :initial_reconnect_delay => 0.02,
+                                       :max_hbread_fails => 3,
+                                       :max_hbrlck_fails => 3,
                                        :randomize => true,
                                        :reliable => true,
                                        :logger => "logger",
-                                       :connect_headers => {'accept-version' => '1.0', 'host' => 'mcollective'},
+                                       :connect_headers => {},
                                        :hosts => [{:passcode => 'password1',
                                                    :host => 'host1',
                                                    :port => 6163,
@@ -132,12 +137,56 @@ module MCollective
           ])
 
           @c.expects(:ssl_parameters).with(2, true).returns(true)
+          @c.expects(:connection_headers).returns({})
 
           @c.instance_variable_set("@connection", nil)
           @c.connect(connector)
         end
       end
 
+      describe "#connection_headers" do
+        before do
+          @c.stubs(:stomp_version).returns("1.2.10")
+        end
+
+        it "should default to stomp 1.0 only" do
+          @config.expects(:pluginconf).returns({}).at_least_once
+          @c.connection_headers[:"accept-version"] == "1.0"
+        end
+
+        it "should support setting the vhost" do
+          @config.expects(:pluginconf).returns("rabbitmq.vhost" => "rspec").at_least_once
+          @c.connection_headers.should == {:host => "rspec", :"accept-version" => "1.0"}
+        end
+
+        it "should log a warning about not using Stomp 1.1" do
+          @config.expects(:pluginconf).returns("rabbitmq.heartbeat_interval" => "0").at_least_once
+          Log.expects(:warn).with(regexp_matches(/without STOMP 1.1 heartbeats/))
+          @c.connection_headers
+        end
+
+        it "should not support stomp 1.1 with older versions of the stomp gem" do
+          @config.expects(:pluginconf).returns("rabbitmq.heartbeat_interval" => "30").at_least_once
+          @c.expects(:stomp_version).returns("1.0.0").once
+          expect { @c.connection_headers }.to raise_error("Setting STOMP 1.1 properties like heartbeat intervals require at least version 1.2.10 of the STOMP gem")
+        end
+
+        it "should force the heartbeat to min 30 seconds" do
+          @config.expects(:pluginconf).returns("rabbitmq.heartbeat_interval" => "10").at_least_once
+          @c.connection_headers[:"heart-beat"].should == "30500,29500"
+        end
+
+        it "should default to 1.0 and 1.1 support" do
+          @config.expects(:pluginconf).returns("rabbitmq.heartbeat_interval" => "30").at_least_once
+          @c.connection_headers[:"accept-version"].should == "1.1,1.0"
+        end
+
+        it "should support stomp 1.1 only operation" do
+          @config.expects(:pluginconf).returns("rabbitmq.heartbeat_interval" => "30", "rabbitmq.stomp_1_0_fallback" => 0).at_least_once
+          @c.connection_headers[:"accept-version"].should == "1.1"
+        end
+      end
+
       describe "#ssl_paramaters" do
         it "should ensure all settings are provided" do
           pluginconf = {"rabbitmq.pool.1.host" => "host1",
@@ -163,6 +212,8 @@ module MCollective
                         "rabbitmq.pool.1.ssl.ca" => "rspec1.ca,rspec2.ca"}
 
           @config.expects(:pluginconf).returns(pluginconf).at_least_once
+          @c.expects(:get_key_file).returns("rspec.key").at_least_once
+          @c.expects(:get_cert_file).returns("rspec.cert").at_least_once
 
           File.expects(:exist?).with("rspec.cert").twice.returns(true)
           File.expects(:exist?).with("rspec.key").twice.returns(true)
@@ -199,6 +250,32 @@ module MCollective
         end
       end
 
+      describe "#get_key_file" do
+        it "should return the filename from the environment variable" do
+          ENV["MCOLLECTIVE_RABBITMQ_POOL2_SSL_KEY"] = "/path/to/rspec/env"
+          @c.get_key_file(2).should == "/path/to/rspec/env"
+        end
+
+        it "should return the filename define in the config file if the environment variable doesn't exist" do
+          ENV.delete("MCOLLECTIVE_RABBITMQ_POOL2_SSL_KEY")
+          @c.expects(:get_option).with("rabbitmq.pool.2.ssl.key", false).returns("/path/to/rspec/conf")
+          @c.get_key_file(2).should == "/path/to/rspec/conf"
+        end
+      end
+
+      describe "#get_cert_file" do
+        it "shold return the filename from the environment variable" do
+          ENV["MCOLLECTIVE_RABBITMQ_POOL2_SSL_CERT"] = "/path/to/rspec/env"
+          @c.get_cert_file(2).should == "/path/to/rspec/env"
+        end
+
+        it "should return the filename defined in the config file if the environment variable doesn't exist" do
+          ENV.delete("MCOLLECTIVE_RABBITMQ_POOL2_SSL_CERT")
+          @c.expects(:get_option).with("rabbitmq.pool.2.ssl.cert", false).returns("/path/to/rspec/conf")
+          @c.get_cert_file(2).should == "/path/to/rspec/conf"
+        end
+      end
+
       describe "#receive" do
         it "should receive from the middleware" do
           payload = mock
@@ -265,10 +342,11 @@ module MCollective
           msg.stubs(:collective).returns("mcollective")
           msg.stubs(:type).returns(:direct_request)
           msg.stubs(:reply_to).returns("/topic/mcollective")
+          msg.stubs(:ttl).returns(60)
           msg.expects(:discovered_hosts).returns(["one", "two"])
 
-          @connection.expects(:publish).with('/exchange/mcollective_directed/one', 'msg', {'reply-to' => '/temp-queue/mcollective_reply_agent'})
-          @connection.expects(:publish).with('/exchange/mcollective_directed/two', 'msg', {'reply-to' => '/temp-queue/mcollective_reply_agent'})
+          @connection.expects(:publish).with('/exchange/mcollective_directed/one', 'msg', {'reply-to' => '/temp-queue/mcollective_reply_agent', 'expiration' => '70000'})
+          @connection.expects(:publish).with('/exchange/mcollective_directed/two', 'msg', {'reply-to' => '/temp-queue/mcollective_reply_agent', 'expiration' => '70000'})
 
           @c.publish(msg)
         end
@@ -332,13 +410,14 @@ module MCollective
         it "should create reply targets based on reply-to headers in requests" do
           message = mock
           message.expects(:type).returns(:reply)
+          message.expects(:ttl).returns(60)
 
           request = mock
           request.expects(:headers).returns({"reply-to" => "foo"})
 
           message.expects(:request).returns(request)
 
-          @c.target_for(message).should == {:name => "foo", :headers => {}, :id => ""}
+          @c.target_for(message).should == {:name => "foo", :headers => {"expiration" => "70000"}, :id => ""}
         end
 
         it "should create new request targets" do
@@ -347,8 +426,9 @@ module MCollective
           message.expects(:agent).returns("rspecagent")
           message.expects(:collective).returns("mcollective")
           message.expects(:reply_to).returns("/topic/rspec")
+          message.expects(:ttl).returns(60)
 
-          @c.expects(:make_target).with("rspecagent", :request, "mcollective", "/topic/rspec", nil)
+          @c.expects(:make_target).with("rspecagent", :request, "mcollective", "/topic/rspec", nil).returns({:name => "", :headers => {}, :id => nil})
           @c.target_for(message)
         end
 
@@ -358,8 +438,9 @@ module MCollective
           message.expects(:agent).returns("rspecagent")
           message.expects(:collective).returns("mcollective")
           message.expects(:reply_to).returns("/topic/rspec")
+          message.expects(:ttl).returns(60)
 
-          @c.expects(:make_target).with("rspecagent", :direct_request, "mcollective", "/topic/rspec", nil)
+          @c.expects(:make_target).with("rspecagent", :direct_request, "mcollective", "/topic/rspec", nil).returns({:name => "", :headers => {}, :id => nil})
           @c.target_for(message)
         end
 
@@ -377,17 +458,87 @@ module MCollective
         it "should disconnect from the stomp connection" do
           @connection.expects(:disconnect)
           @c.disconnect
+          @c.connection.should == nil
         end
       end
 
       describe "#make_target" do
-        it "should create correct targets" do
-          @c.make_target("test", :reply, "mcollective").should == {:name => "/temp-queue/mcollective_reply_test", :headers => {}, :id => "mcollective_test_replies"}
-          @c.make_target("test", :broadcast, "mcollective").should == {:name => "/exchange/mcollective_broadcast/test", :headers => {"reply-to"=>"/temp-queue/mcollective_reply_test"}, :id => "mcollective_broadcast_test"}
-          @c.make_target("test", :request, "mcollective").should == {:name => "/exchange/mcollective_broadcast/test", :headers => {"reply-to"=>"/temp-queue/mcollective_reply_test"}, :id => "mcollective_broadcast_test"}
-          @c.make_target("test", :direct_request, "mcollective", nil, "rspec").should == {:headers=>{"reply-to"=>"/temp-queue/mcollective_reply_test"}, :name=>"/exchange/mcollective_directed/rspec", :id => nil}
-          @c.make_target("test", :directed, "mcollective").should == {:name => "/exchange/mcollective_directed/rspec", :headers=>{}, :id => "rspec_directed_to_identity"}
-          @c.make_target("test", :request, "mcollective", "/topic/rspec", "rspec").should == {:headers=>{"reply-to"=>"/topic/rspec"}, :name=>"/exchange/mcollective_broadcast/test", :id => "mcollective_broadcast_test"}
+        context 'rabbitmq.use_reply_exchange' do
+          context 'default (false)' do
+            it "should create correct targets" do
+              @c.make_target("test", :reply, "mcollective").should eq({
+                :name => "/temp-queue/mcollective_reply_test",
+                :headers => {},
+                :id => "mcollective_test_replies",
+              })
+              @c.make_target("test", :broadcast, "mcollective").should eq({
+                :name => "/exchange/mcollective_broadcast/test",
+                :headers => { "reply-to" => "/temp-queue/mcollective_reply_test" },
+                :id => "mcollective_broadcast_test"
+              })
+              @c.make_target("test", :request, "mcollective").should eq({
+                :name => "/exchange/mcollective_broadcast/test",
+                :headers => { "reply-to" => "/temp-queue/mcollective_reply_test" },
+                :id => "mcollective_broadcast_test",
+              })
+              @c.make_target("test", :direct_request, "mcollective", nil, "rspec").should eq({
+                :headers => { "reply-to" => "/temp-queue/mcollective_reply_test" },
+                :name => "/exchange/mcollective_directed/rspec",
+                :id => nil
+              })
+              @c.make_target("test", :directed, "mcollective").should eq({
+                :name => "/exchange/mcollective_directed/rspec",
+                :headers => {},
+                :id => "mcollective_rspec_directed_to_identity",
+              })
+              @c.make_target("test", :request, "mcollective", "/topic/rspec", "rspec").should eq({
+                :headers => { "reply-to" => "/topic/rspec" },
+                :name => "/exchange/mcollective_broadcast/test",
+                :id => "mcollective_broadcast_test",
+              })
+            end
+          end
+
+          context 'true' do
+            before :each do
+              @config.stubs(:pluginconf).returns({
+                'rabbitmq.use_reply_exchange' => '1',
+              })
+            end
+
+            it "should create correct targets" do
+              @c.make_target("test", :reply, "mcollective").should eq({
+                :name => "/exchange/mcollective_reply/rspec_#{$$}",
+                :headers => {},
+                :id => "mcollective_test_replies",
+              })
+              @c.make_target("test", :broadcast, "mcollective").should eq({
+                :name => "/exchange/mcollective_broadcast/test",
+                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}" },
+                :id => "mcollective_broadcast_test"
+              })
+              @c.make_target("test", :request, "mcollective").should eq({
+                :name => "/exchange/mcollective_broadcast/test",
+                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}" },
+                :id => "mcollective_broadcast_test",
+              })
+              @c.make_target("test", :direct_request, "mcollective", nil, "rspec").should eq({
+                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}" },
+                :name => "/exchange/mcollective_directed/rspec",
+                :id => nil
+              })
+              @c.make_target("test", :directed, "mcollective").should eq({
+                :name => "/exchange/mcollective_directed/rspec",
+                :headers => {},
+                :id => "mcollective_rspec_directed_to_identity",
+              })
+              @c.make_target("test", :request, "mcollective", "/topic/rspec", "rspec").should eq({
+                :headers => { "reply-to" => "/topic/rspec" },
+                :name => "/exchange/mcollective_broadcast/test",
+                :id => "mcollective_broadcast_test",
+              })
+            end
+          end
         end
 
         it "should raise an error for unknown collectives" do
@@ -453,28 +604,11 @@ module MCollective
       end
 
       describe "#get_bool_option" do
-        it "should return the default if option isnt set" do
-          @config.expects(:pluginconf).returns({}).once
-          @c.get_bool_option("test", "default").should == "default"
-        end
-
-        ["1", "yes", "true"].each do |boolean|
-          it "should map options to true correctly" do
-            @config.expects(:pluginconf).returns({"test" => boolean}).twice
-            @c.get_bool_option("test", "default").should == true
-          end
-        end
-
-        ["0", "no", "false"].each do |boolean|
-          it "should map options to false correctly" do
-            @config.expects(:pluginconf).returns({"test" => boolean}).twice
-            @c.get_bool_option("test", "default").should == false
-          end
-        end
+        it "should use Util::str_to_bool to translate a boolean value found in the config" do
+          @config.expects(:pluginconf).returns({"rspec" => "true"})
+          Util.expects(:str_to_bool).with("true").returns(true)
 
-        it "should return default for non boolean options" do
-          @config.expects(:pluginconf).returns({"test" => "foo"}).twice
-          @c.get_bool_option("test", "default").should == "default"
+          @c.get_bool_option("rspec", "true").should be_true
         end
       end
     end

data/spec/unit/plugins/mcollective/data/agent_data_spec.rb

@@ -10,6 +10,7 @@ module MCollective
       describe "#query_data" do
         before do
           @ddl = mock
+          @ddl.stubs(:dataquery_interface).returns({:output => {}})
           @ddl.stubs(:meta).returns({:timeout => 1})
           DDL.stubs(:new).returns(@ddl)
           @plugin = Agent_data.new

data/spec/unit/plugins/mcollective/data/fstat_data_spec.rb

@@ -11,6 +11,7 @@ module MCollective
         before do
           @ddl = mock
           @ddl.stubs(:meta).returns({:timeout => 1})
+          @ddl.stubs(:dataquery_interface).returns({:output => {}})
           DDL.stubs(:new).returns(@ddl)
           @plugin = Fstat_data.new
 

data/spec/unit/plugins/mcollective/discovery/flatfile_spec.rb

@@ -42,6 +42,16 @@ module MCollective
         it "should filter against non regex nodes" do
           Flatfile.discover(Util.empty_filter.merge("identity" => ["one"]), 0, 0, @client).should == ["one"]
         end
+
+        it "should fail for invalid identities" do
+          [" one", "two ", " three ", "four four"].each do |host|
+            File.expects(:readlines).with("/nonexisting").returns([host])
+
+            expect {
+              Flatfile.discover(Util.empty_filter, 0, 0, @client).should == ["one", "two", "three", "four"]
+            }.to raise_error('Identities can only match /\w\.\-/')
+          end
+        end
       end
     end
   end

data/spec/unit/plugins/mcollective/discovery/stdin_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/discovery/stdin.rb'
+
+module MCollective
+  class Discovery
+    describe Stdin do
+      describe "#discover" do
+        before do
+          @client = mock
+          @client.stubs(:options).returns({})
+          @client.stubs(:options).returns({:discovery_options => []})
+          STDIN.stubs(:read).with().returns("one\ntwo\n")
+        end
+
+        it "should use a simple string list" do
+          Stdin.discover(Util.empty_filter, 0, 0, @client).should == ["one", "two"]
+        end
+
+        ['auto', 'json', 'text', nil].each do |type|
+          it "should fail if no data is given (type %{type})" do
+            unless type.nil?
+              @client.stubs(:options).returns({:discovery_options => [type]})
+            end
+            STDIN.stubs(:read).with().returns(" ")
+            expect { Stdin.discover(Util.empty_filter, 0, 0, @client) }.to raise_error("data piped on STDIN contained only whitespace - could not discover hosts from it.")
+          end
+        end
+
+        it "should work for JSON data" do
+          STDIN.stubs(:read).with().returns('[{"sender":"example.com"},{"sender":"another.com"}]')
+          Stdin.discover(Util.empty_filter, 0, 0, @client).should == ["example.com", "another.com"]
+        end
+
+        it "should regex filters" do
+          Stdin.discover(Util.empty_filter.merge("identity" => [/one/]), 0, 0, @client).should == ["one"]
+        end
+
+        it "should filter against non regex nodes" do
+          Stdin.discover(Util.empty_filter.merge("identity" => ["one"]), 0, 0, @client).should == ["one"]
+        end
+
+        it "should fail for invalid identities" do
+          [" one", "two ", " three ", "four four"].each do |host|
+            STDIN.stubs(:read).with().returns("#{host}\n")
+
+            expect {
+              Stdin.discover(Util.empty_filter, 0, 0, @client)
+            }.to raise_error('Identities can only match /\w\.\-/')
+          end
+        end
+
+        it "should raise on incorrect options" do
+            @client.stubs(:options).returns({:discovery_options => ['foo']})
+            expect {
+              Stdin.discover(Util.empty_filter, 0, 0, @client)
+            }.to raise_error('stdin discovery plugin only knows the types auto/text/json, not "foo"')
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/facts/yaml_facts_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require File.join(File.dirname(__FILE__), '../../../../../', 'plugins', 'mcollective', 'facts', 'yaml_facts.rb')
+
+module MCollective
+  module Facts
+    describe Yaml_facts do
+      before :each do
+        config = mock
+        config.stubs(:pluginconf).returns({'yaml' => 'facts.yaml'})
+        Config.stubs(:instance).returns(config)
+        @stat = mock
+        File.stubs(:stat).returns(@stat)
+        @facts = Yaml_facts.new
+      end
+
+      describe '#initialize' do
+        it 'should initialize a mtimes instance variable' do
+          facts = Yaml_facts.new
+          facts.instance_variable_get(:@yaml_file_mtimes).should == {}
+        end
+      end
+
+      describe '#load_facts_from_source' do
+        it 'should fail and return empty facts if the source file does not exist' do
+          File.stubs(:exist?).with('facts.yaml').returns(false)
+          Log.expects(:error)
+          @facts.load_facts_from_source.should == {}
+        end
+
+        it 'should fail and return empty facts in the yaml cannot be parsed' do
+          yaml = "---"
+          YAML.stubs(:load).raises("error")
+          File.stubs(:exist?).with('facts.yaml').returns(true)
+          File.stubs(:read).with('facts.yaml').returns(yaml)
+          Log.expects(:error)
+          @facts.load_facts_from_source.should == {}
+        end
+
+        it 'should return the facts if the file exists and can be parsed' do
+          yaml = "---\n  osfamily : Magic"
+          File.stubs(:exist?).with('facts.yaml').returns(true)
+          File.stubs(:read).with('facts.yaml').returns(yaml)
+          Log.expects(:error).never
+          @facts.load_facts_from_source.should == {"osfamily" => "Magic"}
+        end
+      end
+
+      describe '#force_reload?' do
+        it 'should return true if the mtime has changed' do
+          @facts.instance_variable_get(:@yaml_file_mtimes)['facts.yaml'] = 1234
+          @stat.stubs(:mtime).returns(1235)
+          @facts.force_reload?.should be_true
+        end
+
+        it 'should return false if the mtime is the same' do
+          @facts.instance_variable_get(:@yaml_file_mtimes)['facts.yaml'] = 1234
+          @stat.stubs(:mtime).returns(1234)
+          @facts.force_reload?.should be_false
+        end
+      end
+    end
+  end
+end