mcollective-client 2.10.6 → 2.11.0

data/lib/mcollective.rb

@@ -59,7 +59,7 @@ module MCollective
 
   MCollective::Vendor.load_vendored
 
-  VERSION="2.10.6"
+  VERSION="2.11.0"
 
   def self.version
     VERSION

data/lib/mcollective/audit/logfile.rb

@@ -10,7 +10,7 @@ module MCollective
       require 'pp'
 
       def audit_request(request, connection)
-        logfile = Config.instance.pluginconf["rpcaudit.logfile"] || "/var/log/mcollective-audit.log"
+        logfile = Config.instance.pluginconf["rpcaudit.logfile"] || "/var/log/puppetlabs/mcollective/mcollective-audit.log"
 
         now = Time.now
         # Already told timezone to be in UTC so we don't look it up again

data/lib/mcollective/client.rb

@@ -66,10 +66,7 @@ module MCollective
     # responses and doesn't execute any passed in code blocks for responses
     def sendreq(msg, agent, filter = {})
       request = createreq(msg, agent, filter)
-
-      Log.debug("Sending request #{request.requestid} to the #{request.agent} agent with ttl #{request.ttl} in collective #{request.collective}")
-
-      request.publish
+      publish(request)
       request.requestid
     end
 
@@ -224,14 +221,18 @@ module MCollective
       Log.debug("Starting publishing with publish timeout of #{publish_timeout}")
       begin
         Timeout.timeout(publish_timeout) do
-          Log.debug("Sending request #{request.requestid} to the #{request.agent} agent with ttl #{request.ttl} in collective #{request.collective}")
-          request.publish
+          publish(request)
         end
       rescue Timeout::Error => e
         Log.warn("Could not publish all messages. Publishing timed out.")
       end
     end
 
+    def publish(request)
+      Log.info("Sending request #{request.requestid} for agent '#{request.agent}' with ttl #{request.ttl} in collective '#{request.collective}'")
+      request.publish
+    end
+
     # Starts the response receiver routine
     # Expected to return the amount of received responses.
     def start_receiver(requestid, waitfor, timeout, &block)

data/lib/mcollective/ddl/agentddl.rb

@@ -166,13 +166,53 @@ module MCollective
         return unless input
 
         input.keys.each do |key|
-          if !arguments.include?(key) && !input[key][:default].nil? && !input[key][:optional]
+          if key.is_a?(Symbol) && arguments.include?(key.to_s) && !input.include?(key.to_s)
+            compat_arg = key.to_s
+          else
+            compat_arg = key
+          end
+
+          if !arguments.include?(compat_arg) && !input[key][:default].nil? && !input[key][:optional]
             Log.debug("Setting default value for input '%s' to '%s'" % [key, input[key][:default]])
-            arguments[key] = input[key][:default]
+            arguments[compat_arg] = input[key][:default]
           end
         end
       end
 
+      # Creates a new set of arguments with string arguments mapped to symbol ones
+      #
+      # This is to assist with moving to a JSON pure world where requests might come
+      # in from REST or other languages, those languages and indeed JSON itself does
+      # not support symbols.
+      #
+      # It ensures a backward compatible mode where for rpcutil both of these requests
+      # are equivelant
+      #
+      #   c.get_fact(:fact => "cluster")
+      #   c.get_fact("fact" => "cluster")
+      #
+      # The case where both :fact and "fact" is in the DDL cannot be handled correctly
+      # and this code will assume the caller means "fact" in that case.  There's no
+      # way to represent such a request in JSON and just in general sounds like a bad
+      # idea, so a warning is logged which would in default client configuration appear
+      # on the clients display
+      def symbolize_basic_input_arguments(input, arguments)
+        warned = false
+
+        Hash[arguments.map do |key, value|
+          if input.include?(key.intern) && input.include?(key.to_s) && !warned
+            Log.warn("String and Symbol versions of input %s found in the DDL for %s, ensure your DDL keys are unique." % [key, @pluginname])
+            warned = true
+          end
+
+          if key.is_a?(String) && input.include?(key.intern) && !input.include?(key)
+            [key.intern, value]
+          else
+            [key, value]
+          end
+        end]
+      end
+
       # Helper to use the DDL to figure out if the remote call to an
       # agent should be allowed based on action name and inputs.
       def validate_rpc_request(action, arguments)
