octavia 14.0.0__py3-none-any.whl → 15.0.0__py3-none-any.whl

octavia/amphorae/backends/agent/agent_jinja_cfg.py

@@ -25,7 +25,7 @@ TEMPLATES_DIR = (os.path.dirname(os.path.realpath(__file__)) +
                  constants.AGENT_API_TEMPLATES + '/')
 
 
-class AgentJinjaTemplater(object):
+class AgentJinjaTemplater:
 
     def __init__(self):
         template_loader = jinja2.FileSystemLoader(searchpath=os.path.dirname(
@@ -52,9 +52,6 @@ class AgentJinjaTemplater(object):
              'haproxy_cmd': CONF.haproxy_amphora.haproxy_cmd,
              'heartbeat_interval': CONF.health_manager.heartbeat_interval,
              'heartbeat_key': CONF.health_manager.heartbeat_key,
-             'use_upstart': CONF.haproxy_amphora.use_upstart,
-             'respawn_count': CONF.haproxy_amphora.respawn_count,
-             'respawn_interval': CONF.haproxy_amphora.respawn_interval,
              'amphora_udp_driver': CONF.amphora_agent.amphora_udp_driver,
              'agent_tls_protocol': CONF.amphora_agent.agent_tls_protocol,
              'topology': topology,

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

@@ -30,7 +30,7 @@ from octavia.common import exceptions
 LOG = logging.getLogger(__name__)
 
 
-class AmphoraInfo(object):
+class AmphoraInfo:
     def __init__(self, osutils):
         self._osutils = osutils
 
@@ -105,7 +105,7 @@ class AmphoraInfo(object):
     def _get_version_of_installed_package(self, name):
 
         cmd = self._osutils.cmd_get_version_of_installed_package(name)
-        version = subprocess.check_output(cmd.split())
+        version = subprocess.check_output(cmd.split(), encoding='utf-8')
         return version
 
     def _count_haproxy_processes(self, lb_list):
@@ -129,13 +129,13 @@ class AmphoraInfo(object):
         extend_data = {}
         for extend in extend_info:
             package_version = self._get_version_of_installed_package(extend)
-            extend_data['%s_version' % extend] = package_version
+            extend_data[f'{extend}_version'] = package_version
         return extend_data
 
     def _get_meminfo(self):
         re_parser = re.compile(r'^(?P<key>\S*):\s*(?P<value>\d*)\s*kB')
         result = {}
-        with open('/proc/meminfo', 'r', encoding='utf-8') as meminfo:
+        with open('/proc/meminfo', encoding='utf-8') as meminfo:
             for line in meminfo:
                 match = re_parser.match(line)
                 if not match:
@@ -199,7 +199,7 @@ class AmphoraInfo(object):
     def _get_active_tuned_profiles(self) -> str:
         """Returns the active TuneD profile(s)"""
         try:
-            with open("/etc/tuned/active_profile", "r", encoding="utf-8") as f:
+            with open("/etc/tuned/active_profile", encoding="utf-8") as f:
                 return f.read(1024).strip()
         except OSError as ex:
             LOG.debug("Reading active TuneD profiles failed: %r", ex)

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

@@ -34,13 +34,11 @@ LOG = logging.getLogger(__name__)
 
 j2_env = jinja2.Environment(autoescape=True, loader=jinja2.FileSystemLoader(
     os.path.dirname(os.path.realpath(__file__)) + consts.AGENT_API_TEMPLATES))
-UPSTART_TEMPLATE = j2_env.get_template(consts.KEEPALIVED_JINJA2_UPSTART)
-SYSVINIT_TEMPLATE = j2_env.get_template(consts.KEEPALIVED_JINJA2_SYSVINIT)
 SYSTEMD_TEMPLATE = j2_env.get_template(consts.KEEPALIVED_JINJA2_SYSTEMD)
 check_script_template = j2_env.get_template(consts.CHECK_SCRIPT_CONF)
 
 
-class Keepalived(object):
+class Keepalived:
 
     def upload_keepalived_config(self):
         stream = loadbalancer.Wrapped(flask.request.stream)
@@ -60,33 +58,17 @@ class Keepalived(object):
                 f.write(b)
                 b = stream.read(BUFFER)
 
-        init_system = util.get_os_init_system()
-
-        file_path = util.keepalived_init_path(init_system)
-
-        if init_system == consts.INIT_SYSTEMD:
-            template = SYSTEMD_TEMPLATE
-            init_enable_cmd = "systemctl enable octavia-keepalived"
-
-            # Render and install the network namespace systemd service
-            util.install_netns_systemd_service()
-            util.run_systemctl_command(
-                consts.ENABLE, consts.AMP_NETNS_SVC_PREFIX)
-        elif init_system == consts.INIT_UPSTART:
-            template = UPSTART_TEMPLATE
-        elif init_system == consts.INIT_SYSVINIT:
-            template = SYSVINIT_TEMPLATE
-            init_enable_cmd = "insserv {file}".format(file=file_path)
-        else:
-            raise util.UnknownInitError()
-
-        if init_system == consts.INIT_SYSTEMD:
-            # mode 00644
-            mode = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
-        else:
-            # mode 00755
-            mode = (stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
-                    stat.S_IROTH | stat.S_IXOTH)
+        file_path = util.keepalived_init_path()
+
+        template = SYSTEMD_TEMPLATE
+
+        # Render and install the network namespace systemd service
+        util.install_netns_systemd_service()
+        util.run_systemctl_command(
+            consts.ENABLE, consts.AMP_NETNS_SVC_PREFIX, False)
+
+        # mode 00644
+        mode = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
         if not os.path.exists(file_path):
             with os.fdopen(os.open(file_path, flags, mode), 'w') as text_file:
                 text = template.render(
@@ -117,16 +99,13 @@ class Keepalived(object):
         util.vrrp_check_script_update(None, consts.AMP_ACTION_START)
 
         # Make sure the new service is enabled on boot
-        if init_system != consts.INIT_UPSTART:
-            try:
-                subprocess.check_output(init_enable_cmd.split(),
-                                        stderr=subprocess.STDOUT)
-            except subprocess.CalledProcessError as e:
-                LOG.debug('Failed to enable octavia-keepalived service: '
-                          '%(err)s %(output)s', {'err': e, 'output': e.output})
-                return webob.Response(json={
-                    'message': "Error enabling octavia-keepalived service",
-                    'details': e.output}, status=500)
+        try:
+            util.run_systemctl_command(consts.ENABLE,
+                                       consts.KEEPALIVED_SYSTEMD)
+        except subprocess.CalledProcessError as e:
+            return webob.Response(json={
+                'message': "Error enabling octavia-keepalived service",
+                'details': e.output}, status=500)
 
         res = webob.Response(json={'message': 'OK'}, status=200)
         res.headers['ETag'] = stream.get_md5()
@@ -140,37 +119,31 @@ class Keepalived(object):
                           consts.AMP_ACTION_RELOAD]:
             return webob.Response(json={
                 'message': 'Invalid Request',
-                'details': "Unknown action: {0}".format(action)}, status=400)
+                'details': f"Unknown action: {action}"}, status=400)
 
         if action == consts.AMP_ACTION_START:
             keepalived_pid_path = util.keepalived_pid_path()
             try:
                 # 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)
 
                 # If we got here, it means the keepalived process is running.
                 # We should reload it instead of trying to start it again.
                 action = consts.AMP_ACTION_RELOAD
