mcollective-client 2.5.3 → 2.6.0

data/lib/mcollective/rpc/helpers.rb

@@ -264,9 +264,14 @@ module MCollective
         parser.on('--one', '-1', 'Send request to only one discovered nodes') do |v|
           options[:mcollective_limit_targets] = 1
         end
-
-        parser.on('--batch SIZE', Integer, 'Do requests in batches') do |v|
-          options[:batch_size] = v
+    
+        parser.on('--batch SIZE', 'Do requests in batches') do |v|
+          # validate batch string. Is it x% where x > 0 or is it an integer
+          if ((v =~ /^(\d+)%$/ && Integer($1) != 0) || v =~ /^(\d+)$/)
+            options[:batch_size] = v
+          else
+            raise(::OptionParser::InvalidArgument.new(v))
+          end
         end
 
         parser.on('--batch-sleep SECONDS', Float, 'Sleep time between batches') do |v|

data/lib/mcollective/rpc/result.rb

@@ -40,6 +40,10 @@ module MCollective
          :statusmsg => @results[:statusmsg],
          :data => @results[:data]}.to_json(*a)
       end
+
+      def <=>(other)
+        self[:sender] <=> other[:sender]
+      end
     end
   end
 end

data/lib/mcollective/rpc/stats.rb

@@ -242,8 +242,12 @@ module MCollective
           result_text.puts Util.colorize(:red, "No response from:")
           result_text.puts
 
-          @noresponsefrom.sort.in_groups_of(3) do |c|
-            result_text.puts "   %-30s%-30s%-30s" % c
+          field_size = Util.field_size(@noresponsefrom, 30)
+          fields_num = Util.field_number(field_size)
+          format = "   " + ( " %-#{field_size}s" * fields_num )
+
+          @noresponsefrom.sort.in_groups_of(fields_num) do |c|
+            result_text.puts format % c
           end
 
           result_text.puts

data/lib/mcollective/shell.rb

@@ -57,7 +57,9 @@ module MCollective
               @environment = {}
             else
               @environment.merge!(val.dup)
+              @environment = @environment.delete_if { |k,v| v.nil? }
             end
+
           when "timeout"
             raise "timeout should be a positive integer or the symbol :on_thread_exit symbol" unless val.eql?(:on_thread_exit) || ( val.is_a?(Fixnum) && val>0 )
             @timeout = val

data/lib/mcollective/ssl.rb

@@ -193,6 +193,11 @@ module MCollective
     end
 
     def self.base64_decode(string)
+      # The Base 64 character set is A-Z a-z 0-9 + / =
+      # Also allow for whitespace, but raise if we get anything else
+      if string !~ /^[A-Za-z0-9+\/=\s]+$/
+        raise ArgumentError, 'invalid base64'
+      end
       Base64.decode64(string)
     end
 

data/lib/mcollective/util.rb

@@ -75,11 +75,21 @@ module MCollective
       return false if fact.nil?
 
       fact = fact.clone
+      case fact
+      when Array
+        return fact.any? { |element| test_fact_value(element, value, operator)}
+      when Hash
+        return fact.keys.any? { |element| test_fact_value(element, value, operator)}
+      else
+        return test_fact_value(fact, value, operator)
+      end
+    end
 
+    def self.test_fact_value(fact, value, operator)
       if operator == '=~'
         # to maintain backward compat we send the value
         # as /.../ which is what 1.0.x needed.  this strips
-        # off the /'s wich is what we need here
+        # off the /'s which is what we need here
         if value =~ /^\/(.+)\/$/
           value = $1
         end
@@ -104,6 +114,7 @@ module MCollective
 
       false
     end
+    private_class_method :test_fact_value
 
     # Checks if the configured identity matches the one supplied
     #
@@ -492,5 +503,22 @@ module MCollective
       template_path = File.join("/etc/mcollective", template_file)
       return template_path
     end
