octavia 12.0.0.0rc2__py3-none-any.whl → 13.0.0.0rc1__py3-none-any.whl

octavia/network/drivers/neutron/base.py

@@ -12,7 +12,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from neutronclient.common import exceptions as neutron_client_exceptions
+from openstack.connection import Connection
+import openstack.exceptions as os_exceptions
+from openstack.network.v2._proxy import Proxy
 from oslo_config import cfg
 from oslo_log import log as logging
 
@@ -23,33 +25,28 @@ from octavia.network import base
 from octavia.network import data_models as network_models
 from octavia.network.drivers.neutron import utils
 
-
 LOG = logging.getLogger(__name__)
 DNS_INT_EXT_ALIAS = 'dns-integration'
 SEC_GRP_EXT_ALIAS = 'security-group'
 QOS_EXT_ALIAS = 'qos'
+CONF_GROUP = 'neutron'
 
 CONF = cfg.CONF
 
 
 class BaseNeutronDriver(base.AbstractNetworkDriver):
-
     def __init__(self):
-        self.neutron_client = clients.NeutronAuth.get_neutron_client(
-            endpoint=CONF.neutron.endpoint,
-            region=CONF.neutron.region_name,
-            endpoint_type=CONF.neutron.endpoint_type,
-            service_name=CONF.neutron.service_name,
-            insecure=CONF.neutron.insecure,
-            ca_cert=CONF.neutron.ca_certificates_file
-        )
+        self.network_proxy: Proxy = self.os_connection.network
         self._check_extension_cache = {}
         self.sec_grp_enabled = self._check_extension_enabled(SEC_GRP_EXT_ALIAS)
         self.dns_integration_enabled = self._check_extension_enabled(
             DNS_INT_EXT_ALIAS)
         self._qos_enabled = self._check_extension_enabled(QOS_EXT_ALIAS)
-        self.project_id = self.neutron_client.get_auth_info().get(
-            'auth_tenant_id')
+        self.project_id = self.os_connection.current_project_id
+
+    @property
+    def os_connection(self) -> Connection:
+        return clients.NeutronAuth.get_neutron_client()
 
     def _check_extension_enabled(self, extension_alias):
         if extension_alias in self._check_extension_cache:
@@ -60,12 +57,11 @@ class BaseNeutronDriver(base.AbstractNetworkDriver):
                           'status': 'enabled' if status else 'disabled'
                       })
         else:
-            try:
-                self.neutron_client.show_extension(extension_alias)
+            if self.network_proxy.find_extension(extension_alias):
                 LOG.debug('Neutron extension %(ext)s found enabled',
                           {'ext': extension_alias})
                 self._check_extension_cache[extension_alias] = True
-            except neutron_client_exceptions.NotFound:
+            else:
                 LOG.debug('Neutron extension %(ext)s is not enabled',
                           {'ext': extension_alias})
                 self._check_extension_cache[extension_alias] = False
@@ -123,64 +119,51 @@ class BaseNeutronDriver(base.AbstractNetworkDriver):
                                         fixed_ips=fixed_ips)
 
     def _add_allowed_address_pairs_to_port(self, port_id, ip_address_list):
-        aap = {
-            'port': {
-                'allowed_address_pairs': [
-                    {'ip_address': ip} for ip in ip_address_list
-                ]
-            }
-        }
-        self.neutron_client.update_port(port_id, aap)
+        aap = [{'ip_address': ip} for ip in ip_address_list]
+        self.network_proxy.update_port(port_id,
+                                       allowed_address_pairs=aap)
 
     def _add_security_group_to_port(self, sec_grp_id, port_id):
-        port_update = {'port': {'security_groups': [sec_grp_id]}}
         # Note: Neutron accepts the SG even if it already exists
         try:
-            self.neutron_client.update_port(port_id, port_update)
-        except neutron_client_exceptions.PortNotFoundClient as e:
+            self.network_proxy.update_port(
+                port_id, security_groups=[sec_grp_id])
+        except os_exceptions.NotFoundException as e:
             raise base.PortNotFound(str(e))
         except Exception as e:
             raise base.NetworkException(str(e))
 
     def _get_ports_by_security_group(self, sec_grp_id):
