def validate_network_mapping_list_without_seg_id_validation( network_mapping, check_vlan): """Validate network mapping list in connection.""" if network_mapping.get('segmentation_id'): if check_vlan: raise exceptions.InvalidInput( error_message=_("default segmentation_id should not be" " provided when segmentation_id is assigned" " during l2gateway creation")) # This method doen't check segmentation id range. if not network_mapping.get('segmentation_id'): if check_vlan is False: raise exceptions.InvalidInput( error_message=_("Segmentation id must be specified in create " "l2gateway connections")) network_id = network_mapping.get(l2gw_const.NETWORK_ID) if not network_id: raise exceptions.InvalidInput( error_message=_("A valid network identifier must be specified " "when connecting a network to a network " "gateway. Unable to complete operation")) connection_attrs = set(network_mapping.keys()) if not connection_attrs.issubset( l2gw_validators.ALLOWED_CONNECTION_ATTRIBUTES): raise exceptions.InvalidInput( error_message=(_("Invalid keys found among the ones provided " "in request : %(connection_attrs)s."), connection_attrs)) return network_id
def validate_network_mapping_list_without_seg_id_validation(network_mapping, check_vlan): """Validate network mapping list in connection.""" if network_mapping.get('segmentation_id'): if check_vlan: raise exceptions.InvalidInput( error_message=_("default segmentation_id should not be" " provided when segmentation_id is assigned" " during l2gateway creation")) # This method doen't check segmentation id range. if not network_mapping.get('segmentation_id'): if check_vlan is False: raise exceptions.InvalidInput( error_message=_("Segmentation id must be specified in create " "l2gateway connections")) network_id = network_mapping.get(l2gw_const.NETWORK_ID) if not network_id: raise exceptions.InvalidInput( error_message=_("A valid network identifier must be specified " "when connecting a network to a network " "gateway. Unable to complete operation")) connection_attrs = set(network_mapping.keys()) if not connection_attrs.issubset(l2gw_validators. ALLOWED_CONNECTION_ATTRIBUTES): raise exceptions.InvalidInput( error_message=(_("Invalid keys found among the ones provided " "in request : %(connection_attrs)s."), connection_attrs)) return network_id
def add_known_arguments(self, parser): parser.add_argument( '--management-ip', dest='management_ip', help=_('Management IP to the device. Defaults to None.')) parser.add_argument( '--management-port', dest='management_port', help=_('Management port to the device. Defaults to None.')) parser.add_argument( '--management-protocol', dest='management_protocol', help=_('Management protocol to manage the device: ovsdb or none. ' 'If management ip and port are specified, ' 'defaults to ovsdb. Otherwise to none.')) parser.add_argument( '--type', metavar='<hw_vtep | router_vtep | network_vlan>', choices=['hw_vtep', 'router_vtep', 'network_vlan'], help=_('Type of the device: hw_vtep, router_vtep or network_vlan. ' 'Defaults to hw_vtep')) parser.add_argument( '--resource-id', dest='resource_id', help=_('Resource UUID or None (for type router_vtep will ' 'be router UUID and for type network_vlan will be network ' 'UUID)')) add_name_and_tunnel_ips_to_arguments(parser) return parser
def validate_gwdevice_list(data, valid_values=None): """Validate the list of devices.""" if not data: # Devices must be provided msg = _("Cannot create a gateway with an empty device list") return msg if len(data) > 1: # The number of devices must be exactly one msg = _("Exactly one device must be specified to create a gateway") return msg try: for device in data: err_msg = validators.validate_dict(device, None) if err_msg: return err_msg device_id = device.get('device_id') if not device_id: msg = _("Cannot create a gateway with an empty device_id") return msg # Don't accept any interface. However, when supporting HW VTEPs # this must be supported. # TODO(RYU): Allow setting segmentation ID in some way if device.get('interfaces'): msg = _("Interfaces are not allowed in MidoNet L2GW") return msg device['interfaces'] = [] except TypeError: return (_("%s: provided data are not iterable") % validate_gwdevice_list.__name__) return None
def validate_gwdevice_list(data, valid_values=None): """Validate the list of devices.""" if not data: # Devices must be provided msg = _("Cannot create a gateway with an empty device list") return msg if len(data) > 1: # The number of devices must be exactly one msg = _("Exactly one device must be specified to create a gateway") return msg try: for device in data: err_msg = attributes._validate_dict(device, None) if err_msg: return err_msg device_id = device.get('device_id') if not device_id: msg = _("Cannot create a gateway with an empty device_id") return msg # Don't accept any interface. However, when supporting HW VTEPs # this must be supported. # TODO(RYU): Allow setting segmentation ID in some way if device.get('interfaces'): msg = _("Interfaces are not allowed in MidoNet L2GW") return msg device['interfaces'] = [] except TypeError: return (_("%s: provided data are not iterable") % validate_gwdevice_list.__name__)
def is_valid_vxlan_id(seg_id): try: int_seg_id = int(seg_id) except ValueError: msg = _("Segmentation id must be a valid integer") raise exceptions.InvalidInput(error_message=msg) if int_seg_id < 0 or int_seg_id >= constants.MAX_VXLAN_VNI: msg = _("Segmentation id is out of range") raise exceptions.InvalidInput(error_message=msg)
def add_common_paramaters_to_arguments(parser): parser.add_argument( '--enabled', metavar='<True | False>', choices=['True', 'False'], help=_('Enable/disable for the logging. Defaults to False.')) parser.add_argument('--description', dest='description', help=_('Description of logging.'))
def add_name_and_tunnel_ips_to_arguments(parser): parser.add_argument( '--name', dest='name', help=_('User defined device name.')) parser.add_argument( '--tunnel-ip', metavar='TUNNEL_IP', action='append', dest='tunnel_ips', help=_('IP address on which gateway device originates or ' 'terminates tunnel.'))
def add_name_and_tunnel_ips_to_arguments(parser): parser.add_argument('--name', dest='name', help=_('User defined device name.')) parser.add_argument('--tunnel-ip', metavar='TUNNEL_IP', action='append', dest='tunnel_ips', help=_( 'IP address on which gateway device originates or ' 'terminates tunnel.'))
def add_known_arguments(self, parser): super(RemoteMacEntryCreate, self).add_known_arguments(parser) parser.add_argument('--mac-address', dest='mac_address', required=True, help=_('Remote MAC address')) parser.add_argument('--vtep-address', dest='vtep_address', required=True, help=_('Remote VTEP Tunnel IP')) parser.add_argument('--segmentation-id', dest='segmentation_id', required=True, help=_('VNI to be used'))
class ResourceInUseByLoggingResource(nexception.InUse): message = _("%(resource_name)s %(resource_id)s %(reason)s") def __init__(self, **kwargs): if 'reason' not in kwargs: kwargs['reason'] = "is in use by logging resource" super(ResourceInUseByLoggingResource, self).__init__(**kwargs)
def add_known_arguments(self, parser): parser.add_argument('name', metavar='NAME', help=_('User defined logging name.')) add_common_paramaters_to_arguments(parser) return parser
def get_parser(self, parser): parser = super(gw_deviceV20.CreateCommand, self).get_parser(parser) parser.add_argument( '--mac-address', dest='mac_address', required=True, help=_('Remote MAC address')) parser.add_argument( '--vtep-address', dest='vtep_address', required=True, help=_('Remote VTEP Tunnel IP')) parser.add_argument( '--segmentation-id', dest='segmentation_id', required=True, help=_('VNI to be used')) self.add_known_arguments(parser) return parser
class BgpSpeakerInUse(nexception.InUse): message = _("Bgp speaker %(id)s %(reason)s") def __init__(self, **kwargs): if 'reason' not in kwargs: kwargs['reason'] = "is still associated with bgp peers" super(BgpSpeakerInUse, self).__init__(**kwargs)
class GatewayDeviceInUse(nexception.InUse): message = _("Gateway device %(id)s %(reason)s") def __init__(self, **kwargs): if 'reason' not in kwargs: kwargs['reason'] = "is in use by l2 gateway" super(GatewayDeviceInUse, self).__init__(**kwargs)
class GatewayDeviceParamDuplicate(nexception.InUse): message = _("%(param_name)s %(param_value)s %(reason)s") def __init__(self, **kwargs): if 'reason' not in kwargs: kwargs['reason'] = "is already used" super(GatewayDeviceParamDuplicate, self).__init__(**kwargs)
class MidonetBgpPeerInUse(nexception.InUse): message = _("bgp peer %(id)s %(reason)s") def __init__(self, **kwargs): if 'reason' not in kwargs: kwargs['reason'] = "is already associated with bgp speaker" super(MidonetBgpPeerInUse, self).__init__(**kwargs)
class DeviceInUseByGatewayDevice(nexception.InUse): message = _("device %(resource_id)s (%(resource_type)s) %(reason)s") def __init__(self, **kwargs): if 'reason' not in kwargs: kwargs['reason'] = "is in use by gateway device" super(DeviceInUseByGatewayDevice, self).__init__(**kwargs)
def add_known_arguments(self, parser): parser.add_argument( '--device', metavar='device_id=DEVICE_ID,segmentaion_id=SEGMENTAION_ID', action='append', dest='devices', type=helpers.str2dict, help=_('Device id and segmentation id of l2gateway. ' '--device option can be repeated'))
def is_midonet_network(context): """Checks whether the context is mech driver context for MidoNet driver """ if isinstance(context, ctx.NetworkContext): net = context.current elif isinstance(context, ctx.PortContext): net = context.network.current elif isinstance(context, ctx.SubnetContext): net = context.network.current else: raise ValueError(_("Invalid Mechanism driver context passed in.")) return net.get(provider_net.NETWORK_TYPE) in const.MIDONET_NET_TYPES
def _process_provider_create(self, network): net_type = network.get(pnet.NETWORK_TYPE) if not validators.is_attr_set(net_type): return None if net_type == m_const.TYPE_MIDONET: return None if net_type != m_const.TYPE_UPLINK: msg = _('Unsupported network type %(type)s detected ' 'in a create network request.') % {'type': net_type} raise n_exc.InvalidInput(error_message=msg) return net_type
def _process_provider_create(self, network): net_type = network.get(pnet.NETWORK_TYPE) if not attributes.is_attr_set(net_type): return None if net_type in _MIDONET_TYPES: # NOTE(yamamoto): Accept a few well-known types as # the default type. This is a workaround for Horizon, which # currently doesn't have a way to specify MidoNet network types # or "no provider network". # REVISIT(yamamoto): Clean this up once Horizon is fixed if net_type != m_const.TYPE_MIDONET: LOG.warning(_LW('Unsupported network type %(type)s detected ' 'in a create network request.'), {'type': net_type}) return None if net_type != m_const.TYPE_UPLINK: msg = _('Unsupported network type %(type)s detected ' 'in a create network request.') % {'type': net_type} raise n_exc.InvalidInput(error_message=msg) return net_type
class MidonetL2GatewayUnavailable(nexception.ServiceUnavailable): message = _("Midonet L2 Gateway Service is unavailable " "because Gateway Device Management Service is disabled.")
class RemoteMacEntryNotFound(nexception.NotFound): message = _("Remote MAC entry %(id)s does not exist")
class DuplicateRemoteMacEntry(nexception.InUse): message = _("Request contains duplicate remote mac address entry: " "mac_address %(mac_address)s.")
parser.set_defaults(func=data_show) parser = subparsers.add_parser('data-readonly') parser.set_defaults(func=data_readonly) parser = subparsers.add_parser('data-readwrite') parser.set_defaults(func=data_readwrite) parser = subparsers.add_parser('data-version-list') parser.set_defaults(func=data_version_list) parser = subparsers.add_parser('data-version-sync') parser.set_defaults(func=data_version_sync) parser = subparsers.add_parser('data-version-activate') parser.set_defaults(func=data_version_activate) command_opt = cfg.SubCommandOpt('command', title='Command', help=_('Available commands'), handler=add_command_parsers) # Override the db management options with our own version CONF.unregister_opt(n_cli.command_opt) CONF.register_cli_opt(command_opt) def get_alembic_config(): config = alembic_config.Config(os.path.join(os.path.dirname(__file__), 'alembic.ini')) config.set_main_option('script_location', 'midonet.neutron.db.migration:alembic_migration') return config
class RouterVtepTypeInvalid(nexception.InvalidInput): message = _("Gateway device %(type)s must be specified with " "resource_id")
class NetworkVlanTypeInvalid(nexception.InvalidInput): message = _("Gateway device %(type)s must be specified with " "resource_id")
class HwVtepTypeInvalid(nexception.InvalidInput): message = _("Gateway device %(type)s must be specified with " "management_port and management_ip")
class TunnelIPsRequired(nexception.BadRequest): message = _("Unable to complete operation for Gateway Device. " "The tunnel ips are required for %(gw_type)s type.")
def validate_provider_segment(self, segment): for key, value in six.iteritems(segment): if value and key != api.NETWORK_TYPE: msg = _("%s prohibited for uplink provider network") % key raise exc.InvalidInput(error_message=msg)
class TunnelIPsExhausted(nexception.BadRequest): message = _("Unable to complete operation for Gateway Device. " "The number of tunnel ips exceeds the maximum 1.")
class GatewayDeviceNotFound(nexception.NotFound): message = _("Gateway device %(id)s does not exist")
class RemoteMacEntryWrongGatewayDevice(nexception.InvalidInput): message = _("Remote MAC entry %(id)s does not belong to gateway " "device %(gateway_device_id)s")
class ResourceNotFound(nexception.NotFound): message = _("specified resource %(resource_id)s does not exist")
class OperationRemoteMacEntryNotSupported(nexception.Conflict): message = _("Unable to operate remote_mac_entry for gateway device " "%(type)s type.")
def add_known_arguments(self, parser): parser.add_argument( 'gateway_device', metavar='GATEWAY_DEVICE', help=_('ID of the gateway device.'))
# 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 oslo_config import cfg from midonet.neutron._i18n import _ mido_opts = [ cfg.StrOpt('midonet_uri', default='http://localhost:8080/midonet-api', help=_('MidoNet API server URI.')), cfg.StrOpt('username', default='admin', help=_('MidoNet admin username.')), cfg.StrOpt('password', default='passw0rd', secret=True, help=_('MidoNet admin password.')), cfg.StrOpt('project_id', default='77777777-7777-7777-7777-777777777777', help=_('ID of the project that MidoNet admin user ' 'belongs to.')), cfg.StrOpt('tunnel_protocol', default='vxlan', help=_('Tunnel protocol used by Midonet')), cfg.StrOpt('cluster_ip', default='localhost', help=_('IP that the cluster service can be reached on')), cfg.StrOpt('cluster_port', default='8088', help=_('Port that the cluster service can be reached on')),
def _validate_port_create(self, port): if (port.get('device_owner') == n_const.DEVICE_OWNER_ROUTER_GW and not port['fixed_ips']): msg = (_("No IPs assigned to the gateway port for" " router %s") % port['device_id']) raise n_exc.BadRequest(resource='router', msg=msg)
class MidonetL2GatewayConnectionExists(nexception.InUse): message = _("L2 Gateway Connection related to " "specified L2 Gateway %(l2_gateway_id)s already exists")
def create_port(self, context, port): LOG.debug("MidonetPluginV2.create_port called: port=%r", port) port_data = port['port'] # REVISIT(yamamoto): this nested transaction is a workaround # for bug #1490917. with db_api.autonested_transaction(context.session): # Set status along admin_state_up if the parameter is specified. if port['port'].get('admin_state_up') is not None: if not port['port']['admin_state_up']: port['port']['status'] = n_const.PORT_STATUS_DOWN # Create a Neutron port new_port = super(MidonetPluginV2, self).create_port(context, port) # Do not create a gateway port if it has no IP address assigned as # MidoNet does not yet handle this case. if (new_port.get('device_owner') == n_const.DEVICE_OWNER_ROUTER_GW and not new_port['fixed_ips']): msg = (_("No IPs assigned to the gateway port for" " router %s") % port_data['device_id']) raise n_exc.BadRequest(resource='router', msg=msg) dhcp_opts = port['port'].get(edo_ext.EXTRADHCPOPTS, []) # Make sure that the port created is valid if "id" not in new_port: raise n_exc.BadRequest(resource='port', msg="Invalid port created") # Update fields port_data.update(new_port) port_psec, has_ip = self._determine_port_security_and_has_ip( context, port['port']) port['port'][psec.PORTSECURITY] = port_psec self._process_port_port_security_create(context, port['port'], new_port) if port_psec is False: if self._check_update_has_security_groups(port): raise psec.PortSecurityAndIPRequiredForSecurityGroups() if self._check_update_has_allowed_address_pairs(port): raise addr_pair.AddressPairAndPortSecurityRequired() else: # Bind security groups to the port self._ensure_default_security_group_on_port(context, port) sg_ids = self._get_security_groups_on_port(context, port) self._process_port_create_security_group(context, new_port, sg_ids) # Process port bindings self._process_portbindings_create_and_update(context, port_data, new_port) self._process_mido_portbindings_create_and_update(context, port_data, new_port) self._process_port_create_extra_dhcp_opts(context, new_port, dhcp_opts) new_port[addr_pair.ADDRESS_PAIRS] = ( self._process_create_allowed_address_pairs( context, new_port, port_data.get(addr_pair.ADDRESS_PAIRS))) self.client.create_port_precommit(context, new_port) try: self.client.create_port_postcommit(new_port) except Exception as ex: with excutils.save_and_reraise_exception(): LOG.error(_LE("Failed to create a port %(new_port)s: %(err)s"), {"new_port": new_port, "err": ex}) try: self.delete_port(context, new_port['id'], l3_port_check=False) except Exception: LOG.exception(_LE("Failed to delete port %s"), new_port['id']) # NOTE(kevinbenton): this extra lookup is necessary to get the # latest db model for the extension functions port_model = self._get_port(context, new_port['id']) self._apply_dict_extend_functions('ports', new_port, port_model) LOG.debug("MidonetPluginV2.create_port exiting: port=%r", new_port) return new_port