+
+    # subscribe to the direct addressing queue
+    def self.subscribe_to_direct_addressing_queue
+      subscribe(make_subscriptions("mcollective", :directed))
+    end
+
+    # Get field size for printing
+    def self.field_size(elements, min_size=40)
+      max_length = elements.max_by { |e| e.length }.length
+      max_length > min_size ? max_length : min_size
+    end
+
+    # Calculate number of fields for printing
+    def self.field_number(field_size, max_size=90)
+      number = (max_size/field_size).to_i
+      (number == 0) ? 1 : number
+    end
   end
 end

data/lib/mcollective/validator.rb

@@ -1,12 +1,18 @@
 module MCollective
   module Validator
     @last_load = nil
+    @@validator_mutex = Mutex.new
 
     # Loads the validator plugins. Validators will only be loaded every 5 minutes
     def self.load_validators
-      if load_validators?
-        @last_load = Time.now.to_i
-        PluginManager.find_and_load("validator")
+      begin
+        @@validator_mutex.lock
+        if load_validators?
+          @last_load = Time.now.to_i
+          PluginManager.find_and_load("validator")
+        end
+      ensure
+        @@validator_mutex.unlock
       end
     end
 
@@ -44,7 +50,6 @@ module MCollective
 
     def self.load_validators?
       return true if @last_load.nil?
-
       (@last_load - Time.now.to_i) > 300
     end
 

data/spec/spec_helper.rb

@@ -28,3 +28,9 @@ RSpec.configure do |config|
     MCollective::PluginManager.clear
   end
 end
+
+# With the addition of the ddl requirement for connectors its becomes necessary
+# to stub the inherited method. Because tests don't use a real config files libdirs
+# aren't set and connectors have no way of finding their ddls so we stub it out
+# in the general case and test for is specifically.
+MCollective::Connector::Base.stubs(:inherited)

data/spec/unit/config_spec.rb

@@ -141,6 +141,16 @@ module MCollective
           Config.instance.loadconfig("/nonexisting")
         end
       end
+
+      it 'should enable agents by default' do
+        File.expects(:readlines).with("/nonexisting").returns(["libdir=/nonexistinglib"])
+        File.expects(:exists?).with("/nonexisting").returns(true)
+        PluginManager.stubs(:loadclass)
+        PluginManager.stubs("<<")
+
+        Config.instance.loadconfig("/nonexisting")
+        Config.instance.activate_agents.should == true
+      end
     end
 
     describe "#read_plugin_config_dir" do

data/spec/unit/connector/base_spec.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Connector
+    describe "base" do
+
+      before :each do
+        Base.unstub(:inherited)
+      end
+
+      it "should fail if the ddl isn't valid" do
+        PluginManager.expects(:<<).never
+
+        expect {
+          class TestConnectorA<Connector::Base;end
+        }.to raise_error RuntimeError
+      end
+
+      it "should load the ddl and add the connector to the PluginManager" do
+        DDL.stubs(:new)
+        class TestConnectorB<Connector::Base;end
+        PluginManager["connector_plugin"].class.should == MCollective::Connector::TestConnectorB
+      end
+    end
+  end
+end

data/spec/unit/facts/base_spec.rb

@@ -114,5 +114,40 @@ module MCollective::Facts
       end
     end
 
+    describe '#normalize_facts' do
+      it 'should make symbols that are keys be strings' do
+        Testfacts.new.send(:normalize_facts, {
+          :foo  => "1",
+          "bar" => "2",
+        }).should == {
+          "foo" => "1",
+          "bar" => "2",
+        }
+      end
+
+      it 'should make values that are not strings be strings' do
+        Testfacts.new.send(:normalize_facts, {
+          "foo" => 1,
+          "bar" => :baz,
+        }).should == {
+          "foo" => "1",
+          "bar" => "baz",
+        }
+      end
+
+      it 'should not flatten arrays or hashes' do
+        Testfacts.new.send(:normalize_facts, {
+          "foo" => [ "1", "quux", 2 ],
+          "bar" => {
+            :baz => "quux",
+          },
+        }).should == {
+          "foo" => [ "1", "quux", "2" ],
+          "bar" => {
+            "baz" => "quux",
+          },
+        }
+      end
+    end
   end
 end