-        all_ports = self.neutron_client.list_ports(project_id=self.project_id)
-        filtered_ports = []
-        for port in all_ports.get('ports', []):
-            if sec_grp_id in port.get('security_groups', []):
-                filtered_ports.append(port)
+        all_ports = self.network_proxy.ports(project_id=self.project_id)
+        filtered_ports = [
+            p for p in all_ports if (p.security_group_ids and
+                                     sec_grp_id in p.security_group_ids)]
         return filtered_ports
 
     def _create_security_group(self, name):
-        new_sec_grp = {'security_group': {'name': name}}
-        sec_grp = self.neutron_client.create_security_group(new_sec_grp)
-        return sec_grp['security_group']
+        sec_grp = self.network_proxy.create_security_group(name=name)
+        return sec_grp
 
     def _create_security_group_rule(self, sec_grp_id, protocol,
                                     direction='ingress', port_min=None,
                                     port_max=None, ethertype='IPv6',
                                     cidr=None):
         rule = {
-            'security_group_rule': {
-                'security_group_id': sec_grp_id,
-                'direction': direction,
-                'protocol': protocol,
-                'port_range_min': port_min,
-                'port_range_max': port_max,
-                'ethertype': ethertype,
-                'remote_ip_prefix': cidr,
-            }
+            'security_group_id': sec_grp_id,
+            'direction': direction,
+            'protocol': protocol,
+            'port_range_min': port_min,
+            'port_range_max': port_max,
+            'ethertype': ethertype,
+            'remote_ip_prefix': cidr,
         }
 
-        self.neutron_client.create_security_group_rule(rule)
+        self.network_proxy.create_security_group_rule(**rule)
 
     def apply_qos_on_port(self, qos_id, port_id):
-        body = {
-            'port':
-                {'qos_policy_id': qos_id}
-        }
         try:
-            self.neutron_client.update_port(port_id, body)
-        except neutron_client_exceptions.PortNotFoundClient as e:
+            self.network_proxy.update_port(port_id, qos_policy_id=qos_id)
+        except os_exceptions.ResourceNotFound as e:
             raise base.PortNotFound(str(e))
         except Exception as e:
             raise base.NetworkException(str(e))
@@ -188,26 +171,26 @@ class BaseNeutronDriver(base.AbstractNetworkDriver):
     def get_plugged_networks(self, compute_id):
         # List neutron ports associated with the Amphora
         try:
-            ports = self.neutron_client.list_ports(device_id=compute_id)
+            ports = self.network_proxy.ports(device_id=compute_id)
         except Exception:
             LOG.debug('Error retrieving plugged networks for compute '
                       'device %s.', compute_id)
-            ports = {'ports': []}
-        return [self._port_to_octavia_interface(
-                compute_id, port) for port in ports['ports']]
+            ports = tuple()
+        return [self._port_to_octavia_interface(compute_id, port) for port in
+                ports]
 
     def _get_resource(self, resource_type, resource_id, context=None):
-        neutron_client = self.neutron_client
+        network = self.network_proxy
         if context and not CONF.networking.allow_invisible_resource_usage:
-            neutron_client = clients.NeutronAuth.get_user_neutron_client(
+            network = clients.NeutronAuth.get_user_neutron_client(
                 context)
 
         try:
-            resource = getattr(neutron_client, 'show_%s' %
-                               resource_type)(resource_id)
-            return getattr(utils, 'convert_%s_dict_to_model' %
+            resource = getattr(
+                network, f"get_{resource_type}")(resource_id)
+            return getattr(utils, 'convert_%s_to_model' %
                            resource_type)(resource)
-        except neutron_client_exceptions.NotFound as e:
+        except os_exceptions.ResourceNotFound as e:
             message = _('{resource_type} not found '
                         '({resource_type} id: {resource_id}).').format(
                 resource_type=resource_type, resource_id=resource_id)
@@ -228,20 +211,25 @@ class BaseNeutronDriver(base.AbstractNetworkDriver):
         If unique_item set to True, only the first resource is returned.
         """
         try:
-            resource = getattr(self.neutron_client, 'list_%ss' %
-                               resource_type)(**filters)
+            resources = getattr(
+                self.network_proxy, f"{resource_type}s")(**filters)
             conversion_function = getattr(
                 utils,
-                'convert_%s_dict_to_model' % resource_type)
-            if not resource['%ss' % resource_type]:
-                # no items found
-                raise neutron_client_exceptions.NotFound()
+                'convert_%s_to_model' % resource_type)
+            try:
+                # get first item to see if there is at least one resource
+                res_list = [conversion_function(next(resources))]
+            except StopIteration:
+                # pylint: disable=raise-missing-from
+                raise os_exceptions.NotFoundException(
+                    f'No resource of type {resource_type} found that matches '
+                    f'given filter criteria: {filters}.')
+
             if unique_item:
-                return conversion_function(resource['%ss' % resource_type][0])
+                return res_list[0]
+            return res_list + [conversion_function(r) for r in resources]
 
-            return list(map(conversion_function,
-                            resource['%ss' % resource_type]))
-        except neutron_client_exceptions.NotFound as e:
+        except os_exceptions.NotFoundException as e:
             message = _('{resource_type} not found '
                         '({resource_type} Filters: {filters}.').format(
                 resource_type=resource_type, filters=filters)
@@ -300,10 +288,10 @@ class BaseNeutronDriver(base.AbstractNetworkDriver):
 
         fixed_ips.append(new_fixed_ip_dict)
 
-        body = {'port': {'fixed_ips': fixed_ips}}
         try:
-            updated_port = self.neutron_client.update_port(port_id, body)
-            return utils.convert_port_dict_to_model(updated_port)
+            updated_port = self.network_proxy.update_port(
+                port_id, fixed_ips=fixed_ips)
+            return utils.convert_port_to_model(updated_port)
         except Exception as e:
             raise base.NetworkException(str(e))
 
@@ -315,9 +303,9 @@ class BaseNeutronDriver(base.AbstractNetworkDriver):
             if fixed_ip.subnet_id != subnet_id
         ]
 
-        body = {'port': {'fixed_ips': fixed_ips}}
         try:
-            updated_port = self.neutron_client.update_port(port_id, body)
-            return utils.convert_port_dict_to_model(updated_port)
+            updated_port = self.network_proxy.update_port(
+                port_id, fixed_ips=fixed_ips)
+            return utils.convert_port_to_model(updated_port)
         except Exception as e:
             raise base.NetworkException(str(e))

octavia/network/drivers/neutron/utils.py

@@ -13,113 +13,97 @@
 #    under the License.
 
 
-from octavia.common import constants
+from openstack.network.v2.network_ip_availability import NetworkIPAvailability
+
 from octavia.network import data_models as network_models
 
 
-def convert_subnet_dict_to_model(subnet_dict):
-    subnet = subnet_dict.get('subnet', subnet_dict)
-    subnet_hrs = subnet.get('host_routes', [])
+def convert_subnet_to_model(subnet):
     host_routes = [network_models.HostRoute(nexthop=hr.get('nexthop'),
                                             destination=hr.get('destination'))
-                   for hr in subnet_hrs]
-    return network_models.Subnet(id=subnet.get(constants.ID),
-                                 name=subnet.get(constants.NAME),
-                                 network_id=subnet.get('network_id'),
-                                 project_id=subnet.get(constants.TENANT_ID),
-                                 gateway_ip=subnet.get('gateway_ip'),
-                                 cidr=subnet.get('cidr'),
-                                 ip_version=subnet.get('ip_version'),
-                                 host_routes=host_routes
-                                 )
-
-
-def convert_port_dict_to_model(port_dict):
-    port = port_dict.get('port', port_dict)
-    fixed_ips = [network_models.FixedIP(subnet_id=fixed_ip.get('subnet_id'),
-                                        ip_address=fixed_ip.get('ip_address'))
-                 for fixed_ip in port.get('fixed_ips', [])]
+                   for hr in subnet.host_routes] if subnet.host_routes else []
+    return network_models.Subnet(
+        id=subnet.id,
+        name=subnet.name,
+        network_id=subnet.network_id,
+        project_id=subnet.project_id,
+        gateway_ip=subnet.gateway_ip,
+        cidr=subnet.cidr,
+        ip_version=subnet.ip_version,
+        host_routes=host_routes,
+    )
+
+
+def convert_port_to_model(port):
+    if port.get('fixed_ips'):
+        fixed_ips = [convert_fixed_ip_dict_to_model(fixed_ip)
+                     for fixed_ip in port.fixed_ips]
+    else:
+        fixed_ips = []
     return network_models.Port(
-        id=port.get(constants.ID),
-        name=port.get(constants.NAME),
-        device_id=port.get('device_id'),
-        device_owner=port.get('device_owner'),
-        mac_address=port.get('mac_address'),
-        network_id=port.get('network_id'),
-        status=port.get('status'),
-        project_id=port.get(constants.TENANT_ID),
-        admin_state_up=port.get('admin_state_up'),
+        id=port.id,
+        name=port.name,
+        device_id=port.device_id,
+        device_owner=port.device_owner,
+        mac_address=port.mac_address,
+        network_id=port.network_id,
+        status=port.status,
+        project_id=port.project_id,
+        admin_state_up=port.is_admin_state_up,
         fixed_ips=fixed_ips,
-        qos_policy_id=port.get('qos_policy_id'),
-        security_group_ids=port.get(constants.SECURITY_GROUPS, [])
+        qos_policy_id=port.qos_policy_id,
+        security_group_ids=port.security_group_ids
     )
 
 
-def convert_network_dict_to_model(network_dict):
-    nw = network_dict.get('network', network_dict)
+def convert_network_to_model(nw):
     return network_models.Network(
-        id=nw.get(constants.ID),
-        name=nw.get(constants.NAME),
-        subnets=nw.get('subnets'),
-        project_id=nw.get(constants.TENANT_ID),
-        admin_state_up=nw.get('admin_state_up'),
-        mtu=nw.get('mtu'),
-        provider_network_type=nw.get('provider:network_type'),
-        provider_physical_network=nw.get('provider:physical_network'),
-        provider_segmentation_id=nw.get('provider:segmentation_id'),
-        router_external=nw.get('router:external'),
-        port_security_enabled=nw.get('port_security_enabled')
+        id=nw.id,
+        name=nw.name,
+        subnets=nw.subnet_ids,
+        project_id=nw.project_id,
+        admin_state_up=nw.is_admin_state_up,
+        mtu=nw.mtu,
+        provider_network_type=nw.provider_network_type,
+        provider_physical_network=nw.provider_physical_network,
+        provider_segmentation_id=nw.provider_segmentation_id,
+        router_external=nw.is_router_external,
+        port_security_enabled=nw.is_port_security_enabled,
     )
 
 
-def convert_fixed_ip_dict_to_model(fixed_ip_dict):
-    fixed_ip = fixed_ip_dict.get('fixed_ip', fixed_ip_dict)
+def convert_fixed_ip_dict_to_model(fixed_ip: dict):
     return network_models.FixedIP(subnet_id=fixed_ip.get('subnet_id'),
                                   ip_address=fixed_ip.get('ip_address'))
 
 
-def convert_qos_policy_dict_to_model(qos_policy_dict):
-    qos_policy = qos_policy_dict.get('policy', qos_policy_dict)
-    return network_models.QosPolicy(id=qos_policy.get(constants.ID))
-
-
-# We can't use "floating_ip" because we need to match the neutron client method
-def convert_floatingip_dict_to_model(floating_ip_dict):
-    floating_ip = floating_ip_dict.get('floatingip', floating_ip_dict)
-    return network_models.FloatingIP(
-        id=floating_ip.get(constants.ID),
-        description=floating_ip.get(constants.DESCRIPTION),
-        project_id=floating_ip.get(constants.PROJECT_ID,
-                                   floating_ip.get(constants.TENANT_ID)),
-        status=floating_ip.get('status'),
-        router_id=floating_ip.get('router_id'),
-        port_id=floating_ip.get('port_id'),
-        floating_network_id=floating_ip.get('floating_network_id'),
-        floating_ip_address=floating_ip.get('floating_ip_address'),
-        fixed_ip_address=floating_ip.get('fixed_ip_address'),
-        fixed_port_id=floating_ip.get('fixed_port_id')
-    )
+def convert_qos_policy_to_model(qos_policy):
+    return network_models.QosPolicy(id=qos_policy.id)
 
 
-def convert_network_ip_availability_dict_to_model(
-        network_ip_availability_dict):
-    nw_ip_avail = network_ip_availability_dict.get(
-        'network_ip_availability', network_ip_availability_dict)
-    ip_avail = network_models.Network_IP_Availability.from_dict(nw_ip_avail)
-    ip_avail.subnet_ip_availability = nw_ip_avail.get('subnet_ip_availability')
+def convert_network_ip_availability_to_model(
+        nw_ip_avail: NetworkIPAvailability):
+    ip_avail = network_models.Network_IP_Availability(
+        network_id=nw_ip_avail.network_id,
+        tenant_id=nw_ip_avail.tenant_id,
+        project_id=nw_ip_avail.project_id,
+        network_name=nw_ip_avail.network_name, total_ips=nw_ip_avail.total_ips,
+        used_ips=nw_ip_avail.used_ips,
+        subnet_ip_availability=nw_ip_avail.subnet_ip_availability)
     return ip_avail
 
 
-def convert_security_group_dict_to_model(security_group_dict):
-    sg_rule_ids = [rule.get(constants.ID) for rule in
-                   security_group_dict.get(constants.SECURITY_GROUP_RULES, [])]
+def convert_security_group_to_model(security_group):
+    if security_group.security_group_rules:
+        sg_rule_ids = [rule['id'] for rule in
+                       security_group.security_group_rules]
+    else:
+        sg_rule_ids = []
     return network_models.SecurityGroup(
-        id=security_group_dict.get(constants.ID),
-        project_id=security_group_dict.get(
-            constants.PROJECT_ID,
-            security_group_dict.get(constants.TENANT_ID)),
-        name=security_group_dict.get(constants.NAME),
-        description=security_group_dict.get(constants.DESCRIPTION),
+        id=security_group.id,
+        project_id=security_group.project_id,
+        name=security_group.name,
+        description=security_group.description,
         security_group_rule_ids=sg_rule_ids,
-        tags=security_group_dict.get(constants.TAGS, []),
-        stateful=security_group_dict.get('stateful'))
+        tags=security_group.tags,
+        stateful=security_group.stateful)

octavia/network/drivers/noop_driver/driver.py

@@ -352,10 +352,6 @@ class NoopManager(object):
 
         return amp_configs
 
-    def wait_for_port_detach(self, amphora):
-        LOG.debug("failover %s no-op, wait_for_port_detach, amphora id %s",
-                  self.__class__.__name__, amphora.id)
-
     def get_qos_policy(self, qos_policy_id):
         LOG.debug("Qos Policy %s no-op, get_qos_policy qos_policy_id %s",
                   self.__class__.__name__, qos_policy_id)
@@ -520,9 +516,6 @@ class NoopNetworkDriver(driver_base.AbstractNetworkDriver):
     def get_network_configs(self, loadbalancer, amphora=None):
         return self.driver.get_network_configs(loadbalancer, amphora)
 
-    def wait_for_port_detach(self, amphora):
-        self.driver.wait_for_port_detach(amphora)
-
     def apply_qos_on_port(self, qos_id, port_id):
         self.driver.apply_qos_on_port(qos_id, port_id)
 

octavia/statistics/drivers/update_db.py

@@ -31,13 +31,13 @@ class StatsUpdateDb(stats_base.StatsDriverMixin):
 
     def update_stats(self, listener_stats, deltas=False):
         """This function is to update the db with listener stats"""
-        session = db_api.get_session()
-        for stats_object in listener_stats:
-            LOG.debug("Updating listener stats in db for listener `%s` / "
-                      "amphora `%s`: %s",
-                      stats_object.listener_id, stats_object.amphora_id,
-                      stats_object.get_stats())
-            if deltas:
-                self.listener_stats_repo.increment(session, stats_object)
-            else:
-                self.listener_stats_repo.replace(session, stats_object)
+        with db_api.session().begin() as session:
+            for stats_object in listener_stats:
+                LOG.debug("Updating listener stats in db for listener `%s` / "
+                          "amphora `%s`: %s",
+                          stats_object.listener_id, stats_object.amphora_id,
+                          stats_object.get_stats())
+                if deltas:
+                    self.listener_stats_repo.increment(session, stats_object)
+                else:
+                    self.listener_stats_repo.replace(session, stats_object)