-            except (IOError, OSError):
+            except OSError:
                 pass
 
-        cmd = ("/usr/sbin/service octavia-keepalived {action}".format(
-            action=action))
-
         try:
-            subprocess.check_output(cmd.split(), stderr=subprocess.STDOUT)
+            util.run_systemctl_command(action,
+                                       consts.KEEPALIVED_SYSTEMD)
         except subprocess.CalledProcessError as e:
-            LOG.debug('Failed to %s octavia-keepalived service: %s %s',
-                      action, e, e.output)
             return webob.Response(json={
-                'message': "Failed to {0} octavia-keepalived service".format(
-                    action),
+                'message': f"Failed to {action} octavia-keepalived service",
                 'details': e.output}, status=500)
 
         return webob.Response(
             json={'message': 'OK',
-                  'details': 'keepalived {action}ed'.format(action=action)},
+                  'details': f'keepalived {action}ed'},
             status=202)

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

@@ -38,8 +38,6 @@ LOG = logging.getLogger(__name__)
 
 j2_env = jinja2.Environment(autoescape=True, loader=jinja2.FileSystemLoader(
     os.path.dirname(os.path.realpath(__file__)) + consts.AGENT_API_TEMPLATES))
-UPSTART_TEMPLATE = j2_env.get_template(consts.KEEPALIVED_JINJA2_UPSTART)
-SYSVINIT_TEMPLATE = j2_env.get_template(consts.KEEPALIVED_JINJA2_SYSVINIT)
 SYSTEMD_TEMPLATE = j2_env.get_template(consts.KEEPALIVED_JINJA2_SYSTEMD)
 check_script_file_template = j2_env.get_template(
     consts.KEEPALIVED_CHECK_SCRIPT)