data/spec/unit/log_spec.rb

@@ -53,6 +53,15 @@ module MCollective
       end
     end
 
+    describe '#reopen' do
+      it 'should delegate the the logger' do
+        @logger.expects(:reopen)
+
+        Log.configure(@logger)
+        Log.reopen
+      end
+    end
+
     describe "#from" do
       let(:execution_stack) do
         if Util.windows?

data/spec/unit/logger/base_spec.rb

@@ -42,7 +42,7 @@ module MCollective::Logger
         logger = Base.new
 
         expect {
-          logger.send(:log, nil, nil, nil)
+          logger.log(nil, nil, nil)
         }.to raise_error("The logging class did not supply a log method")
       end
     end
@@ -52,11 +52,21 @@ module MCollective::Logger
         logger = Base.new
 
         expect {
-          logger.send(:start)
+          logger.start
         }.to raise_error("The logging class did not supply a start method")
       end
     end
 
+    describe '#reopen' do
+      it 'should do nothing' do
+        logger = Base.new
+
+        expect {
+          logger.reopen
+        }.to_not raise_error
+      end
+    end
+
     describe "#map_level" do
       it "should map levels correctly" do
         logger = Base.new

data/spec/unit/logger/file_logger_spec.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  require 'mcollective/logger/file_logger'
+
+  module Logger
+    describe File_logger do
+      let(:mock_logger) { mock('logger') }
+
+      before :each do
+        Config.instance.stubs(:loglevel).returns("error")
+        Config.instance.stubs(:logfile).returns("testfile")
+        Config.instance.stubs(:keeplogs).returns(false)
+        Config.instance.stubs(:max_log_size).returns(42)
+        ::Logger.stubs(:new).returns(mock_logger)
+        mock_logger.stubs(:formatter=)
+        mock_logger.stubs(:level=)
+      end
+
+      describe "#start" do
+        it "should set the level to be that specfied in the config" do
+          logger = File_logger.new
+
+          logger.expects(:set_level).with(:error)
+          logger.start
+        end
+      end
+
+      describe 'reopen' do
+        let(:logger) {
+          logger = File_logger.new
+          logger.instance_variable_set(:@logger, mock_logger)
+          logger
+        }
+
+        before :each do
+          mock_logger.stubs(:level)
+          mock_logger.stubs(:close)
+          logger.stubs(:start)
+          mock_logger.stubs(:level=)
+        end
+
+        it 'should close the current handle' do
+          mock_logger.expects(:close)
+          logger.reopen
+        end
+
+        it 'should open a new handle' do
+          logger.expects(:start)
+          logger.reopen
+        end
+
+        it 'should preserve the level' do
+          mock_logger.expects(:level).returns(12252)
+          mock_logger.expects(:level=).with(12252)
+          logger.reopen
+        end
+      end
+
+      describe '#set_logging_level' do
+        it 'should set the level' do
+          logger = File_logger.new
+          logger.instance_variable_set(:@logger, mock_logger)
+          mock_logger.expects(:level=).with(::Logger::ERROR)
+          logger.set_level("error")
+        end
+      end
+
+      describe "#log" do
+        it "should delegate to logger" do
+          logger = File_logger.new
+          logger.instance_variable_set(:@logger, mock_logger)
+
+          mock_logger.expects(:add).with(::Logger::INFO)
+          logger.log(:info, "rspec", "message")
+        end
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/application/plugin_spec.rb

@@ -22,6 +22,7 @@ module MCollective
           PluginManager.stubs(:find).with(:data, "ddl").returns([""])
           PluginManager.stubs(:find).with(:discovery, "ddl").returns([""])
           PluginManager.stubs(:find).with(:validator, "ddl").returns([""])
+          PluginManager.stubs(:find).with(:connector, "ddl").returns([""])
           @app.stubs(:load_plugin_ddl).with('rspec', :agent).returns(ddl)
           ddl.expects(:help).with("rspec-helptemplate.erb").returns("agent_template")
           @app.expects(:puts).with("agent_template")

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

