import netaddr from neutron_lib.utils import helpers from oslo_config import cfg from oslo_log import log as logging from neutron._i18n import _ from neutron.common import _deprecate from neutron.db import db_base_plugin_v2 from neutron.db import l3_db from neutron.db.models import l3 as l3_models from neutron.db import models_v2 from neutron.extensions import extraroute from neutron.extensions import l3 _deprecate._moved_global('RouterRoute', new_module=l3_models) LOG = logging.getLogger(__name__) extra_route_opts = [ #TODO(nati): use quota framework when it support quota for attributes cfg.IntOpt('max_routes', default=30, help=_("Maximum number of routes per router")), ] cfg.CONF.register_opts(extra_route_opts) class ExtraRoute_dbonly_mixin(l3_db.L3_NAT_dbonly_mixin): """Mixin class to support extra route configuration on router."""
from oslo_utils import uuidutils from sqlalchemy.orm import exc from neutron.callbacks import events from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.db import api as db_api from neutron.db import common_db_mixin from neutron.db.models import segment as segment_model from neutron.db import segments_db as db from neutron.extensions import segment as extension from neutron import manager from neutron.services.segments import exceptions _deprecate._moved_global('SegmentHostMapping', new_module=segment_model) class SegmentDbMixin(common_db_mixin.CommonDbMixin): """Mixin class to add segment.""" def _make_segment_dict(self, segment_db, fields=None): res = {'id': segment_db['id'], 'network_id': segment_db['network_id'], 'name': segment_db['name'], 'description': segment_db['description'], db.PHYSICAL_NETWORK: segment_db[db.PHYSICAL_NETWORK], db.NETWORK_TYPE: segment_db[db.NETWORK_TYPE], db.SEGMENTATION_ID: segment_db[db.SEGMENTATION_ID], 'hosts': [mapping.host for mapping in segment_db.segment_host_mapping],
# under the License. from debtcollector import moves from neutron_lib.api import converters as lib_converters from neutron_lib.api import validators as lib_validators from neutron_lib import constants import six import webob.exc from neutron._i18n import _ from neutron.common import _deprecate # Defining a constant to avoid repeating string literal in several modules SHARED = 'shared' _deprecate._moved_global('UNLIMITED', new_module=lib_validators) # TODO(HenryG): use DB field sizes (neutron-lib 0.1.1) NAME_MAX_LEN = 255 TENANT_ID_MAX_LEN = 255 DESCRIPTION_MAX_LEN = 255 LONG_DESCRIPTION_MAX_LEN = 1024 DEVICE_ID_MAX_LEN = 255 DEVICE_OWNER_MAX_LEN = 255 def _lib(old_name): """Deprecate a function moved to neutron_lib.api.converters/validators.""" new_func = getattr(lib_validators, old_name, None) if not new_func: # Try non-private name (without leading underscore)
from neutron.db.availability_zone import router as router_az_db from neutron.db import common_db_mixin from neutron.db import l3_dvr_db from neutron.db.l3_dvr_db import is_distributed_router from neutron.db.models import agent as agent_model from neutron.db.models import l3 as l3_models from neutron.db.models import l3_attrs from neutron.db.models import l3ha as l3ha_model from neutron.extensions import l3 from neutron.extensions import l3_ext_ha_mode as l3_ha from neutron.extensions import portbindings from neutron.extensions import providernet from neutron.plugins.common import utils as p_utils _deprecate._moved_global('L3HARouterAgentPortBinding', new_module=l3ha_model) _deprecate._moved_global('L3HARouterNetwork', new_module=l3ha_model) _deprecate._moved_global('L3HARouterVRIdAllocation', new_module=l3ha_model) VR_ID_RANGE = set(range(1, 255)) MAX_ALLOCATION_TRIES = 10 UNLIMITED_AGENTS_PER_ROUTER = 0 LOG = logging.getLogger(__name__) L3_HA_OPTS = [ cfg.BoolOpt('l3_ha', default=False, help=_('Enable HA mode for virtual routers.')), cfg.IntOpt('max_l3_agents_per_router', default=3,
from sqlalchemy import sql from neutron._i18n import _, _LI from neutron.agent.common import utils as agent_utils from neutron.common import _deprecate from neutron.common import utils as n_utils from neutron.db import agentschedulers_db from neutron.db.models import agent as agent_model from neutron.db.models import l3_attrs from neutron.db.models import l3agent as rb_model from neutron.extensions import l3agentscheduler from neutron.extensions import router_availability_zone as router_az from neutron import manager from neutron.plugins.common import constants as service_constants _deprecate._moved_global('RouterL3AgentBinding', new_module=rb_model) LOG = logging.getLogger(__name__) L3_AGENTS_SCHEDULER_OPTS = [ cfg.StrOpt('router_scheduler_driver', default='neutron.scheduler.l3_agent_scheduler.' 'LeastRoutersScheduler', help=_('Driver to use for scheduling ' 'router to a default L3 agent')), cfg.BoolOpt('router_auto_schedule', default=True, help=_('Allow auto scheduling of routers to L3 agent.')), cfg.BoolOpt('allow_automatic_l3agent_failover', default=False, help=_('Automatically reschedule routers from offline L3 '
# 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. # TODO(ihrachys): consider renaming the module since now it does not contain # any models at all from neutron.api.v2 import attributes from neutron.common import _deprecate from neutron.db import common_db_mixin from neutron.db.models import subnet_service_type as sst_model _deprecate._moved_global('SubnetServiceType', new_module=sst_model) class SubnetServiceTypeMixin(object): """Mixin class to extend subnet with service type attribute""" def _extend_subnet_service_types(self, subnet_res, subnet_db): subnet_res['service_types'] = [service_type['service_type'] for service_type in subnet_db.service_types] common_db_mixin.CommonDbMixin.register_dict_extend_funcs( attributes.SUBNETS, [_extend_subnet_service_types]) _deprecate._MovedGlobals()
# 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. from oslo_config import cfg from neutron._i18n import _ from neutron.common import _deprecate from neutron.db import db_base_plugin_v2 from neutron.db.models import l3_attrs from neutron.extensions import availability_zone as az from neutron.extensions import l3 _deprecate._moved_global('RouterExtraAttributes', new_module=l3_attrs) def get_attr_info(): """Returns api visible attr names and their default values.""" return {'distributed': {'default': cfg.CONF.router_distributed}, 'ha': {'default': cfg.CONF.l3_ha}, 'ha_vr_id': {'default': 0}, 'availability_zone_hints': { 'default': '[]', 'transform_to_db': az.convert_az_list_to_string, 'transform_from_db': az.convert_az_string_to_list} } class ExtraAttributesMixin(object):
from neutron_lib import constants from neutron_lib.db import model_base import sqlalchemy as sa from sqlalchemy import orm from sqlalchemy import sql from neutron.api.v2 import attributes as attr from neutron.common import _deprecate from neutron.db.network_dhcp_agent_binding import models as ndab_model from neutron.db import rbac_db_models from neutron.db import standard_attr # NOTE(kevinbenton): these are here for external projects that expect them # to be found in this module. _deprecate._moved_global('HasTenant', new_name='HasProject', new_module=model_base) _deprecate._moved_global('HasId', new_module=model_base) _deprecate._moved_global('HasStatusDescription', new_module=model_base) class IPAvailabilityRange(model_base.BASEV2): """Internal representation of available IPs for Neutron subnets. Allocation - first entry from the range will be allocated. If the first entry is equal to the last entry then this row will be deleted. Recycling ips involves reading the IPAllocationPool and IPAllocation tables and inserting ranges representing available ips. This happens after the final allocation is pulled from this table and a new ip allocation is requested. Any contiguous ranges of available ips will be inserted as a
# 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. from neutron_lib.api import validators from neutron.api.v2 import attributes from neutron.common import _deprecate from neutron.db import db_base_plugin_v2 from neutron.db.models import portbinding as pmodels from neutron.db import models_v2 from neutron.db import portbindings_base from neutron.extensions import portbindings _deprecate._moved_global('PortBindingPort', new_module=pmodels) class PortBindingMixin(portbindings_base.PortBindingBaseMixin): extra_binding_dict = None def _port_model_hook(self, context, original_model, query): query = query.outerjoin( pmodels.PortBindingPort, (original_model.id == pmodels.PortBindingPort.port_id)) return query def _port_result_filter_hook(self, query, filters): values = filters and filters.get(portbindings.HOST_ID, []) if not values: return query
from neutron_lib import exceptions as n_exc from oslo_config import cfg from oslo_log import log from neutron._i18n import _LE from neutron.common import _deprecate from neutron.conf.plugins.ml2.drivers import driver_type from neutron.db.models.plugins.ml2 import geneveallocation \ as geneve_model from neutron.plugins.common import constants as p_const from neutron.plugins.ml2.drivers import type_tunnel LOG = log.getLogger(__name__) _deprecate._moved_global('GeneveAllocation', new_module=geneve_model) _deprecate._moved_global('GeneveEndpoints', new_module=geneve_model) driver_type.register_ml2_drivers_geneve_opts() class GeneveTypeDriver(type_tunnel.EndpointTunnelTypeDriver): def __init__(self): super(GeneveTypeDriver, self).__init__(geneve_model.GeneveAllocation, geneve_model.GeneveEndpoints) self.max_encap_size = cfg.CONF.ml2_type_geneve.max_header_size def get_type(self): return p_const.TYPE_GENEVE
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from neutron_lib.api import validators from neutron.api.v2 import attributes from neutron.common import _deprecate from neutron.db import db_base_plugin_v2 from neutron.db.models import portbinding as pmodels from neutron.db import models_v2 from neutron.db import portbindings_base from neutron.extensions import portbindings _deprecate._moved_global('PortBindingPort', new_module=pmodels) class PortBindingMixin(portbindings_base.PortBindingBaseMixin): extra_binding_dict = None def _port_model_hook(self, context, original_model, query): query = query.outerjoin( pmodels.PortBindingPort, (original_model.id == pmodels.PortBindingPort.port_id)) return query def _port_result_filter_hook(self, query, filters): values = filters and filters.get(portbindings.HOST_ID, []) if not values: return query
# # 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. # from sqlalchemy.orm import aliased from neutron.common import _deprecate from neutron.db.models import tag as tag_model _deprecate._moved_global('Tag', new_module=tag_model) def _get_tag_list(tag_strings): tags = set() for tag_str in tag_strings: tags |= set(tag_str.split(',')) return list(tags) def apply_tag_filters(model, query, filters): """Apply tag filters There are four types of filter: `tags` -- One or more strings that will be used to filter results in an AND expression: T1 AND T2
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from oslo_log import log as logging from oslo_utils import uuidutils from sqlalchemy.orm import exc from neutron._i18n import _LI from neutron.callbacks import events from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.db.models import segment as segments_model _deprecate._moved_global('NetworkSegment', new_module=segments_model) LOG = logging.getLogger(__name__) NETWORK_TYPE = segments_model.NetworkSegment.network_type.name PHYSICAL_NETWORK = segments_model.NetworkSegment.physical_network.name SEGMENTATION_ID = segments_model.NetworkSegment.segmentation_id.name def _make_segment_dict(record): """Make a segment dictionary out of a DB record.""" return {'id': record.id, NETWORK_TYPE: record.network_type, PHYSICAL_NETWORK: record.physical_network, SEGMENTATION_ID: record.segmentation_id}
from neutron.common import _deprecate from neutron.db import _utils as db_utils from neutron.db import db_base_plugin_v2 from neutron.db.models import external_net as ext_net_models from neutron.db.models import l3 as l3_models from neutron.db import models_v2 from neutron.db import rbac_db_models as rbac_db from neutron.extensions import external_net from neutron.extensions import rbac as rbac_ext from neutron import manager from neutron.plugins.common import constants as service_constants DEVICE_OWNER_ROUTER_GW = lib_constants.DEVICE_OWNER_ROUTER_GW _deprecate._moved_global('ExternalNetwork', new_module=ext_net_models) class External_net_db_mixin(object): """Mixin class to add external network methods to db_base_plugin_v2.""" def _network_model_hook(self, context, original_model, query): query = query.outerjoin(ext_net_models.ExternalNetwork, (original_model.id == ext_net_models.ExternalNetwork.network_id)) return query @staticmethod def _network_filter_hook(context, original_model, conditions): if conditions is not None and not hasattr(conditions, '__iter__'): conditions = (conditions, )
from neutron._i18n import _, _LE from neutron.common import _deprecate from neutron.common import utils from neutron.db import db_base_plugin_v2 from neutron.db.models import dns as dns_models from neutron.extensions import dns from neutron.extensions import l3 from neutron.objects import floatingip as fip_obj from neutron.objects import network from neutron.objects import ports as port_obj from neutron.services.externaldns import driver LOG = logging.getLogger(__name__) _deprecate._moved_global('PortDNS', new_module=dns_models) _deprecate._moved_global('NetworkDNSDomain', new_module=dns_models) _deprecate._moved_global('FloatingIPDNS', new_module=dns_models) class DNSActionsData(object): def __init__(self, current_dns_name=None, current_dns_domain=None, previous_dns_name=None, previous_dns_domain=None): self.current_dns_name = current_dns_name self.current_dns_domain = current_dns_domain self.previous_dns_name = previous_dns_name self.previous_dns_domain = previous_dns_domain
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from oslo_log import log as logging from oslo_utils import uuidutils from sqlalchemy.orm import exc from neutron._i18n import _LI from neutron.callbacks import events from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.db.models import segment as segments_model _deprecate._moved_global('NetworkSegment', new_module=segments_model) LOG = logging.getLogger(__name__) NETWORK_TYPE = segments_model.NetworkSegment.network_type.name PHYSICAL_NETWORK = segments_model.NetworkSegment.physical_network.name SEGMENTATION_ID = segments_model.NetworkSegment.segmentation_id.name def _make_segment_dict(record): """Make a segment dictionary out of a DB record.""" return { 'id': record.id, NETWORK_TYPE: record.network_type, PHYSICAL_NETWORK: record.physical_network, SEGMENTATION_ID: record.segmentation_id
from neutron._i18n import _, _LE from neutron.common import _deprecate from neutron.common import utils from neutron.db import db_base_plugin_v2 from neutron.db.models import dns as dns_models from neutron.extensions import dns from neutron.extensions import l3 from neutron.objects import floatingip as fip_obj from neutron.objects import network from neutron.objects import ports as port_obj from neutron.services.externaldns import driver LOG = logging.getLogger(__name__) _deprecate._moved_global('PortDNS', new_module=dns_models) _deprecate._moved_global('NetworkDNSDomain', new_module=dns_models) _deprecate._moved_global('FloatingIPDNS', new_module=dns_models) class DNSActionsData(object): def __init__(self, current_dns_name=None, current_dns_domain=None, previous_dns_name=None, previous_dns_domain=None): self.current_dns_name = current_dns_name self.current_dns_domain = current_dns_domain self.previous_dns_name = previous_dns_name self.previous_dns_domain = previous_dns_domain class DNSDbMixin(object):
# # 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. from neutron_lib.db import model_base as lib_mb import sqlalchemy as sa from neutron.common import _deprecate _deprecate._moved_global('HasTenant', new_module=lib_mb, new_name='HasProject') def get_unique_keys(model): try: constraints = model.__table__.constraints except AttributeError: constraints = [] return [[c.name for c in constraint.columns] for constraint in constraints if isinstance(constraint, sa.UniqueConstraint)] # This shim is used to deprecate the old contents. _deprecate._MovedGlobals(lib_mb)
from neutron.callbacks import registry from neutron.callbacks import resources from neutron.db import api as db_api from neutron.common import _deprecate from neutron.db.models import provisioning_block as pb_model from neutron.db import models_v2 LOG = logging.getLogger(__name__) PROVISIONING_COMPLETE = 'provisioning_complete' # identifiers for the various entities that participate in provisioning DHCP_ENTITY = 'DHCP' L2_AGENT_ENTITY = 'L2' _RESOURCE_TO_MODEL_MAP = {resources.PORT: models_v2.Port} _deprecate._moved_global('ProvisioningBlock', new_module=pb_model) def add_model_for_resource(resource, model): """Adds a mapping between a callback resource and a DB model.""" _RESOURCE_TO_MODEL_MAP[resource] = model @db_api.retry_if_session_inactive() def add_provisioning_component(context, object_id, object_type, entity): """Adds a provisioning block by an entity to a given object. Adds a provisioning block to the DB for object_id with an identifier of the entity that is doing the provisioning. While an object has these provisioning blocks present, this module will not emit any callback events indicating that provisioning has completed. Any logic that depends on
from debtcollector import moves from neutron_lib.api import converters as lib_converters from neutron_lib.api import validators as lib_validators from neutron_lib import constants import six import webob.exc from neutron._i18n import _ from neutron.common import _deprecate # Defining a constant to avoid repeating string literal in several modules SHARED = 'shared' _deprecate._moved_global('UNLIMITED', new_module=lib_validators) # TODO(HenryG): use DB field sizes (neutron-lib 0.1.1) NAME_MAX_LEN = 255 TENANT_ID_MAX_LEN = 255 DESCRIPTION_MAX_LEN = 255 LONG_DESCRIPTION_MAX_LEN = 1024 DEVICE_ID_MAX_LEN = 255 DEVICE_OWNER_MAX_LEN = 255 def _lib(old_name): """Deprecate a function moved to neutron_lib.api.converters/validators.""" new_func = getattr(lib_validators, old_name, None) if not new_func: # Try non-private name (without leading underscore)
# # 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. # TODO(ihrachys): consider renaming the module since now it does not contain # any models at all from neutron.api.v2 import attributes from neutron.common import _deprecate from neutron.db import common_db_mixin from neutron.db.models import subnet_service_type as sst_model _deprecate._moved_global('SubnetServiceType', new_module=sst_model) class SubnetServiceTypeMixin(object): """Mixin class to extend subnet with service type attribute""" def _extend_subnet_service_types(self, subnet_res, subnet_db): subnet_res['service_types'] = [ service_type['service_type'] for service_type in subnet_db.service_types ] common_db_mixin.CommonDbMixin.register_dict_extend_funcs( attributes.SUBNETS, [_extend_subnet_service_types]) _deprecate._MovedGlobals()
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from itertools import chain from oslo_log import log as logging from neutron.common import _deprecate from neutron.db.models import servicetype as st_model from neutron.objects import servicetype as servicetype_obj from neutron.services import provider_configuration as pconf LOG = logging.getLogger(__name__) _deprecate._moved_global('ProviderResourceAssociation', new_module=st_model) class ServiceTypeManager(object): """Manage service type objects in Neutron.""" _instance = None @classmethod def get_instance(cls): if cls._instance is None: cls._instance = cls() return cls._instance def __init__(self): self.config = {}
from sqlalchemy import or_ from sqlalchemy.orm import exc from neutron._i18n import _, _LE from neutron.callbacks import events from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.common import utils from neutron.db import api as db_api from neutron.db.models import dvr as dvr_models from neutron.db import models_v2 from neutron.extensions import dvr as ext_dvr from neutron.extensions import portbindings _deprecate._moved_global('DistributedVirtualRouterMacAddress', new_module=dvr_models) LOG = logging.getLogger(__name__) dvr_mac_address_opts = [ cfg.StrOpt('dvr_base_mac', default="fa:16:3f:00:00:00", help=_("The base mac address used for unique " "DVR instances by Neutron. The first 3 octets will " "remain unchanged. If the 4th octet is not 00, it will " "also be used. The others will be randomly generated. " "The 'dvr_base_mac' *must* be different from " "'base_mac' to avoid mixing them up with MAC's " "allocated for tenant ports. A 4 octet example would be " "dvr_base_mac = fa:16:3f:4f:00:00. The default is 3 " "octet")),
# 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. from neutron.common import _deprecate from neutron.db.models import allowed_address_pair as aap_models _deprecate._moved_global('AllowedAddressPair', new_module=aap_models) _deprecate._MovedGlobals()
# under the License. from neutron_lib import exceptions as n_exc from oslo_config import cfg from oslo_log import log from neutron._i18n import _LE from neutron.common import _deprecate from neutron.conf.plugins.ml2.drivers import driver_type from neutron.db.models.plugins.ml2 import vxlanallocation as vxlan_model from neutron.plugins.common import constants as p_const from neutron.plugins.ml2.drivers import type_tunnel LOG = log.getLogger(__name__) _deprecate._moved_global('VxlanAllocation', new_module=vxlan_model) _deprecate._moved_global('VxlanEndpoints', new_module=vxlan_model) driver_type.register_ml2_drivers_vxlan_opts() class VxlanTypeDriver(type_tunnel.EndpointTunnelTypeDriver): def __init__(self): super(VxlanTypeDriver, self).__init__( vxlan_model.VxlanAllocation, vxlan_model.VxlanEndpoints) def get_type(self): return p_const.TYPE_VXLAN def initialize(self):
from neutron._i18n import _ from neutron.api.v2 import attributes from neutron.callbacks import events from neutron.callbacks import exceptions from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.common import constants as n_const from neutron.common import utils from neutron.db import api as db_api from neutron.db import db_base_plugin_v2 from neutron.db.models import securitygroup as sg_models from neutron.extensions import securitygroup as ext_sg _deprecate._moved_global("DefaultSecurityGroup", new_module=sg_models) _deprecate._moved_global("SecurityGroupPortBinding", new_module=sg_models) _deprecate._moved_global("SecurityGroupRule", new_module=sg_models) class SecurityGroupDbMixin(ext_sg.SecurityGroupPluginBase): """Mixin class to add security group to db_base_plugin_v2.""" __native_bulk_support = True def create_security_group_bulk(self, context, security_group_rule): return self._create_bulk("security_group", context, security_group_rule) def _registry_notify(self, res, event, id=None, exc_cls=None, **kwargs): # NOTE(armax): a callback exception here will prevent the request # from being processed. This is a hook point for backend's validation;
from neutron_lib import constants from oslo_utils import uuidutils from neutron._i18n import _ from neutron.api.v2 import attributes as attr from neutron.common import _deprecate from neutron.db import _utils as db_utils from neutron.db import api as db_api from neutron.db import db_base_plugin_v2 from neutron.db.models import address_scope as address_scope_model from neutron.extensions import address_scope as ext_address_scope from neutron.objects import address_scope as obj_addr_scope from neutron.objects import base as base_obj from neutron.objects import subnetpool as subnetpool_obj _deprecate._moved_global('AddressScope', new_module=address_scope_model) class AddressScopeDbMixin(ext_address_scope.AddressScopePluginBase): """Mixin class to add address scope to db_base_plugin_v2.""" __native_bulk_support = True @staticmethod def _make_address_scope_dict(address_scope, fields=None): res = { 'id': address_scope['id'], 'name': address_scope['name'], 'tenant_id': address_scope['tenant_id'], 'shared': address_scope['shared'], 'ip_version': address_scope['ip_version']
from oslo_utils import uuidutils from neutron._i18n import _ from neutron.api.v2 import attributes as attr from neutron.common import _deprecate from neutron.db import _utils as db_utils from neutron.db import api as db_api from neutron.db import db_base_plugin_v2 from neutron.db.models import address_scope as address_scope_model from neutron.extensions import address_scope as ext_address_scope from neutron.objects import address_scope as obj_addr_scope from neutron.objects import base as base_obj from neutron.objects import subnetpool as subnetpool_obj _deprecate._moved_global('AddressScope', new_module=address_scope_model) class AddressScopeDbMixin(ext_address_scope.AddressScopePluginBase): """Mixin class to add address scope to db_base_plugin_v2.""" __native_bulk_support = True @staticmethod def _make_address_scope_dict(address_scope, fields=None): res = {'id': address_scope['id'], 'name': address_scope['name'], 'tenant_id': address_scope['tenant_id'], 'shared': address_scope['shared'], 'ip_version': address_scope['ip_version']} return db_utils.resource_fields(res, fields)
from neutron.common import _deprecate from neutron.common import exceptions as n_exc from neutron.conf.plugins.ml2.drivers import driver_type from neutron.db.models.plugins.ml2 import flatallocation as type_flat_model from neutron.objects import exceptions as obj_base from neutron.objects.plugins.ml2 import flatallocation as flat_obj from neutron.plugins.common import constants as p_const from neutron.plugins.ml2 import driver_api as api from neutron.plugins.ml2.drivers import helpers LOG = log.getLogger(__name__) driver_type.register_ml2_drivers_flat_opts() _deprecate._moved_global('FlatAllocation', new_module=type_flat_model) class FlatTypeDriver(helpers.BaseTypeDriver): """Manage state for flat networks with ML2. The FlatTypeDriver implements the 'flat' network_type. Flat network segments provide connectivity between VMs and other devices using any connected IEEE 802.1D conformant physical_network, without the use of VLAN tags, tunneling, or other segmentation mechanisms. Therefore at most one flat network segment can exist on each available physical_network. """ def __init__(self): super(FlatTypeDriver, self).__init__()
# 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. from itertools import chain from oslo_log import log as logging from neutron.common import _deprecate from neutron.db.models import servicetype as st_model from neutron.services import provider_configuration as pconf LOG = logging.getLogger(__name__) _deprecate._moved_global('ProviderResourceAssociation', new_module=st_model) class ServiceTypeManager(object): """Manage service type objects in Neutron.""" _instance = None @classmethod def get_instance(cls): if cls._instance is None: cls._instance = cls() return cls._instance def __init__(self): self.config = {}
from sqlalchemy.orm import exc from neutron._i18n import _, _LE from neutron.callbacks import events from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.common import utils from neutron.db import api as db_api from neutron.db.models import dvr as dvr_models from neutron.db import models_v2 from neutron.extensions import dvr as ext_dvr from neutron.extensions import portbindings from neutron import manager _deprecate._moved_global('DistributedVirtualRouterMacAddress', new_module=dvr_models) LOG = logging.getLogger(__name__) dvr_mac_address_opts = [ cfg.StrOpt('dvr_base_mac', default="fa:16:3f:00:00:00", help=_("The base mac address used for unique " "DVR instances by Neutron. The first 3 octets will " "remain unchanged. If the 4th octet is not 00, it will " "also be used. The others will be randomly generated. " "The 'dvr_base_mac' *must* be different from " "'base_mac' to avoid mixing them up with MAC's " "allocated for tenant ports. A 4 octet example would be " "dvr_base_mac = fa:16:3f:4f:00:00. The default is 3 "
# 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. """ Used by test cases in test__deprecate.py """ from neutron.common import _deprecate from neutron.tests.unit.common import moved_globals_target # a has been moved to moved_globals_target.a b = 'barasingha' # c has been renamed to d d = 'capybara' # e has been moved to moved_globals_target.f g = 'gelada' _deprecate._moved_global('c', new_name='d') _deprecate._moved_global('e', new_name='f', new_module=moved_globals_target) _deprecate._MovedGlobals(moved_globals_target)
from neutron_lib import constants from neutron_lib.db import model_base import sqlalchemy as sa from sqlalchemy import orm from sqlalchemy import sql from neutron.api.v2 import attributes as attr from neutron.common import _deprecate from neutron.db.network_dhcp_agent_binding import models as ndab_model from neutron.db import rbac_db_models from neutron.db import standard_attr # NOTE(kevinbenton): these are here for external projects that expect them # to be found in this module. _deprecate._moved_global('HasTenant', new_name='HasProject', new_module=model_base) _deprecate._moved_global('HasId', new_module=model_base) _deprecate._moved_global('HasStatusDescription', new_module=model_base) class IPAllocationPool(model_base.BASEV2, model_base.HasId): """Representation of an allocation pool in a Neutron subnet.""" subnet_id = sa.Column(sa.String(36), sa.ForeignKey('subnets.id', ondelete="CASCADE"), nullable=True) first_ip = sa.Column(sa.String(64), nullable=False) last_ip = sa.Column(sa.String(64), nullable=False) def __repr__(self): return "%s - %s" % (self.first_ip, self.last_ip)
from neutron.plugins.common import constants as p_const from neutron.plugins.ml2.drivers import type_tunnel LOG = log.getLogger(__name__) gre_opts = [ cfg.ListOpt('tunnel_id_ranges', default=[], help=_("Comma-separated list of <tun_min>:<tun_max> tuples " "enumerating ranges of GRE tunnel IDs that are " "available for tenant network allocation")) ] cfg.CONF.register_opts(gre_opts, "ml2_type_gre") _deprecate._moved_global('GreAllocation', new_module=gre_model) _deprecate._moved_global('GreEndpoints', new_module=gre_model) class GreTypeDriver(type_tunnel.EndpointTunnelTypeDriver): def __init__(self): super(GreTypeDriver, self).__init__(gre_model.GreAllocation, gre_model.GreEndpoints) def get_type(self): return p_const.TYPE_GRE def initialize(self): try: self._initialize(cfg.CONF.ml2_type_gre.tunnel_id_ranges) except n_exc.NetworkTunnelRangeError:
# License for the specific language governing permissions and limitations # under the License. import netaddr from oslo_utils import uuidutils from sqlalchemy import orm from neutron.api.rpc.agentnotifiers import metering_rpc_agent_api from neutron.common import _deprecate from neutron.common import constants from neutron.db import common_db_mixin as base_db from neutron.db.models import l3 as l3_models from neutron.db.models import metering as metering_models from neutron.extensions import metering _deprecate._moved_global('MeteringLabelRule', new_module=metering_models) _deprecate._moved_global('MeteringLabel', new_module=metering_models) class MeteringDbMixin(metering.MeteringPluginBase, base_db.CommonDbMixin): def __init__(self): self.meter_rpc = metering_rpc_agent_api.MeteringAgentNotifyAPI() def _make_metering_label_dict(self, metering_label, fields=None): res = { 'id': metering_label['id'], 'name': metering_label['name'], 'description': metering_label['description'], 'shared': metering_label['shared'], 'tenant_id': metering_label['tenant_id'] }
from six import moves from neutron._i18n import _, _LE, _LI, _LW from neutron.common import _deprecate from neutron.conf.plugins.ml2.drivers import driver_type from neutron import context from neutron.db import api as db_api from neutron.db.models.plugins.ml2 import vlanallocation as vlan_alloc_model from neutron.plugins.common import constants as p_const from neutron.plugins.common import utils as plugin_utils from neutron.plugins.ml2 import driver_api as api from neutron.plugins.ml2.drivers import helpers LOG = log.getLogger(__name__) _deprecate._moved_global('VlanAllocation', new_module=vlan_alloc_model) driver_type.register_ml2_drivers_vlan_opts() class VlanTypeDriver(helpers.SegmentTypeDriver): """Manage state for VLAN networks with ML2. The VlanTypeDriver implements the 'vlan' network_type. VLAN network segments provide connectivity between VMs and other devices using any connected IEEE 802.1Q conformant physical_network segmented into virtual networks via IEEE 802.1Q headers. Up to 4094 VLAN network segments can exist on each available physical_network. """ def __init__(self):
'Example: dhcp_load_type=networks')), cfg.BoolOpt('enable_new_agents', default=True, help=_("Agent starts with admin_state_up=False when " "enable_new_agents=False. In the case, user's " "resources will not be scheduled automatically to the " "agent until admin changes admin_state_up to True.")), ] cfg.CONF.register_opts(AGENT_OPTS) # this is the ratio from agent_down_time to the time we use to consider # the agents down for considering their resource versions in the # version_manager callback DOWNTIME_VERSIONS_RATIO = 2 _deprecate._moved_global('Agent', new_module=agent_model) class AgentAvailabilityZoneMixin(az_ext.AvailabilityZonePluginBase): """Mixin class to add availability_zone extension to AgentDbMixin.""" def _list_availability_zones(self, context, filters=None): result = {} query = self._get_collection_query(context, agent_model.Agent, filters=filters) columns = (agent_model.Agent.admin_state_up, agent_model.Agent.availability_zone, agent_model.Agent.agent_type) for agent in query.with_entities(*columns).group_by(*columns): if not agent.availability_zone: continue
from neutron.api.v2 import attributes from neutron.callbacks import events from neutron.callbacks import exceptions from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.common import constants as n_const from neutron.common import utils from neutron.db import _utils as db_utils from neutron.db import api as db_api from neutron.db import db_base_plugin_v2 from neutron.db.models import securitygroup as sg_models from neutron.extensions import securitygroup as ext_sg _deprecate._moved_global('DefaultSecurityGroup', new_module=sg_models) _deprecate._moved_global('SecurityGroupPortBinding', new_module=sg_models) _deprecate._moved_global('SecurityGroupRule', new_module=sg_models) class SecurityGroupDbMixin(ext_sg.SecurityGroupPluginBase): """Mixin class to add security group to db_base_plugin_v2.""" __native_bulk_support = True def create_security_group_bulk(self, context, security_groups): return self._create_bulk('security_group', context, security_groups) def _registry_notify(self, res, event, id=None, exc_cls=None, **kwargs): # NOTE(armax): a callback exception here will prevent the request
from neutron.plugins.ml2.drivers import type_tunnel LOG = log.getLogger(__name__) gre_opts = [ cfg.ListOpt('tunnel_id_ranges', default=[], help=_("Comma-separated list of <tun_min>:<tun_max> tuples " "enumerating ranges of GRE tunnel IDs that are " "available for tenant network allocation")) ] cfg.CONF.register_opts(gre_opts, "ml2_type_gre") _deprecate._moved_global('GreAllocation', new_module=gre_model) _deprecate._moved_global('GreEndpoints', new_module=gre_model) class GreTypeDriver(type_tunnel.EndpointTunnelTypeDriver): def __init__(self): super(GreTypeDriver, self).__init__( gre_model.GreAllocation, gre_model.GreEndpoints) def get_type(self): return p_const.TYPE_GRE def initialize(self): try: self._initialize(cfg.CONF.ml2_type_gre.tunnel_id_ranges)
from oslo_log import log from six import moves from neutron._i18n import _, _LE, _LI, _LW from neutron.common import _deprecate from neutron.conf.plugins.ml2.drivers import driver_type from neutron.db import api as db_api from neutron.db.models.plugins.ml2 import vlanallocation as vlan_alloc_model from neutron.plugins.common import constants as p_const from neutron.plugins.common import utils as plugin_utils from neutron.plugins.ml2 import driver_api as api from neutron.plugins.ml2.drivers import helpers LOG = log.getLogger(__name__) _deprecate._moved_global('VlanAllocation', new_module=vlan_alloc_model) driver_type.register_ml2_drivers_vlan_opts() class VlanTypeDriver(helpers.SegmentTypeDriver): """Manage state for VLAN networks with ML2. The VlanTypeDriver implements the 'vlan' network_type. VLAN network segments provide connectivity between VMs and other devices using any connected IEEE 802.1Q conformant physical_network segmented into virtual networks via IEEE 802.1Q headers. Up to 4094 VLAN network segments can exist on each available physical_network. """
import netaddr from oslo_config import cfg from oslo_log import log as logging from neutron._i18n import _ from neutron.common import _deprecate from neutron.common import utils from neutron.db import db_base_plugin_v2 from neutron.db import l3_db from neutron.db.models import l3 as l3_models from neutron.db import models_v2 from neutron.extensions import extraroute from neutron.extensions import l3 _deprecate._moved_global('RouterRoute', new_module=l3_models) LOG = logging.getLogger(__name__) extra_route_opts = [ #TODO(nati): use quota framework when it support quota for attributes cfg.IntOpt('max_routes', default=30, help=_("Maximum number of routes per router")), ] cfg.CONF.register_opts(extra_route_opts) class ExtraRoute_dbonly_mixin(l3_db.L3_NAT_dbonly_mixin): """Mixin class to support extra route configuration on router."""
from neutron.db import api as db_api from neutron.db.availability_zone import router as router_az_db from neutron.db import l3_dvr_db from neutron.db.l3_dvr_db import is_distributed_router from neutron.db.models import agent as agent_model from neutron.db.models import l3 as l3_models from neutron.db.models import l3_attrs from neutron.db.models import l3ha as l3ha_model from neutron.extensions import l3 from neutron.extensions import l3_ext_ha_mode as l3_ha from neutron.extensions import portbindings from neutron.extensions import providernet from neutron.plugins.common import utils as p_utils _deprecate._moved_global('L3HARouterAgentPortBinding', new_module=l3ha_model) _deprecate._moved_global('L3HARouterNetwork', new_module=l3ha_model) _deprecate._moved_global('L3HARouterVRIdAllocation', new_module=l3ha_model) VR_ID_RANGE = set(range(1, 255)) MAX_ALLOCATION_TRIES = 10 UNLIMITED_AGENTS_PER_ROUTER = 0 LOG = logging.getLogger(__name__) L3_HA_OPTS = [ cfg.BoolOpt('l3_ha', default=False, help=_('Enable HA mode for virtual routers.')), cfg.IntOpt('max_l3_agents_per_router', default=3,
# under the License. from oslo_db import exception as db_exc from oslo_log import log as logging from oslo_utils import uuidutils from sqlalchemy.orm import exc as sa_exc from neutron.common import _deprecate from neutron.db import _utils as db_utils from neutron.db import api as db_api from neutron.db import common_db_mixin from neutron.db.models import flavor as flavor_models from neutron.db import servicetype_db as sdb from neutron.extensions import flavors as ext_flavors _deprecate._moved_global("Flavor", new_module=flavor_models) _deprecate._moved_global("ServiceProfile", new_module=flavor_models) _deprecate._moved_global("FlavorServiceProfileBinding", new_module=flavor_models) LOG = logging.getLogger(__name__) class FlavorsDbMixin(common_db_mixin.CommonDbMixin): """Class to support flavors and service profiles.""" def _get_flavor(self, context, flavor_id): try: return self._get_by_id(context, flavor_models.Flavor, flavor_id) except sa_exc.NoResultFound:
# License for the specific language governing permissions and limitations # under the License. from oslo_db import exception as db_exc from oslo_log import log as logging from oslo_utils import uuidutils from sqlalchemy.orm import exc as sa_exc from neutron.common import _deprecate from neutron.db import _utils as db_utils from neutron.db import common_db_mixin from neutron.db.models import flavor as flavor_models from neutron.db import servicetype_db as sdb from neutron.extensions import flavors as ext_flavors _deprecate._moved_global('Flavor', new_module=flavor_models) _deprecate._moved_global('ServiceProfile', new_module=flavor_models) _deprecate._moved_global('FlavorServiceProfileBinding', new_module=flavor_models) LOG = logging.getLogger(__name__) class FlavorsDbMixin(common_db_mixin.CommonDbMixin): """Class to support flavors and service profiles.""" def _get_flavor(self, context, flavor_id): try: return self._get_by_id(context, flavor_models.Flavor, flavor_id) except sa_exc.NoResultFound: raise ext_flavors.FlavorNotFound(flavor_id=flavor_id)
# under the License. import netaddr from oslo_utils import uuidutils from sqlalchemy import orm from neutron.api.rpc.agentnotifiers import metering_rpc_agent_api from neutron.common import _deprecate from neutron.common import constants from neutron.db import common_db_mixin as base_db from neutron.db.models import l3 as l3_models from neutron.db.models import metering as metering_models from neutron.extensions import metering _deprecate._moved_global('MeteringLabelRule', new_module=metering_models) _deprecate._moved_global('MeteringLabel', new_module=metering_models) class MeteringDbMixin(metering.MeteringPluginBase, base_db.CommonDbMixin): def __init__(self): self.meter_rpc = metering_rpc_agent_api.MeteringAgentNotifyAPI() def _make_metering_label_dict(self, metering_label, fields=None): res = {'id': metering_label['id'], 'name': metering_label['name'], 'description': metering_label['description'], 'shared': metering_label['shared'], 'tenant_id': metering_label['tenant_id']}
from oslo_utils import uuidutils from sqlalchemy.orm import exc from neutron.callbacks import events from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.db import api as db_api from neutron.db import common_db_mixin from neutron.db.models import segment as segment_model from neutron.db import segments_db as db from neutron.extensions import segment as extension from neutron import manager from neutron.services.segments import exceptions _deprecate._moved_global('SegmentHostMapping', new_module=segment_model) class SegmentDbMixin(common_db_mixin.CommonDbMixin): """Mixin class to add segment.""" def _make_segment_dict(self, segment_db, fields=None): res = { 'id': segment_db['id'], 'network_id': segment_db['network_id'], 'name': segment_db['name'], 'description': segment_db['description'], db.PHYSICAL_NETWORK: segment_db[db.PHYSICAL_NETWORK], db.NETWORK_TYPE: segment_db[db.NETWORK_TYPE], db.SEGMENTATION_ID: segment_db[db.SEGMENTATION_ID], 'hosts': [mapping.host for mapping in segment_db.segment_host_mapping],
from sqlalchemy.orm import joinedload from sqlalchemy import sql from neutron._i18n import _, _LI from neutron.agent.common import utils as agent_utils from neutron.common import _deprecate from neutron.common import utils as n_utils from neutron.db import agentschedulers_db from neutron.db.models import agent as agent_model from neutron.db.models import l3_attrs from neutron.db.models import l3agent as rb_model from neutron.extensions import l3agentscheduler from neutron.extensions import router_availability_zone as router_az _deprecate._moved_global('RouterL3AgentBinding', new_module=rb_model) LOG = logging.getLogger(__name__) L3_AGENTS_SCHEDULER_OPTS = [ cfg.StrOpt('router_scheduler_driver', default='neutron.scheduler.l3_agent_scheduler.' 'LeastRoutersScheduler', help=_('Driver to use for scheduling ' 'router to a default L3 agent')), cfg.BoolOpt('router_auto_schedule', default=True, help=_('Allow auto scheduling of routers to L3 agent.')), cfg.BoolOpt('allow_automatic_l3agent_failover', default=False, help=_('Automatically reschedule routers from offline L3 ' 'agents to online L3 agents.')),
from neutron.api.v2 import attributes from neutron.callbacks import events from neutron.callbacks import exceptions from neutron.callbacks import registry from neutron.callbacks import resources from neutron.common import _deprecate from neutron.common import constants as n_const from neutron.common import utils from neutron.db import _utils as db_utils from neutron.db import api as db_api from neutron.db import db_base_plugin_v2 from neutron.db.models import securitygroup as sg_models from neutron.extensions import securitygroup as ext_sg _deprecate._moved_global('DefaultSecurityGroup', new_module=sg_models) _deprecate._moved_global('SecurityGroupPortBinding', new_module=sg_models) _deprecate._moved_global('SecurityGroupRule', new_module=sg_models) class SecurityGroupDbMixin(ext_sg.SecurityGroupPluginBase): """Mixin class to add security group to db_base_plugin_v2.""" __native_bulk_support = True def create_security_group_bulk(self, context, security_group_rule): return self._create_bulk('security_group', context, security_group_rule) def _registry_notify(self, res, event, id=None, exc_cls=None, **kwargs): # NOTE(armax): a callback exception here will prevent the request
# 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. from oslo_config import cfg from neutron._i18n import _ from neutron.common import _deprecate from neutron.db import db_base_plugin_v2 from neutron.db.models import l3_attrs from neutron.extensions import availability_zone as az from neutron.extensions import l3 _deprecate._moved_global('RouterExtraAttributes', new_module=l3_attrs) def get_attr_info(): """Returns api visible attr names and their default values.""" return { 'distributed': { 'default': cfg.CONF.router_distributed }, 'ha': { 'default': cfg.CONF.l3_ha }, 'ha_vr_id': { 'default': 0 }, 'availability_zone_hints': {