@@ -92,32 +90,18 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
                 f.write(b)
                 b = stream.read(BUFFER)
 
-        init_system = util.get_os_init_system()
+        file_path = util.keepalived_lvs_init_path(listener_id)
 
-        file_path = util.keepalived_lvs_init_path(init_system, listener_id)
+        template = SYSTEMD_TEMPLATE
 
-        if init_system == consts.INIT_SYSTEMD:
-            template = SYSTEMD_TEMPLATE
-
-            # Render and install the network namespace systemd service
-            util.install_netns_systemd_service()
-            util.run_systemctl_command(
-                consts.ENABLE, consts.AMP_NETNS_SVC_PREFIX)
-        elif init_system == consts.INIT_UPSTART:
-            template = UPSTART_TEMPLATE
-        elif init_system == consts.INIT_SYSVINIT:
-            template = SYSVINIT_TEMPLATE
-        else:
-            raise util.UnknownInitError()
+        # Render and install the network namespace systemd service
+        util.install_netns_systemd_service()
+        util.run_systemctl_command(
+            consts.ENABLE, consts.AMP_NETNS_SVC_PREFIX, False)
 
         # Render and install the keepalivedlvs init script
-        if init_system == consts.INIT_SYSTEMD:
-            # mode 00644
-            mode = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
-        else:
-            # mode 00755
-            mode = (stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
-                    stat.S_IROTH | stat.S_IXOTH)
+        # mode 00644
+        mode = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
         keepalived_pid, vrrp_pid, check_pid = util.keepalived_lvs_pids_path(
             listener_id)
         if not os.path.exists(file_path):
@@ -136,22 +120,15 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
                 text_file.write(text)
 
         # Make sure the keepalivedlvs service is enabled on boot
-        if init_system == consts.INIT_SYSTEMD:
+        try:
             util.run_systemctl_command(
-                consts.ENABLE, "octavia-keepalivedlvs-%s" % str(listener_id))
-        elif init_system == consts.INIT_SYSVINIT:
-            init_enable_cmd = "insserv {file}".format(file=file_path)
-            try:
-                subprocess.check_output(init_enable_cmd.split(),
-                                        stderr=subprocess.STDOUT)
-            except subprocess.CalledProcessError as e:
-                LOG.debug('Failed to enable '
-                          'octavia-keepalivedlvs service: '
-                          '%(err)s', {'err': str(e)})
-                return webob.Response(json={
-                    'message': ("Error enabling "
-                                "octavia-keepalivedlvs service"),
-                    'details': e.output}, status=500)
+                consts.ENABLE,
+                consts.KEEPALIVEDLVS_SYSTEMD % listener_id)
+        except subprocess.CalledProcessError as e:
+            return webob.Response(json={
+                'message': ("Error enabling "
+                            "octavia-keepalivedlvs service"),
+                'details': e.output}, status=500)
 
         if NEED_CHECK:
             # inject the check script for keepalived process
@@ -165,7 +142,6 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
                                'w') as script_file:
                     text = check_script_file_template.render(
                         consts=consts,
-                        init_system=init_system,
                         keepalived_lvs_pid_dir=util.keepalived_lvs_dir()
                     )
                     script_file.write(text)
@@ -180,8 +156,8 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
             raise exceptions.HTTPException(
                 response=webob.Response(json={
                     'message': 'UDP Listener Not Found',
-                    'details': "No UDP listener with UUID: {0}".format(
-                        listener_id)}, status=404))
+                    'details': f"No UDP listener with UUID: {listener_id}"},
+                    status=404))
 
     def get_lvs_listener_config(self, listener_id):
         """Gets the keepalivedlvs config
@@ -190,7 +166,7 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
         """
         self._check_lvs_listener_exists(listener_id)
         with open(util.keepalived_lvs_cfg_path(listener_id),
-                  'r', encoding='utf-8') as file:
+                  encoding='utf-8') as file:
             cfg = file.read()
             resp = webob.Response(cfg, content_type='text/plain')
             return resp
@@ -202,7 +178,7 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
                           consts.AMP_ACTION_RELOAD]:
             return webob.Response(json={
                 'message': 'Invalid Request',
-                'details': "Unknown action: {0}".format(action)}, status=400)
+                'details': f"Unknown action: {action}"}, status=400)
 
         # When octavia requests a reload of keepalived, force a restart since
         # a keepalived reload doesn't restore members in their initial state.
@@ -216,25 +192,19 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
             if consts.OFFLINE == self._check_lvs_listener_status(listener_id):
                 action = consts.AMP_ACTION_START
 
-        cmd = ("/usr/sbin/service "
-               "octavia-keepalivedlvs-{listener_id} "
-               "{action}".format(listener_id=listener_id, action=action))
-
         try:
-            subprocess.check_output(cmd.split(), stderr=subprocess.STDOUT)
+            util.run_systemctl_command(
+                action, consts.KEEPALIVEDLVS_SYSTEMD % listener_id)
         except subprocess.CalledProcessError as e:
-            LOG.debug('Failed to %s keepalivedlvs listener %s',
-                      listener_id + ' : ' + action, str(e))
             return webob.Response(json={
-                'message': ("Failed to {0} keepalivedlvs listener {1}"
-                            .format(action, listener_id)),
+                'message': (f"Failed to {action} keepalivedlvs listener "
+                            f"{listener_id}"),
                 'details': e.output}, status=500)
 
         return webob.Response(
             json={'message': 'OK',
-                  'details': 'keepalivedlvs listener {listener_id} '
-                             '{action}ed'.format(listener_id=listener_id,
-                                                 action=action)},
+                  'details': (f'keepalivedlvs listener {listener_id} '
+                              f'{action}ed')},
             status=202)
 
     def _check_lvs_listener_status(self, listener_id):
@@ -243,7 +213,7 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
                     '/proc', util.get_keepalivedlvs_pid(listener_id))):
                 # Check if the listener is disabled
                 with open(util.keepalived_lvs_cfg_path(listener_id),
-                          'r', encoding='utf-8') as file:
+                          encoding='utf-8') as file:
                     cfg = file.read()
                     m = re.search('virtual_server', cfg)
                     if m:
@@ -280,12 +250,12 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
         if os.path.exists(keepalived_pid) and os.path.exists(
                 os.path.join('/proc',
                              util.get_keepalivedlvs_pid(listener_id))):
-            cmd = ("/usr/sbin/service "
-                   "octavia-keepalivedlvs-{0} stop".format(listener_id))
             try:
-                subprocess.check_output(cmd.split(), stderr=subprocess.STDOUT)
+                util.run_systemctl_command(
+                    consts.STOP,
+                    consts.KEEPALIVEDLVS_SYSTEMD % listener_id)
             except subprocess.CalledProcessError as e:
-                LOG.error("Failed to stop keepalivedlvs service: %s", str(e))
+                LOG.error("Failed to stop keepalivedlvs service: %s", e)
                 return webob.Response(json={
                     'message': "Error stopping keepalivedlvs",
                     'details': e.output}, status=500)
@@ -300,30 +270,21 @@ class KeepalivedLvs(lvs_listener_base.LvsListenerApiServerBase):
                 os.remove(pid)
 
         # disable the service
-        init_system = util.get_os_init_system()
-        init_path = util.keepalived_lvs_init_path(init_system, listener_id)
+        init_path = util.keepalived_lvs_init_path(listener_id)
 
-        if init_system == consts.INIT_SYSTEMD:
+        try:
             util.run_systemctl_command(
-                consts.DISABLE, "octavia-keepalivedlvs-%s" % str(listener_id))
-        elif init_system == consts.INIT_SYSVINIT:
-            init_disable_cmd = "insserv -r {file}".format(file=init_path)
-        elif init_system != consts.INIT_UPSTART:
-            raise util.UnknownInitError()
-
-        if init_system == consts.INIT_SYSVINIT:
-            try:
-                subprocess.check_output(init_disable_cmd.split(),
-                                        stderr=subprocess.STDOUT)
-            except subprocess.CalledProcessError as e:
-                LOG.error("Failed to disable "
-                          "octavia-keepalivedlvs-%(list)s service: "
-                          "%(err)s", {'list': listener_id, 'err': str(e)})
-                return webob.Response(json={
-                    'message': (
-                        "Error disabling octavia-keepalivedlvs-"
-                        "{0} service".format(listener_id)),
-                    'details': e.output}, status=500)
+                consts.DISABLE,
+                consts.KEEPALIVEDLVS_SYSTEMD % listener_id)
+        except subprocess.CalledProcessError as e:
+            LOG.error("Failed to disable "
+                      "octavia-keepalivedlvs-%(list)s service: "
+                      "%(err)s", {'list': listener_id, 'err': str(e)})
+            return webob.Response(json={
+                'message': (
+                    f"Error disabling octavia-keepalivedlvs-{listener_id} "
+                    "service"),
+                'details': e.output}, status=500)
 
         # delete init script ,config file and log file for that listener
         if os.path.exists(init_path):