octavia 14.0.0.0rc1__py3-none-any.whl → 15.0.0__py3-none-any.whl

octavia/amphorae/backends/utils/nftable_utils.py

@@ -26,16 +26,26 @@ from octavia.common import utils
 LOG = logging.getLogger(__name__)
 
 
-def write_nftable_vip_rules_file(interface_name, rules):
+def write_nftable_rules_file(interface_name, rules):
     flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
     # mode 00600
     mode = stat.S_IRUSR | stat.S_IWUSR
 
     # Create some strings shared on both code paths
-    table_string = f'table {consts.NFT_FAMILY} {consts.NFT_VIP_TABLE} {{\n'
-    chain_string = f'  chain {consts.NFT_VIP_CHAIN} {{\n'
-    hook_string = (f'    type filter hook ingress device {interface_name} '
-                   f'priority {consts.NFT_SRIOV_PRIORITY}; policy drop;\n')
+    table_string = f'table {consts.NFT_FAMILY} {consts.NFT_TABLE} {{\n'
+    chain_string = f'  chain {consts.NFT_CHAIN} {{\n'
+    vip_chain_string = f'  chain {consts.NFT_VIP_CHAIN} {{\n'
+    hook_string = ('    type filter hook input priority filter; '
+                   'policy drop;\n')
+
+    # Conntrack is used to allow flow return traffic
+    conntrack_string = ('      ct state vmap { established : accept, '
+                        'related : accept, invalid : drop }\n')
+
+    # Allow loopback traffic on the loopback interface, no where else
+    loopback_string = '      iif lo accept\n'
+    loopback_addr_string = '      ip saddr 127.0.0.0/8 drop\n'
+    loopback_ipv6_addr_string = '      ip6 saddr ::1 drop\n'
 
     # Allow ICMP destination unreachable for PMTUD
     icmp_string = '      icmp type destination-unreachable accept\n'
@@ -47,38 +57,50 @@ def write_nftable_vip_rules_file(interface_name, rules):
     dhcp_string = '      udp sport 67 udp dport 68 accept\n'
     dhcpv6_string = '      udp sport 547 udp dport 546 accept\n'
 
+    # If the packet came in on the VIP interface, goto the VIP rules chain
+    vip_interface_goto_string = (
+        f'      iifname {consts.NETNS_PRIMARY_INTERFACE} '
+        f'goto {consts.NFT_VIP_CHAIN}\n')
+
     # Check if an existing rules file exists or we be need to create an
     # "drop all" file with no rules except for VRRP. If it exists, we should
     # not overwrite it here as it could be a reboot unless we were passed new
     # rules.
-    if os.path.isfile(consts.NFT_VIP_RULES_FILE):
+    if os.path.isfile(consts.NFT_RULES_FILE):
         if not rules:
             return
         with os.fdopen(
-                os.open(consts.NFT_VIP_RULES_FILE, flags, mode), 'w') as file:
+                os.open(consts.NFT_RULES_FILE, flags, mode), 'w') as file:
             # Clear the existing rules in the kernel
             # Note: The "nft -f" method is atomic, so clearing the rules will
             #       not leave the amphora exposed.
             # Create and delete the table to not get errors if the table does
             # not exist yet.
-            file.write(f'table {consts.NFT_FAMILY} {consts.NFT_VIP_TABLE} '
+            file.write(f'table {consts.NFT_FAMILY} {consts.NFT_TABLE} '
                        '{}\n')
             file.write(f'delete table {consts.NFT_FAMILY} '
-                       f'{consts.NFT_VIP_TABLE}\n')
+                       f'{consts.NFT_TABLE}\n')
             file.write(table_string)
             file.write(chain_string)
             file.write(hook_string)
+            file.write(conntrack_string)
+            file.write(loopback_string)
+            file.write(loopback_addr_string)
+            file.write(loopback_ipv6_addr_string)
             file.write(icmp_string)
             file.write(icmpv6_string)
             file.write(dhcp_string)
             file.write(dhcpv6_string)
