Add NAT rules to the floating IP workflow

The floating IP workflow is now able to manage NAT
rules (portforwarding) if the floating IP is not
associated with any NICs (ports).

This patch is the one of a series of patches
to implement floating ip port forwarding with
port ranges.

The specification is defined in:
https://github.com/openstack/neutron-specs/blob/master/specs/wallaby/port-forwarding-port-ranges.rst

Implements: blueprint https://blueprints.launchpad.net/neutron/+spec/floatingips-portforwarding-ranges
Change-Id: Id715da6591124de45f41cc367bf39a6bfe190c9a

2 files changed, 119 insertions, 0 deletions

diff --git a/openstack_dashboard/test/test_data/neutron_data.py b/openstack_dashboard/test/test_data/neutron_data.py
index 78bd93df3..024ec79bc 100644
--- a/openstack_dashboard/test/test_data/neutron_data.py
+++ b/openstack_dashboard/test/test_data/neutron_data.py
@@ -34,6 +34,7 @@ def data(TEST):
     TEST.routers_with_rules = utils.TestDataContainer()
     TEST.routers_with_routes = utils.TestDataContainer()
     TEST.floating_ips = utils.TestDataContainer()
+    TEST.port_forwardings = utils.TestDataContainer()
     TEST.security_groups = utils.TestDataContainer()
     TEST.security_group_rules = utils.TestDataContainer()
     TEST.providers = utils.TestDataContainer()
@@ -63,6 +64,7 @@ def data(TEST):
     TEST.api_routers = utils.TestDataContainer()
     TEST.api_routers_with_routes = utils.TestDataContainer()
     TEST.api_floating_ips = utils.TestDataContainer()
+    TEST.api_port_forwardings = utils.TestDataContainer()
     TEST.api_security_groups = utils.TestDataContainer()
     TEST.api_security_group_rules = utils.TestDataContainer()
     TEST.api_pools = utils.TestDataContainer()
@@ -647,6 +649,7 @@ def data(TEST):
                 'id': '9012cd70-cfae-4e46-b71e-6a409e9e0063',
                 'fixed_ip_address': None,
                 'port_id': None,
+                'port_forwardings': [],
                 'router_id': None}
     TEST.api_floating_ips.add(fip_dict)
     fip_with_instance = copy.deepcopy(fip_dict)
@@ -659,6 +662,7 @@ def data(TEST):
                 'floating_ip_address': '172.16.88.228',
                 'floating_network_id': ext_net['id'],
                 'id': 'a97af8f2-3149-4b97-abbd-e49ad19510f7',
+                'port_forwardings': [],
                 'fixed_ip_address': assoc_port['fixed_ips'][0]['ip_address'],
                 'port_id': assoc_port['id'],
                 'router_id': router_dict['id']}
@@ -668,6 +672,46 @@ def data(TEST):
                               'instance_type': 'compute'})
     TEST.floating_ips.add(neutron.FloatingIp(fip_with_instance))
 
