Add compliance information to a server

app/models/manageiq/providers/lenovo/physical_infra_manager/parser.rb

@@ -34,12 +34,16 @@ def parse_physical_switch(switch)
       PhysicalSwitchParser.parse_physical_switch(switch)
     end
 
-    def parse_physical_server(node, rack = nil)
-      PhysicalServerParser.parse_physical_server(node, rack)
+    def parse_physical_server(node, compliance, rack = nil)
+      PhysicalServerParser.parse_physical_server(node, compliance, rack)
     end
 
     def parse_config_pattern(config_pattern)
       ConfigPatternParser.parse_config_pattern(config_pattern)
     end
+
+    def parse_compliance_policy(compliance_policies)
+      CompliancePolicyParser.parse_compliance_policy(compliance_policies)
+    end
   end
 end

app/models/manageiq/providers/lenovo/physical_infra_manager/parser/compliance_policy_parser.rb

@@ -0,0 +1,40 @@
+module ManageIQ::Providers::Lenovo
+  class PhysicalInfraManager::Parser::CompliancePolicyParser < PhysicalInfraManager::Parser::ComponentParser
+    COMPLIANCE_NAME = 'No policy assigned'.freeze
+    COMPLIANCE_STATUS = {
+      'no'  => 'Non-compliant',
+      'yes' => 'Compliant',
+      ''    => 'None'
+    }.freeze
+
+    class << self
+      def parse_compliance_policy(compliance_policies)
+        parse_to_hash(compliance_policies)
+      end
+
+      private
+
+      def map_by_uuid(collection)
+        collection.collect do |result|
+          policy_name = result['policyName']
+          data = {
+            :policy_name => policy_name.empty? ? COMPLIANCE_NAME : policy_name,
+            :status      => "#{COMPLIANCE_STATUS[result['endpointCompliant']]} #{result['message'].join(', ')}".strip,
+          }
+          # Return a tuple [key, value] for each result
+          [result['uuid'], data]
+        end.to_h
+      end
+
+      def parse_to_hash(persisted_results)
+        persisted_results.collect do |persisted_result|
+          if persisted_result.xITEs.present?
+            map_by_uuid(persisted_result.xITEs)
+          elsif persisted_result.racklist.present?
+            map_by_uuid(persisted_result.racklist)
+          end
+        end.compact.reduce({}, :merge)
+      end
+    end
+  end
+end

app/models/manageiq/providers/lenovo/physical_infra_manager/parser/physical_server_parser.rb

@@ -8,12 +8,14 @@ class << self
       #
       # @return [Hash] containing the physical server information
       #
-      def parse_physical_server(node, rack = nil)
+      def parse_physical_server(node, compliance, rack = nil)
         result = parse(node, parent::ParserDictionaryConstants::PHYSICAL_SERVER)
 
         # Keep track of the rack where this server is in, if it is in any rack
         result[:physical_rack]              = rack if rack
 
+        result[:ems_compliance_name]        = compliance[:policy_name]
+        result[:ems_compliance_status]      = compliance[:status]
         result[:vendor]                     = "lenovo"
         result[:type]                       = parent::ParserDictionaryConstants::MIQ_TYPES["physical_server"]
         result[:power_state]                = parent::ParserDictionaryConstants::POWER_STATE_MAP[node.powerStatus]

app/models/manageiq/providers/lenovo/physical_infra_manager/refresh_parser.rb

@@ -65,7 +65,7 @@ def get_all_physical_infra
         rack_uid, rack = @parser.parse_physical_rack(cab)
 
         get_physical_servers(cab) do |node|
-          _, parsed = @parser.parse_physical_server(node, rack)
+          _, parsed = @parser.parse_physical_server(node, find_compliance(node), rack)
           physical_servers << parsed
         end
 
@@ -74,7 +74,7 @@ def get_all_physical_infra
 
       nodes = get_physical_servers(standalone)
       process_collection(nodes, :physical_servers) do |node|
-        @parser.parse_physical_server(node)
+        @parser.parse_physical_server(node, find_compliance(node))
       end
 
       @data[:physical_servers].concat(physical_servers)
@@ -120,6 +120,19 @@ def get_physical_switches
       end
     end
 
+    def find_compliance(node)
+      @compliance_policies ||= @connection.fetch_compliance_policies
+      @compliance_policies_parsed ||= @parser.parse_compliance_policy(@compliance_policies)
+      @compliance_policies_parsed[node.uuid] || create_default_compliance
+    end
+
+    def create_default_compliance
+      {
+        :policy_name => PhysicalInfraManager::Parser::CompliancePolicyParser::COMPLIANCE_NAME,
+        :status      => PhysicalInfraManager::Parser::CompliancePolicyParser::COMPLIANCE_STATUS['']
+      }
+    end
+
     def get_config_patterns
       config_patterns = @connection.discover_config_pattern
       process_collection(config_patterns, :customization_scripts) { |config_pattern| @parser.parse_config_pattern(config_pattern) }

spec/models/manageiq/providers/lenovo/physical_infra_manager/refresh_parser_spec.rb

@@ -7,6 +7,7 @@
     VCR.insert_cassette("#{vcr_path}/mock_cabinet", options)
     VCR.insert_cassette("#{vcr_path}/mock_config_patterns", options)
     VCR.insert_cassette("#{vcr_path}/mock_switches", options)
+    VCR.insert_cassette("#{vcr_path}/mock_compliance_policy", options)
   end
   after(:all) do
     while VCR.cassettes.last
@@ -147,6 +148,16 @@
       end
     end
 
+    it 'will retrieve compliance policy information from a physical server' do
+      ph1 = @result[:physical_servers][0]
+      ph2 = @result[:physical_servers][1]
+
+      expect(ph2[:ems_compliance_name]).to eq('No policy assigned')
+      expect(ph2[:ems_compliance_status]).to eq('None')
+      expect(ph1[:ems_compliance_name]).to eq('policy1')
+      expect(ph1[:ems_compliance_status]).to eq('Compliant')
+    end
+
     it 'will retrieve the amout of memory in MB' do
       physical_server = @result[:physical_servers][1]
       memory_amount = physical_server[:computer_system][:hardware][:memory_mb]

spec/models/manageiq/providers/lenovo/physical_infra_manager/refresher_spec.rb

@@ -7,6 +7,7 @@
     VCR.insert_cassette("#{vcr_path}/mock_cabinet", options)
     VCR.insert_cassette("#{vcr_path}/mock_config_patterns", options)
     VCR.insert_cassette("#{vcr_path}/mock_switches", options)
+    VCR.insert_cassette("#{vcr_path}/mock_compliance_policy", options)
     VCR.insert_cassette("#{vcr_path}/full_refresh", options)
   end
   after(:all) do