+            file.write(vip_interface_goto_string)
+            file.write('  }\n')  # close the chain
+            file.write(vip_chain_string)
             for rule in rules:
                 file.write(f'      {_build_rule_cmd(rule)}\n')
             file.write('  }\n')  # close the chain
             file.write('}\n')  # close the table
     else:  # No existing rules, create the "drop all" base rules
         with os.fdopen(
-                os.open(consts.NFT_VIP_RULES_FILE, flags, mode), 'w') as file:
+                os.open(consts.NFT_RULES_FILE, flags, mode), 'w') as file:
             file.write(table_string)
             file.write(chain_string)
             file.write(hook_string)
@@ -113,7 +135,7 @@ def _build_rule_cmd(rule):
 
 
 def load_nftables_file():
-    cmd = [consts.NFT_CMD, '-o', '-f', consts.NFT_VIP_RULES_FILE]
+    cmd = [consts.NFT_CMD, '-o', '-f', consts.NFT_RULES_FILE]
     try:
         with network_namespace.NetworkNamespace(consts.AMPHORA_NAMESPACE):
             subprocess.check_output(cmd, stderr=subprocess.STDOUT)

octavia/amphorae/drivers/driver_base.py

@@ -19,7 +19,7 @@ from typing import Optional
 from octavia.db import models as db_models
 
 
