Migrate Node Network List Functionality Into esisdk

Originally, this functionality existed in python-esiclient. We moved
it into esisdk so that multiple projects can reuse the same package,
and to centralize the logic in one place.

esi/lib/networks.py

@@ -0,0 +1,112 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+
+import concurrent.futures
+
+
+def get_ports(connection, filter_network=None):
+    if filter_network:
+        neutron_ports = connection.network.ports(network_id=filter_network.id)
+    else:
+        neutron_ports = connection.network.ports()
+    return neutron_ports
+
+
+def network_and_port_list(connection, filter_network=None):
+    """Gets accessible networking information
+
+    :param connection: An OpenStack connection
+    :type connection: :class:`~openstack.connection.Connection`
+    :param filter_network: The name or ID of a network
+
+    :returns: A tuple of network ports, networks, floating ips, and port forwardings of the form:
+    (
+        [openstack.network.v2.port.Port],
+        {openstack.network.v2.network.Network.id: openstack.network.v2.network.Network},
+        {openstack.network.v2.port.Port.id: openstack.network.v2.floating_ip.FloatingIP},
+        {openstack.network.v2.port.Port.id: openstack.network.v2.port_forwarding.PortForwarding}
+    )
+    """
+
+    floating_ips_dict = {}
+    port_forwardings_dict = {}
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        f1 = executor.submit(get_ports, connection, filter_network)
+        f2 = executor.submit(connection.network.networks)
+        f3 = executor.submit(connection.network.ips)
+        network_ports = list(f1.result())
+        networks_dict = {network.id: network for network in list(f2.result())}
+        floating_ips = list(f3.result())
+
+    for floating_ip in floating_ips:
+        # no need to do this for floating IPs associated with a port,
+        # as port forwarding is irrelevant in such a case
+        if not floating_ip.port_id:
+            pfwds = list(connection.network.port_forwardings(floating_ip=floating_ip))
+            if len(pfwds):
+                floating_ip.port_id = pfwds[0].internal_port_id
+                port_forwardings_dict[floating_ip.port_id] = pfwds
+        floating_ips_dict[floating_ip.port_id] = floating_ip
+
+    return network_ports, networks_dict, floating_ips_dict, port_forwardings_dict
+
+
+def get_networks_from_port(connection, port, networks_dict={}, floating_ips_dict={}):
+    """Gets associated network objects from a port object
+
+    :param connection: An OpenStack connection
+    :type connection: :class:`~openstack.connection.Connection`
+    :param port: A network port
+    :type port: :class:`~openstack.network.v2.port.Port`
+    :param networks_dict: A dictionary mapping network IDs to network objects
+    :param floating_ips_dict: A dictionary mapping port IDs to floating IPs
+
+    :returns: A tuple containing the parent network, trunk networks, and the floating
+              network associated with the given port
+    """
+
+    parent_network = None
+    trunk_networks = []
+
+    if port.network_id in networks_dict:
+        parent_network = networks_dict[port.network_id]
+    else:
+        parent_network = connection.network.get_network(network=port.network_id)
+
+    if port.trunk_details:
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            subport_futures = []
+            subports = port.trunk_details['sub_ports']
+            for subport_info in subports:
+                subport_futures.append(executor.submit(
+                    connection.network.get_port,
+                    port=subport_info['port_id']
+                ))
+            for subport_future in subport_futures:
+                subport = subport_future.result()
+                if subport.network_id in networks_dict:
+                    trunk_network = networks_dict[subport.network_id]
+                else:
+                    trunk_network = connection.network.get_network(subport.network_id)
+                trunk_networks.append(trunk_network)
+
+    floating_network_id = getattr(floating_ips_dict.get(port.id),
+                                  'floating_network_id', None)
+    if floating_network_id is None:
+        floating_network = None
+    elif networks_dict.get(floating_network_id):
+        floating_network = networks_dict[floating_network_id]
+    else:
+        floating_network = connection.network.get_network(floating_network_id)
+
+    return parent_network, trunk_networks, floating_network

esi/lib/nodes.py