@@ -47,9 +47,9 @@ module MCollective
 
       let(:subscription) do
         sub = mock
-        sub.stubs("<<").returns(true)
-        sub.stubs("include?").returns(false)
-        sub.stubs("delete").returns(false)
+        sub.stubs(:<<).returns(true)
+        sub.stubs(:include?).returns(false)
+        sub.stubs(:delete).returns(false)
         sub
       end
 
@@ -452,46 +452,46 @@ module MCollective
         end
 
         it "should use the make_target correctly" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
           connector.subscribe("test", :broadcast, "mcollective")
         end
 
         it "should check for existing subscriptions" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
-          subscription.expects("include?").with("rspec").returns(false)
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          subscription.expects(:include?).with("rspec").returns(false)
           connection.expects(:subscribe).never
 
           connector.subscribe("test", :broadcast, "mcollective")
         end
 
         it "should subscribe to the middleware" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           connection.expects(:subscribe).with("test", {}, "rspec")
           connector.subscribe("test", :broadcast, "mcollective")
         end
 
         it "should add to the list of subscriptions" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
-          subscription.expects("<<").with("rspec")
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          subscription.expects(:<<).with("rspec")
           connector.subscribe("test", :broadcast, "mcollective")
         end
       end
 
       describe "#unsubscribe" do
         it "should use make_target correctly" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
           connector.unsubscribe("test", :broadcast, "mcollective")
         end
 
         it "should unsubscribe from the target" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           connection.expects(:unsubscribe).with("test", {}, "rspec").once
 
           connector.unsubscribe("test", :broadcast, "mcollective")
         end
 
         it "should delete the source from subscriptions" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           subscription.expects(:delete).with("rspec").once
 
           connector.unsubscribe("test", :broadcast, "mcollective")
@@ -633,11 +633,38 @@ module MCollective
 
       describe "#make_target" do
         it "should create correct targets" do
-          connector.make_target("test", :reply, "mcollective").should == {:name => "/queue/mcollective.reply.rspec_#{$$}", :headers => {}, :id => "/queue/mcollective.reply.rspec_#{$$}"}
-          connector.make_target("test", :broadcast, "mcollective").should == {:name => "/topic/mcollective.test.agent", :headers => {}, :id => "/topic/mcollective.test.agent"}
-          connector.make_target("test", :request, "mcollective").should == {:name => "/topic/mcollective.test.agent", :headers => {}, :id => "/topic/mcollective.test.agent"}
-          connector.make_target("test", :direct_request, "mcollective").should == {:headers=>{}, :name=>"/queue/mcollective.nodes", :id => "/queue/mcollective.nodes"}
-          connector.make_target("test", :directed, "mcollective").should == {:name => "/queue/mcollective.nodes", :headers=>{"selector"=>"mc_identity = 'rspec'"}, :id => "mcollective_directed_to_identity"}
+          Client.stubs(:request_sequence).returns(42)
+          connector.make_target("test", :reply, "mcollective").should == {
+            :name => "/queue/mcollective.reply.rspec_#{$$}.42",
+            :headers => {},
+            :id => "/queue/mcollective.reply.rspec_#{$$}.42",
+          }
+
+          connector.make_target("test", :broadcast, "mcollective").should == {
+            :name => "/topic/mcollective.test.agent",
+            :headers => {},
+            :id => "/topic/mcollective.test.agent",
+          }
+
+          connector.make_target("test", :request, "mcollective").should == {
+            :name => "/topic/mcollective.test.agent",
+            :headers => {},
+            :id => "/topic/mcollective.test.agent",
+          }
+
+          connector.make_target("test", :direct_request, "mcollective").should == {
+            :name => "/queue/mcollective.nodes",
+            :headers => {},
+            :id => "/queue/mcollective.nodes",
+          }
+
+          connector.make_target("test", :directed, "mcollective").should == {
+            :name => "/queue/mcollective.nodes",
+            :headers => {
+              "selector" => "mc_identity = 'rspec'",
+            },
+            :id => "mcollective_directed_to_identity",
+          }
         end
 
         it "should raise an error for unknown collectives" do