-class AmphoraLoadBalancerDriver(object, metaclass=abc.ABCMeta):
+class AmphoraLoadBalancerDriver(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def update_amphora_listeners(self, loadbalancer, amphora,
                                  timeout_dict):
@@ -264,7 +264,7 @@ class AmphoraLoadBalancerDriver(object, metaclass=abc.ABCMeta):
         """
 
 
-class VRRPDriverMixin(object, metaclass=abc.ABCMeta):
+class VRRPDriverMixin(metaclass=abc.ABCMeta):
     """Abstract mixin class for VRRP support in loadbalancer amphorae
 
     Usage: To plug VRRP support in another service driver XYZ, use:

octavia/amphorae/drivers/haproxy/rest_api_driver.py

@@ -14,6 +14,7 @@
 # under the License.
 import functools
 import hashlib
+import json
 import os
 import ssl
 import time
@@ -24,7 +25,6 @@ from oslo_context import context as oslo_context
 from oslo_log import log as logging
 from oslo_utils.secretutils import md5
 import requests
-import simplejson
 from stevedore import driver as stevedore_driver
 
 from octavia.amphorae.driver_exceptions import exceptions as driver_except
@@ -308,7 +308,7 @@ class HaproxyAmphoraLoadBalancerDriver(
         for cert_id in certs_to_delete:
             self.clients[amphora.api_version].delete_cert_pem(
                 amphora, listener.load_balancer.id,
-                '{id}.pem'.format(id=cert_id))
+                f'{cert_id}.pem')
 
         # See how many non-UDP/SCTP listeners we have left
         non_lvs_listener_count = len([
@@ -451,7 +451,7 @@ class HaproxyAmphoraLoadBalancerDriver(
             for cert in certs:
                 pem = cert_parser.build_pem(cert)
                 md5sum = md5(pem, usedforsecurity=False).hexdigest()  # nosec
-                name = '{id}.pem'.format(id=cert.id)
+                name = f'{cert.id}.pem'
                 cert_filename_list.append(
                     os.path.join(
                         CONF.haproxy_amphora.base_cert_dir, obj_id, name))
@@ -460,10 +460,10 @@ class HaproxyAmphoraLoadBalancerDriver(
             if certs:
                 # Build and upload the crt-list file for haproxy
                 crt_list = "\n".join(cert_filename_list)
-                crt_list = f'{crt_list}\n'.encode('utf-8')
+                crt_list = f'{crt_list}\n'.encode()
                 md5sum = md5(crt_list,
                              usedforsecurity=False).hexdigest()  # nosec
-                name = '{id}.pem'.format(id=listener.id)
+                name = f'{listener.id}.pem'
                 self._upload_cert(amphora, obj_id, crt_list, md5sum, name)
         return {'tls_cert': tls_cert, 'sni_certs': sni_certs}
 
@@ -482,7 +482,7 @@ class HaproxyAmphoraLoadBalancerDriver(
             pass
         md5sum = md5(secret, usedforsecurity=False).hexdigest()  # nosec
         id = hashlib.sha1(secret).hexdigest()  # nosec
-        name = '{id}.pem'.format(id=id)
+        name = f'{id}.pem'
 
         if amphora and obj_id:
             self._upload_cert(
@@ -520,7 +520,7 @@ class HaproxyAmphoraLoadBalancerDriver(
             except AttributeError:
                 pass
             md5sum = md5(pem, usedforsecurity=False).hexdigest()  # nosec
-            name = '{id}.pem'.format(id=tls_cert.id)
+            name = f'{tls_cert.id}.pem'
             if amphora and obj_id:
                 self._upload_cert(amphora, obj_id, pem=pem,
                                   md5sum=md5sum, name=name)
@@ -625,11 +625,11 @@ class CustomHostNameCheckingAdapter(requests.adapters.HTTPAdapter):
 
     def init_poolmanager(self, *pool_args, **pool_kwargs):
         proto = CONF.amphora_agent.agent_tls_protocol.replace('.', '_')
-        pool_kwargs['ssl_version'] = getattr(ssl, "PROTOCOL_%s" % proto)
+        pool_kwargs['ssl_version'] = getattr(ssl, f"PROTOCOL_{proto}")
         return super().init_poolmanager(*pool_args, **pool_kwargs)
 
 
-class AmphoraAPIClientBase(object):
+class AmphoraAPIClientBase:
     def __init__(self):
         super().__init__()
 
@@ -646,19 +646,13 @@ class AmphoraAPIClientBase(object):
 
     def _base_url(self, ip, api_version=None):
         if utils.is_ipv6_lla(ip):
-            ip = '[{ip}%{interface}]'.format(
-                ip=ip,
-                interface=CONF.haproxy_amphora.lb_network_interface)
+            ip = f'[{ip}%{CONF.haproxy_amphora.lb_network_interface}]'
         elif utils.is_ipv6(ip):
-            ip = '[{ip}]'.format(ip=ip)
+            ip = f'[{ip}]'
         if api_version:
-            return "https://{ip}:{port}/{version}/".format(
-                ip=ip,
-                port=CONF.haproxy_amphora.bind_port,
-                version=api_version)
-        return "https://{ip}:{port}/".format(
-            ip=ip,
-            port=CONF.haproxy_amphora.bind_port)
+            return (f"https://{ip}:{CONF.haproxy_amphora.bind_port}"
+                    f"/{api_version}/")
+        return f"https://{ip}:{CONF.haproxy_amphora.bind_port}/"
 
     def request(self, method: str, amp: db_models.Amphora, path: str = '/',
                 timeout_dict: Optional[dict] = None,
@@ -723,7 +717,7 @@ class AmphoraAPIClientBase(object):
                         if 'No suitable network interface found' in json_data:
                             LOG.debug("Amphora network interface not found.")
                             raise requests.ConnectionError
-                    except simplejson.JSONDecodeError:  # if r.json() fails
+                    except json.JSONDecodeError:  # if r.json() fails
                         pass  # TODO(rm_work) Should we do something?
                 return r
             except (requests.ConnectionError, requests.Timeout) as e:
@@ -774,31 +768,28 @@ class AmphoraAPIClient1_0(AmphoraAPIClientBase):
     def upload_config(self, amp, loadbalancer_id, config, timeout_dict=None):
         r = self.put(
             amp,
-            'loadbalancer/{amphora_id}/{loadbalancer_id}/haproxy'.format(
-                amphora_id=amp.id, loadbalancer_id=loadbalancer_id),
+            f'loadbalancer/{amp.id}/{loadbalancer_id}/haproxy',
             timeout_dict, data=config)
         return exc.check_exception(r)
 
     def get_listener_status(self, amp, listener_id):
         r = self.get(
             amp,
-            'listeners/{listener_id}'.format(listener_id=listener_id))
+            f'listeners/{listener_id}')
         if exc.check_exception(r):
             return r.json()
         return None
 
     def _action(self, action, amp, object_id, timeout_dict=None):
         r = self.put(
-            amp, 'loadbalancer/{object_id}/{action}'.format(
-                object_id=object_id, action=action),
+            amp, f'loadbalancer/{object_id}/{action}',
             timeout_dict=timeout_dict)
         return exc.check_exception(r)
 
     def upload_cert_pem(self, amp, loadbalancer_id, pem_filename, pem_file):
         r = self.put(
             amp,
-            'loadbalancer/{loadbalancer_id}/certificates/{filename}'.format(
-                loadbalancer_id=loadbalancer_id, filename=pem_filename),
+            f'loadbalancer/{loadbalancer_id}/certificates/{pem_filename}',
             data=pem_file)
         return exc.check_exception(r)
 
@@ -806,8 +797,7 @@ class AmphoraAPIClient1_0(AmphoraAPIClientBase):
                         ignore=tuple()):
         r = self.get(
             amp,
-            'loadbalancer/{loadbalancer_id}/certificates/{filename}'.format(
-                loadbalancer_id=loadbalancer_id, filename=pem_filename))
+            f'loadbalancer/{loadbalancer_id}/certificates/{pem_filename}')
         if exc.check_exception(r, ignore):
             return r.json().get("md5sum")
         return None
@@ -815,8 +805,7 @@ class AmphoraAPIClient1_0(AmphoraAPIClientBase):
     def delete_cert_pem(self, amp, loadbalancer_id, pem_filename):
         r = self.delete(
             amp,
-            'loadbalancer/{loadbalancer_id}/certificates/{filename}'.format(
-                loadbalancer_id=loadbalancer_id, filename=pem_filename))
+            f'loadbalancer/{loadbalancer_id}/certificates/{pem_filename}')
         return exc.check_exception(r, (404,))
 
     def update_cert_for_rotation(self, amp, pem_file):
@@ -825,7 +814,7 @@ class AmphoraAPIClient1_0(AmphoraAPIClientBase):
 
     def delete_listener(self, amp, object_id):
         r = self.delete(
-            amp, 'listeners/{object_id}'.format(object_id=object_id))
+            amp, f'listeners/{object_id}')
         return exc.check_exception(r, (404,))
 
     def get_info(self, amp, raise_retry_exception=False,
@@ -855,7 +844,7 @@ class AmphoraAPIClient1_0(AmphoraAPIClientBase):
 
     def plug_vip(self, amp, vip, net_info):
         r = self.post(amp,
-                      'plug/vip/{vip}'.format(vip=vip),
+                      f'plug/vip/{vip}',
                       json=net_info)
         return exc.check_exception(r)
 
@@ -864,12 +853,12 @@ class AmphoraAPIClient1_0(AmphoraAPIClientBase):
         return exc.check_exception(r)
 
     def _vrrp_action(self, action, amp, timeout_dict=None):
-        r = self.put(amp, 'vrrp/{action}'.format(action=action),
+        r = self.put(amp, f'vrrp/{action}',
                      timeout_dict=timeout_dict)
         return exc.check_exception(r)
 
     def get_interface(self, amp, ip_addr, timeout_dict=None, log_error=True):
-        r = self.get(amp, 'interface/{ip_addr}'.format(ip_addr=ip_addr),
+        r = self.get(amp, f'interface/{ip_addr}',
                      timeout_dict=timeout_dict)
         return exc.check_exception(r, log_error=log_error).json()
 
@@ -877,8 +866,7 @@ class AmphoraAPIClient1_0(AmphoraAPIClientBase):
     def upload_udp_config(self, amp, listener_id, config, timeout_dict=None):
         r = self.put(
             amp,
-            'listeners/{amphora_id}/{listener_id}/udp_listener'.format(
-                amphora_id=amp.id, listener_id=listener_id), timeout_dict,
+            f'listeners/{amp.id}/{listener_id}/udp_listener', timeout_dict,
             data=config)
         return exc.check_exception(r)
 

octavia/amphorae/drivers/health/heartbeat_udp.py

@@ -37,7 +37,7 @@ CONF = cfg.CONF
 LOG = logging.getLogger(__name__)
 
 
-class UDPStatusGetter(object):
+class UDPStatusGetter:
     """This class defines methods that will gather heartbeats
 
     The heartbeats are transmitted via UDP and this class will bind to a port

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

@@ -30,7 +30,7 @@ CONF = cfg.CONF
 LOG = logging.getLogger(__name__)
 
 
-class KeepalivedJinjaTemplater(object):
+class KeepalivedJinjaTemplater:
 
     def __init__(self, keepalived_template=None):
         """Keepalived configuration generation
@@ -123,7 +123,6 @@ class KeepalivedJinjaTemplater(object):
                 peers_ips.append(amp.vrrp_ip)
         return self.get_template(self.keepalived_template).render(
             {'vrrp_group_name': loadbalancer.vrrp_group.vrrp_group_name,
-             'amp_role': amphora.role,
              'amp_intf': amphora.vrrp_interface,
              'amp_vrrp_id': amphora.vrrp_id,
              'amp_priority': amphora.vrrp_priority,

octavia/amphorae/drivers/keepalived/jinja/templates/keepalived_base.template

@@ -21,7 +21,6 @@ vrrp_script check_script {
 }
 
 vrrp_instance {{ vrrp_group_name }} {
-    state {{ amp_role }}
     interface {{ amp_intf }}
     virtual_router_id {{ amp_vrrp_id }}
     priority {{ amp_priority }}

octavia/amphorae/drivers/noop_driver/driver.py

@@ -23,7 +23,7 @@ from octavia.db import repositories
 LOG = logging.getLogger(__name__)
 
 
-class NoopManager(object):
+class NoopManager:
 
     def __init__(self):
         super().__init__()

octavia/api/app.py

@@ -80,8 +80,7 @@ def _wrap_app(app):
                 audit_map_file=CONF.audit.audit_map_file,
                 ignore_req_list=CONF.audit.ignore_req_list
             )
-        except (EnvironmentError, OSError,
-                audit_middleware.PycadfAuditApiConfigError) as e:
+        except (OSError, audit_middleware.PycadfAuditApiConfigError) as e:
             raise exceptions.InputFileError(
                 file_name=CONF.audit.audit_map_file,
                 reason=e

octavia/api/common/pagination.py

@@ -32,7 +32,7 @@ CONF = cfg.CONF
 LOG = logging.getLogger(__name__)
 
 
-class PaginationHelper(object):
+class PaginationHelper:
     """Class helping to interact with pagination functionality
 
     Pass this class to `db.repositories` to apply it on query
@@ -142,40 +142,34 @@ class PaginationHelper(object):
 
     def _make_links(self, model_list):
         if CONF.api_settings.api_base_uri:
-            path_url = "{api_base_url}{path}".format(
-                api_base_url=CONF.api_settings.api_base_uri.rstrip('/'),
-                path=request.path)
+            path_url = (f"{CONF.api_settings.api_base_uri.rstrip('/')}"
+                        f"{request.path}")
         else:
             path_url = request.path_url
         links = []
         if model_list:
-            prev_attr = ["limit={}".format(self.limit)]
+            prev_attr = [f"limit={self.limit}"]
             if self.params.get('sort'):
-                prev_attr.append("sort={}".format(self.params.get('sort')))
+                prev_attr.append(f"sort={self.params.get('sort')}")
             if self.params.get('sort_key'):
-                prev_attr.append("sort_key={}".format(
-                    self.params.get('sort_key')))
+                prev_attr.append(f"sort_key={self.params.get('sort_key')}")
             next_attr = copy.copy(prev_attr)
             if self.marker:
-                prev_attr.append("marker={}".format(model_list[0].get('id')))
+                prev_attr.append(f"marker={model_list[0].get('id')}")
                 prev_attr.append("page_reverse=True")
                 prev_link = {
                     "rel": "previous",
-                    "href": "{url}?{params}".format(
-                        url=path_url,
-                        params="&".join(prev_attr))
+                    "href": f"{path_url}?{'&'.join(prev_attr)}"
                 }
                 links.append(prev_link)
             # TODO(rm_work) Do we need to know when there are more vs exact?
             # We safely know if we have a full page, but it might include the
             # last element or it might not, it is unclear
-            if len(model_list) >= self.limit:
-                next_attr.append("marker={}".format(model_list[-1].get('id')))
+            if self.limit is None or len(model_list) >= self.limit:
+                next_attr.append(f"marker={model_list[-1].get('id')}")
                 next_link = {
                     "rel": "next",
-                    "href": "{url}?{params}".format(
-                        url=path_url,
-                        params="&".join(next_attr))
+                    "href": f"{path_url}?{'&'.join(next_attr)}"
                 }
                 links.append(next_link)
         links = [types.PageType(**link) for link in links]
@@ -361,7 +355,7 @@ class PaginationHelper(object):
                         attr = sa_sql.expression.case(
                             (model_attr.isnot(None), model_attr),
                             else_=default)
-                        crit_attrs.append((attr == marker_values[j]))
+                        crit_attrs.append(attr == marker_values[j])
 
                     model_attr = getattr(model, self.sort_keys[i][0])
                     default = PaginationHelper._get_default_column_value(
@@ -372,14 +366,14 @@ class PaginationHelper(object):
                     this_sort_dir = self.sort_keys[i][1]
                     if this_sort_dir == constants.DESC:
                         if self.page_reverse == "True":
-                            crit_attrs.append((attr > marker_values[i]))
+                            crit_attrs.append(attr > marker_values[i])
                         else:
-                            crit_attrs.append((attr < marker_values[i]))
+                            crit_attrs.append(attr < marker_values[i])
                     elif this_sort_dir == constants.ASC:
                         if self.page_reverse == "True":
-                            crit_attrs.append((attr < marker_values[i]))
+                            crit_attrs.append(attr < marker_values[i])
                         else:
-                            crit_attrs.append((attr > marker_values[i]))
+                            crit_attrs.append(attr > marker_values[i])
                     else:
                         raise exceptions.InvalidSortDirection(
                             key=this_sort_dir)

octavia/api/common/types.py

@@ -127,7 +127,7 @@ class BaseMeta(wtypes.BaseMeta):
                 get_tenant_id, set_tenant_id)
             # This will let us know if tenant_id was explicitly set to Unset
             dct['_unset_tenant'] = False
-        return super(BaseMeta, mcs).__new__(mcs, name, bases, dct)
+        return super().__new__(mcs, name, bases, dct)
 
 
 class BaseType(wtypes.Base, metaclass=BaseMeta):

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

@@ -76,8 +76,8 @@ class AmphoraProviderDriver(driver_base.ProviderDriver):
 
     def _validate_pool_algorithm(self, pool):
         if pool.lb_algorithm not in AMPHORA_SUPPORTED_LB_ALGORITHMS:
-            msg = ('Amphora provider does not support %s algorithm.'
-                   % pool.lb_algorithm)
+            msg = (f'Amphora provider does not support {pool.lb_algorithm} '
+                   f'algorithm.')
             raise exceptions.UnsupportedOptionError(
                 user_fault_string=msg,
                 operator_fault_string=msg)
@@ -473,9 +473,9 @@ class AmphoraProviderDriver(driver_base.ProviderDriver):
         except js_exceptions.ValidationError as e:
             error_object = ''
             if e.relative_path:
-                error_object = '{} '.format(e.relative_path[0])
+                error_object = f'{e.relative_path[0]} '
             raise exceptions.UnsupportedOptionError(
-                user_fault_string='{0}{1}'.format(error_object, e.message),
+                user_fault_string=f'{error_object}{e.message}',
                 operator_fault_string=str(e))
         except Exception as e:
             raise exceptions.DriverError(
@@ -559,9 +559,9 @@ class AmphoraProviderDriver(driver_base.ProviderDriver):
         except js_exceptions.ValidationError as e:
             error_object = ''
             if e.relative_path:
-                error_object = '{} '.format(e.relative_path[0])
+                error_object = f'{e.relative_path[0]} '
             raise exceptions.UnsupportedOptionError(
-                user_fault_string='{0}{1}'.format(error_object, e.message),
+                user_fault_string=f'{error_object}{e.message}',
                 operator_fault_string=str(e))
         except Exception as e:
             raise exceptions.DriverError(

octavia/api/drivers/driver_agent/driver_listener.py

@@ -62,7 +62,7 @@ class StatusRequestHandler(socketserver.BaseRequestHandler):
 
         # Send the response
         json_data = jsonutils.dump_as_bytes(response)
-        len_str = '{}\n'.format(len(json_data)).encode('utf-8')
+        len_str = f'{len(json_data)}\n'.encode()
         try:
             self.request.send(len_str)
             self.request.sendall(json_data)
@@ -86,7 +86,7 @@ class StatsRequestHandler(socketserver.BaseRequestHandler):
 
         # Send the response
         json_data = jsonutils.dump_as_bytes(response)
-        len_str = '{}\n'.format(len(json_data)).encode('utf-8')
+        len_str = f'{len(json_data)}\n'.encode()
         try:
             self.request.send(len_str)
             self.request.sendall(json_data)
@@ -109,7 +109,7 @@ class GetRequestHandler(socketserver.BaseRequestHandler):
 
         # Send the response
         json_data = jsonutils.dump_as_bytes(response)
-        len_str = '{}\n'.format(len(json_data)).encode('utf-8')
+        len_str = f'{len(json_data)}\n'.encode()
         try:
             self.request.send(len_str)
             self.request.sendall(json_data)

octavia/api/drivers/driver_agent/driver_updater.py

@@ -29,7 +29,7 @@ from octavia.statistics import stats_base
 LOG = logging.getLogger(__name__)
 
 
-class DriverUpdater(object):
+class DriverUpdater:
 
     def __init__(self, **kwargs):
         self.repos = repo.Repositories()

octavia/api/drivers/noop_driver/driver.py

@@ -23,7 +23,7 @@ from octavia.api.drivers import utils as driver_utils
 LOG = logging.getLogger(__name__)
 
 
-class NoopManager(object):
+class NoopManager:
     def __init__(self):
         super().__init__()
         self.driverconfig = {}

octavia/api/root_controller.py

@@ -27,7 +27,7 @@ CONF = cfg.CONF
 LOG = logging.getLogger(__name__)
 
 
-class RootController(object):
+class RootController:
     """The controller with which the pecan wsgi app should be created."""
 
     def __init__(self):
@@ -65,7 +65,7 @@ class RootController(object):
         host_url = pecan_request.path_url
 
         if not host_url.endswith('/'):
-            host_url = '{}/'.format(host_url)
+            host_url = f'{host_url}/'
 
         versions = []
         self._add_a_version(versions, 'v2.0', 'v2', 'SUPPORTED',

octavia/api/v2/controllers/base.py

@@ -223,8 +223,7 @@ class BaseController(pecan_rest.RestController):
 
     def _auth_get_all(self, context, project_id):
         # Check authorization to list objects under all projects
-        action = '{rbac_obj}{action}'.format(
-            rbac_obj=self.RBAC_TYPE, action=constants.RBAC_GET_ALL_GLOBAL)
+        action = f'{self.RBAC_TYPE}{constants.RBAC_GET_ALL_GLOBAL}'
         target = {'project_id': project_id}
         if not policy.get_enforcer().authorize(action, target,
                                                context, do_raise=False):
@@ -247,8 +246,7 @@ class BaseController(pecan_rest.RestController):
 
     def _auth_validate_action(self, context, project_id, action):
         # Check that the user is authorized to do an action in this object
-        action = '{rbac_obj}{action}'.format(
-            rbac_obj=self.RBAC_TYPE, action=action)
+        action = f'{self.RBAC_TYPE}{action}'
         target = {'project_id': project_id}
         policy.get_enforcer().authorize(action, target, context)
 

octavia/api/v2/controllers/health_monitor.py

@@ -152,7 +152,7 @@ class HealthMonitorController(base.BaseController):
         if hm_dict.get('http_version') and hm_dict.get('domain_name'):
             if hm_dict['http_version'] < 1.1:
                 raise exceptions.InvalidOption(
-                    value='http_version %s' % hm_dict['http_version'],
+                    value=f"http_version {hm_dict['http_version']}",
                     option='health monitors HTTP 1.1 domain name health check')
 
         try:
@@ -188,7 +188,9 @@ class HealthMonitorController(base.BaseController):
             request.type == consts.HEALTH_MONITOR_UDP_CONNECT)
         conf_min_delay = (
             CONF.api_settings.udp_connect_min_interval_health_monitor)
-        if hm_is_type_udp and request.delay < conf_min_delay:
+        if (hm_is_type_udp and
+                not isinstance(request.delay, wtypes.UnsetType) and
+                request.delay < conf_min_delay):
             raise exceptions.ValidationException(detail=_(
                 "The request delay value %(delay)s should be larger than "
                 "%(conf_min_delay)s for %(type)s health monitor type.") % {
@@ -315,7 +317,7 @@ class HealthMonitorController(base.BaseController):
             http_version = health_monitor.http_version or db_hm.http_version
             if http_version < 1.1:
                 raise exceptions.InvalidOption(
-                    value='http_version %s' % http_version,
+                    value=f'http_version {http_version}',
                     option='health monitors HTTP 1.1 domain name health check')
 
     def _set_default_on_none(self, health_monitor):

octavia/api/v2/controllers/listener.py

@@ -136,7 +136,7 @@ class ListenersController(base.BaseController):
                 constants.LISTENER_PROTOCOLS_SUPPORTING_HEADER_INSERTION):
             raise exceptions.InvalidOption(
                 value='insert-headers',
-                option='a %s protocol listener.' % listener_protocol)
+                option=f'a {listener_protocol} protocol listener.')
         if list(set(insert_header_list) - (
                 set(constants.SUPPORTED_HTTP_HEADERS +
                     constants.SUPPORTED_SSL_HEADERS))):
@@ -155,7 +155,7 @@ class ListenersController(base.BaseController):
                         headers.append(header_name)
                 raise exceptions.InvalidOption(
                     value=headers,
-                    option='%s protocol listener.' % listener_protocol)
+                    option=f'{listener_protocol} protocol listener.')
 
     def _validate_cidr_compatible_with_vip(self, vips, allowed_cidrs):
         for cidr in allowed_cidrs: