def _get_l3_admin_net(self, create=False): network = None context = self._get_admin_context() filters = self._get_l3_admin_net_query_filter() networks = self._plugin.get_networks(context, filters=filters) if len(networks) == 0 and create: try: network = self._create_l3_admin_net(context) self._create_l3_admin_subnet(context, network["id"]) except Exception: with excutils.save_and_reraise_exception(): LOG.error(_LE("Error in creating L3 admin network.")) elif len(networks) == 1: network = networks[0] subnet_ids = network.get("subnets") net_id = network["id"] if not subnet_ids and create: try: self._create_l3_admin_subnet(context, net_id) except Exception: with excutils.save_and_reraise_exception(): LOG.error(_LE("Error in creating l3 admin subnet.")) elif len(subnet_ids) == 1: self._validate_l3_admin_subnet(context, subnet_ids[0]) else: msg = _("Expected number of subnets in l3 admin network is " "1, found %d.") % len(subnet_ids) raise exc.L3AdminNetSubnetError(error_message=msg) else: msg = _("Expected number of l3 admin networks is 1, found " "%d.") % len(networks) raise exc.L3AdminNetError(error_message=msg) return network
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) try: idlutils.row_by_value(self.api.idl, 'Logical_Router_Port', 'name', self.name) # The LRP entry with certain name has already exist, raise an # exception to notice caller. It's caller's responsibility to # call UpdateLRouterPortCommand to get LRP entry processed # correctly. msg = _("Logical Router Port with name \"%s\" " "already exists.") % self.name raise RuntimeError(msg) except idlutils.RowNotFound: lrouter_port = txn.insert(self.api._tables['Logical_Router_Port']) lrouter_port.name = self.name for col, val in self.columns.items(): setattr(lrouter_port, col, val) lrouter.verify('ports') lrouter_ports = getattr(lrouter, 'ports', []) if lrouter_port not in lrouter_ports: lrouter_ports.append(lrouter_port) setattr(lrouter, 'ports', lrouter_ports)
def validate_and_get_data_from_binding_profile(self, port): if (ovn_const.OVN_PORT_BINDING_PROFILE not in port or not validators.is_attr_set( port[ovn_const.OVN_PORT_BINDING_PROFILE])): return {} param_set = {} param_dict = {} for param_set in ovn_const.OVN_PORT_BINDING_PROFILE_PARAMS: param_keys = param_set.keys() for param_key in param_keys: try: param_dict[param_key] = (port[ ovn_const.OVN_PORT_BINDING_PROFILE][param_key]) except KeyError: pass if len(param_dict) == 0: continue if len(param_dict) != len(param_keys): msg = _('Invalid binding:profile. %s are all ' 'required.') % param_keys raise n_exc.InvalidInput(error_message=msg) if (len(port[ovn_const.OVN_PORT_BINDING_PROFILE]) != len( param_keys)): msg = _('Invalid binding:profile. too many parameters') raise n_exc.InvalidInput(error_message=msg) break if not param_dict: return {} for param_key, param_type in param_set.items(): if param_type is None: continue param_value = param_dict[param_key] if not isinstance(param_value, param_type): msg = _('Invalid binding:profile. %(key)s %(value)s ' 'value invalid type') % {'key': param_key, 'value': param_value} raise n_exc.InvalidInput(error_message=msg) # Make sure we can successfully look up the port indicated by # parent_name. Just let it raise the right exception if there is a # problem. if 'parent_name' in param_set: self._plugin.get_port(n_context.get_admin_context(), param_dict['parent_name']) if 'tag' in param_set: tag = int(param_dict['tag']) if tag < 0 or tag > 4095: msg = _('Invalid binding:profile. tag "%s" must be ' 'an integer between 0 and 4095, inclusive') % tag raise n_exc.InvalidInput(error_message=msg) return param_dict
def run_idl(self, txn): try: port_chain = idlutils.row_by_value(self.api.idl, 'Logical_Port_Chain', 'name', self.lport_chain) fc = getattr(port_chain, 'flow_classifier', []) except idlutils.RowNotFound: msg = _("Logical port chain %s does not exist") % self.lport_chain raise RuntimeError(msg) if self.may_exist: flow_classifier = idlutils.row_by_value( self.api.idl, 'Logical_Flow_Classifier', 'name', self.lflow_classifier, None) if flow_classifier: return port_chain.verify('flow_classifier') flow_classifier = txn.insert( self.api._tables['Logical_Flow_Classifier']) flow_classifier.name = self.lflow_classifier for col, val in self.columns.items(): setattr(flow_classifier, col, val) # add the newly created flow_classifier to existing lswitch fc.append(flow_classifier.uuid) setattr(port_chain, 'flow_classifier', fc)
def run_idl(self, txn): try: lport_pair = idlutils.row_by_value(self.api.idl, 'Logical_Port_Pair', 'name', self.lport_pair) lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) lppg = idlutils.row_by_value(self.api.idl, 'Logical_Port_Pair_Group', 'name', self.lport_pair_group) port_pairs = getattr(lswitch, 'port_pairs', []) port_pairs_ppg = getattr(lppg, 'port_pairs', []) except idlutils.RowNotFound: if self.if_exists: return msg = _("Port Pair %s does not exist") % self.lport_pair raise RuntimeError(msg) lswitch.verify('port_pairs') lppg.verify('port_pairs') port_pairs.remove(lport_pair) port_pairs_ppg.remove(lport_pair) setattr(lswitch, 'port_pairs', port_pairs) setattr(lppg, 'port_pairs', port_pairs_ppg) self.api._tables['Logical_Port_Pair'].rows[lport_pair.uuid].delete()
def run_idl(self, txn): try: lport_chain = idlutils.row_by_value(self.api.idl, 'Logical_Port_Chain', 'name', self.lport_chain) port_pair_groups = getattr(lport_chain, 'port_pair_groups', []) except idlutils.RowNotFound: msg = _("Logical Port Chain %s does not exist") % self.lport_chain raise RuntimeError(msg) if self.may_exist: port_pair_group = idlutils.row_by_value( self.api.idl, 'Logical_Port_Pair_Group', 'name', self.lport_pair_group, None) if port_pair_group: return lport_chain.verify('port_pair_groups') port_pair_group = txn.insert( self.api._tables['Logical_Port_Pair_Group']) port_pair_group.name = self.lport_pair_group for col, val in self.columns.items(): setattr(port_pair_group, col, val) # add the newly created port_pair to existing lswitch port_pair_groups.append(port_pair_group.uuid) setattr(lport_chain, 'port_pair_groups', port_pair_groups)
def run_idl(self, txn): try: lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) except idlutils.RowNotFound: msg = _("Logical Switch %s does not exist") % self.lswitch raise RuntimeError(msg) if self.may_exist: port = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport, None) if port: return port = txn.insert(self.api._tables['Logical_Switch_Port']) port.name = self.lport dhcpv4_options = self.columns.pop('dhcpv4_options', []) if isinstance(dhcpv4_options, list): port.dhcpv4_options = dhcpv4_options else: port.dhcpv4_options = [dhcpv4_options.result] dhcpv6_options = self.columns.pop('dhcpv6_options', []) if isinstance(dhcpv6_options, list): port.dhcpv6_options = dhcpv6_options else: port.dhcpv6_options = [dhcpv6_options.result] for col, val in self.columns.items(): setattr(port, col, val) # add the newly created port to existing lswitch _addvalue_to_list(lswitch, 'ports', port.uuid)
def run_idl(self, txn): if self.row_uuid not in self.api._tables['DHCP_Options'].rows: if self.if_exists: return msg = _("DHCP Options row %s does not exist") % self.row_uuid raise RuntimeError(msg) self.api._tables['DHCP_Options'].rows[self.row_uuid].delete()
def _delete_acls(self, lswitch_name, acls, acls_delete): for acl_delete in acls_delete: try: acls.remove(acl_delete) except ValueError: msg = _("Logical Switch %s missing acl") % lswitch_name raise RuntimeError(msg) acl_delete.delete()
def delete_lswitch_port(self, lport_name=None, lswitch_name=None, ext_id=None, if_exists=True): if lport_name is not None: return cmd.DelLSwitchPortCommand(self, lport_name, lswitch_name, if_exists) else: raise RuntimeError(_("Currently only supports " "delete by lport-name"))
def delete_lport_chain(self, lswitch_name, lport_chain_name=None, if_exists=True): if lport_chain_name is not None: return cmd.DelLPortChainCommand(self, lswitch_name, lport_chain_name, if_exists) else: raise RuntimeError(_("Currently only supports delete " "by lport-chain-name"))
def delete_lport_pair_group(self, lport_pair_group_name=None, lport_chain=None, ext_id=None, if_exists=True): if lport_pair_group_name is not None: return cmd.DelLogicalPortPairGroupCommand( self, lport_pair_group_name, lport_chain, if_exists) else: raise RuntimeError(_("Currently only supports " "delete by lport-pair-group-name"))
def run_idl(self, txn): try: lrouter_port = idlutils.row_by_value(self.api.idl, 'Logical_Router_Port', 'name', self.name) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router Port %s does not exist") % self.name raise RuntimeError(msg) try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) _delvalue_from_list(lrouter, 'ports', lrouter_port)
def get_chassis_data_for_ml2_bind_port(self, hostname): try: chassis = idlutils.row_by_value(self.idl, 'Chassis', 'hostname', hostname) except idlutils.RowNotFound: msg = _('Chassis with hostname %s does not exist') % hostname raise RuntimeError(msg) return (chassis.external_ids.get('datapath-type', ''), chassis.external_ids.get('iface-types', ''), self._get_chassis_physnets(chassis))
def delete_lflow_classifier(self, lport_chain_name, lflow_classifier_name=None, if_exists=True): if lflow_classifier_name is not None: return cmd.DelLogicalFlowClassifierCommand(self, lport_chain_name, lflow_classifier_name, if_exists) else: raise RuntimeError(_("Currently only delete " "supports by lflow-classifier-name"))
def delete_lport_pair(self, lport_pair_name=None, lswitch=None, lport_pair_group_name=None, if_exists=True): if lport_pair_name is not None: return cmd.DelLogicalPortPairCommand(self, lport_pair_name, lswitch, lport_pair_group_name, if_exists) else: raise RuntimeError(_("Currently only supports " "delete by lport-pair-name"))
def _validate_l3_admin_subnet(self, context, subnet_id): subnet = None try: subnet = self._plugin.get_subnet(context, subnet_id) except Exception: with excutils.save_and_reraise_exception(): LOG.exception(_LE("L3 admin subnet not found")) if subnet.get("cidr") != self._cidr: msg = _("Subnet CIDR %(a)s does not match configured value " "%(e)s.") % { "a": subnet.get("cidr"), "e": self._cidr, } raise exc.L3AdminNetSubnetError(error_message=msg) if subnet.get("name") != ovn_const.OVN_L3_ADMIN_NET_SUBNET_NAME: msg = _("Subnet name %(a)s does not match expected name " "%(e)s.") % { "a": subnet.get("name"), "e": ovn_const.OVN_L3_ADMIN_NET_SUBNET_NAME, } raise exc.L3AdminNetSubnetError(error_message=msg)
def run_idl(self, txn): dhcp_options_row = self._get_dhcp_options_row() if not dhcp_options_row: if self.if_exists: return msg = _("DHCP Options for subnet_id %(lswitch)s , port_id" " % (port_id)s does not exist") % { 'subnet_id': self.subnet_id, 'port_id': self.port_id} raise RuntimeError(msg) self.api._tables['DHCP_Options'].rows[dhcp_options_row.uuid].delete()
def run_idl(self, txn): try: port = idlutils.row_by_value(self.api.idl, 'Logical_Port', 'name', self.lport) except idlutils.RowNotFound: msg = _("Logical Port %s does not exist") % self.lport raise RuntimeError(msg) options = {'router-port': self.lrouter_port} setattr(port, 'options', options) setattr(port, 'type', 'router')
def run_idl(self, txn): try: lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.name) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Switch %s does not exist") % self.name raise RuntimeError(msg) self.api._tables['Logical_Switch'].rows[lswitch.uuid].delete()
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) row = txn.insert(self.api._tables['Logical_Router_Static_Route']) for col, val in self.columns.items(): setattr(row, col, val) _addvalue_to_list(lrouter, 'static_routes', row.uuid)
def run_idl(self, txn): try: addrset = idlutils.row_by_value(self.api.idl, 'Address_Set', 'name', self.name) except idlutils.RowNotFound: if self.if_exists: return msg = _("Address set %s does not exist. " "Can't delete.") % self.name raise RuntimeError(msg) self.api._tables['Address_Set'].rows[addrset.uuid].delete()
def run_idl(self, txn): try: lrouter_port = idlutils.row_by_value(self.api.idl, 'Logical_Router_Port', 'name', self.name) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router Port %s does not exist") % self.name raise RuntimeError(msg) try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) lrouter_ports = getattr(lrouter, 'ports', []) if (lrouter_port in lrouter_ports): lrouter_ports.remove(lrouter_port) setattr(lrouter, 'ports', lrouter_ports)
def run_idl(self, txn): try: port = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Switch Port %s does not exist") % self.lport raise RuntimeError(msg) for col, val in self.columns.items(): setattr(port, col, val)
def _validate_l3_admin_net_ports(self, ports, names): network = netaddr.IPNetwork(self._cidr) for port in ports: fixed_ips = port.get("fixed_ips", []) if not fixed_ips or (fixed_ips and len(fixed_ips) > 1): msg = _("Unexpected fixed ips %(f) for port %(n)s.") % {"f": fixed_ips, "n": port.get("name")} raise exc.L3AdminNetPortsError(error_message=msg) ip = netaddr.IPAddress(fixed_ips[0]["ip_address"]) if ip not in network: msg = _("IP %(ip)s of port %(n)s is not in l3 admin subnet " "cidr %(c)s.") % { "ip": ip, "n": port.get("name"), "c": self._cidr, } raise exc.L3AdminNetPortsError(error_message=msg) port_names = [port["name"] for port in ports] if sorted(port_names) != sorted(names): msg = _("Port names %(a)r does not match expected names " "%(e)r.") % {"a": port_names, "e": names} raise exc.L3AdminNetPortsError(error_message=msg)
def run_idl(self, txn): try: lport_chain = idlutils.row_by_value(self.api.idl, 'Logical_Port_Chain', 'name', self.lport_chain) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Port Chain %s does not exist") % self.lport_chain raise RuntimeError(msg) for col, val in self.columns.items(): setattr(lport_chain, col, val)
def run_idl(self, txn): try: lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) except idlutils.RowNotFound: msg = _("Logical Switch %s does not exist") % self.lswitch raise RuntimeError(msg) row = txn.insert(self.api._tables['ACL']) for col, val in self.columns.items(): setattr(row, col, val) row.external_ids = {'neutron:lport': self.lport} _addvalue_to_list(lswitch, 'acls', row.uuid)
def create_network_precommit(self, context): """Allocate resources for a new network. :param context: NetworkContext instance describing the new network. Create a new network, allocating resources as necessary in the database. Called inside transaction context on session. Call cannot block. Raising an exception will result in a rollback of the current transaction. """ network = context.current # TODO(rtheis): Add support for multi-provider networks when # routed networks are supported. if self._get_attribute(network, mpnet.SEGMENTS): msg = _("Multi-provider networks are not supported") raise n_exc.InvalidInput(error_message=msg) network_segments = context.network_segments network_type = network_segments[0]["network_type"] segmentation_id = network_segments[0]["segmentation_id"] physical_network = network_segments[0]["physical_network"] LOG.debug( "Creating network with type %(network_type)s, " "segmentation ID %(segmentation_id)s, " "physical network %(physical_network)s" % {"network_type": network_type, "segmentation_id": segmentation_id, "physical_network": physical_network} ) if network_type not in [ plugin_const.TYPE_LOCAL, plugin_const.TYPE_FLAT, plugin_const.TYPE_GENEVE, plugin_const.TYPE_VLAN, ]: msg = _("Network type %s is not supported") % network_type raise n_exc.InvalidInput(error_message=msg)
def run_idl(self, txn): try: lport = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) except idlutils.RowNotFound: if self.if_exists: return msg = _("Port %s does not exist") % self.lport raise RuntimeError(msg) _delvalue_from_list(lswitch, 'ports', lport) self.api._tables['Logical_Switch_Port'].rows[lport.uuid].delete()
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.name, None) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router %s does not exist") % self.name raise RuntimeError(msg) if lrouter: for col, val in self.columns.items(): setattr(lrouter, col, val) return
def run_idl(self, txn): try: lport = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) ports = getattr(lswitch, 'ports', []) except idlutils.RowNotFound: if self.if_exists: return msg = _("Port %s does not exist") % self.lport raise RuntimeError(msg) lswitch.verify('ports') ports.remove(lport) setattr(lswitch, 'ports', ports) self.api._tables['Logical_Switch_Port'].rows[lport.uuid].delete()
def run_idl(self, txn): try: lrouter_port = idlutils.row_by_value(self.api.idl, 'Logical_Router_Port', 'name', self.name) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router Port %s does not exist") % self.name raise RuntimeError(msg) if lrouter_port: for col, val in self.columns.items(): if col == 'gateway_chassis': col, val = _add_gateway_chassis(self.api, txn, self.name, val) setattr(lrouter_port, col, val) return
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) static_routes = getattr(lrouter, 'static_routes', []) for route in static_routes: ip_prefix = getattr(route, 'ip_prefix', '') nexthop = getattr(route, 'nexthop', '') if self.ip_prefix == ip_prefix and self.nexthop == nexthop: _delvalue_from_list(lrouter, 'static_routes', route) route.delete() break
def run_idl(self, txn): try: port = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Switch Port %s does not exist") % self.lport raise RuntimeError(msg) # Delete DHCP_Options records no longer referred by this port. # The table rows should be consistent for the same transaction. # After we get DHCP_Options rows uuids from port dhcpv4_options # and dhcpv6_options references, the rows shouldn't disappear for # this transaction before we delete it. cur_port_dhcp_opts = get_lsp_dhcp_options_uuids(port, self.lport) new_port_dhcp_opts = set() dhcpv4_options = self.columns.pop('dhcpv4_options', None) if dhcpv4_options is None: new_port_dhcp_opts.update([ option.uuid for option in getattr(port, 'dhcpv4_options', []) ]) elif isinstance(dhcpv4_options, list): new_port_dhcp_opts.update(dhcpv4_options) port.dhcpv4_options = dhcpv4_options else: new_port_dhcp_opts.add(dhcpv4_options.result) port.dhcpv4_options = [dhcpv4_options.result] dhcpv6_options = self.columns.pop('dhcpv6_options', None) if dhcpv6_options is None: new_port_dhcp_opts.update([ option.uuid for option in getattr(port, 'dhcpv6_options', []) ]) elif isinstance(dhcpv6_options, list): new_port_dhcp_opts.update(dhcpv6_options) port.dhcpv6_options = dhcpv6_options else: new_port_dhcp_opts.add(dhcpv6_options.result) port.dhcpv6_options = [dhcpv6_options.result] for uuid in cur_port_dhcp_opts - new_port_dhcp_opts: self.api._tables['DHCP_Options'].rows[uuid].delete() for col, val in self.columns.items(): setattr(port, col, val)
def run_idl(self, txn): try: lport = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) except idlutils.RowNotFound: if self.if_exists: return msg = _("Port %s does not exist") % self.lport raise RuntimeError(msg) # Delete DHCP_Options records no longer referred by this port. cur_port_dhcp_opts = get_lsp_dhcp_options_uuids(lport, self.lport) for uuid in cur_port_dhcp_opts: self.api._tables['DHCP_Options'].rows[uuid].delete() _delvalue_from_list(lswitch, 'ports', lport) self.api._tables['Logical_Switch_Port'].rows[lport.uuid].delete()
def run_idl(self, txn): try: lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Switch %s does not exist") % self.lswitch raise RuntimeError(msg) acls_to_del = [] acls = getattr(lswitch, 'acls', []) for acl in acls: ext_ids = getattr(acl, 'external_ids', {}) if ext_ids.get('neutron:lport') == self.lport: acls_to_del.append(acl) for acl in acls_to_del: acl.delete() _updatevalues_in_list(lswitch, 'acls', old_values=acls_to_del)
def run_idl(self, txn): try: lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch', 'name', self.lswitch) except idlutils.RowNotFound: msg = _("Logical Switch %s does not exist") % self.lswitch raise RuntimeError(msg) if self.may_exist: port = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport, None) if port: return port = txn.insert(self.api._tables['Logical_Switch_Port']) port.name = self.lport for col, val in self.columns.items(): setattr(port, col, val) # add the newly created port to existing lswitch _addvalue_to_list(lswitch, 'ports', port.uuid)
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) nats = getattr(lrouter, 'nat', []) for nat in nats: logical_ip = getattr(nat, 'logical_ip', '') external_ip = getattr(nat, 'external_ip', '') type = getattr(nat, 'type', '') if (not self.logical_ip or self.logical_ip == logical_ip) and \ (not self.external_ip or self.external_ip == external_ip) and \ (not self.type or self.type == type): _delvalue_from_list(lrouter, 'nat', nat) nat.delete() break
def get_lrouter_nat_rules(self, lrouter_name): try: lrouter = idlutils.row_by_value(self.idl, 'Logical_Router', 'name', lrouter_name) except idlutils.RowNotFound: msg = _("Logical Router %s does not exist") % lrouter_name raise RuntimeError(msg) nat_rules = [] for nat_rule in getattr(lrouter, 'nat', []): ext_ids = {} # TODO(dalvarez): remove this check once the minimum OVS required # version contains the column (when OVS 2.8.2 is released). if self.is_col_present('NAT', 'external_ids'): ext_ids = dict(getattr(nat_rule, 'external_ids', {})) nat_rules.append({'external_ip': nat_rule.external_ip, 'logical_ip': nat_rule.logical_ip, 'type': nat_rule.type, 'uuid': nat_rule.uuid, 'external_ids': ext_ids}) return nat_rules
def run_idl(self, txn): try: port = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Switch Port %s does not exist") % self.lport raise RuntimeError(msg) # Delete DHCP_Options records no longer refered by this port. # The table rows should be consistent for the same transaction. # After we get a DHCP_Options row uuid from port dhcpv4_options # reference, the row shouldn't disappear for this transaction, # before we delete it. cur_port_dhcp_opts = get_lsp_dhcpv4_options_uuids(port, self.lport) new_port_dhcp_opts = set(self.columns.get('dhcpv4_options', [])) for uuid in cur_port_dhcp_opts - new_port_dhcp_opts: self.api._tables['DHCP_Options'].rows[uuid].delete() for col, val in self.columns.items(): setattr(port, col, val)
def run_idl(self, txn): try: lrouter_port = idlutils.row_by_value(self.api.idl, 'Logical_Router_Port', 'name', self.name) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router Port %s does not exist") % self.name raise RuntimeError(msg) # TODO(lucasagomes): Remove this check once we drop the support # for OVS versions <= 2.8 ipv6_ra_configs_supported = self.api.is_col_present( 'Logical_Router_Port', 'ipv6_ra_configs') for col, val in self.columns.items(): if col == 'ipv6_ra_configs' and not ipv6_ra_configs_supported: continue if col == 'gateway_chassis': col, val = _add_gateway_chassis(self.api, txn, self.name, val) setattr(lrouter_port, col, val)
def run_idl(self, txn): try: addrset = idlutils.row_by_value(self.api.idl, 'Address_Set', 'name', self.name) except idlutils.RowNotFound: if self.if_exists: return msg = _("Address set %s does not exist. " "Can't update addresses") % self.name raise RuntimeError(msg) addrset.verify('addresses') addresses_col = getattr(addrset, 'addresses', []) if self.addrs_add: # OVN will ignore duplicate addresses. for addr_add in self.addrs_add: addresses_col.append(addr_add) if self.addrs_remove: # OVN will ignore addresses that don't exist. for addr_remove in self.addrs_remove: if addr_remove in addresses_col: addresses_col.remove(addr_remove) setattr(addrset, 'addresses', addresses_col)
def run_idl(self, txn): try: lport = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) except idlutils.RowNotFound: msg = _("Logical Switch Port %s does not exist") % self.lport raise RuntimeError(msg) lport.verify('addresses') addresses = getattr(lport, 'addresses', []) lport.verify('options') options = getattr(lport, 'options', {}) nat_ip_list = options.get('nat-addresses', '').split() if not nat_ip_list: nat_ips = addresses[0].split()[0] + ' ' + self.nat_ip elif self.nat_ip not in nat_ip_list: nat_ip_list.append(self.nat_ip) nat_ips = ' '.join(nat_ip_list) else: return options['nat-addresses'] = nat_ips lport.options = options
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) lrouter.verify('nat') # TODO(chandrav): convert this to ovs transaction mutate nats = getattr(lrouter, 'nat', []) for nat in nats: type = getattr(nat, 'type', '') external_ip = getattr(nat, 'external_ip', '') logical_ip = getattr(nat, 'logical_ip', '') if (self.type == type and self.external_ip == external_ip and self.logical_ip == logical_ip): nats.remove(nat) nat.delete() break setattr(lrouter, 'nat', nats)
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: if self.if_exists: return msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) static_routes = getattr(lrouter, 'static_routes', []) for route in static_routes: ip_prefix = getattr(route, 'ip_prefix', '') nexthop = getattr(route, 'nexthop', '') if self.ip_prefix == ip_prefix and self.nexthop == nexthop: # TODO(rtheis): Use mutate for adding and deleting static # routes once bug 1629099 is fixed. _delvalue_from_list(lrouter, 'static_routes', route, mutate=False) route.delete() break
def run_idl(self, txn): try: lrouter = idlutils.row_by_value(self.api.idl, 'Logical_Router', 'name', self.lrouter) except idlutils.RowNotFound: msg = _("Logical Router %s does not exist") % self.lrouter raise RuntimeError(msg) try: idlutils.row_by_value(self.api.idl, 'Logical_Router_Port', 'name', self.name) # TODO(chandrav) This might be a case of multiple prefixes # on the same port. yet to figure out if and how OVN needs # to cater to this case except idlutils.RowNotFound: lrouter_port = txn.insert(self.api._tables['Logical_Router_Port']) lrouter_port.name = self.name for col, val in self.columns.items(): setattr(lrouter_port, col, val) lrouter.verify('ports') lrouter_ports = getattr(lrouter, 'ports', []) if lrouter_port not in lrouter_ports: lrouter_ports.append(lrouter_port) setattr(lrouter, 'ports', lrouter_ports)
def run_idl(self, txn): try: lport = idlutils.row_by_value(self.api.idl, 'Logical_Switch_Port', 'name', self.lport) except idlutils.RowNotFound: msg = _("Logical Switch Port %s does not exist") % self.port raise RuntimeError(msg) lport.verify('options') options = getattr(lport, 'options', {}) nat_ip_list = options.get('nat-addresses', '').split() if self.nat_ip not in nat_ip_list: return nat_ip_list.remove(self.nat_ip) if len(nat_ip_list) is 1: nat_ips = '' else: nat_ips = ' '.join(nat_ip_list) if not nat_ips: del options['nat-addresses'] else: options['nat-addresses'] = nat_ips lport.options = options
# 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 networking_ovn._i18n import _ from neutron.extensions import portbindings ovn_opts = [ cfg.StrOpt('ovsdb_connection', deprecated_for_removal=True, default='tcp:127.0.0.1:6640', help=_('The connection string for the native OVSDB backend.' 'This option is going to be deprecated and be replaced' 'by option ovn_nb_connection.')), cfg.StrOpt('ovn_nb_connection', deprecated_name='ovsdb_connection', default='tcp:127.0.0.1:6641', help=_('The connection string for the OVN_Northbound OVSDB')), cfg.StrOpt('ovn_sb_connection', default='tcp:127.0.0.1:6642', help=_('The connection string for the OVN_Southbound OVSDB')), cfg.IntOpt('ovsdb_connection_timeout', default=60, help=_('Timeout in seconds for the OVSDB ' 'connection transaction')), cfg.StrOpt('neutron_sync_mode', default='log', choices=('off', 'log', 'repair'),
class OvsdbConnectionUnavailable(n_exc.ServiceUnavailable): message = _("OVS database connection to %(db_schema)s failed with error: " "'%(error)s'. Verify that the OVS and OVN services are " "available and that the 'ovn_nb_connection' and " "'ovn_sb_connection' configuration options are correct.")
EXTRA_LOG_LEVEL_DEFAULTS = [] VLOG_LEVELS = { 'CRITICAL': vlog.CRITICAL, 'ERROR': vlog.ERROR, 'WARNING': vlog.WARN, 'INFO': vlog.INFO, 'DEBUG': vlog.DEBUG } ovn_opts = [ cfg.StrOpt('ovn_nb_connection', default='tcp:127.0.0.1:6641', help=_('The connection string for the OVN_Northbound OVSDB.\n' 'Use tcp:IP:PORT for TCP connection.\n' 'Use ssl:IP:PORT for SSL connection. The ' 'ovn_nb_private_key, ovn_nb_certificate and ' 'ovn_nb_ca_cert are mandatory.\n' 'Use unix:FILE for unix domain socket connection.')), cfg.StrOpt('ovn_nb_private_key', default='', help=_('The PEM file with private key for SSL connection to ' 'OVN-NB-DB')), cfg.StrOpt('ovn_nb_certificate', default='', help=_('The PEM file with certificate that certifies the ' 'private key specified in ovn_nb_private_key')), cfg.StrOpt('ovn_nb_ca_cert', default='', help=_('The PEM file with CA certificate that OVN should use to' ' verify certificates presented to it by SSL peers')), cfg.StrOpt('ovn_sb_connection',
class UnknownResourceType(n_exc.NeutronException): message = _('Uknown resource type: %(resource_type)s')
from neutron_lib.utils import host from oslo_config import cfg from networking_ovn._i18n import _ DEDUCE_MODE = 'deduce' USER_MODE = 'user' GROUP_MODE = 'group' ALL_MODE = 'all' SOCKET_MODES = (DEDUCE_MODE, USER_MODE, GROUP_MODE, ALL_MODE) SHARED_OPTS = [ cfg.StrOpt('metadata_proxy_socket', default='$state_path/metadata_proxy', help=_('Location for Metadata Proxy UNIX domain socket.')), cfg.StrOpt('metadata_proxy_user', default='', help=_("User (uid or name) running metadata proxy after " "its initialization (if empty: agent effective " "user).")), cfg.StrOpt('metadata_proxy_group', default='', help=_("Group (gid or name) running metadata proxy after " "its initialization (if empty: agent effective " "group).")), cfg.StrOpt('ovs_integration_bridge', default='br-int', help=_('Name of Open vSwitch bridge to use')) ]
class HashRingIsEmpty(n_exc.NeutronException): message = _('Hash Ring returned empty when hashing "%(key)s". ' 'This should never happen in a normal situation, please ' 'check the status of your cluster')
class RevisionConflict(n_exc.NeutronException): message = _('OVN revision number for %(resource_id)s (type: ' '%(resource_type)s) is equal or higher than the given ' 'resource. Skipping update')
class JournalAlreadyStarted(n_exc.NeutronException): message = _('Journal thread already started')
class StandardAttributeIDNotFound(n_exc.NeutronException): message = _('Standard attribute ID not found for %(resource_uuid)s')
# # 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 networking_ovn._i18n import _ from neutron.extensions import portbindings ovn_opts = [ cfg.StrOpt('ovsdb_connection', default='tcp:127.0.0.1:6640', help=_('The connection string for the native OVSDB backend')), cfg.IntOpt('ovsdb_connection_timeout', default=60, help=_('Timeout in seconds for the OVSDB ' 'connection transaction')), cfg.StrOpt('neutron_sync_mode', default='log', choices=('off', 'log', 'repair'), help=_('The synchronization mode of OVN with Neutron DB. \n' 'off - synchronization is off \n' 'log - during neutron-server startup, ' 'check to see if OVN is in sync with ' 'the Neutron database. ' ' Log warnings for any inconsistencies found so' ' that an admin can investigate \n' 'repair - during neutron-server startup, automatically'
class ProtocolNotSupported(n_exceptions.NeutronException): message = _('The protocol "%(protocol)s" is not supported. Valid ' 'protocols are: %(valid_protocols)s; or protocol ' 'numbers ranging from 0 to 255.')
class AgentStatsNotFound(n_exc.NeutronException): _message = _('The stats for agent %(agent_id)s could not be found')