octavia 14.0.0.0rc1__py3-none-any.whl → 15.0.0.0rc1__py3-none-any.whl

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

@@ -41,41 +41,18 @@ class ParsingError(Exception):
     pass
 
 
-class UnknownInitError(Exception):
-    pass
-
-
-def init_path(lb_id, init_system):
-    if init_system == consts.INIT_SYSTEMD:
-        return os.path.join(consts.SYSTEMD_DIR,
-                            'haproxy-{0}.service'.format(lb_id))
-    if init_system == consts.INIT_UPSTART:
-        return os.path.join(consts.UPSTART_DIR,
-                            'haproxy-{0}.conf'.format(lb_id))
-    if init_system == consts.INIT_SYSVINIT:
-        return os.path.join(consts.SYSVINIT_DIR,
-                            'haproxy-{0}'.format(lb_id))
-    raise UnknownInitError()
+def init_path(lb_id):
+    return os.path.join(consts.SYSTEMD_DIR, f'haproxy-{lb_id}.service')
 
 
 def keepalived_lvs_dir():
     return os.path.join(CONF.haproxy_amphora.base_path, 'lvs')
 
 
-def keepalived_lvs_init_path(init_system, listener_id):
-    if init_system == consts.INIT_SYSTEMD:
-        return os.path.join(consts.SYSTEMD_DIR,
-                            consts.KEEPALIVED_SYSTEMD_PREFIX %
-                            str(listener_id))
-    if init_system == consts.INIT_UPSTART:
-        return os.path.join(consts.UPSTART_DIR,
-                            consts.KEEPALIVED_UPSTART_PREFIX %
-                            str(listener_id))
-    if init_system == consts.INIT_SYSVINIT:
-        return os.path.join(consts.SYSVINIT_DIR,
-                            consts.KEEPALIVED_SYSVINIT_PREFIX %
-                            str(listener_id))
-    raise UnknownInitError()
+def keepalived_lvs_init_path(listener_id):
+    return os.path.join(consts.SYSTEMD_DIR,
+                        consts.KEEPALIVEDLVS_SYSTEMD %
+                        str(listener_id))
 
 
 def keepalived_backend_check_script_dir():
@@ -92,15 +69,14 @@ def keepalived_lvs_pids_path(listener_id):
     for file_ext in ['pid', 'vrrp.pid', 'check.pid']:
         pids_path[file_ext] = (
             os.path.join(CONF.haproxy_amphora.base_path,
-                         ('lvs/octavia-keepalivedlvs-%s.%s') %
-                         (str(listener_id), file_ext)))
+                         f"lvs/octavia-keepalivedlvs-{str(listener_id)}."
+                         f"{file_ext}"))
     return pids_path['pid'], pids_path['vrrp.pid'], pids_path['check.pid']
 
 
 def keepalived_lvs_cfg_path(listener_id):
     return os.path.join(CONF.haproxy_amphora.base_path,
-                        ('lvs/octavia-keepalivedlvs-%s.conf') %
-                        str(listener_id))
+                        f"lvs/octavia-keepalivedlvs-{str(listener_id)}.conf")
 
 
 def haproxy_dir(lb_id):
@@ -120,13 +96,13 @@ def state_file_path(lb_id):
 
 
 def get_haproxy_pid(lb_id):
-    with open(pid_path(lb_id), 'r', encoding='utf-8') as f:
+    with open(pid_path(lb_id), encoding='utf-8') as f:
         return f.readline().rstrip()
 
 
 def get_keepalivedlvs_pid(listener_id):
     pid_file = keepalived_lvs_pids_path(listener_id)[0]
-    with open(pid_file, 'r', encoding='utf-8') as f:
+    with open(pid_file, encoding='utf-8') as f:
         return f.readline().rstrip()
 
 
@@ -143,14 +119,8 @@ def keepalived_dir():
     return os.path.join(CONF.haproxy_amphora.base_path, 'vrrp')
 
 
-def keepalived_init_path(init_system):
-    if init_system == consts.INIT_SYSTEMD:
-        return os.path.join(consts.SYSTEMD_DIR, consts.KEEPALIVED_SYSTEMD)
-    if init_system == consts.INIT_UPSTART:
-        return os.path.join(consts.UPSTART_DIR, consts.KEEPALIVED_UPSTART)
-    if init_system == consts.INIT_SYSVINIT:
-        return os.path.join(consts.SYSVINIT_DIR, consts.KEEPALIVED_SYSVINIT)
-    raise UnknownInitError()
+def keepalived_init_path():
+    return os.path.join(consts.SYSTEMD_DIR, consts.KEEPALIVED_SYSTEMD)
 
 
 def keepalived_pid_path():