@@ -182,16 +222,17 @@ module MCollective
         end
 
         input = action_interface(action)[:input] || {}
+        compatible_args = symbolize_basic_input_arguments(input, arguments)
 
         input.keys.each do |key|
           unless input[key][:optional]
-            unless arguments.keys.include?(key)
+            unless compatible_args.include?(key)
               raise DDLValidationError, "Action #{action} needs a #{key} argument"
             end
           end
 
-          if arguments.keys.include?(key)
-            validate_input_argument(input, key, arguments[key])
+          if compatible_args.include?(key)
+            validate_input_argument(input, key, compatible_args[key])
           end
         end
 

data/lib/mcollective/message.rb

@@ -130,6 +130,14 @@ module MCollective
       @base64
     end
 
+    def description
+      cid = ""
+      cid += payload[:callerid] + "@" if payload.include?(:callerid)
+      cid += payload[:senderid]
+
+      "#{requestid} for agent '#{agent}' in collective '#{collective}' from #{cid}"
+    end
+
     def encode!
       case type
         when :reply
@@ -207,17 +215,11 @@ module MCollective
       msg_age = Time.now.utc.to_i - msgtime
 
       if msg_age > ttl
-        cid = ""
-        cid += payload[:callerid] + "@" if payload.include?(:callerid)
-        cid += payload[:senderid]
-
-        if msg_age > ttl
-          PluginManager["global_stats"].ttlexpired
-
-          raise(MsgTTLExpired, "message #{requestid} from #{cid} created at #{msgtime} is #{msg_age} seconds old, TTL is #{ttl}.  Rejecting message.")
-        end
+        PluginManager["global_stats"].ttlexpired
+        raise(MsgTTLExpired, "Message #{description} created at #{msgtime} is #{msg_age} seconds old, TTL is #{ttl}. Rejecting message.")
       end
-      raise(NotTargettedAtUs, "Received message is not targetted to us") unless PluginManager["security_plugin"].validate_filter?(payload[:filter])
+
+      raise(NotTargettedAtUs, "Message #{description} does not pass filters. Ignoring message.") unless PluginManager["security_plugin"].validate_filter?(payload[:filter])
 
       @validated = true
     end

data/lib/mcollective/monkey_patches.rb

@@ -134,7 +134,9 @@ class OpenSSL::SSL::SSLContext
     DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS
   end
 
-  DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+  if DEFAULT_PARAMS[:ciphers]
+    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+  end
 
   alias __mcollective_original_initialize initialize
   private :__mcollective_original_initialize

data/lib/mcollective/rpc/client.rb

@@ -739,8 +739,13 @@ module MCollective
       end
 
       def rpc_result_from_reply(agent, action, reply)
-        Result.new(agent, action, {:sender => reply[:senderid], :statuscode => reply[:body][:statuscode],
-                                   :statusmsg => reply[:body][:statusmsg], :data => reply[:body][:data]})
+        senderid = reply.include?("senderid") ? reply["senderid"] : reply[:senderid]
+        body = reply.include?("body") ? reply["body"] : reply[:body]
+        s_code = body.include?("statuscode") ? body["statuscode"] : body[:statuscode]
+        s_msg = body.include?("statusmsg") ? body["statusmsg"] : body[:statusmsg]
+        data = body.include?("data") ? body["data"] : body[:data]
+
+        Result.new(agent, action, {:sender => senderid, :statuscode => s_code, :statusmsg => s_msg, :data => data})
       end
 
       # for requests that do not care for results just

data/lib/mcollective/rpc/helpers.rb

@@ -231,7 +231,6 @@ module MCollective
           result_text << ""
         else
           [result].flatten.each do |r|
-
             if flags[:verbose]
               result_text << "%-40s: %s\n" % [r[:sender], r[:statusmsg]]
 

data/lib/mcollective/rpc/request.rb

@@ -6,45 +6,69 @@ module MCollective
 
       def initialize(msg, ddl)
         @time = msg[:msgtime]
-        @action = msg[:body][:action]
-        @data = msg[:body][:data]
+        @action = msg[:body][:action] || msg[:body]["action"]
+        @data = msg[:body][:data] || msg[:body]["data"]
         @sender = msg[:senderid]
-        @agent = msg[:body][:agent]
+        @agent = msg[:body][:agent] || msg[:body]["agent"]
         @uniqid = msg[:requestid]
         @caller = msg[:callerid] || "unknown"
         @ddl = ddl
       end
 
+      # In a scenario where a request came from a JSON pure medium like a REST
+      # service or other language client DDL::AgentDDL#validate_rpc_request will
+      # check "package" against the intput :package should the input "package" not
+      # also be known
+      #
+      # Thus once the request is built it will also have "package" and not :package
+      # data, so we need to fetch the correct key out of the hash.
+      def compatible_key(key)
+        return key if data.include?(key)
+
+        if ddl
+          input = ddl.action_interface(action)[:input]
+
+          # if :package is requested and the DDL also declares "package" we cant tell it to fetch
+          # "package", hence the check against the input here
+          return key.to_s if key.is_a?(Symbol) && !input.include?(key.to_s) && data.include?(key.to_s)
+        end
+
+        key
+      end
+
       # If data is a hash, quick helper to get access to it's include? method
       # else returns false
       def include?(key)
         return false unless @data.is_a?(Hash)
-        return @data.include?(key)
+
+        @data.include?(compatible_key(key))
       end
 
       # If no :process_results is specified always respond else respond
       # based on the supplied property
       def should_respond?
+        return false unless @data.is_a?(Hash)
         return @data[:process_results] if @data.include?(:process_results)
+        return @data["process_results"] if @data.include?("process_results")
 
-        return true
+        true
       end
 
       # If data is a hash, gives easy access to its members, else returns nil
       def [](key)
         return nil unless @data.is_a?(Hash)
-        return @data[key]
+        return @data[compatible_key(key)]
       end
 
       def fetch(key, default)
         return nil unless @data.is_a?(Hash)
-        return @data.fetch(key, default)
+        return @data.fetch(compatible_key(key), default)
       end
 
       def to_hash
-        return {:agent => @agent,
-                :action => @action,
-                :data => @data}
+        {:agent => @agent,
+         :action => @action,
+         :data => @data}
       end
 
       # Validate the request against the DDL

data/lib/mcollective/rpc/result.rb

@@ -14,18 +14,59 @@ module MCollective
         @agent = agent
         @action = action
         @results = result
+
+        convert_data_based_on_ddl if ddl
+      end
+
+      def ddl
+        @_ddl ||= DDL.new(agent)
+      rescue
+        nil
+      end
+
+      def data
+        @results[:data] = @results.delete("data") if @results.include?("data")
+
+        self[:data]
+      end
+
+      # Converts keys on the supplied data to those listed as outputs
+      # in the DDL.  This is to facilitate JSON based transports
+      # without forcing everyone to rewrite DDLs and clients to
+      # convert symbols to strings, the data will be on symbol keys
+      # if the DDL has a symbol and not a string output defined
+      def convert_data_based_on_ddl
+        interface = ddl.action_interface(action)
+
+        return if interface.fetch(:output, {}).empty?
+
+        interface[:output].each do |output, properties|
+          next if data.include?(output)
+
+          if output.is_a?(Symbol) && data.include?(output.to_s)
+            data[output] = data.delete(output.to_s)
+          end
+        end
+      end
+
+      def compatible_key(key)
+        if key.is_a?(Symbol) && @results.include?(key.to_s)
+          key.to_s
+        else
+          key
+        end
       end
 
-      def [](idx)
-        @results[idx]
+      def [](key)
+        @results[compatible_key(key)]
       end
 
-      def []=(idx, item)
-        @results[idx] = item
+      def []=(key, item)
+        @results[key] = item
       end
 
       def fetch(key, default)
-        @results.fetch(key, default)
+        @results.fetch(compatible_key(key), default)
       end
 
       def each
@@ -35,10 +76,10 @@ module MCollective
       def to_json(*a)
         {:agent => @agent,
          :action => @action,
-         :sender => @results[:sender],
-         :statuscode => @results[:statuscode],
-         :statusmsg => @results[:statusmsg],
-         :data => @results[:data]}.to_json(*a)
+         :sender => self[:sender],
+         :statuscode => self[:statuscode],
+         :statusmsg => self[:statusmsg],
+         :data => data}.to_json(*a)
       end
 
       def <=>(other)

data/spec/unit/mcollective/audit/logfile_spec.rb

@@ -36,7 +36,7 @@ module MCollective
 
       it 'should log to a default logfile' do
         Config.any_instance.stubs(:pluginconf).returns({})
-        File.expects(:open).with("/var/log/mcollective-audit.log", "a").yields(file)
+        File.expects(:open).with("/var/log/puppetlabs/mcollective/mcollective-audit.log", "a").yields(file)
         Logfile.new.audit_request(request, nil)
       end
     end

data/spec/unit/mcollective/ddl/agentddl_spec.rb

@@ -11,6 +11,54 @@ module MCollective
         @ddl.metadata(:name => "name", :description => "description", :author => "author", :license => "license", :version => "version", :url => "url", :timeout => "timeout")
       end
 
+      describe "#symbolize_basic_input_arguments" do
+        before(:each) do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+          @ddl.input(:test, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1, :default => "default")
+        end
+
+        it "should warn when there are string and symbol inputs for the same stringified key" do
+          @ddl.input("test", :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1, :default => "default")
+
+          Log.expects(:warn).with("String and Symbol versions of input test found in the DDL for rspec, ensure your DDL keys are unique.")
+          @ddl.symbolize_basic_input_arguments(@ddl.action_interface(:test)[:input], {:test => 1, "test" => 2})
+        end
+
+        it "should use the symbol given a string argument when there is not also a matching string input" do
+          result = @ddl.symbolize_basic_input_arguments(@ddl.action_interface(:test)[:input], {"test" => 2})
+          expect(result).to eq(:test => 2)
+        end
+
+        it "should use the string given a string argument when there is also a matching string input" do
+          @ddl.input("test", :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1, :default => "default")
+
+          Log.stubs(:warn)
+          result = @ddl.symbolize_basic_input_arguments(@ddl.action_interface(:test)[:input], {"test" => 2})
+          expect(result).to eq("test" => 2)
+        end
+
+        it "should not change symbols matching symbol inputs" do
+          result = @ddl.symbolize_basic_input_arguments(@ddl.action_interface(:test)[:input], {:test => 2})
+          expect(result).to eq(:test => 2)
+        end
+
+        it "should not change strings matching strings inputs" do
+          @ddl.input("string_test", :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1, :default => "default")
+
+          result = @ddl.symbolize_basic_input_arguments(@ddl.action_interface(:test)[:input], {"string_test" => 2})
+          expect(result).to eq("string_test" => 2)
+        end
+      end
+
       describe "#input" do
         it "should validate that an :optional property is set" do
           expect { @ddl.input(:x, {:y => 1}) }.to raise_error("Input needs a :optional property")
@@ -45,20 +93,29 @@ module MCollective
 
           args.should == {:required => "specified"}
         end
-      end
 
-      describe "#validate_rpc_request" do
-        it "should ensure the action is known" do
-          @ddl.action(:test, :description => "rspec")
+        it "should detect json primitive key names and consider them present as their symbol equivelants" do
+          args = {"required" => "specified"}
 
-          expect {
-            @ddl.validate_rpc_request(:fail, {})
-          }.to raise_error("Attempted to call action fail for rspec but it's not declared in the DDL")
+          @ddl.set_default_input_arguments(:test, args)
 
-          @ddl.validate_rpc_request(:test, {})
+          args.should == {"required" => "specified"}
         end
 
-        it "should check all required arguments are present" do
+        it "should not consider the string key equiv to the symbol one when both symbol and string keys exist" do
+          @ddl.input("required", :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => false, :validation => "",
+                     :maxlength => 1, :default => "string default")
+
+          args = {"required" => "specified"}
+          @ddl.set_default_input_arguments(:test, args)
+
+          args.should == {"required" => "specified", :required=>"default"}
+        end
+      end
+
+      describe "#validate_rpc_request" do
+        before(:each) do
           @ddl.action(:test, :description => "rspec")
           @ddl.instance_variable_set("@current_entity", :test)
           @ddl.input(:optional, :prompt => "prompt", :description => "descr",
@@ -67,7 +124,17 @@ module MCollective
           @ddl.input(:required, :prompt => "prompt", :description => "descr",
                      :type => :string, :optional => false, :validation => "",
                      :maxlength => 1)
+        end
+
+        it "should ensure the action is known" do
+          expect {
+            @ddl.validate_rpc_request(:fail, {})
+          }.to raise_error("Attempted to call action fail for rspec but it's not declared in the DDL")
 
+          @ddl.validate_rpc_request(:test, {:required => "f"})
+        end
+
+        it "should check all required arguments are present" do
           @ddl.stubs(:validate_input_argument).returns(true)
 
           expect {
@@ -78,20 +145,17 @@ module MCollective
         end
 
         it "should input validate every supplied key" do
-          @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_entity", :test)
-          @ddl.input(:optional, :prompt => "prompt", :description => "descr",
-                     :type => :string, :optional => true, :validation => "",
-                     :maxlength => 1)
-          @ddl.input(:required, :prompt => "prompt", :description => "descr",
-                     :type => :string, :optional => false, :validation => "",
-                     :maxlength => 1)
+          @ddl.expects(:validate_input_argument).with(@ddl.entities[:test][:input], :required, "f")
+          @ddl.expects(:validate_input_argument).with(@ddl.entities[:test][:input], :optional, "f")
 
+          @ddl.validate_rpc_request(:test, {:required => "f", :optional => "f"}).should == true
+        end
 
+        it "should input validate string keys for symbol inputs correctly" do
           @ddl.expects(:validate_input_argument).with(@ddl.entities[:test][:input], :required, "f")
           @ddl.expects(:validate_input_argument).with(@ddl.entities[:test][:input], :optional, "f")
 
-          @ddl.validate_rpc_request(:test, {:required => "f", :optional => "f"}).should == true
+          @ddl.validate_rpc_request(:test, {"required" => "f", "optional" => "f"}).should == true
         end
       end
 

data/spec/unit/mcollective/message_spec.rb

@@ -371,13 +371,17 @@ module MCollective
 
         payload = mock
         payload.expects("[]").with(:filter).returns({})
+        payload.expects(:include?).with(:callerid).returns(false)
+        payload.expects("[]").with(:senderid).returns('sender')
 
-        m = Message.new(payload, "message", :type => :request)
+        m = Message.new(payload, "message", {:type => :request, :collective => 'collective',
+                                             :agent => 'rspecagent', :requestid => '1234'})
         m.instance_variable_set("@msgtime", Time.now.to_i)
 
         expect {
           m.validate
-        }.to raise_error(NotTargettedAtUs)
+        }.to raise_error(NotTargettedAtUs,
+                         "Message 1234 for agent 'rspecagent' in collective 'collective' from sender does not pass filters. Ignoring message.")
       end
 
       it "should pass for good messages" do
@@ -413,12 +417,16 @@ module MCollective
 
         MCollective::PluginManager << {:type => "global_stats", :class => stats}
 
-        m = Message.new({:callerid => "caller", :senderid => "sender"}, "message", :type => :request)
-        m.instance_variable_set("@msgtime", (Time.now.to_i - 120))
+        m = Message.new({:callerid => "caller", :senderid => "sender"}, "message",
+                        {:type => :request, :collective => 'collective',
+                         :agent => 'rspecagent', :requestid => '1234'})
+        mtime = Time.now.to_i - 120
+        m.instance_variable_set("@msgtime", mtime)
 
         expect {
           m.validate
-        }.to raise_error(MsgTTLExpired)
+        }.to raise_error(MsgTTLExpired,
+                         /Message 1234 for agent 'rspecagent' in collective 'collective' from caller@sender created at #{mtime} is 1[12][019] seconds old, TTL is 60. Rejecting message./)
       end
     end
 

data/spec/unit/mcollective/rpc/client_spec.rb

@@ -39,6 +39,65 @@ module MCollective
         @client.stubs(:ddl).returns(ddl)
       end
 
+      describe "#rpc_result_from_reply" do
+        it "should support symbol style replies" do
+          raw_result = {
+            :senderid => "rspec.id",
+            :body => {
+              :statuscode => 1,
+              :statusmsg => "rspec status",
+              :data => {
+                :one => 1
+              }
+            }
+          }
+
+          result = @client.rpc_result_from_reply("rspec", "test", raw_result)
+
+          expect(result.agent).to eq("rspec")
+          expect(result.action).to eq("test")
+          expect(result[:sender]).to eq("rspec.id")
+          expect(result[:statuscode]).to eq(1)
+          expect(result[:statusmsg]).to eq("rspec status")
+          expect(result[:data]).to eq(:one => 1)
+          expect(result.results).to eq(
+            :sender => "rspec.id",
+            :statuscode => 1,
+            :statusmsg => "rspec status",
+            :data => {:one => 1}
+          )
+        end
+
+        it "should support string style replies" do
+          raw_result = {
+            "senderid" => "rspec.id",
+            "body" => {
+              "statuscode" => 1,
+              "statusmsg" => "rspec status",
+              "data" => {
+                "one" => 1,
+                "two" => 2
+              }
+            }
+          }
+
+          result = @client.rpc_result_from_reply("rspec", "test", raw_result)
+
+          expect(result.agent).to eq("rspec")
+          expect(result.action).to eq("test")
+          expect(result[:sender]).to eq("rspec.id")
+          expect(result[:statuscode]).to eq(1)
+          expect(result[:statusmsg]).to eq("rspec status")
+          expect(result[:data]).to eq("one" => 1, "two" => 2)
+          expect(result.results).to eq(
+            :sender => "rspec.id",
+            :statuscode => 1,
+            :statusmsg => "rspec status",
+            :data => {"one" => 1, "two" => 2}
+          )
+        end
+      end
+
       describe "#detect_and_set_stdin_discovery" do
         before(:each) do
           @client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :stdin => @stdin}})

data/spec/unit/mcollective/rpc/request_spec.rb

@@ -20,6 +20,28 @@ module MCollective
         @request = Request.new(@req, @ddl)
       end
 
+      describe "#compatible_key" do
+        it "should return the key if its a known key already" do
+          expect(@request.compatible_key(:foo)).to be(:foo)
+        end
+
+        it "should return the symbol key if the DDL defines both" do
+          @ddl.action("test", :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", "test")
+          @ddl.input(:test, :prompt => "test", :description => "test", :type => :boolean, :optional => true)
+          @ddl.input("test", :prompt => "test", :description => "test", :type => :boolean, :optional => true)
+
+          expect(@request.compatible_key(:test)).to be(:test)
+          expect(@request.compatible_key("test")).to eq("test")
+        end
+
+        it "should return the stringified key if a interned version of known string data was requested" do
+          expect(@request.compatible_key(:string)).to eq(:string)
+          @req[:body][:data]["string"] = "string data"
+          expect(@request.compatible_key(:string)).to eq("string")
+        end
+      end
+
       describe "#validate!" do
         it "should validate the request using the supplied DDL" do
           @ddl.expects(:validate_rpc_request).with("test", {:foo => "bar", :process_results => true})
@@ -60,6 +82,18 @@ module MCollective
           @req.delete(:callerid)
           Request.new(@req, @ddl).caller.should == "unknown"
         end
+
+        it "should support JSON pure inputs" do
+          @req[:body] = {"action" => "test",
+                         "data"   => {"foo" => "bar", "process_results" => true},
+                         "agent"  => "tester"}
+
+          request = Request.new(@req, @ddl)
+
+          expect(request.action).to eq("test")
+          expect(request.agent).to eq("tester")
+          expect(request.data).to eq("foo" => "bar", "process_results" => true)
+        end
       end
 
       describe "#include?" do
@@ -82,6 +116,8 @@ module MCollective
         it "should return correct value" do
           @req[:body][:data][:process_results] = false
           Request.new(@req, @ddl).should_respond?.should == false
+          @req[:body][:data]["process_results"] = false
+          Request.new(@req, @ddl).should_respond?.should == false
         end
       end
 

data/spec/unit/mcollective/rpc/result_spec.rb

@@ -27,6 +27,34 @@ module MCollective
         end
       end
 
+      describe "#convert_data_based_on_ddl" do
+        it "should convert string data to symbol data based on the DDL" do
+          ddl = DDL.new("rspec", :agent, false)
+          ddl.metadata(:name => "name", :description => "description", :author => "author", :license => "license", :version => "version", :url => "url", :timeout => "timeout")
+          ddl.action("test", :description => "rspec")
+          ddl.instance_variable_set("@current_entity", "test")
+          ddl.output(:one, :description => "rspec one", :display_as => "One")
+
+          DDL.expects(:new).with("rspec").returns(ddl)
+
+          raw_result = {
+            "sender" => "rspec.id",
+            "statuscode" => 1,
+            "statusmsg" => "rspec status",
+            "data" => {
+              "one" => 1,
+              "two" => 2
+            }
+          }
+
+          result = Result.new("rspec", "test", raw_result)
+          expect(result.data).to eq(
+            :one => 1,
+            "two" => 2
+          )
+        end
+      end
+
       describe "#[]" do
         it "should access the results hash and return correct data" do
           @result[:foo].should == "bar"
@@ -71,17 +99,17 @@ module MCollective
 
       describe "#<=>" do
         it "should implement the Combined Comparison operator based on sender name" do
-          result_a = Result.new("tester", 
-                                "test", 
-                                { :statuscode => 0, 
-                                  :statusmsg => "OK", 
-                                  :sender => "a_rspec",  
+          result_a = Result.new("tester",
+                                "test",
+                                { :statuscode => 0,
+                                  :statusmsg => "OK",
+                                  :sender => "a_rspec",
                                   :data => {}})
-          result_b = Result.new("tester", 
-                                "test", 
-                                { :statuscode => 0, 
-                                  :statusmsg => "OK", 
-                                  :sender => "b_rspec",  
+          result_b = Result.new("tester",
+                                "test",
+                                { :statuscode => 0,
+                                  :statusmsg => "OK",
+                                  :sender => "b_rspec",
                                   :data => {}})
 
           (result_a <=> result_b).should == -1

data/spec/unit/mcollective/runner_spec.rb

@@ -259,7 +259,7 @@ module MCollective
         it 'should log if a message was received by not directed at the server' do
           runner.expects(:receive).raises(NotTargettedAtUs)
           runner.instance_variable_set(:@exit_receiver_thread, true)
-          Log.expects(:debug).with("Message does not pass filters, ignoring")
+          Log.expects(:info)
           runner.send(:receiver_thread)
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcollective-client
 version: !ruby/object:Gem::Version
-  version: 2.10.6
+  version: 2.11.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-02 00:00:00.000000000 Z
+date: 2017-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: systemu