Parsing the connection b/w ports

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

@@ -22,7 +22,59 @@ def parse_network_device_ports(ports)
       #   it ports parsed
       #
       def parse_physical_switch_ports(physical_switch)
-        physical_switch.ports&.map { |port| parse_switch_port(port) }
+        physical_switch.ports&.map { |port| parse_switch_port(port, physical_switch) }
+      end
+
+      #
+      # Binds the connected ports
+      #
+      # @param [Array<Hash>] ports - parsed ports to be bind
+      #
+      def bind_network_ports!(ports)
+        ports.each do |origin_port|
+          connected_port = ports.find { |destination_port| connected_port?(origin_port, destination_port) }
+          origin_port[:connected_port_uid] = connected_port[:uid_ems] if connected_port
+        end
+      end
+
+      #
+      # Selects all the physical network port from physical servers list.
+      #
+      # @param [Array<Hash>] physical_servers - list of physical servers that must
+      #   have its ports selecteds.
+      #
+      # @return [Array<Hash>] the list of physical network ports
+      #
+      def extract_physical_servers_ports(physical_servers)
+        ports = []
+
+        physical_servers.each do |server|
+          network_devices = server[:computer_system][:hardware][:guest_devices]
+
+          network_devices.each do |device|
+            ports.concat(device[:physical_network_ports]) if device[:physical_network_ports].present?
+          end
+        end
+
+        ports
+      end
+
+      #
+      # Selects all the physical network port from physical switches list.
+      #
+      # @param [Array<Hash>] physical_switches - list of physical switches that must
+      #   have its ports selecteds.
+      #
+      # @return [Array<Hash>] the list of physical network ports
+      #
+      def extract_physical_switches_ports(physical_switches)
+        ports = []
+
+        physical_switches.each do |switch|
+          ports.concat(switch[:physical_network_ports]) if switch[:physical_network_ports].present?
+        end
+
+        ports
       end
 
       private
@@ -34,18 +86,20 @@ def parse_physical_server_ports(port)
           parsed_physical_port = parse_physical_port(physical_port)
           logical_ports = physical_port["logicalPorts"]
           parsed_logical_port = parse_logical_port(logical_ports[0])
-          parsed_logical_port[:uid_ems] = mount_uuid(port, physical_port['physicalPortIndex'])
+          parsed_logical_port[:uid_ems] = mount_uuid_server_port(port, physical_port['physicalPortIndex'])
           parsed_logical_port.merge!(parsed_physical_port)
+
           parsed_logical_port
         end
       end
 
-      def parse_switch_port(port)
+      def parse_switch_port(port, physical_switch)
         result = parse(port, parent::ParserDictionaryConstants::PHYSICAL_SWITCH_PORT)
         result.merge(
           :port_name    => port["portName"].presence || port["port"],
           :port_type    => "physical_port",
-          :vlan_enabled => port["PVID"].present?
+          :vlan_enabled => port["PVID"].present?,
+          :uid_ems      => mount_uuid_switch_port(port, physical_switch)
         )
       end
 
@@ -67,9 +121,26 @@ def format_mac_address(mac_address)
         mac_address.scan(/\w{2}/).join(":")
       end
 
-      def mount_uuid(device, port_number = nil)
+      def mount_uuid_server_port(device, port_number = nil)
         (device["uuid"] || "#{device['pciBusNumber']}#{device['pciDeviceNumber']}") + port_number.to_s
       end
+
+      def mount_uuid_switch_port(port, physical_switch)
+        physical_switch.uuid + port["interfaceIndex"]
+      end
+
+      #
+      # Verifies if two ports are connected
+      #
+      # @return [Boolean] true if they are connected
+      #
+      def connected_port?(origin_port, destination_port)
+        return origin_port[:mac_address] == destination_port[:peer_mac_address] if origin_port[:mac_address].present?
+
+        return origin_port[:peer_mac_address] == destination_port[:mac_address] if origin_port[:peer_mac_address].present?
+
+        false
+      end
     end
   end
 end

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

@@ -27,6 +27,8 @@ def ems_inv_to_hashes
       inventory[:physical_switches]     = get_physical_switches
       inventory[:customization_scripts] = get_config_patterns
 
+      bind_network_ports
+
       $log.info("#{log_header}...Complete")
 
       inventory
@@ -139,6 +141,18 @@ def get_config_patterns
       config_patterns = @connection.discover_config_pattern
       config_patterns.map { |config_pattern| @parser.parse_config_pattern(config_pattern) }
     end
+
+    def bind_network_ports
+      physical_servers = @data[:physical_servers]
+      physical_switches = @data[:physical_switches]
+
+      ports = []
+
+      ports.concat(PhysicalInfraManager::Parser::PhysicalNetworkPortsParser.extract_physical_servers_ports(physical_servers))
+      ports.concat(PhysicalInfraManager::Parser::PhysicalNetworkPortsParser.extract_physical_switches_ports(physical_switches))
+
+      PhysicalInfraManager::Parser::PhysicalNetworkPortsParser.bind_network_ports!(ports)
+    end
   end
 end
 # rubocop:enable Naming/AccessorMethodName

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

@@ -62,7 +62,7 @@
       switch = @result[:physical_switches].first
       port   = switch[:physical_network_ports].first
 
-      expect(port[:peer_mac_address]).to eq("7c:d3:0a:e6:47:51")
+      expect(port[:peer_mac_address]).to eq("5C:F3:FC:7F:0B:50")
       expect(port[:port_type]).to eq("physical_port")
       expect(port[:vlan_enabled]).to eq(true)
       expect(port[:vlan_key]).to eq("\"Lenovo-Network-VLAN546\"")

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

@@ -82,6 +82,7 @@
       assert_specific_storage
       assert_guest_table_contents
       assert_physical_network_ports_table_content
+      assert_physical_network_ports_connection
     end
   end
 
@@ -145,4 +146,12 @@ def assert_physical_network_ports_table_content
     expect(port2.port_name).to eq("Physical Port 2")
     expect(port2.mac_address).to eq("00:0A:F7:25:67:39")
   end
+
+  def assert_physical_network_ports_connection
+    port1 = PhysicalNetworkPort.find_by(:mac_address => "00:0A:F7:25:67:39")
+    port2 = PhysicalNetworkPort.find_by(:peer_mac_address => "00:0A:F7:25:67:39")
+
+    expect(port1.connected_port).to eq(port2)
+    expect(port2.connected_port).to eq(port1)
+  end
 end