@@ -226,24 +196,6 @@ def is_lvs_listener_running(listener_id):
         os.path.join('/proc', get_keepalivedlvs_pid(listener_id)))
 
 
-def get_os_init_system():
-    if os.path.exists(consts.INIT_PROC_COMM_PATH):
-        with open(consts.INIT_PROC_COMM_PATH,
-                  'r', encoding='utf-8') as init_comm:
-            init_proc_name = init_comm.read().rstrip('\n')
-            if init_proc_name == consts.INIT_SYSTEMD:
-                return consts.INIT_SYSTEMD
-            if init_proc_name == 'init':
-                init_path = consts.INIT_PATH
-                if os.path.exists(init_path):
-                    args = [init_path, '--version']
-                    init_version = subprocess.check_output(args, shell=False)
-                    if consts.INIT_UPSTART in str(init_version, 'utf-8'):
-                        return consts.INIT_UPSTART
-                    return consts.INIT_SYSVINIT
-    return consts.INIT_UNKOWN
-
-
 def install_netns_systemd_service():
     flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
     # mode 00644
@@ -267,14 +219,17 @@ def install_netns_systemd_service():
             text_file.write(text)
 
 
-def run_systemctl_command(command, service):
-    cmd = "systemctl {cmd} {srvc}".format(cmd=command, srvc=service)
+def run_systemctl_command(command, service, raise_error=True):
+    cmd = f"systemctl {command} {service}"
     try:
-        subprocess.check_output(cmd.split(), stderr=subprocess.STDOUT)
+        subprocess.check_output(cmd.split(), stderr=subprocess.STDOUT,
+                                encoding='utf-8')
     except subprocess.CalledProcessError as e:
