octavia 13.0.0.0rc1__py3-none-any.whl → 14.0.0__py3-none-any.whl

octavia/api/common/pagination.py

@@ -244,7 +244,7 @@ class PaginationHelper(object):
         :param query: the query object to which we should add
         paging/sorting/filtering
         :param model: the ORM model class
-        :param enforce_valid_params: check for invalid enteries in self.params
+        :param enforce_valid_params: check for invalid entries in self.params
 
         :rtype: sqlalchemy.orm.query.Query
         :returns: The query with sorting/pagination/filtering added.
@@ -259,7 +259,7 @@ class PaginationHelper(object):
             secondary_query_filter = filter_params.pop(
                 "project_id", None) if (model == models.Amphora) else None
 
-            # Tranlate arguments from API standard to data model's field name
+            # Translate arguments from API standard to data model's field name
             filter_params = (
                 model.__v2_wsme__.translate_dict_keys_to_data_model(
                     filter_params)

octavia/api/drivers/amphora_driver/flavor_schema.py

@@ -47,6 +47,11 @@ SUPPORTED_FLAVOR_SCHEMA = {
         consts.AMP_IMAGE_TAG: {
             "type": "string",
             "description": "The amphora image tag."
-        }
+        },
+        consts.SRIOV_VIP: {
+            "type": "boolean",
+            "description": "When true, the VIP port will be created using an "
+                           "SR-IOV VF port."
+        },
     }
 }

octavia/api/root_controller.py

@@ -146,6 +146,9 @@ class RootController(object):
         self._add_a_version(versions, 'v2.26', 'v2', 'SUPPORTED',
                             '2022-08-29T00:00:00Z', host_url)
         # HTTP Strict Transport Security (HSTS)
-        self._add_a_version(versions, 'v2.27', 'v2', 'CURRENT',
+        self._add_a_version(versions, 'v2.27', 'v2', 'SUPPORTED',
                             '2023-05-05T00:00:00Z', host_url)
+        # Add port vnic_type for SR-IOV
+        self._add_a_version(versions, 'v2.28', 'v2', 'CURRENT',
+                            '2023-11-08T00:00:00Z', host_url)
         return {'versions': versions}

octavia/api/v2/controllers/health_monitor.py

@@ -238,7 +238,6 @@ class HealthMonitorController(base.BaseController):
         context.session.begin()
         try:
             if self.repositories.check_quota_met(
-                    context.session,
                     context.session,
                     data_models.HealthMonitor,
                     health_monitor.project_id):

octavia/api/v2/controllers/l7policy.py

@@ -151,7 +151,6 @@ class L7PolicyController(base.BaseController):
         lock_session.begin()
         try:
             if self.repositories.check_quota_met(
-                    context.session,
                     lock_session,
                     data_models.L7Policy,
                     l7policy.project_id):

octavia/api/v2/controllers/l7rule.py

@@ -154,7 +154,6 @@ class L7RuleController(base.BaseController):
         context.session.begin()
         try:
             if self.repositories.check_quota_met(
-                    context.session,
                     context.session,
                     data_models.L7Rule,
                     l7rule.project_id):

octavia/api/v2/controllers/listener.py

@@ -372,7 +372,6 @@ class ListenersController(base.BaseController):
         context.session.begin()
         try:
             if self.repositories.check_quota_met(
-                    context.session,
                     context.session,
                     data_models.Listener,
                     listener.project_id):

octavia/api/v2/controllers/load_balancer.py

@@ -465,7 +465,6 @@ class LoadBalancersController(base.BaseController):
         lock_session.begin()
         try:
             if self.repositories.check_quota_met(
-                    context.session,
                     lock_session,
                     data_models.LoadBalancer,
                     load_balancer.project_id):
@@ -497,6 +496,13 @@ class LoadBalancersController(base.BaseController):
                 load_balancer.vip_network_id,
                 valid_networks=az_dict.get(constants.VALID_VIP_NETWORKS))
 
+            # Apply the anticipated vNIC type so the create will return the
+            # right vip_vnic_type
+            if flavor_dict and flavor_dict.get(constants.SRIOV_VIP, False):
+                vip_dict[constants.VNIC_TYPE] = constants.VNIC_TYPE_DIRECT
+            else:
+                vip_dict[constants.VNIC_TYPE] = constants.VNIC_TYPE_NORMAL
+
             db_lb = self.repositories.create_load_balancer_and_vip(
                 lock_session, lb_dict, vip_dict, additional_vip_dicts)
 
@@ -553,7 +559,7 @@ class LoadBalancersController(base.BaseController):
 
             if listeners or pools:
                 db_pools, db_lists = self._graph_create(
-                    context.session, lock_session, db_lb, listeners, pools)
+                    lock_session, db_lb, listeners, pools)
 
             # Prepare the data for the driver data model
             driver_lb_dict = driver_utils.lb_dict_to_provider_dict(
@@ -583,7 +589,7 @@ class LoadBalancersController(base.BaseController):
             db_lb, lb_types.LoadBalancerFullResponse)
         return lb_types.LoadBalancerFullRootResponse(loadbalancer=result)
 
-    def _graph_create(self, session, lock_session, db_lb, listeners, pools):
+    def _graph_create(self, session, db_lb, listeners, pools):
         # Track which pools must have a full specification
         pools_required = set()
         # Look through listeners and find any extra pools, and move them to the
@@ -642,7 +648,7 @@ class LoadBalancersController(base.BaseController):
 
         # Check quotas for pools.
         if pools and self.repositories.check_quota_met(
-                session, lock_session, data_models.Pool, db_lb.project_id,
+                session, data_models.Pool, db_lb.project_id,
                 count=len(pools)):
             raise exceptions.QuotaException(resource=data_models.Pool._name())
 
@@ -661,13 +667,13 @@ class LoadBalancersController(base.BaseController):
             p['load_balancer_id'] = db_lb.id
             p['project_id'] = db_lb.project_id
             new_pool = (pool.PoolsController()._graph_create(
-                session, lock_session, p))
+                session, p))
             new_pools.append(new_pool)
             pool_name_ids[new_pool.name] = new_pool.id
 
         # Now check quotas for listeners
         if listeners and self.repositories.check_quota_met(
-                session, lock_session, data_models.Listener, db_lb.project_id,
+                session, data_models.Listener, db_lb.project_id,
                 count=len(listeners)):
             raise exceptions.QuotaException(
                 resource=data_models.Listener._name())
@@ -687,7 +693,7 @@ class LoadBalancersController(base.BaseController):
             li['load_balancer_id'] = db_lb.id
             li['project_id'] = db_lb.project_id
             new_lists.append(listener.ListenersController()._graph_create(
-                lock_session, li, pool_name_ids=pool_name_ids))
+                session, li, pool_name_ids=pool_name_ids))
 
         return new_pools, new_lists
 

octavia/api/v2/controllers/member.py

@@ -165,7 +165,6 @@ class MemberController(base.BaseController):
         context.session.begin()
         try:
             if self.repositories.check_quota_met(
-                    context.session,
                     context.session,
                     data_models.Member,
                     member.project_id):
@@ -336,7 +335,6 @@ class MembersController(MemberController):
 
         with context.session.begin():
             db_pool = self._get_db_pool(context.session, self.pool_id)
-            old_members = db_pool.members
 
             project_id, provider = self._get_lb_project_id_provider(
                 context.session, db_pool.load_balancer_id)
@@ -354,6 +352,11 @@ class MembersController(MemberController):
         with context.session.begin():
             self._test_lb_and_listener_and_pool_statuses(context.session)
 
+            # Reload the pool, the members may have been updated between the
+            # first query in this function and the lock of the loadbalancer
+            db_pool = self._get_db_pool(context.session, self.pool_id)
+            old_members = db_pool.members
+
             old_member_uniques = {
                 (m.ip_address, m.protocol_port): m.id for m in old_members}
             new_member_uniques = [
@@ -387,7 +390,7 @@ class MembersController(MemberController):
             else:
                 member_count_diff = len(new_members) - len(deleted_members)
             if member_count_diff > 0 and self.repositories.check_quota_met(
-                    context.session, context.session, data_models.Member,
+                    context.session, data_models.Member,
                     db_pool.project_id, count=member_count_diff):
                 raise exceptions.QuotaException(
                     resource=data_models.Member._name())

octavia/api/v2/controllers/pool.py

@@ -260,7 +260,6 @@ class PoolsController(base.BaseController):
         context.session.begin()
         try:
             if self.repositories.check_quota_met(
-                    context.session,
                     context.session,
                     data_models.Pool,
                     pool.project_id):
@@ -304,18 +303,18 @@ class PoolsController(base.BaseController):
         result = self._convert_db_to_type(db_pool, pool_types.PoolResponse)
         return pool_types.PoolRootResponse(pool=result)
 
-    def _graph_create(self, session, lock_session, pool_dict):
+    def _graph_create(self, session, pool_dict):
         load_balancer_id = pool_dict['load_balancer_id']
         pool_dict = db_prepare.create_pool(
             pool_dict, load_balancer_id)
         members = pool_dict.pop('members', []) or []
         hm = pool_dict.pop('health_monitor', None)
         db_pool = self._validate_create_pool(
-            lock_session, pool_dict)
+            session, pool_dict)
 
         # Check quotas for healthmonitors
         if hm and self.repositories.check_quota_met(
-                session, lock_session, data_models.HealthMonitor,
+                session, data_models.HealthMonitor,
                 db_pool.project_id):
             raise exceptions.QuotaException(
                 resource=data_models.HealthMonitor._name())
@@ -325,7 +324,7 @@ class PoolsController(base.BaseController):
             hm[constants.POOL_ID] = db_pool.id
             hm[constants.PROJECT_ID] = db_pool.project_id
             new_hm = health_monitor.HealthMonitorController()._graph_create(
-                lock_session, hm)
+                session, hm)
             if db_pool.protocol in (constants.PROTOCOL_UDP,
                                     lib_consts.PROTOCOL_SCTP):
                 health_monitor.HealthMonitorController(
@@ -344,7 +343,7 @@ class PoolsController(base.BaseController):
 
         # Now check quotas for members
         if members and self.repositories.check_quota_met(
-                session, lock_session, data_models.Member,
+                session, data_models.Member,
                 db_pool.project_id, count=len(members)):
             raise exceptions.QuotaException(
                 resource=data_models.Member._name())
@@ -357,7 +356,7 @@ class PoolsController(base.BaseController):
             m['project_id'] = db_pool.project_id
             new_members.append(
                 member.MembersController(db_pool.id)._graph_create(
-                    lock_session, m))
+                    session, m))
         db_pool.members = new_members
         return db_pool
 

octavia/api/v2/types/load_balancer.py

@@ -25,13 +25,15 @@ class BaseLoadBalancerType(types.BaseType):
                           'vip_port_id': 'vip.port_id',
                           'vip_network_id': 'vip.network_id',
                           'vip_qos_policy_id': 'vip.qos_policy_id',
+                          'vip_vnic_type': 'vip.vnic_type',
                           'admin_state_up': 'enabled'}
     _child_map = {'vip': {
         'ip_address': 'vip_address',
         'subnet_id': 'vip_subnet_id',
         'port_id': 'vip_port_id',
         'network_id': 'vip_network_id',
-        'qos_policy_id': 'vip_qos_policy_id'}}
+        'qos_policy_id': 'vip_qos_policy_id',
+        'vnic_type': 'vip_vnic_type'}}
 
 
 class AdditionalVipsType(types.BaseType):
@@ -63,6 +65,7 @@ class LoadBalancerResponse(BaseLoadBalancerType):
     vip_qos_policy_id = wtypes.wsattr(wtypes.UuidType())
     tags = wtypes.wsattr(wtypes.ArrayType(wtypes.StringType()))
     availability_zone = wtypes.wsattr(wtypes.StringType())
+    vip_vnic_type = wtypes.wsattr(wtypes.StringType())
 
     @classmethod
     def from_data_model(cls, data_model, children=False):
@@ -74,6 +77,7 @@ class LoadBalancerResponse(BaseLoadBalancerType):
             result.vip_address = data_model.vip.ip_address
             result.vip_network_id = data_model.vip.network_id
             result.vip_qos_policy_id = data_model.vip.qos_policy_id
+            result.vip_vnic_type = data_model.vip.vnic_type
         result.additional_vips = [
             AdditionalVipsType.from_data_model(i)
             for i in data_model.additional_vips]

octavia/api/v2/types/pool.py

@@ -106,7 +106,7 @@ class PoolResponse(BasePoolType):
         if cls._full_response():
             del pool.loadbalancers
             member_model = member.MemberFullResponse
-            if pool.healthmonitor:
+            if data_model.health_monitor:
                 pool.healthmonitor = (
                     health_monitor.HealthMonitorFullResponse
                     .from_data_model(data_model.health_monitor))

octavia/certificates/common/pkcs12.py

@@ -18,7 +18,7 @@ Common classes for pkcs12 based certificate handling
 """
 
 from cryptography.hazmat.primitives import serialization
-from OpenSSL import crypto
+from cryptography.hazmat.primitives.serialization import pkcs12
 
 from octavia.certificates.common import cert
 from octavia.common import exceptions
@@ -28,21 +28,21 @@ class PKCS12Cert(cert.Cert):
     """Representation of a Cert for local storage."""
     def __init__(self, certbag):
         try:
-            p12 = crypto.load_pkcs12(certbag)
-        except crypto.Error as e:
+            p12 = pkcs12.load_pkcs12(certbag, None)
+        except (TypeError, ValueError) as e:
             raise exceptions.UnreadablePKCS12(error=str(e))
-        self.certificate = p12.get_certificate()
-        self.intermediates = p12.get_ca_certificates()
-        self.private_key = p12.get_privatekey()
+        self.certificate = p12.cert
+        self.intermediates = p12.additional_certs
+        self.private_key = p12.key
 
     def get_certificate(self):
-        return self.certificate.to_cryptography().public_bytes(
+        return self.certificate.certificate.public_bytes(
             encoding=serialization.Encoding.PEM).strip()
 
     def get_intermediates(self):
         if self.intermediates:
             int_data = [
-                ic.to_cryptography().public_bytes(
+                ic.certificate.public_bytes(
                     encoding=serialization.Encoding.PEM).strip()
                 for ic in self.intermediates
             ]
@@ -50,7 +50,7 @@ class PKCS12Cert(cert.Cert):
         return None
 
     def get_private_key(self):
-        return self.private_key.to_cryptography_key().private_bytes(
+        return self.private_key.private_bytes(
             encoding=serialization.Encoding.PEM,
             format=serialization.PrivateFormat.TraditionalOpenSSL,
             encryption_algorithm=serialization.NoEncryption()).strip()

octavia/certificates/manager/barbican.py

@@ -17,8 +17,9 @@
 """
 Cert manager implementation for Barbican using a single PKCS12 secret
 """
-from OpenSSL import crypto
-
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.serialization import pkcs12 as c_pkcs12
+from cryptography import x509
 from oslo_config import cfg
 from oslo_log import log as logging
 from oslo_utils import encodeutils
@@ -64,25 +65,29 @@ class BarbicanCertManager(cert_mgr.CertManager):
         connection = self.auth.get_barbican_client(context.project_id)
 
         LOG.info("Storing certificate secret '%s' in Barbican.", name)
-        p12 = crypto.PKCS12()
-        p12.set_friendlyname(encodeutils.to_utf8(name))
-        x509_cert = crypto.load_certificate(crypto.FILETYPE_PEM, certificate)
-        p12.set_certificate(x509_cert)
-        x509_pk = crypto.load_privatekey(crypto.FILETYPE_PEM, private_key)
-        p12.set_privatekey(x509_pk)
-        if intermediates:
-            cert_ints = list(cert_parser.get_intermediates_pems(intermediates))
-            x509_ints = [
-                crypto.load_certificate(crypto.FILETYPE_PEM, ci)
-                for ci in cert_ints]
-            p12.set_ca_certificates(x509_ints)
+
         if private_key_passphrase:
             raise exceptions.CertificateStorageException(
                 "Passphrase protected PKCS12 certificates are not supported.")
 
+        x509_cert = x509.load_pem_x509_certificate(certificate)
+        x509_pk = serialization.load_pem_private_key(private_key, None)
+        cas = None
+        if intermediates:
+            cert_ints = list(cert_parser.get_intermediates_pems(intermediates))
+            cas = [
+                x509.load_pem_x509_certificate(ci)
+                for ci in cert_ints]
+
         try:
             certificate_secret = connection.secrets.create(
-                payload=p12.export(),
+                payload=c_pkcs12.serialize_key_and_certificates(
+                    name=encodeutils.safe_encode(name),
+                    key=x509_pk,
+                    cert=x509_cert,
+                    cas=cas,
+                    encryption_algorithm=serialization.NoEncryption()
+                ),
                 expiration=expiration,
                 name=name
             )
@@ -115,7 +120,10 @@ class BarbicanCertManager(cert_mgr.CertManager):
             return pkcs12.PKCS12Cert(cert_secret.payload)
         except exceptions.UnreadablePKCS12:
             raise
-        except Exception:
+        except Exception as e:
+            LOG.warning('Failed to load PKCS12Cert for secret %s with %s',
+                        cert_ref, str(e))
+            LOG.warning('Falling back to the barbican_legacy implementation.')
             # If our get fails, try with the legacy driver.
             # TODO(rm_work): Remove this code when the deprecation cycle for
             # the legacy driver is complete.

octavia/certificates/manager/castellan_mgr.py

@@ -18,7 +18,8 @@ Cert manager implementation for Castellan
 """
 from castellan.common.objects import opaque_data
 from castellan import key_manager
-from OpenSSL import crypto
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.serialization import pkcs12 as c_pkcs12
 from oslo_config import cfg
 from oslo_log import log as logging
 
@@ -41,16 +42,20 @@ class CastellanCertManager(cert_mgr.CertManager):
     def store_cert(self, context, certificate, private_key, intermediates=None,
                    private_key_passphrase=None, expiration=None,
                    name="PKCS12 Certificate Bundle"):
-        p12 = crypto.PKCS12()
-        p12.set_certificate(certificate)
-        p12.set_privatekey(private_key)
-        if intermediates:
-            p12.set_ca_certificates(intermediates)
         if private_key_passphrase:
             raise exceptions.CertificateStorageException(
                 "Passphrases protected PKCS12 certificates are not supported.")
 
-        p12_data = opaque_data.OpaqueData(p12.export(), name=name)
+        p12_data = opaque_data.OpaqueData(
+            c_pkcs12.serialize_key_and_certificates(
+                name=None,
+                key=private_key,
+                cert=certificate,
+                cas=intermediates,
+                encryption_algorithm=serialization.NoEncryption()
+            ),
+            name=name
+        )
         self.manager.store(context, p12_data)
 
     def get_cert(self, context, cert_ref, resource_ref=None, check_only=False,

octavia/certificates/manager/local.py

@@ -50,9 +50,9 @@ class LocalCertManager(cert_mgr.CertManager):
         """
         cert_ref = str(uuid.uuid4())
         filename_base = os.path.join(CONF.certificates.storage_path, cert_ref)
-        if type(certificate) == bytes:
+        if isinstance(certificate, bytes):
             certificate = certificate.decode('utf-8')
-        if type(private_key) == bytes:
+        if isinstance(private_key, bytes):
             private_key = private_key.decode('utf-8')
 
         LOG.info("Storing certificate data on the local filesystem.")
@@ -71,7 +71,7 @@ class LocalCertManager(cert_mgr.CertManager):
 
             if intermediates:
                 filename_intermediates = "{0}.int".format(filename_base)
-                if type(intermediates) == bytes:
+                if isinstance(intermediates, bytes):
                     intermediates = intermediates.decode('utf-8')
                 with os.fdopen(os.open(
                         filename_intermediates, flags, mode), 'w') as int_file:
@@ -79,7 +79,7 @@ class LocalCertManager(cert_mgr.CertManager):
 
             if private_key_passphrase:
                 filename_pkp = "{0}.pass".format(filename_base)
-                if type(private_key_passphrase) == bytes:
+                if isinstance(private_key_passphrase, bytes):
                     private_key_passphrase = private_key_passphrase.decode(
                         'utf-8')
                 with os.fdopen(os.open(

octavia/certificates/manager/noop.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2023 Red Hat
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+import uuid
+
+from oslo_log import log as logging
+
+from octavia.certificates.common import cert
+from octavia.certificates.common import local
+from octavia.certificates.manager import cert_mgr
+from octavia.common.tls_utils import cert_parser
+from octavia.tests.common import sample_certs
+
+LOG = logging.getLogger(__name__)
+
+
+class NoopCertManager(cert_mgr.CertManager):
+    """Cert manager implementation for no-op operations
+
+    """
+    def __init__(self):
+        super().__init__()
+        self._local_cert = None
+
+    @property
+    def local_cert(self):
+        if self._local_cert is None:
+            self._local_cert = self.store_cert(
+                None,
+                sample_certs.X509_CERT,
+                sample_certs.X509_CERT_KEY_ENCRYPTED,
+                sample_certs.X509_IMDS,
+                private_key_passphrase=sample_certs.X509_CERT_KEY_PASSPHRASE)
+        return self._local_cert
+
+    def store_cert(self, context, certificate, private_key, intermediates=None,
+                   private_key_passphrase=None, **kwargs) -> cert.Cert:
+        """Stores (i.e., registers) a cert with the cert manager.
+
+        This method stores the specified cert to the filesystem and returns
+        a UUID that can be used to retrieve it.
+
+        :param context: Ignored in this implementation
+        :param certificate: PEM encoded TLS certificate
+        :param private_key: private key for the supplied certificate
+        :param intermediates: ordered and concatenated intermediate certs
+        :param private_key_passphrase: optional passphrase for the supplied key
+
+        :returns: the UUID of the stored cert
+        :raises CertificateStorageException: if certificate storage fails
+        """
+        cert_ref = str(uuid.uuid4())
+        if isinstance(certificate, bytes):
+            certificate = certificate.decode('utf-8')
+        if isinstance(private_key, bytes):
+            private_key = private_key.decode('utf-8')
+
+        LOG.debug('Driver %s no-op, store_cert certificate %s, cert_ref %s',
+                  self.__class__.__name__, certificate, cert_ref)
+
+        cert_data = {'certificate': certificate, 'private_key': private_key}
+        if intermediates:
+            if isinstance(intermediates, bytes):
+                intermediates = intermediates.decode('utf-8')
+            cert_data['intermediates'] = list(
+                cert_parser.get_intermediates_pems(intermediates))
+        if private_key_passphrase:
+            if isinstance(private_key_passphrase, bytes):
+                private_key_passphrase = private_key_passphrase.decode('utf-8')
+            cert_data['private_key_passphrase'] = private_key_passphrase
+
+        return local.LocalCert(**cert_data)
+
+    def get_cert(self, context, cert_ref, check_only=True, **kwargs) -> (
+            cert.Cert):
+        LOG.debug('Driver %s no-op, get_cert with cert_ref %s',
+                  self.__class__.__name__, cert_ref)
+        return self.local_cert
+
+    def delete_cert(self, context, cert_ref, resource_ref, service_name=None):
+        LOG.debug('Driver %s no-op, delete_cert with cert_ref %s',
+                  self.__class__.__name__, cert_ref)
+
+    def set_acls(self, context, cert_ref):
+        LOG.debug('Driver %s no-op, set_acls with cert_ref %s',
+                  self.__class__.__name__, cert_ref)
+
+    def unset_acls(self, context, cert_ref):
+        LOG.debug('Driver %s no-op, unset_acls with cert_ref %s',
+                  self.__class__.__name__, cert_ref)
+
+    def get_secret(self, context, secret_ref) -> cert.Cert:
+        LOG.debug('Driver %s no-op, get_secret with secret_ref %s',
+                  self.__class__.__name__, secret_ref)
+        return self.local_cert

octavia/cmd/driver_agent.py

@@ -155,7 +155,7 @@ def main():
                             'ignoring and continuing shutdown process.',
                             str(e), proc.name)
             else:
-                LOG.info('Provider agent "%s" has succesfully shutdown.',
+                LOG.info('Provider agent "%s" has successfully shutdown.',
                          proc.name)
 
     signal.signal(signal.SIGTERM, process_cleanup)

octavia/cmd/health_checker.py

@@ -262,7 +262,3 @@ def main():
     else:
         print("Unsupported protocol '{}'".format(protocol))
         sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()

octavia/cmd/health_manager.py

@@ -78,7 +78,7 @@ def hm_health_check(exit_event):
 
 
 def _handle_mutate_config(listener_proc_pid, check_proc_pid, *args, **kwargs):
-    LOG.info("Health Manager recieved HUP signal, mutating config.")
+    LOG.info("Health Manager received HUP signal, mutating config.")
     _mutate_config()
     os.kill(listener_proc_pid, signal.SIGHUP)
     os.kill(check_proc_pid, signal.SIGHUP)
@@ -125,7 +125,3 @@ def main():
             process.join()
     except KeyboardInterrupt:
         process_cleanup()
-
-
-if __name__ == "__main__":
-    main()

octavia/cmd/house_keeping.py

@@ -72,7 +72,7 @@ def cert_rotation():
 
 
 def _mutate_config(*args, **kwargs):
-    LOG.info("Housekeeping recieved HUP signal, mutating config.")
+    LOG.info("Housekeeping received HUP signal, mutating config.")
     CONF.mutate_config_files()
 
 

octavia/cmd/interface.py

@@ -84,7 +84,3 @@ def main():
     except Exception as e:
         print("Error: {}".format(e))
         sys.exit(2)
-
-
-if __name__ == "__main__":
-    main()

octavia/cmd/octavia_worker.py

@@ -36,7 +36,3 @@ def main():
            workers=CONF.controller_worker.workers, args=(CONF,))
     oslo_config_glue.setup(sm, CONF, reload_method="mutate")
     sm.run()
-
-
-if __name__ == "__main__":
-    main()

octavia/cmd/prometheus_proxy.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 #    Copyright 2022 Red Hat
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -810,7 +809,3 @@ def main():
                 httpd.serve_forever()
         except Exception:
             time.sleep(1)
-
-
-if __name__ == "__main__":
-    main()