@@ -0,0 +1,137 @@
+
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+
+import concurrent.futures
+
+from esi.lib import networks
+
+
+def node_and_port_list(connection, filter_node=None):
+    """Get lists baremetal nodes and ports
+
+    :param connection: An OpenStack connection
+    :type connection: :class:`~openstack.connection.Connection`
+    :param filter_node: The name or ID of a node
+
+    :returns: A tuple of lists of nodes and ports of the form:
+    (
+        [openstack.baremetal.v1.node.Node],
+        [openstack.baremetal.v1.port.Port]
+    )
+    """
+
+    nodes = None
+    ports = None
+
+    if filter_node:
+        nodes = [connection.baremetal.find_node(name_or_id=filter_node,
+                                                ignore_missing=False)]
+        ports = connection.baremetal.ports(details=True, node_id=nodes[0].id)
+    else:
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            f1 = executor.submit(connection.baremetal.nodes)
+            f2 = executor.submit(connection.baremetal.ports, details=True)
+            nodes = list(f1.result())
+            ports = list(f2.result())
+
+    return nodes, ports
+
+
+def network_list(connection, filter_node=None, filter_network=None):
+    """List nodes and their network attributes
+
+    :param connection: An OpenStack connection
+    :type connection: :class:`~openstack.connection.Connection`
+    :param filter_node: the name or ID of a node
+    :param filter_network: The name or ID of a network
+
+    :returns: A list of dictionaries of the form:
+    {
+        'node': openstack.baremetal.v1.node.Node,
+        'network_info': [
+            {
+                'baremetal_port': openstack.baremetal.v1.port.Port,
+                'network_port': openstack.network.v2.port.Port or None,
+                'networks': {
+                    'parent': openstack.network.v2.network.Network or None,
+                    'trunk': [openstack.network.v2.network.Network] or [],
+                    'floating': openstack.network.v2.network.Network or None,
+                },
+                'floating_ip': openstack.network.v2.floating_ip.FloatingIP or None,
+                'port_forwardings': [openstack.network.v2.port_forwarding.PortForwarding] or []
+            },
+            ...
+        ]
+    }
+    """
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        f1 = executor.submit(node_and_port_list, connection, filter_node)
+        f2 = executor.submit(networks.network_and_port_list, connection, filter_network)
+        if filter_network:
+            f3 = executor.submit(connection.network.find_network,
+                                 name_or_id=filter_network,
+                                 ignore_missing=False)
+        baremetal_nodes, baremetal_ports = f1.result()
+        network_ports, networks_dict, floating_ips_dict, port_forwardings_dict = f2.result()
+        if filter_network:
+            filter_network = f3.result()
+
+    data = []
+    for baremetal_node in baremetal_nodes:
+        network_info = []
+        node_ports = [bp for bp in baremetal_ports
+                      if bp.node_id == baremetal_node.id]
+
+        for baremetal_port in node_ports:
+            network_port = None
+            network_port_id = baremetal_port.internal_info.get('tenant_vif_port_id', None)
+
+            if network_port_id:
+                network_port = next((np for np in network_ports
+                                     if np.id == network_port_id), None)
+
+            if network_port is not None and (not filter_network or filter_network.id == network_port.network_id):
+                parent_network, trunk_networks, floating_network \
+                    = networks.get_networks_from_port(connection,
+                                                      network_port,
+                                                      networks_dict,
+                                                      floating_ips_dict)
+
+                network_info.append({
+                    'baremetal_port': baremetal_port,
+                    'network_port': network_port,
+                    'networks': {
+                        'parent': parent_network,
+                        'trunk': trunk_networks,
+                        'floating': floating_network
+                    },
+                    'floating_ip': floating_ips_dict.get(network_port.id, None),
+                    'port_forwardings': port_forwardings_dict.get(network_port.id, []),
+                })
+            elif not filter_network:
+                network_info.append({
+                    'baremetal_port': baremetal_port,
+                    'network_port': None,
+                    'networks': {},
+                    'floating_ip': None,
+                    'port_forwardings': [],
+                })
+
+        if network_info != []:
+            data.append({
+                'node': baremetal_node,
+                'network_info': network_info
+            })
+
+    return data

esi/tests/unit/base.py

@@ -0,0 +1,32 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import mock
+import testtools
+
+
+class TestCase(testtools.TestCase):
+    """Base class for all unit tests"""
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+
+
+class TestCommand(TestCase):
+    """Base class for all command unit tests"""
+
+    def setUp(self):
+        super(TestCommand, self).setUp()
+        self.connection = mock.Mock()
+        self.connection.baremetal = mock.Mock()
+        self.connection.network = mock.Mock()