-        LOG.error("Failed to %(cmd)s %(srvc)s service: "
+        LOG.debug("Failed to %(cmd)s %(srvc)s service: "
                   "%(err)s %(out)s", {'cmd': command, 'srvc': service,
                                       'err': e, 'out': e.output})
+        if raise_error:
+            raise
 
 
 def get_backend_for_lb_object(object_id):
@@ -295,7 +250,7 @@ def get_backend_for_lb_object(object_id):
 
 
 def parse_haproxy_file(lb_id):
-    with open(config_path(lb_id), 'r', encoding='utf-8') as file:
+    with open(config_path(lb_id), encoding='utf-8') as file:
         cfg = file.read()
 
         listeners = {}
@@ -364,7 +319,7 @@ def vrrp_check_script_update(lb_id, action):
     for lbid in lb_ids:
         args.append(haproxy_sock_path(lbid))
 
-    cmd = 'haproxy-vrrp-check {args}; exit $?'.format(args=' '.join(args))
+    cmd = f"haproxy-vrrp-check {' '.join(args)}; exit $?"
     with open(haproxy_check_script_path(), 'w', encoding='utf-8') as text_file:
         text_file.write(cmd)
 
@@ -376,7 +331,7 @@ def get_haproxy_vip_addresses(lb_id):
     :returns: List of VIP addresses (IPv4 and IPv6)
     """
     vips = []
-    with open(config_path(lb_id), 'r', encoding='utf-8') as file:
+    with open(config_path(lb_id), encoding='utf-8') as file:
         for line in file:
             current_line = line.strip()
             if current_line.startswith('bind'):

octavia/amphorae/backends/agent/templates/amphora_agent_conf.template

@@ -23,9 +23,6 @@ base_path = {{ base_path }}
 bind_host = {{ bind_host }}
 bind_port = {{ bind_port }}
 haproxy_cmd = {{ haproxy_cmd }}
-respawn_count = {{ respawn_count }}
-respawn_interval = {{ respawn_interval }}
-use_upstart = {{ use_upstart }}
 user_log_facility = {{ user_log_facility }}
 administrative_log_facility = {{ administrative_log_facility }}
 

octavia/amphorae/backends/health_daemon/health_daemon.py

@@ -15,6 +15,7 @@
 #    under the License.
 
 import errno
+import json
 import os
 import queue
 import stat
@@ -22,7 +23,6 @@ import time
 
 from oslo_config import cfg
 from oslo_log import log as logging
-import simplejson
 
 from octavia.amphorae.backends.agent.api_server import util
 from octavia.amphorae.backends.health_daemon import health_sender
@@ -73,8 +73,8 @@ def get_counters():
     global COUNTERS
     if COUNTERS is None:
         try:
-            COUNTERS = simplejson.load(get_counters_file()) or {}
-        except (simplejson.JSONDecodeError, AttributeError):
+            COUNTERS = json.load(get_counters_file()) or {}
+        except (json.JSONDecodeError, AttributeError):
             COUNTERS = {}
     return COUNTERS
 
@@ -84,7 +84,7 @@ def persist_counters():
     if COUNTERS is None:
         return
     try:
-        stats = simplejson.dumps(COUNTERS)
+        stats = json.dumps(COUNTERS)
         counters_file = get_counters_file()
         counters_file.truncate(0)
         counters_file.write(stats)
@@ -118,14 +118,13 @@ def run_sender(cmd_queue):
             # heartbeat
             if os.path.isfile(keepalived_cfg_path):
                 # Is there a pid file for keepalived?
-                with open(keepalived_pid_path,
-                          'r', encoding='utf-8') as pid_file:
+                with open(keepalived_pid_path, encoding='utf-8') as pid_file:
                     pid = int(pid_file.readline())
                 os.kill(pid, 0)
 
             message = build_stats_message()
             sender.dosend(message)
-        except (IOError, OSError) as e:
+        except OSError as e:
             if e.errno == errno.ENOENT:
                 # Missing PID file, skip health heartbeat.
                 LOG.error('Missing keepalived PID file %s, skipping health '

octavia/amphorae/backends/health_daemon/health_sender.py

@@ -31,7 +31,7 @@ def round_robin_addr(addrinfo_list):
     return addrinfo
 
 
-class UDPStatusSender(object):
+class UDPStatusSender:
     def __init__(self):
         self._update_dests()
         self.v4sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -56,7 +56,7 @@ class UDPStatusSender(object):
                 self.v4sock.sendto(envelope_str, dest[4])
             elif dest[0] == socket.AF_INET6:
                 self.v6sock.sendto(envelope_str, dest[4])
-        except socket.error:
+        except OSError:
             # Pass here as on amp boot it will get one or more
             # error: [Errno 101] Network is unreachable
             # while the networks are coming up

octavia/amphorae/backends/utils/haproxy_query.py

@@ -24,7 +24,7 @@ from octavia.i18n import _
 LOG = logging.getLogger(__name__)
 
 
-class HAProxyQuery(object):
+class HAProxyQuery:
     """Class used for querying the HAProxy statistics socket.
 
     The CSV output is defined in the HAProxy documentation:
@@ -51,7 +51,7 @@ class HAProxyQuery(object):
 
         try:
             sock.connect(self.socket)
-        except socket.error as e:
+        except OSError as e:
             raise Exception(
                 _("HAProxy '{0}' query failed.").format(query)) from e
 
@@ -95,10 +95,7 @@ class HAProxyQuery(object):
         """
 
         results = self._query(
-            'show stat {proxy_iid} {object_type} {server_id}'.format(
-                proxy_iid=proxy_iid,
-                object_type=object_type,
-                server_id=server_id))
+            f'show stat {proxy_iid} {object_type} {server_id}')
         list_results = results[2:].split('\n')
         csv_reader = csv.DictReader(list_results)
         stats_list = list(csv_reader)

octavia/amphorae/backends/utils/interface.py

@@ -37,7 +37,7 @@ CONF = cfg.CONF
 LOG = logging.getLogger(__name__)
 
 
-class InterfaceController(object):
+class InterfaceController:
     ADD = 'add'
     DELETE = 'delete'
     SET = 'set'
@@ -106,10 +106,9 @@ class InterfaceController(object):
     def _dhclient_up(self, interface_name):
         cmd = ["/sbin/dhclient",
                "-lf",
-               "/var/lib/dhclient/dhclient-{}.leases".format(
-                   interface_name),
+               f"/var/lib/dhclient/dhclient-{interface_name}.leases",
                "-pf",
-               "/run/dhclient-{}.pid".format(interface_name),
+               f"/run/dhclient-{interface_name}.pid",
                interface_name]
         LOG.debug("Running '%s'", cmd)
         subprocess.check_output(cmd, stderr=subprocess.STDOUT)
@@ -118,10 +117,9 @@ class InterfaceController(object):
         cmd = ["/sbin/dhclient",
                "-r",
                "-lf",
-               "/var/lib/dhclient/dhclient-{}.leases".format(
-                   interface_name),
+               f"/var/lib/dhclient/dhclient-{interface_name}.leases",
                "-pf",
-               "/run/dhclient-{}.pid".format(interface_name),
+               f"/run/dhclient-{interface_name}.pid",
                interface_name]
         LOG.debug("Running '%s'", cmd)
         subprocess.check_output(cmd, stderr=subprocess.STDOUT)
@@ -134,8 +132,7 @@ class InterfaceController(object):
                            ('autoconf', 1)):
             cmd = ["/sbin/sysctl",
                    "-w",
-                   "net.ipv6.conf.{}.{}={}".format(interface_name,
-                                                   key, value)]
+                   f"net.ipv6.conf.{interface_name}.{key}={value}"]
             LOG.debug("Running '%s'", cmd)
             subprocess.check_output(cmd, stderr=subprocess.STDOUT)
 
@@ -144,8 +141,7 @@ class InterfaceController(object):
                            ('autoconf', 0)):
             cmd = ["/sbin/sysctl",
                    "-w",
-                   "net.ipv6.conf.{}.{}={}".format(interface_name,
-                                                   key, value)]
+                   f"net.ipv6.conf.{interface_name}.{key}={value}"]
             LOG.debug("Running '%s'", cmd)
             subprocess.check_output(cmd, stderr=subprocess.STDOUT)
 
@@ -176,47 +172,12 @@ class InterfaceController(object):
         ip_network = ipaddress.ip_network(address, strict=False)
         return ip_network.compressed
 
-    def _setup_nftables_chain(self, interface):
-        # TODO(johnsom) Move this to pyroute2 when the nftables library
-        #               improves.
-
-        # Create the nftable
-        cmd = [consts.NFT_CMD, consts.NFT_ADD, 'table', consts.NFT_FAMILY,
-               consts.NFT_VIP_TABLE]
-        try:
-            subprocess.check_output(cmd, stderr=subprocess.STDOUT)
-        except Exception as e:
-            if hasattr(e, 'output'):
-                LOG.error(e.output)
-            else:
-                LOG.error(e)
-            raise
-
-        # Create the chain with -310 priority to put it in front of the
-        # lvs-masquerade configured chain
-        cmd = [consts.NFT_CMD, consts.NFT_ADD, 'chain', consts.NFT_FAMILY,
-               consts.NFT_VIP_TABLE, consts.NFT_VIP_CHAIN,
-               '{', 'type', 'filter', 'hook', 'ingress', 'device',
-               interface.name, 'priority', consts.NFT_SRIOV_PRIORITY, ';',
-               'policy', 'drop', ';', '}']
-        try:
-            subprocess.check_output(cmd, stderr=subprocess.STDOUT)
-        except Exception as e:
-            if hasattr(e, 'output'):
-                LOG.error(e.output)
-            else:
-                LOG.error(e)
-            raise
-
-        nftable_utils.write_nftable_vip_rules_file(interface.name, [])
-
-        nftable_utils.load_nftables_file()
-
     def up(self, interface):
         LOG.info("Setting interface %s up", interface.name)
 
         if interface.is_sriov:
-            self._setup_nftables_chain(interface)
+            nftable_utils.write_nftable_rules_file(interface.name, [])
+            nftable_utils.load_nftables_file()
 
         with pyroute2.IPRoute() as ipr:
             idx = ipr.link_lookup(ifname=interface.name)[0]
@@ -305,8 +266,8 @@ class InterfaceController(object):
                 'RTA_DST',
                 '0.0.0.0' if family == socket.AF_INET else '::')  # nosec
 
-            key = ("{}/{}".format(self._normalize_ip_address(dst),
-                                  route.get('dst_len', 0)),
+            key = (f"{self._normalize_ip_address(dst)}/"
+                   f"{route.get('dst_len', 0)}",
                    self._normalize_ip_address(attrs.get('RTA_GATEWAY')),
                    self._normalize_ip_address(attrs.get('RTA_PREFSRC')),
                    attrs.get('RTA_TABLE'))

octavia/amphorae/backends/utils/interface_file.py

@@ -13,18 +13,18 @@
 # under the License.
 
 import ipaddress
+import json
 import os
 import stat
 
 from oslo_config import cfg
-import simplejson
 
 from octavia.common import constants as consts
 
 CONF = cfg.CONF
 
 
-class InterfaceFile(object):
+class InterfaceFile:
     def __init__(self, name, if_type, mtu=None, addresses=None,
                  routes=None, rules=None, scripts=None, is_sriov=False):
         self.name = name
@@ -45,11 +45,11 @@ class InterfaceFile(object):
 
     @classmethod
     def load(cls, fp):
-        return simplejson.load(fp)
+        return json.load(fp)
 
     @classmethod
     def dump(cls, obj):
-        return simplejson.dumps(obj)
+        return json.dumps(obj)
 
     @classmethod
     def from_file(cls, filename):
@@ -88,7 +88,7 @@ class InterfaceFile(object):
         except OSError:
             pass
 
-        interface_file = "{}.json".format(self.name)
+        interface_file = f"{self.name}.json"
 
         with os.fdopen(os.open(os.path.join(net_dir, interface_file),
                                flags, mode), 'w') as fp:
@@ -168,7 +168,7 @@ class VIPInterfaceFile(InterfaceFile):
             })
 
             vip_cidr = ipaddress.ip_network(
-                "{}/{}".format(vip['ip_address'], vip['prefixlen']),
+                f"{vip['ip_address']}/{vip['prefixlen']}",
                 strict=False)
             self.routes.append({
                 consts.DST: vip_cidr.exploded,
@@ -227,22 +227,28 @@ class VIPInterfaceFile(InterfaceFile):
                 fixed_ip.get('host_routes', []))
             self.routes.extend(host_routes)
 
+        if is_sriov:
+            sriov_param = ' sriov'
+        else:
+            sriov_param = ''
+
         for ip_v in ip_versions:
             self.scripts[consts.IFACE_UP].append({
                 consts.COMMAND: (
-                    "/usr/local/bin/lvs-masquerade.sh add {} {}".format(
-                        'ipv6' if ip_v == 6 else 'ipv4', name))
+                    "/usr/local/bin/lvs-masquerade.sh add {} {}{}".format(
+                        'ipv6' if ip_v == 6 else 'ipv4', name, sriov_param))
             })
             self.scripts[consts.IFACE_DOWN].append({
                 consts.COMMAND: (
-                    "/usr/local/bin/lvs-masquerade.sh delete {} {}".format(
-                        'ipv6' if ip_v == 6 else 'ipv4', name))
+                    "/usr/local/bin/lvs-masquerade.sh delete {} {}{}".format(
+                        'ipv6' if ip_v == 6 else 'ipv4', name, sriov_param))
             })
 
 
 class PortInterfaceFile(InterfaceFile):
-    def __init__(self, name, mtu, fixed_ips):
-        super().__init__(name, if_type=consts.BACKEND, mtu=mtu)
+    def __init__(self, name, mtu, fixed_ips, is_sriov=False):
+        super().__init__(name, if_type=consts.BACKEND, mtu=mtu,
+                         is_sriov=is_sriov)
 
         if fixed_ips:
             ip_versions = set()
@@ -271,14 +277,21 @@ class PortInterfaceFile(InterfaceFile):
                 consts.IPV6AUTO: True
             })
 
+        if is_sriov:
+            sriov_param = ' sriov'
+        else:
+            sriov_param = ''
+
         for ip_version in ip_versions:
             self.scripts[consts.IFACE_UP].append({
                 consts.COMMAND: (
-                    "/usr/local/bin/lvs-masquerade.sh add {} {}".format(
-                        'ipv6' if ip_version == 6 else 'ipv4', name))
+                    "/usr/local/bin/lvs-masquerade.sh add {} {}{}".format(
+                        'ipv6' if ip_version == 6 else 'ipv4', name,
+                        sriov_param))
             })
             self.scripts[consts.IFACE_DOWN].append({
                 consts.COMMAND: (
-                    "/usr/local/bin/lvs-masquerade.sh delete {} {}".format(
-                        'ipv6' if ip_version == 6 else 'ipv4', name))
+                    "/usr/local/bin/lvs-masquerade.sh delete {} {}{}".format(
+                        'ipv6' if ip_version == 6 else 'ipv4', name,
+                        sriov_param))
             })

octavia/amphorae/backends/utils/ip_advertisement.py

@@ -80,7 +80,7 @@ def calculate_icmpv6_checksum(packet):
 
     # Add up 16-bit words
     num_words = len(packet) // 2
-    for chunk in struct.unpack("!%sH" % num_words, packet[0:num_words * 2]):
+    for chunk in struct.unpack(f"!{num_words}H", packet[0:num_words * 2]):
         total += chunk
 
     # Add any left over byte

octavia/amphorae/backends/utils/keepalivedlvs_query.py

@@ -42,8 +42,7 @@ CHECKER_REGEX = re.compile(r"(MISC_CHECK|HTTP_GET|TCP_CHECK)")
 
 
 def read_kernel_file(ns_name, file_path):
-    cmd = ("ip netns exec {ns} cat {lvs_stat_path}".format(
-        ns=ns_name, lvs_stat_path=file_path))
+    cmd = f"ip netns exec {ns_name} cat {file_path}"
     try:
         output = subprocess.check_output(cmd.split(),
                                          stderr=subprocess.STDOUT)
@@ -75,12 +74,12 @@ def get_listener_realserver_mapping(ns_name, listener_ip_ports,
         ip_obj = ipaddress.ip_address(listener_ip.strip('[]'))
         output = read_kernel_file(ns_name, KERNEL_LVS_PATH).split('\n')
         if ip_obj.version == 4:
-            ip_to_hex_format = "%.8X" % ip_obj._ip
+            ip_to_hex_format = f"{ip_obj._ip:08X}"
         else:
             ip_to_hex_format = r'\[' + ip_obj.exploded + r'\]'
-        port_hex_format = "%.4X" % int(listener_port)
+        port_hex_format = f"{int(listener_port):04X}"
         idex_list.append(ip_to_hex_format + ':' + port_hex_format)
-    idex = "({})".format("|".join(idex_list))
+    idex = f"({'|'.join(idex_list)})"
 
     if health_monitor_enabled:
         member_status = constants.UP
@@ -147,7 +146,7 @@ def get_lvs_listener_resource_ipports_nsname(listener_id):
     #                            'HealthMonitor': {'id': healthmonitor-id}}
     resource_ipport_mapping = {}
     with open(util.keepalived_lvs_cfg_path(listener_id),
-              'r', encoding='utf-8') as f:
+              encoding='utf-8') as f:
         cfg = f.read()
 
         ret = VS_ADDRESS_REGEX.findall(cfg)
@@ -192,7 +191,7 @@ def get_lvs_listener_resource_ipports_nsname(listener_id):
         for resource_type, resource_id in resource_type_ids:
             value = {'id': resource_id}
             if resource_type == 'Member':
-                resource_type = '%ss' % resource_type
+                resource_type = f'{resource_type}s'
                 if resource_type not in resource_ipport_mapping:
                     value = [value]
             if resource_type not in resource_ipport_mapping:
@@ -260,7 +259,7 @@ def get_lvs_listener_pool_status(listener_id):
     restarting = config_stat.st_mtime > check_pid_stat.st_mtime
 
     with open(util.keepalived_lvs_cfg_path(listener_id),
-              'r', encoding='utf-8') as f:
+              encoding='utf-8') as f:
         cfg = f.read()
         hm_enabled = len(CHECKER_REGEX.findall(cfg)) > 0
 

octavia/amphorae/backends/utils/network_namespace.py

@@ -15,7 +15,7 @@ import ctypes
 import os
 
 
-class NetworkNamespace(object):
+class NetworkNamespace:
     """A network namespace context manager.
 
     Runs wrapped code inside the specified network namespace.
@@ -32,8 +32,8 @@ class NetworkNamespace(object):
             raise OSError(errno, os.strerror(errno))
 
     def __init__(self, netns):
-        self.current_netns = '/proc/{pid}/ns/net'.format(pid=os.getpid())
-        self.target_netns = '/var/run/netns/{netns}'.format(netns=netns)
+        self.current_netns = f'/proc/{os.getpid()}/ns/net'
+        self.target_netns = f'/var/run/netns/{netns}'
         # reference: man setns(2)
         self.set_netns = ctypes.CDLL('libc.so.6', use_errno=True).setns
         self.set_netns.errcheck = self._error_handler