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

octavia/api/v2/controllers/pool.py

@@ -34,7 +34,6 @@ from octavia.common import constants
 from octavia.common import data_models
 from octavia.common import exceptions
 from octavia.common import validate
-from octavia.db import api as db_api
 from octavia.db import prepare as db_prepare
 from octavia.i18n import _
 
@@ -54,7 +53,9 @@ class PoolsController(base.BaseController):
     def get(self, id, fields=None):
         """Gets a pool's details."""
         context = pecan_request.context.get('octavia_context')
-        db_pool = self._get_db_pool(context.session, id, show_deleted=False)
+        with context.session.begin():
+            db_pool = self._get_db_pool(context.session, id,
+                                        show_deleted=False)
 
         self._auth_validate_action(context, db_pool.project_id,
                                    constants.RBAC_GET_ONE)
@@ -73,10 +74,11 @@ class PoolsController(base.BaseController):
 
         query_filter = self._auth_get_all(context, project_id)
 
-        db_pools, links = self.repositories.pool.get_all_API_list(
-            context.session, show_deleted=False,
-            pagination_helper=pcontext.get(constants.PAGINATION_HELPER),
-            **query_filter)
+        with context.session.begin():
+            db_pools, links = self.repositories.pool.get_all_API_list(
+                context.session, show_deleted=False,
+                pagination_helper=pcontext.get(constants.PAGINATION_HELPER),
+                **query_filter)
         result = self._convert_db_to_type(db_pools, [pool_types.PoolResponse])
         if fields is not None:
             result = self._filter_fields(result, fields)
@@ -141,9 +143,11 @@ class PoolsController(base.BaseController):
             validate.check_alpn_protocols(pool_dict['alpn_protocols'])
 
         try:
-            return self.repositories.create_pool_on_load_balancer(
+            ret = self.repositories.create_pool_on_load_balancer(
                 lock_session, pool_dict,
                 listener_id=listener_id)
+            lock_session.flush()
+            return ret
         except odb_exceptions.DBDuplicateEntry as e:
             raise exceptions.IDAlreadyExists() from e
         except odb_exceptions.DBReferenceError as e:
@@ -211,19 +215,20 @@ class PoolsController(base.BaseController):
         pool = pool_.pool
         context = pecan_request.context.get('octavia_context')
         listener = None
-        if pool.loadbalancer_id:
-            pool.project_id, provider = self._get_lb_project_id_provider(
-                context.session, pool.loadbalancer_id)
-        elif pool.listener_id:
-            listener = self.repositories.listener.get(
-                context.session, id=pool.listener_id)
-            pool.loadbalancer_id = listener.load_balancer_id
-            pool.project_id, provider = self._get_lb_project_id_provider(
-                context.session, pool.loadbalancer_id)
-        else:
-            msg = _("Must provide at least one of: "
-                    "loadbalancer_id, listener_id")
-            raise exceptions.ValidationException(detail=msg)
+        with context.session.begin():
+            if pool.loadbalancer_id:
+                pool.project_id, provider = self._get_lb_project_id_provider(
+                    context.session, pool.loadbalancer_id)
+            elif pool.listener_id:
+                listener = self.repositories.listener.get(
+                    context.session, id=pool.listener_id)
+                pool.loadbalancer_id = listener.load_balancer_id
+                pool.project_id, provider = self._get_lb_project_id_provider(
+                    context.session, pool.loadbalancer_id)
+            else:
+                msg = _("Must provide at least one of: "
+                        "loadbalancer_id, listener_id")
+                raise exceptions.ValidationException(detail=msg)
 
         self._auth_validate_action(context, pool.project_id,
                                    constants.RBAC_POST)
@@ -252,11 +257,11 @@ class PoolsController(base.BaseController):
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             if self.repositories.check_quota_met(
                     context.session,
-                    lock_session,
+                    context.session,
                     data_models.Pool,
                     pool.project_id):
                 raise exceptions.QuotaException(
@@ -268,16 +273,16 @@ class PoolsController(base.BaseController):
 
             listener_id = pool_dict.pop('listener_id', None)
             if listener_id:
-                if listener_repo.has_default_pool(lock_session,
+                if listener_repo.has_default_pool(context.session,
                                                   listener_id):
                     raise exceptions.DuplicatePoolEntry()
 
             self._test_lb_and_listener_statuses(
-                lock_session, lb_id=pool_dict['load_balancer_id'],
+                context.session, lb_id=pool_dict['load_balancer_id'],
                 listener_ids=[listener_id] if listener_id else [])
 
             db_pool = self._validate_create_pool(
-                lock_session, pool_dict, listener_id)
+                context.session, pool_dict, listener_id)
 
             # Prepare the data for the driver data model
             provider_pool = (
@@ -289,12 +294,13 @@ class PoolsController(base.BaseController):
             driver_utils.call_provider(
                 driver.name, driver.pool_create, provider_pool)
 
-            lock_session.commit()
+            context.session.commit()
         except Exception:
             with excutils.save_and_reraise_exception():
-                lock_session.rollback()
+                context.session.rollback()
 
-        db_pool = self._get_db_pool(context.session, db_pool.id)
+        with context.session.begin():
+            db_pool = self._get_db_pool(context.session, db_pool.id)
         result = self._convert_db_to_type(db_pool, pool_types.PoolResponse)
         return pool_types.PoolRootResponse(pool=result)
 
@@ -435,10 +441,12 @@ class PoolsController(base.BaseController):
         """Updates a pool on a load balancer."""
         pool = pool_.pool
         context = pecan_request.context.get('octavia_context')
-        db_pool = self._get_db_pool(context.session, id, show_deleted=False)
+        with context.session.begin():
+            db_pool = self._get_db_pool(context.session, id,
+                                        show_deleted=False)
 
-        project_id, provider = self._get_lb_project_id_provider(
-            context.session, db_pool.load_balancer_id)
+            project_id, provider = self._get_lb_project_id_provider(
+                context.session, db_pool.load_balancer_id)
 
         self._auth_validate_action(context, project_id, constants.RBAC_PUT)
 
@@ -458,9 +466,9 @@ class PoolsController(base.BaseController):
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        with db_api.get_lock_session() as lock_session:
+        with context.session.begin():
             self._test_lb_and_listener_statuses(
-                lock_session, lb_id=db_pool.load_balancer_id,
+                context.session, lb_id=db_pool.load_balancer_id,
                 listener_ids=self._get_affected_listener_ids(db_pool))
 
             # Prepare the data for the driver data model
@@ -483,13 +491,14 @@ class PoolsController(base.BaseController):
             # Update the database to reflect what the driver just accepted
             pool.provisioning_status = constants.PENDING_UPDATE
             db_pool_dict = pool.to_dict(render_unsets=False)
-            self.repositories.update_pool_and_sp(lock_session, id,
+            self.repositories.update_pool_and_sp(context.session, id,
                                                  db_pool_dict)
 
         # Force SQL alchemy to query the DB, otherwise we get inconsistent
         # results
         context.session.expire_all()
-        db_pool = self._get_db_pool(context.session, id)
+        with context.session.begin():
+            db_pool = self._get_db_pool(context.session, id)
         result = self._convert_db_to_type(db_pool, pool_types.PoolResponse)
         return pool_types.PoolRootResponse(pool=result)
 
@@ -497,10 +506,12 @@ class PoolsController(base.BaseController):
     def delete(self, id):
         """Deletes a pool from a load balancer."""
         context = pecan_request.context.get('octavia_context')
-        db_pool = self._get_db_pool(context.session, id, show_deleted=False)
+        with context.session.begin():
+            db_pool = self._get_db_pool(context.session, id,
+                                        show_deleted=False)
 
-        project_id, provider = self._get_lb_project_id_provider(
-            context.session, db_pool.load_balancer_id)
+            project_id, provider = self._get_lb_project_id_provider(
+                context.session, db_pool.load_balancer_id)
 
         self._auth_validate_action(context, project_id, constants.RBAC_DELETE)
 
@@ -511,12 +522,12 @@ class PoolsController(base.BaseController):
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        with db_api.get_lock_session() as lock_session:
+        with context.session.begin():
             self._test_lb_and_listener_statuses(
-                lock_session, lb_id=db_pool.load_balancer_id,
+                context.session, lb_id=db_pool.load_balancer_id,
                 listener_ids=self._get_affected_listener_ids(db_pool))
             self.repositories.pool.update(
-                lock_session, db_pool.id,
+                context.session, db_pool.id,
                 provisioning_status=constants.PENDING_DELETE)
 
             LOG.info("Sending delete Pool %s to provider %s", id, driver.name)
@@ -536,7 +547,9 @@ class PoolsController(base.BaseController):
         context = pecan_request.context.get('octavia_context')
         if pool_id and remainder and remainder[0] == 'members':
             remainder = remainder[1:]
-            db_pool = self.repositories.pool.get(context.session, id=pool_id)
+            with context.session.begin():
+                db_pool = self.repositories.pool.get(context.session,
+                                                     id=pool_id)
             if not db_pool:
                 LOG.info("Pool %s not found.", pool_id)
                 raise exceptions.NotFound(resource=data_models.Pool._name(),

octavia/api/v2/controllers/quotas.py

@@ -72,8 +72,9 @@ class QuotasController(base.BaseController):
         self._auth_validate_action(context, project_id, constants.RBAC_PUT)
 
         quotas_dict = quotas.to_dict()
-        self.repositories.quotas.update(context.session, project_id,
-                                        **quotas_dict)
+        with context.session.begin():
+            self.repositories.quotas.update(context.session, project_id,
+                                            **quotas_dict)
         db_quotas = self._get_db_quotas(context.session, project_id)
         return self._convert_db_to_type(db_quotas, quota_types.QuotaResponse)
 
@@ -87,7 +88,8 @@ class QuotasController(base.BaseController):
 
         self._auth_validate_action(context, project_id, constants.RBAC_DELETE)
 
-        self.repositories.quotas.delete(context.session, project_id)
+        with context.session.begin():
+            self.repositories.quotas.delete(context.session, project_id)
         db_quotas = self._get_db_quotas(context.session, project_id)
         return self._convert_db_to_type(db_quotas, quota_types.QuotaResponse)
 

octavia/api/v2/types/listener.py

@@ -63,6 +63,9 @@ class ListenerResponse(BaseListenerType):
     tls_ciphers = wtypes.StringType()
     tls_versions = wtypes.wsattr(wtypes.ArrayType(wtypes.StringType()))
     alpn_protocols = wtypes.wsattr(wtypes.ArrayType(types.AlpnProtocolType()))
+    hsts_max_age = wtypes.wsattr(wtypes.IntegerType())
+    hsts_include_subdomains = wtypes.wsattr(bool)
+    hsts_preload = wtypes.wsattr(bool)
 
     @classmethod
     def from_data_model(cls, data_model, children=False):
@@ -86,6 +89,9 @@ class ListenerResponse(BaseListenerType):
 
         listener.tls_versions = data_model.tls_versions
         listener.alpn_protocols = data_model.alpn_protocols
+        listener.hsts_max_age = data_model.hsts_max_age
+        listener.hsts_include_subdomains = data_model.hsts_include_subdomains
+        listener.hsts_preload = data_model.hsts_preload
 
         return listener
 
@@ -155,6 +161,9 @@ class ListenerPOST(BaseListenerType):
     tls_versions = wtypes.wsattr(wtypes.ArrayType(wtypes.StringType(
         max_length=32)))
     alpn_protocols = wtypes.wsattr(wtypes.ArrayType(types.AlpnProtocolType()))
+    hsts_max_age = wtypes.wsattr(wtypes.IntegerType(minimum=0))
+    hsts_include_subdomains = wtypes.wsattr(bool, default=False)
+    hsts_preload = wtypes.wsattr(bool, default=False)
 
 
 class ListenerRootPOST(types.BaseType):
@@ -196,6 +205,9 @@ class ListenerPUT(BaseListenerType):
     tls_versions = wtypes.wsattr(wtypes.ArrayType(wtypes.StringType(
         max_length=32)))
     alpn_protocols = wtypes.wsattr(wtypes.ArrayType(types.AlpnProtocolType()))
+    hsts_max_age = wtypes.wsattr(wtypes.IntegerType(minimum=0))
+    hsts_include_subdomains = wtypes.wsattr(bool)
+    hsts_preload = wtypes.wsattr(bool)
 
 
 class ListenerRootPUT(types.BaseType):
@@ -247,6 +259,9 @@ class ListenerSingleCreate(BaseListenerType):
     tls_versions = wtypes.wsattr(wtypes.ArrayType(wtypes.StringType(
         max_length=32)))
     alpn_protocols = wtypes.wsattr(wtypes.ArrayType(types.AlpnProtocolType()))
+    hsts_max_age = wtypes.wsattr(wtypes.IntegerType())
+    hsts_include_subdomains = wtypes.wsattr(bool, default=False)
+    hsts_preload = wtypes.wsattr(bool, default=False)
 
 
 class ListenerStatusResponse(BaseListenerType):

octavia/cmd/octavia_worker.py

@@ -20,7 +20,6 @@ from oslo_config import cfg
 from oslo_reports import guru_meditation_report as gmr
 
 from octavia.common import service as octavia_service
-from octavia.controller.queue.v1 import consumer as consumer_v1
 from octavia.controller.queue.v2 import consumer as consumer_v2
 from octavia import version
 
@@ -33,8 +32,6 @@ def main():
     gmr.TextGuruMeditation.setup_autorun(version)
 
     sm = cotyledon.ServiceManager()
-    sm.add(consumer_v1.ConsumerService, workers=CONF.controller_worker.workers,
-           args=(CONF,))
     sm.add(consumer_v2.ConsumerService,
            workers=CONF.controller_worker.workers, args=(CONF,))
     oslo_config_glue.setup(sm, CONF, reload_method="mutate")

octavia/cmd/status.py

@@ -22,7 +22,6 @@ from stevedore import driver as stevedore_driver
 # Need to import to load config
 from octavia.common import config  # noqa: F401 pylint: disable=unused-import
 from octavia.common import constants
-from octavia.common import policy
 from octavia.controller.worker.v2 import taskflow_jobboard_driver as tsk_driver
 from octavia.i18n import _
 
@@ -77,9 +76,8 @@ class Checks(upgradecheck.UpgradeCommands):
               'section.'))
 
     def _check_amphorav2(self):
-        default_provider_driver = CONF.api_settings.default_provider_driver
         enabled_provider_drivers = CONF.api_settings.enabled_provider_drivers
-        if (default_provider_driver == constants.AMPHORAV2 or
+        if (constants.AMPHORA in enabled_provider_drivers or
                 constants.AMPHORAV2 in enabled_provider_drivers):
             persistence = self._check_persistence()
             if isinstance(persistence, upgradecheck.Result):
@@ -120,7 +118,6 @@ class Checks(upgradecheck.UpgradeCommands):
 
 
 def main():
-    policy.Policy()
     return upgradecheck.main(
         CONF, project='octavia', upgrade_command=Checks())
 

octavia/common/clients.py

@@ -12,9 +12,11 @@
 
 from cinderclient import client as cinder_client
 from glanceclient import client as glance_client
-from neutronclient.neutron import client as neutron_client
+from keystoneauth1 import session
+from keystoneauth1 import token_endpoint
 from novaclient import api_versions
 from novaclient import client as nova_client
+import openstack
 from oslo_config import cfg
 from oslo_log import log as logging
 from oslo_utils import excutils
@@ -25,7 +27,6 @@ LOG = logging.getLogger(__name__)
 CONF = cfg.CONF
 
 GLANCE_VERSION = '2'
-NEUTRON_VERSION = '2.0'
 NOVA_VERSION = '2.15'
 CINDER_VERSION = '3'
 
@@ -73,38 +74,20 @@ class NeutronAuth(object):
     neutron_client = None
 
     @classmethod
-    def get_neutron_client(cls, region, service_name=None, endpoint=None,
-                           endpoint_type='publicURL', insecure=False,
-                           ca_cert=None):
-        """Create neutron client object.
-
-        :param region: The region of the service
-        :param service_name: The name of the neutron service in the catalog
-        :param endpoint: The endpoint of the service
-        :param endpoint_type: The endpoint_type of the service
-        :param insecure: Turn off certificate validation
-        :param ca_cert: CA Cert file path
-        :return: a Neutron Client object.
-        :raises Exception: if the client cannot be created
-        """
-        ksession = keystone.KeystoneSession()
+    def get_neutron_client(cls):
+        """Create neutron client object."""
+        ksession = keystone.KeystoneSession('neutron')
         if not cls.neutron_client:
-            kwargs = {'region_name': region,
-                      'session': ksession.get_session(),
-                      'endpoint_type': endpoint_type,
-                      'insecure': insecure}
-            if service_name:
-                kwargs['service_name'] = service_name
-            if endpoint:
-                kwargs['endpoint_override'] = endpoint
-            if ca_cert:
-                kwargs['ca_cert'] = ca_cert
-            try:
-                cls.neutron_client = neutron_client.Client(
-                    NEUTRON_VERSION, **kwargs)
-            except Exception:
-                with excutils.save_and_reraise_exception():
-                    LOG.exception("Error creating Neutron client.")
+            sess = ksession.get_session()
+
+            kwargs = {}
+            if CONF.neutron.endpoint_override:
+                kwargs['network_endpoint_override'] = (
+                    CONF.neutron.endpoint_override)
+
+            conn = openstack.connection.Connection(
+                session=sess, **kwargs)
+            cls.neutron_client = conn
         return cls.neutron_client
 
     @classmethod
@@ -113,26 +96,23 @@ class NeutronAuth(object):
 
         It's possible that the token in the context is a trust scoped
         which can't be used to initialize a keystone session.
-
         We directly use the token and endpoint_url to initialize neutron
         client.
         """
-        neutron_endpoint = CONF.neutron.endpoint
-        if not neutron_endpoint:
-            session = keystone.KeystoneSession().get_session()
-            endpoint_data = session.get_endpoint_data(
+        sess = keystone.KeystoneSession('neutron').get_session()
+        neutron_endpoint = CONF.neutron.endpoint_override
+        if neutron_endpoint is None:
+            endpoint_data = sess.get_endpoint_data(
                 service_type='network', interface=CONF.neutron.endpoint_type,
                 region_name=CONF.neutron.region_name)
             neutron_endpoint = endpoint_data.catalog_url
 
-        kwargs = {
-            'token': context.auth_token,
-            'endpoint_url': neutron_endpoint,
-            'insecure': CONF.neutron.insecure,
-            'ca_cert': CONF.neutron.ca_certificates_file
-        }
+        user_auth = token_endpoint.Token(neutron_endpoint, context.auth_token)
+        user_sess = session.Session(auth=user_auth)
 
-        return neutron_client.Client(NEUTRON_VERSION, **kwargs)
+        conn = openstack.connection.Connection(
+            session=user_sess, oslo_conf=CONF)
+        return conn.network
 
 
 class GlanceAuth(object):

octavia/common/config.py

@@ -37,10 +37,6 @@ from octavia import version
 
 LOG = logging.getLogger(__name__)
 
-EXTRA_LOG_LEVEL_DEFAULTS = [
-    'neutronclient.v2_0.client=INFO',
-]
-
 core_opts = [
     cfg.HostnameOpt('host', default=utils.get_hostname(),
                     sample_default='<server-hostname.example.com>',
@@ -89,7 +85,7 @@ api_opts = [
                        'octavia.api.drivers entrypoint.'),
                 default={'amphora': 'The Octavia Amphora driver.',
                          'octavia': 'Deprecated alias of the Octavia Amphora '
-                         'driver.',
+                                    'driver.',
                          }),
     cfg.StrOpt('default_provider_driver', default='amphora',
                help=_('Default provider driver.')),
@@ -747,21 +743,27 @@ cinder_opts = [
 ]
 
 neutron_opts = [
-    cfg.StrOpt('service_name',
-               help=_('The name of the neutron service in the '
-                      'keystone catalog')),
     cfg.StrOpt('endpoint', help=_('A new endpoint to override the endpoint '
-                                  'in the keystone catalog.')),
-    cfg.StrOpt('region_name',
-               help=_('Region in Identity service catalog to use for '
-                      'communication with the OpenStack services.')),
-    cfg.StrOpt('endpoint_type', default='publicURL',
-               help=_('Endpoint interface in identity service to use')),
+                                  'in the keystone catalog.'),
+               deprecated_for_removal=True,
+               deprecated_reason=_('The endpoint_override option defined by '
+                                   'keystoneauth1 is the new name for this '
+                                   'option.'),
+               deprecated_since='2023.2/Bobcat'),
+    cfg.StrOpt('endpoint_type', help=_('Endpoint interface in identity '
+                                       'service to use'),
+               deprecated_for_removal=True,
+               deprecated_reason=_('This option was replaced by the '
+                                   'valid_interfaces option defined by '
+                                   'keystoneauth.'),
+               deprecated_since='2023.2/Bobcat'),
     cfg.StrOpt('ca_certificates_file',
-               help=_('CA certificates file path')),
-    cfg.BoolOpt('insecure',
-                default=False,
-                help=_('Disable certificate validation on SSL connections ')),
+               help=_('CA certificates file path'),
+               deprecated_for_removal=True,
+               deprecated_reason=_('The cafile option defined by '
+                                   'keystoneauth1 is the new name for this '
+                                   'option.'),
+               deprecated_since='2023.2/Bobcat'),
 ]
 
 glance_opts = [
@@ -902,8 +904,16 @@ _SQL_CONNECTION_DEFAULT = 'sqlite://'
 db_options.set_defaults(cfg.CONF, connection=_SQL_CONNECTION_DEFAULT,
                         max_pool_size=10, max_overflow=20, pool_timeout=10)
 
-ks_loading.register_auth_conf_options(cfg.CONF, constants.SERVICE_AUTH)
-ks_loading.register_session_conf_options(cfg.CONF, constants.SERVICE_AUTH)
+
+def register_ks_options(group):
+    ks_loading.register_auth_conf_options(cfg.CONF, group)
+    ks_loading.register_session_conf_options(cfg.CONF, group)
+    ks_loading.register_adapter_conf_options(cfg.CONF, group,
+                                             include_deprecated=False)
+
+
+register_ks_options(constants.SERVICE_AUTH)
+register_ks_options('neutron')
 
 
 def register_cli_opts():
@@ -911,6 +921,31 @@ def register_cli_opts():
     logging.register_options(cfg.CONF)
 
 
+def handle_neutron_deprecations():
+    # Apply neutron deprecated options to their new setting if needed
+
+    # Basicaly: if the value of the deprecated option is not the default:
+    # * convert it to a valid "new" value if needed
+    # * set it as the default for the new option
+    # Thus [neutron].<new_option> has an higher precedence than
+    # [neutron].<deprecated_option>
+    loc = cfg.CONF.get_location('endpoint', 'neutron')
+    if loc and loc.location != cfg.Locations.opt_default:
+        cfg.CONF.set_default('endpoint_override', cfg.CONF.neutron.endpoint,
+                             'neutron')
+
+    loc = cfg.CONF.get_location('endpoint_type', 'neutron')
+    if loc and loc.location != cfg.Locations.opt_default:
+        endpoint_type = cfg.CONF.neutron.endpoint_type.replace('URL', '')
+        cfg.CONF.set_default('valid_interfaces', [endpoint_type],
+                             'neutron')
+
+    loc = cfg.CONF.get_location('ca_certificates_file', 'neutron')
+    if loc and loc.location != cfg.Locations.opt_default:
+        cfg.CONF.set_default('cafile', cfg.CONF.neutron.ca_certificates_file,
+                             'neutron')
+
+
 def init(args, **kwargs):
     register_cli_opts()
     cfg.CONF(args=args, project='octavia',
@@ -920,14 +955,20 @@ def init(args, **kwargs):
     setup_remote_debugger()
     validate.check_default_ciphers_prohibit_list_conflict()
 
+    # Override default auth_type for plugins with the default from service_auth
+    auth_type = cfg.CONF.service_auth.auth_type
+    cfg.CONF.set_default('auth_type', auth_type, 'neutron')
+
+    handle_neutron_deprecations()
+
 
 def setup_logging(conf):
     """Sets up the logging options for a log with supplied name.
 
     :param conf: a cfg.ConfOpts object
     """
-    logging.set_defaults(default_log_levels=logging.get_default_log_levels() +
-                         EXTRA_LOG_LEVEL_DEFAULTS)
+    ll = logging.get_default_log_levels()
+    logging.set_defaults(default_log_levels=ll)
     product_name = "octavia"
     logging.setup(conf, product_name)
     LOG.info("Logging enabled!")
@@ -944,6 +985,7 @@ def _enable_pydev(debugger_host, debugger_port):
         import pydevd  # pylint: disable=import-outside-toplevel
 
     pydevd.settrace(debugger_host,
+                    suspend=False,
                     port=int(debugger_port),
                     stdoutToServer=True,
                     stderrToServer=True)

octavia/common/constants.py

@@ -796,8 +796,6 @@ RBAC_ROLES_DEPRECATED_REASON = (
 # PROVIDERS
 OCTAVIA = 'octavia'
 AMPHORAV2 = 'amphorav2'
-# Deprecated in Z, to be removed
-AMPHORAV1 = 'amphorav1'
 
 # systemctl commands
 DISABLE = 'disable'
@@ -913,6 +911,9 @@ AMPHORA_SUPPORTED_ALPN_PROTOCOLS = [lib_consts.ALPN_PROTOCOL_HTTP_2,
                                     lib_consts.ALPN_PROTOCOL_HTTP_1_0]
 
 # Amphora interface fields
+IF_TYPE = 'if_type'
+BACKEND = 'backend'
+LO = 'lo'
 MTU = 'mtu'
 ADDRESSES = 'addresses'
 ROUTES = 'routes'

octavia/common/data_models.py

@@ -16,6 +16,7 @@
 
 import datetime
 import re
+import typing as tp
 
 from oslo_log import log as logging
 from sqlalchemy.orm import collections
@@ -419,7 +420,8 @@ class Listener(BaseDataModel):
                  tags=None, client_ca_tls_certificate_id=None,
                  client_authentication=None, client_crl_container_id=None,
                  allowed_cidrs=None, tls_ciphers=None, tls_versions=None,
-                 alpn_protocols=None):
+                 alpn_protocols=None, hsts_max_age=None,
+                 hsts_include_subdomains=None, hsts_preload=None):
         self.id = id
         self.project_id = project_id
         self.name = name
@@ -455,6 +457,10 @@ class Listener(BaseDataModel):
         self.tls_ciphers = tls_ciphers
         self.tls_versions = tls_versions
         self.alpn_protocols = alpn_protocols
+        self.hsts_max_age: tp.Optional[int] = hsts_max_age
+        self.hsts_include_subdomains: tp.Optional[bool] = (
+            hsts_include_subdomains)
+        self.hsts_preload: tp.Optional[bool] = hsts_preload
 
     def update(self, update_dict):
         for key, value in update_dict.items():