+    # port forwardings
+
+    TEST.api_port_forwardings.add({
+        "protocol": "tcp",
+        "internal_ip_address": "10.0.0.11",
+        "internal_port": 25,
+        "internal_port_id": "1238be08-a2a8-4b8d-addf-fb5e2250e480",
+        "external_port": 2230,
+        "internal_port_range": "25:25",
+        "external_port_range": "2230:2230",
+        "description": "",
+        "id": "e0a0274e-4d19-4eab-9e12-9e77a8caf3ea"
+    })
+    TEST.api_port_forwardings.add({
+        "protocol": "tcp",
+        "internal_port": 80,
+        "external_port": 8080,
+        "internal_ip_address": "10.0.0.12",
+        "internal_port_range": "80:90",
+        "internal_port_id": "2057ec54-8be2-11eb-8dcd-0242ac130003",
+        "external_port_range": "8080:8090",
+        "description": "using port ranges",
+        "id": "0f23a90a-8be2-11eb-8dcd-0242ac130003"
+    })
+    TEST.api_port_forwardings.add({
+        "protocol": "tcp",
+        "internal_ip_address": "10.0.0.24",
+        "internal_port": 25,
+        "internal_port_id": "070ef0b2-0175-4299-be5c-01fea8cca522",
+        "external_port": 2229,
+        "internal_port_range": "25:25",
+        "external_port_range": "2229:2229",
+        "description": "Some description",
+        "id": "1798dc82-c0ed-4b79-b12d-4c3c18f90eb2"
+    })
+
+    TEST.port_forwardings.add(neutron.PortForwarding(
+        TEST.api_port_forwardings.first(), fip_dict['id']
+    ))
+
     # Security group.
 
     sec_group_1 = {'tenant_id': '1',
diff --git a/openstack_dashboard/test/unit/api/test_neutron.py b/openstack_dashboard/test/unit/api/test_neutron.py
index 19bde8df1..4d9d1e8d0 100644
--- a/openstack_dashboard/test/unit/api/test_neutron.py
+++ b/openstack_dashboard/test/unit/api/test_neutron.py
@@ -2321,6 +2321,81 @@ class NeutronApiSecurityGroupTests(test.APIMockTestCase):
         self.qclient.update_port.assert_has_calls(expected_calls)
 
 
+class NeutronApiFloatingIpPortForwardingTest(test.APIMockTestCase):
+    def setUp(self):
+        super().setUp()
+        neutronclient = mock.patch.object(api.neutron, 'neutronclient').start()
+        self.client_mock = neutronclient.return_value
+
+    def test_port_forwarding_list(self):
+        pfws = {'port_forwardings': self.api_port_forwardings.list()}
+        self.client_mock.list_port_forwardings.return_value = pfws
+        response = api.neutron.floating_ip_port_forwarding_list(
+            self.request, 'fip')
+        for i in range(len(response)):
+            resp_val = response[i]
+            expected_val = pfws['port_forwardings'][i]
+            for attr in resp_val.to_dict():
+                self.assertEqual(getattr(resp_val, attr), expected_val[attr])
+
+        self.client_mock.list_port_forwardings.assert_called_once_with('fip')
+
+    def test_port_forwarding_get(self):
+        pfw = self.api_port_forwardings.first()
+        pfw_id = pfw['id']
+        self.client_mock.show_port_forwarding.return_value = pfw
+        response = api.neutron.floating_ip_port_forwarding_get(
+            self.request, 'fip', pfw_id)
+        for attr in response.to_dict():
+            self.assertEqual(getattr(response, attr), pfw[attr])
+        self.client_mock.show_port_forwarding.assert_called_once_with(
+            'fip', pfw_id)
+
+    def test_port_forwarding_create(self):
+        pfw_resp_mock = {'port_forwarding': self.api_port_forwardings.first()}
+        pfw_expected = self.port_forwardings.get().to_dict()
+        pfw = {
+            "protocol": "tcp",
+            "internal_ip_address": "10.0.0.24",
+            "internal_port": 25,
+            "internal_port_id": "070ef0b2-0175-4299-be5c-01fea8cca522",
+            "external_port": 2229,
+            "description": "Some description",
+        }
+        self.client_mock.create_port_forwarding.return_value = pfw_resp_mock
+        response = api.neutron.floating_ip_port_forwarding_create(
+            self.request, 'fip', **pfw)
+        for attr in response.to_dict():
+            self.assertEqual(getattr(response, attr), pfw_expected[attr])
+        self.client_mock.create_port_forwarding.assert_called_once_with(
+            'fip', {'port_forwarding': pfw})
+
+    def test_port_forwarding_update(self):
+        pfw_resp_mock = {'port_forwarding': self.api_port_forwardings.first()}
+        pfw_expected = self.port_forwardings.get().to_dict()
+        pfw_id = pfw_resp_mock['port_forwarding']['id']
+        pfw = {
+            "protocol": "tcp",
+            "internal_port": 25,
+            "description": "Some description",
+        }
+        self.client_mock.update_port_forwarding.return_value = pfw_resp_mock
+        response = api.neutron.floating_ip_port_forwarding_update(
+            self.request, 'fip', portforwarding_id=pfw_id, **pfw)
+        for attr in response.to_dict():
+            self.assertEqual(getattr(response, attr), pfw_expected[attr])
+        self.client_mock.update_port_forwarding.assert_called_once_with(
+            'fip', pfw_id, {'port_forwarding': pfw})
+
+    def test_port_forwarding_delete(self):
+        pfw_id = self.api_port_forwardings.first()['id']
+        self.client_mock.delete_port_forwarding.return_value = None
+        api.neutron.floating_ip_port_forwarding_delete(
+            self.request, 'fip', pfw_id)
+        self.client_mock.delete_port_forwarding.assert_called_once_with(
+            'fip', pfw_id)
+
+
 class NeutronApiFloatingIpTests(test.APIMockTestCase):
 
     def setUp(self):