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

octavia/amphorae/backends/agent/api_server/osutils.py

@@ -56,6 +56,7 @@ class BaseOS(object):
     def write_interface_file(self, interface, ip_address, prefixlen):
         interface = interface_file.InterfaceFile(
             name=interface,
+            if_type=consts.LO,
             addresses=[{
                 "address": ip_address,
                 "prefixlen": prefixlen

octavia/amphorae/backends/agent/api_server/plug.py

@@ -14,6 +14,7 @@
 # under the License.
 
 import ipaddress
+import itertools
 import os
 import socket
 import stat
@@ -24,6 +25,7 @@ import pyroute2
 import webob
 from werkzeug import exceptions
 
+from octavia.amphorae.backends.agent.api_server import util
 from octavia.common import constants as consts
 
 
@@ -196,6 +198,8 @@ class Plug(object):
                     fixed_ips=fixed_ips,
                     mtu=mtu)
                 self._osutils.bring_interface_up(existing_interface, 'network')
+
+            util.send_member_advertisements(fixed_ips)
             return webob.Response(json={
                 'message': "OK",
                 'details': "Updated existing interface {interface}".format(
@@ -209,13 +213,7 @@ class Plug(object):
 
         # We need to determine the interface name when inside the namespace
         # to avoid name conflicts
-        with pyroute2.NetNS(consts.AMPHORA_NAMESPACE,
-                            flags=os.O_CREAT) as netns:
-
-            # 1 means just loopback, but we should already have a VIP. This
-            # works for the add/delete/add case as we don't delete interfaces
-            # Note, eth0 is skipped because that is the VIP interface
-            netns_interface = 'eth{0}'.format(len(netns.get_links()))
+        netns_interface = self._netns_get_next_interface()
 
         LOG.info('Plugged interface %s will become %s in the namespace %s',
                  default_netns_interface, netns_interface,
@@ -236,6 +234,7 @@ class Plug(object):
                      IFLA_IFNAME=netns_interface)
 
         self._osutils.bring_interface_up(netns_interface, 'network')
+        util.send_member_advertisements(fixed_ips)
 
         return webob.Response(json={
             'message': "OK",
@@ -246,6 +245,8 @@ class Plug(object):
         try:
             with pyroute2.IPRoute() as ipr:
                 idx = ipr.link_lookup(address=mac)[0]
+                # Workaround for https://github.com/PyCQA/pylint/issues/8497
+                # pylint: disable=E1136, E1121
                 addr = ipr.get_links(idx)[0]
                 for attr in addr['attrs']:
                     if attr[0] == consts.IFLA_IFNAME:
@@ -289,3 +290,16 @@ class Plug(object):
 
     def _netns_interface_exists(self, mac_address):
         return self._netns_interface_by_mac(mac_address) is not None
+
+    def _netns_get_next_interface(self):
+        with pyroute2.NetNS(consts.AMPHORA_NAMESPACE,
+                            flags=os.O_CREAT) as netns:
+            existing_ifaces = [
+                dict(link['attrs']).get(consts.IFLA_IFNAME)
+                for link in netns.get_links()]
+            # find the first unused ethXXX
+            for idx in itertools.count(start=2):
+                iface_name = f"eth{idx}"
+                if iface_name not in existing_ifaces:
+                    break
+            return iface_name

octavia/amphorae/backends/agent/api_server/templates/amphora-netns.systemd.j2

@@ -10,6 +10,8 @@ RemainAfterExit=yes
 ExecStart=-/sbin/ip netns add {{ amphora_nsname }}
 # Load the system sysctl into the new namespace
 ExecStart=-/sbin/ip netns exec {{ amphora_nsname }} sysctl --system
+# Enable kernel module ip_vs for lvs function in amphora network namespace
+ExecStart=-/sbin/ip netns exec {{ amphora_nsname }} modprobe ip_vs
 # Set nf_conntrack_buckets sysctl in the main namespace (nf_conntrack_buckets
 # cannot be set in another net namespace, but its value is inherited from the
 # main namespace)
@@ -17,8 +19,6 @@ ExecStart=-/sbin/sysctl -w net.netfilter.nf_conntrack_buckets=125000
 # Update conntrack table sizes using the formula for the default values
 ExecStart=-/sbin/sysctl -w net.netfilter.nf_conntrack_max=125000
 ExecStart=-/sbin/sysctl -w net.netfilter.nf_conntrack_expect_max=488
-# Enable kernel module ip_vs for lvs function in amphora network namespace
-ExecStart=-/sbin/ip netns exec {{ amphora_nsname }} modprobe ip_vs
 # Enable ip_forward and conntrack kernel configuration
 ExecStart=-/sbin/ip netns exec {{ amphora_nsname }} sysctl -w net.ipv4.ip_forward=1
 ExecStart=-/sbin/ip netns exec {{ amphora_nsname }} sysctl -w net.ipv4.vs.conntrack=1

octavia/amphorae/backends/agent/api_server/util.py

@@ -17,6 +17,7 @@ import os
 import re
 import stat
 import subprocess
+import typing as tp
 
 import jinja2
 from oslo_config import cfg
@@ -411,3 +412,23 @@ def send_vip_advertisements(lb_id):
     except Exception as e:
         LOG.debug('Send VIP advertisement failed due to :%s. '
                   'This amphora may not be the MASTER. Ignoring.', str(e))
+
+
+def send_member_advertisements(fixed_ips: tp.Iterable[tp.Dict[str, str]]):
+    """Sends advertisements for each fixed_ip of a list
+
+    This method will send either GARP (IPv4) or neighbor advertisements (IPv6)
+    for the addresses of the subnets of the members.
+
+    :param fixed_ips: a list of dicts that contain 'ip_address' elements
+    :returns: None
+    """
+    try:
+        for fixed_ip in fixed_ips:
+            ip_address = fixed_ip[consts.IP_ADDRESS]
+            interface = network_utils.get_interface_name(
+                ip_address, net_ns=consts.AMPHORA_NAMESPACE)
+            ip_advertisement.send_ip_advertisement(
+                interface, ip_address, net_ns=consts.AMPHORA_NAMESPACE)
+    except Exception as e:
+        LOG.debug('Send member advertisement failed due to: %s', str(e))

octavia/amphorae/backends/health_daemon/health_daemon.py

@@ -157,9 +157,15 @@ def run_sender(cmd_queue):
 
 
 def get_stats(stat_sock_file):
-    stats_query = haproxy_query.HAProxyQuery(stat_sock_file)
-    stats = stats_query.show_stat()
-    pool_status = stats_query.get_pool_status()
+    try:
+        stats_query = haproxy_query.HAProxyQuery(stat_sock_file)
+        stats = stats_query.show_stat()
+        pool_status = stats_query.get_pool_status()
+    except Exception as e:
+        LOG.warning('Unable to query the HAProxy stats (%s) due to: %s',
+                    stat_sock_file, str(e))
+        # Return empty lists so that the heartbeat will still be sent
+        return [], {}
     return stats, pool_status
 
 

octavia/amphorae/backends/health_daemon/health_sender.py

@@ -70,6 +70,8 @@ class UDPStatusSender(object):
         for ipport in CONF.health_manager.controller_ip_port_list:
             try:
                 ip, port = ipport.rsplit(':', 1)
+                if ip and ip[0] == '[' and ip[-1] == ']':
+                    ip = ip[1:-1]
             except ValueError:
                 LOG.error("Invalid ip and port '%s' in health_manager "
                           "controller_ip_port_list", ipport)

octavia/amphorae/backends/utils/interface.py

@@ -181,6 +181,8 @@ class InterfaceController(object):
         with pyroute2.IPRoute() as ipr:
             idx = ipr.link_lookup(ifname=interface.name)[0]
 
+            # Workaround for https://github.com/PyCQA/pylint/issues/8497
+            # pylint: disable=E1136, E1121
             link = ipr.get_links(idx)[0]
             current_state = link.get(consts.STATE)
 
@@ -195,7 +197,9 @@ class InterfaceController(object):
 
             self._addresses_up(interface, ipr, idx)
             self._routes_up(interface, ipr, idx)
-            self._rules_up(interface, ipr, idx)
+            # only the vip port updates the rules
+            if interface.if_type == consts.VIP:
+                self._rules_up(interface, ipr, idx)
 
             self._scripts_up(interface, current_state)
 
@@ -370,15 +374,19 @@ class InterfaceController(object):
         with pyroute2.IPRoute() as ipr:
             idx = ipr.link_lookup(ifname=interface.name)[0]
 
+            # Workaround for https://github.com/PyCQA/pylint/issues/8497
+            # pylint: disable=E1136, E1121
             link = ipr.get_links(idx)[0]
             current_state = link.get(consts.STATE)
 
             if current_state == consts.IFACE_UP:
-                for rule in interface.rules:
-                    rule[consts.FAMILY] = self._family(rule[consts.SRC])
-                    LOG.debug("%s: Deleting rule %s", interface.name, rule)
-                    self._ipr_command(ipr.rule, self.DELETE,
-                                      raise_on_error=False, **rule)
+                # only the vip port updates the rules
+                if interface.if_type == consts.VIP:
+                    for rule in interface.rules:
+                        rule[consts.FAMILY] = self._family(rule[consts.SRC])
+                        LOG.debug("%s: Deleting rule %s", interface.name, rule)
+                        self._ipr_command(ipr.rule, self.DELETE,
+                                          raise_on_error=False, **rule)
 
                 for route in interface.routes:
                     route[consts.FAMILY] = self._family(route[consts.DST])

octavia/amphorae/backends/utils/interface_file.py

@@ -25,9 +25,11 @@ CONF = cfg.CONF
 
 
 class InterfaceFile(object):
-    def __init__(self, name, mtu=None, addresses=None,
+    def __init__(self, name, if_type,
+                 mtu=None, addresses=None,
                  routes=None, rules=None, scripts=None):
         self.name = name
+        self.if_type = if_type
         self.mtu = mtu
         self.addresses = addresses or []
         self.routes = routes or []
@@ -92,6 +94,7 @@ class InterfaceFile(object):
                                flags, mode), 'w') as fp:
             interface = {
                 consts.NAME: self.name,
+                consts.IF_TYPE: self.if_type,
                 consts.ADDRESSES: self.addresses,
                 consts.ROUTES: self.routes,
                 consts.RULES: self.rules,
@@ -105,7 +108,7 @@ class InterfaceFile(object):
 class VIPInterfaceFile(InterfaceFile):
     def __init__(self, name, mtu, vips, vrrp_info, fixed_ips, topology):
 
-        super().__init__(name, mtu=mtu)
+        super().__init__(name, if_type=consts.VIP, mtu=mtu)
 
         has_ipv4 = any(vip['ip_version'] == 4 for vip in vips)
         has_ipv6 = any(vip['ip_version'] == 6 for vip in vips)
@@ -236,7 +239,7 @@ class VIPInterfaceFile(InterfaceFile):
 
 class PortInterfaceFile(InterfaceFile):
     def __init__(self, name, mtu, fixed_ips):
-        super().__init__(name, mtu=mtu)
+        super().__init__(name, if_type=consts.BACKEND, mtu=mtu)
 
         if fixed_ips:
             ip_versions = set()

octavia/amphorae/backends/utils/keepalivedlvs_query.py

@@ -94,13 +94,10 @@ def get_listener_realserver_mapping(ns_name, listener_ip_ports,
         if 'RemoteAddress:Port' in line:
             result_keys = re.split(r'\s+',
                                    LVS_KEY_REGEX.findall(line)[0].strip())
-        elif ((line.startswith(constants.PROTOCOL_UDP) or
-               line.startswith(lib_consts.PROTOCOL_SCTP)) and
-              find_target_block):
-            break
-        elif re.match(r'^(UDP|SCTP)\s+%s\s+\w+' % idex,
-                      line):
-            find_target_block = True
+        elif (line.startswith(constants.PROTOCOL_UDP) or
+              line.startswith(lib_consts.PROTOCOL_SCTP)):
+            find_target_block = re.match(r'^(UDP|SCTP)\s+%s\s+\w+' % idex,
+                                         line) is not None
         elif find_target_block and line:
             rs_is_ipv4 = True
             all_values = V4_RS_VALUE_REGEX.findall(line)
@@ -136,7 +133,7 @@ def get_listener_realserver_mapping(ns_name, listener_ip_ports,
                         result_keys[index]] = result_values[index]
             continue
 
-    return find_target_block, actual_member_result
+    return actual_member_result
 
 
 def get_lvs_listener_resource_ipports_nsname(listener_id):
@@ -267,7 +264,7 @@ def get_lvs_listener_pool_status(listener_id):
         cfg = f.read()
         hm_enabled = len(CHECKER_REGEX.findall(cfg)) > 0
 
-    _, realserver_result = get_listener_realserver_mapping(
+    realserver_result = get_listener_realserver_mapping(
         ns_name, resource_ipport_mapping['Listener']['ipports'],
         hm_enabled)
     pool_status = constants.UP
@@ -460,6 +457,8 @@ def get_lvs_listeners_stats():
         status = constants.OPEN
         # Get scur
         for listener_ipport in listener_ipports:
+            if listener_ipport not in scur_res:
+                continue
             for m in scur_res[listener_ipport]['Members']:
                 for item in m:
                     if item[0] == 'ActiveConn':

octavia/amphorae/drivers/driver_base.py

@@ -151,8 +151,7 @@ class AmphoraLoadBalancerDriver(object, metaclass=abc.ABCMeta):
         """
 
     def post_vip_plug(self, amphora, load_balancer, amphorae_network_config,
-                      vrrp_port=None, vip_subnet=None,
-                      additional_vip_data=None):
+                      vrrp_port, vip_subnet, additional_vip_data=None):
         """Called after network driver has allocated and plugged the VIP
 
         :param amphora:

octavia/amphorae/drivers/haproxy/rest_api_driver.py

@@ -37,10 +37,9 @@ import octavia.common.jinja.haproxy.combined_listeners.jinja_cfg as jinja_combo
 from octavia.common.jinja.lvs import jinja_cfg as jinja_udp_cfg
 from octavia.common.tls_utils import cert_parser
 from octavia.common import utils
-from octavia.db import api as db_apis
+from octavia.db import api as db_api
 from octavia.db import models as db_models
 from octavia.db import repositories as repo
-from octavia.network import data_models as network_models
 
 
 LOG = logging.getLogger(__name__)
@@ -183,9 +182,10 @@ class HaproxyAmphoraLoadBalancerDriver(
                                   '"%s". Skipping this listener.',
                                   listener.id, str(e))
                     listener_repo = repo.ListenerRepository()
-                    listener_repo.update(db_apis.get_session(), listener.id,
-                                         provisioning_status=consts.ERROR,
-                                         operating_status=consts.ERROR)
+                    with db_api.session().begin() as session:
+                        listener_repo.update(session, listener.id,
+                                             provisioning_status=consts.ERROR,
+                                             operating_status=consts.ERROR)
 
         if has_tcp:
             if listeners_to_update:
@@ -358,26 +358,16 @@ class HaproxyAmphoraLoadBalancerDriver(
         return net_info
 
     def post_vip_plug(self, amphora, load_balancer, amphorae_network_config,
-                      vrrp_port=None, vip_subnet=None,
-                      additional_vip_data=None):
+                      vrrp_port, vip_subnet, additional_vip_data=None):
         if amphora.status != consts.DELETED:
             self._populate_amphora_api_version(amphora)
-            if vip_subnet is None:
-                vip_subnet = amphorae_network_config.get(amphora.id).vip_subnet
-            if vrrp_port is None:
-                port = amphorae_network_config.get(amphora.id).vrrp_port
-                mtu = port.network.mtu
-            else:
-                port = vrrp_port
-                mtu = port.network['mtu']
+            port = vrrp_port.to_dict(recurse=True)
+            mtu = port[consts.NETWORK][consts.MTU]
             LOG.debug("Post-VIP-Plugging with vrrp_ip %s vrrp_port %s",
-                      amphora.vrrp_ip, port.id)
+                      amphora.vrrp_ip, port[consts.ID])
             net_info = self._build_net_info(
-                port.to_dict(recurse=True), amphora.to_dict(),
+                port, amphora.to_dict(),
                 vip_subnet.to_dict(recurse=True), mtu)
-            if additional_vip_data is None:
-                additional_vip_data = amphorae_network_config.get(
-                    amphora.id).additional_vip_data
             for add_vip in additional_vip_data:
                 add_host_routes = [{'nexthop': hr.nexthop,
                                     'destination': hr.destination}
@@ -393,7 +383,7 @@ class HaproxyAmphoraLoadBalancerDriver(
             except exc.Conflict:
                 LOG.warning('VIP with MAC %(mac)s already exists on amphora, '
                             'skipping post_vip_plug',
-                            {'mac': port.mac_address})
+                            {'mac': port[consts.MAC_ADDRESS]})
 
     def post_network_plug(self, amphora, port, amphora_network_config):
         fixed_ips = []
@@ -410,10 +400,6 @@ class HaproxyAmphoraLoadBalancerDriver(
                      'fixed_ips': fixed_ips,
                      'mtu': port.network.mtu}
         if port.id == amphora.vrrp_port_id:
-            if isinstance(amphora_network_config,
-                          network_models.AmphoraNetworkConfig):
-                amphora_network_config = amphora_network_config.to_dict(
-                    recurse=True)
             # We have to special-case sharing the vrrp port and pass through
             # enough extra information to populate the whole VIP port
             net_info = self._build_net_info(

octavia/amphorae/drivers/health/heartbeat_udp.py

@@ -331,8 +331,9 @@ class UpdateHealthDb:
         session = db_api.get_session()
 
         # We need to see if all of the listeners are reporting in
-        db_lb = self.amphora_repo.get_lb_for_health_update(session,
-                                                           health['id'])
+        with session.begin():
+            db_lb = self.amphora_repo.get_lb_for_health_update(session,
+                                                               health['id'])
         ignore_listener_count = False
 
         if db_lb:
@@ -353,11 +354,13 @@ class UpdateHealthDb:
                         l for k, l in db_lb.get('listeners', {}).items()
                         if l['protocol'] == constants.PROTOCOL_UDP]
                     if udp_listeners:
-                        expected_listener_count = (
-                            self._update_listener_count_for_UDP(
-                                session, db_lb, expected_listener_count))
+                        with session.begin():
+                            expected_listener_count = (
+                                self._update_listener_count_for_UDP(
+                                    session, db_lb, expected_listener_count))
         else:
-            amp = self.amphora_repo.get(session, id=health['id'])
+            with session.begin():
+                amp = self.amphora_repo.get(session, id=health['id'])
             # This is debug and not warning because this can happen under
             # normal deleting operations.
             LOG.debug('Received a health heartbeat from amphora %s with '
@@ -392,8 +395,6 @@ class UpdateHealthDb:
         # does not match the expected listener count
         if len(listeners) == expected_listener_count or ignore_listener_count:
 
-            lock_session = db_api.get_session(autocommit=False)
-
             # if we're running too far behind, warn and bail
             proc_delay = time.time() - health['recv_time']
             hb_interval = CONF.health_manager.heartbeat_interval
@@ -409,6 +410,9 @@ class UpdateHealthDb:
                             {'id': health['id'], 'delay': proc_delay})
                 return
 
+            lock_session = db_api.get_session()
+            lock_session.begin()
+
             # if the input amphora is healthy, we update its db info
             try:
                 self.amphora_health_repo.replace(
@@ -472,9 +476,10 @@ class UpdateHealthDb:
             try:
                 if (listener_status is not None and
                         listener_status != db_op_status):
-                    self._update_status(
-                        session, self.listener_repo, constants.LISTENER,
-                        listener_id, listener_status, db_op_status)
+                    with session.begin():
+                        self._update_status(
+                            session, self.listener_repo, constants.LISTENER,
+                            listener_id, listener_status, db_op_status)
             except sqlalchemy.orm.exc.NoResultFound:
                 LOG.error("Listener %s is not in DB", listener_id)
 
@@ -496,9 +501,11 @@ class UpdateHealthDb:
                     if db_pool_id in processed_pools:
                         continue
                     db_pool_dict = db_lb['pools'][db_pool_id]
-                    lb_status = self._process_pool_status(
-                        session, db_pool_id, db_pool_dict, pools,
-                        lb_status, processed_pools, potential_offline_pools)
+                    with session.begin():
+                        lb_status = self._process_pool_status(
+                            session, db_pool_id, db_pool_dict, pools,
+                            lb_status, processed_pools,
+                            potential_offline_pools)
 
         if health_msg_version >= 2:
             raw_pools = health['pools']
@@ -514,9 +521,10 @@ class UpdateHealthDb:
                 if db_pool_id in processed_pools:
                     continue
                 db_pool_dict = db_lb['pools'][db_pool_id]
-                lb_status = self._process_pool_status(
-                    session, db_pool_id, db_pool_dict, pools,
-                    lb_status, processed_pools, potential_offline_pools)
+                with session.begin():
+                    lb_status = self._process_pool_status(
+                        session, db_pool_id, db_pool_dict, pools,
+                        lb_status, processed_pools, potential_offline_pools)
 
         for pool_id, pool in potential_offline_pools.items():
             # Skip if we eventually found a status for this pool
@@ -525,19 +533,21 @@ class UpdateHealthDb:
             try:
                 # If the database doesn't already show the pool offline, update
                 if pool != constants.OFFLINE:
-                    self._update_status(
-                        session, self.pool_repo, constants.POOL,
-                        pool_id, constants.OFFLINE, pool)
+                    with session.begin():
+                        self._update_status(
+                            session, self.pool_repo, constants.POOL,
+                            pool_id, constants.OFFLINE, pool)
             except sqlalchemy.orm.exc.NoResultFound:
                 LOG.error("Pool %s is not in DB", pool_id)
 
         # Update the load balancer status last
         try:
             if lb_status != db_lb['operating_status']:
-                self._update_status(
-                    session, self.loadbalancer_repo,
-                    constants.LOADBALANCER, db_lb['id'], lb_status,
-                    db_lb[constants.OPERATING_STATUS])
+                with session.begin():
+                    self._update_status(
+                        session, self.loadbalancer_repo,
+                        constants.LOADBALANCER, db_lb['id'], lb_status,
+                        db_lb[constants.OPERATING_STATUS])
         except sqlalchemy.orm.exc.NoResultFound:
             LOG.error("Load balancer %s is not in DB", db_lb.id)
 

octavia/amphorae/drivers/keepalived/jinja/jinja_cfg.py

@@ -60,9 +60,7 @@ class KeepalivedJinjaTemplater(object):
 
         :param loadbalancer: A loadbalancer object
         :param amphora: An amphora object
-        :param amp_net_config: The amphora network config,
-                               an AmphoraeNetworkConfig object in amphorav1,
-                               a dict in amphorav2
+        :param amp_net_config: The amphora network config, a dict
         """
         # Note on keepalived configuration: The current base configuration
         # enforced Master election whenever a high priority VRRP instance
@@ -74,15 +72,8 @@ class KeepalivedJinjaTemplater(object):
         peers_ips = []
 
         # Get the VIP subnet for the amphora
-        # For amphorav2 amphorae_network_config will be list of dicts
-        if isinstance(amp_net_config, dict):
-            additional_vip_data = amp_net_config['additional_vip_data']
-            vip_subnet = amp_net_config[constants.VIP_SUBNET]
-        else:
-            additional_vip_data = [
-                add_vip.to_dict(recurse=True)
-                for add_vip in amp_net_config.additional_vip_data]
-            vip_subnet = amp_net_config.vip_subnet.to_dict()
+        additional_vip_data = amp_net_config['additional_vip_data']
+        vip_subnet = amp_net_config[constants.VIP_SUBNET]
 
         # Sort VIPs by their IP so we can guarantee interface_index matching
         sorted_add_vips = sorted(additional_vip_data,

octavia/amphorae/drivers/noop_driver/driver.py

@@ -93,8 +93,7 @@ class NoopManager(object):
                                                    'post_network_plug')
 
     def post_vip_plug(self, amphora, load_balancer, amphorae_network_config,
-                      vrrp_port=None, vip_subnet=None,
-                      additional_vip_data=None):
+                      vrrp_port, vip_subnet, additional_vip_data=None):
         LOG.debug("Amphora %s no-op, post vip plug load balancer %s",
                   self.__class__.__name__, load_balancer.id)
         self.amphoraconfig[(load_balancer.id, id(amphorae_network_config))] = (
@@ -167,12 +166,11 @@ class NoopAmphoraLoadBalancerDriver(
         self.driver.post_network_plug(amphora, port, amphora_network_config)
 
     def post_vip_plug(self, amphora, load_balancer, amphorae_network_config,
-                      vrrp_port=None, vip_subnet=None,
-                      additional_vip_data=None):
+                      vrrp_port, vip_subnet, additional_vip_data=None):
 
         self.driver.post_vip_plug(amphora,
                                   load_balancer, amphorae_network_config,
-                                  vrrp_port=vrrp_port, vip_subnet=vip_subnet,
+                                  vrrp_port, vip_subnet,
                                   additional_vip_data=additional_vip_data)
 
     def upload_cert_amp(self, amphora, pem_file):

octavia/api/common/pagination.py

@@ -359,16 +359,16 @@ class PaginationHelper(object):
                         default = PaginationHelper._get_default_column_value(
                             model_attr.property.columns[0].type)
                         attr = sa_sql.expression.case(
-                            [(model_attr.isnot(None),
-                              model_attr), ], else_=default)
+                            (model_attr.isnot(None), model_attr),
+                            else_=default)
                         crit_attrs.append((attr == marker_values[j]))
 
                     model_attr = getattr(model, self.sort_keys[i][0])
                     default = PaginationHelper._get_default_column_value(
                         model_attr.property.columns[0].type)
                     attr = sa_sql.expression.case(
-                        [(model_attr.isnot(None),
-                          model_attr), ], else_=default)
+                        (model_attr.isnot(None), model_attr),
+                        else_=default)
                     this_sort_dir = self.sort_keys[i][1]
                     if this_sort_dir == constants.DESC:
                         if self.page_reverse == "True":

octavia/api/drivers/amphora_driver/v2/driver.py

@@ -273,8 +273,10 @@ class AmphoraProviderDriver(driver_base.ProviderDriver):
     # Member
     def member_create(self, member):
         pool_id = member.pool_id
-        db_pool = self.repositories.pool.get(db_apis.get_session(),
-                                             id=pool_id)
+        session = db_apis.get_session()
+        with session.begin():
+            db_pool = self.repositories.pool.get(session,
+                                                 id=pool_id)
         self._validate_members(db_pool, [member])
 
         payload = {consts.MEMBER: member.to_dict()}
@@ -296,7 +298,9 @@ class AmphoraProviderDriver(driver_base.ProviderDriver):
 
     def member_batch_update(self, pool_id, members):
         # The DB should not have updated yet, so we can still use the pool
-        db_pool = self.repositories.pool.get(db_apis.get_session(), id=pool_id)
+        session = db_apis.get_session()
+        with session.begin():
+            db_pool = self.repositories.pool.get(session, id=pool_id)
 
         self._validate_members(db_pool, members)
 
@@ -385,8 +389,10 @@ class AmphoraProviderDriver(driver_base.ProviderDriver):
 
     # L7 Policy
     def l7policy_create(self, l7policy):
-        db_listener = self.repositories.listener.get(db_apis.get_session(),
-                                                     id=l7policy.listener_id)
+        session = db_apis.get_session()
+        with session.begin():
+            db_listener = self.repositories.listener.get(
+                session, id=l7policy.listener_id)
         if db_listener.protocol not in VALID_L7POLICY_LISTENER_PROTOCOLS:
             msg = ('%s protocol listeners do not support L7 policies' % (
                 db_listener.protocol))