import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargetsBuilder;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceBuilder;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortipPortData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetAddedToVpnBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetDeletedFromVpnBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapBuilder;
public class NetvirtVpnUtils {
private static final Logger logger = LoggerFactory.getLogger(NetvirtVpnUtils.class);
private final static String ELAN_PREFIX = "elan.";
- private final static String TRUNK_SUFFIX = "-trunk";
- private final static String VLAN_SEPARATOR = ".";
private final static String IP_ADDR_SUFFIX = "/32";
private final static String IP_MUSK_SEPARATOR = "/";
- private final static int MaxRetries = 10;
public static void createVpnInstance(DataBroker dataBroker, String instanceName) {
+ WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
+ createVpnInstance(instanceName, tx);
+ MdsalUtils.commitTransaction(tx);
+ }
+
+ public static void createVpnInstance(String instanceName, WriteTransaction tx) {
VpnInstanceBuilder builder = new VpnInstanceBuilder();
builder.setVpnInstanceName(instanceName);
Ipv4FamilyBuilder ipv4FamilyBuilder = new Ipv4FamilyBuilder();
- ipv4FamilyBuilder.setVpnTargets(new VpnTargetsBuilder().build());
+ VpnTargetsBuilder vpnTargetsB = new VpnTargetsBuilder();
+ vpnTargetsB.setVpnTarget(new ArrayList<VpnTarget>());
+ ipv4FamilyBuilder.setVpnTargets(vpnTargetsB.build());
+
// WA till netvirt will allow creation of VPN without RD
UUID vpnId = UUID.fromString(instanceName);
String rd = String.valueOf(Math.abs(vpnId.getLeastSignificantBits()));
ipv4FamilyBuilder.setRouteDistinguisher(rd);
builder.setIpv4Family(ipv4FamilyBuilder.build());
- MdsalUtils.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
- getVpnInstanceInstanceIdentifier(instanceName), builder.build());
+ tx.put(LogicalDatastoreType.CONFIGURATION, getVpnInstanceInstanceIdentifier(instanceName), builder.build());
+ }
+
+ public static void removeVpnInstance(String instanceName, WriteTransaction tx) {
+ tx.delete(LogicalDatastoreType.CONFIGURATION, getVpnInstanceInstanceIdentifier(instanceName));
+ }
+
+ private static InstanceIdentifier<VpnInstance> getVpnInstanceInstanceIdentifier(String instanceName) {
+ return InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class, new VpnInstanceKey(instanceName))
+ .build();
}
public static void createUpdateVpnInterface(DataBroker dataBroker, String vpnName, String interfaceName,
- IpPrefix ifPrefix, MacAddress macAddress, boolean primary, IpPrefix gwIpAddress) {
+ String ifAddr, String macAddress, boolean primary, String gwIpAddress) {
+ WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
+ createUpdateVpnInterface(vpnName, interfaceName, ifAddr, macAddress, primary, gwIpAddress, tx);
+ MdsalUtils.commitTransaction(tx);
+ }
+
+ public static void createUpdateVpnInterface(String vpnName, String interfaceName, IpPrefix ifPrefix,
+ String macAddress, boolean primary, IpPrefix gwIpAddress, WriteTransaction tx) {
synchronized (interfaceName.intern()) {
String ipAddress = null;
String nextHopIp = null;
if (primary) {
- ipAddress = getPrefixFromSubnet(MefUtils.ipPrefixToString(ifPrefix));
+ ipAddress = getAddressFromSubnet(ipPrefixToString(ifPrefix));
} else {
- ipAddress = MefUtils.ipPrefixToString(ifPrefix);
- nextHopIp = getIpAddressFromPrefix(MefUtils.ipPrefixToString(gwIpAddress));
+ ipAddress = ipPrefixToString(ifPrefix);
+ nextHopIp = getIpAddressFromPrefix(ipPrefixToString(gwIpAddress));
}
+ createUpdateVpnInterface(vpnName, interfaceName, ipAddress, macAddress, primary, nextHopIp, tx);
+ }
+ }
+ public static void createUpdateVpnInterface(String vpnName, String interfaceName, String ipAddress,
+ String macAddress, boolean primary, String nextHopIp, WriteTransaction tx) {
+ synchronized (interfaceName.intern()) {
Adjacencies adjancencies = buildInterfaceAdjacency(ipAddress, macAddress, primary, nextHopIp);
VpnInterfaceBuilder einterfaceBuilder = createVpnInterface(vpnName, interfaceName, adjancencies);
- MdsalUtils.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
- getVpnInterfaceInstanceIdentifier(interfaceName), einterfaceBuilder.build());
+ tx.merge(LogicalDatastoreType.CONFIGURATION, getVpnInterfaceInstanceIdentifier(interfaceName),
+ einterfaceBuilder.build());
}
}
- private static Adjacencies buildInterfaceAdjacency(String ipAddress, MacAddress macAddress, boolean primary,
+ private static VpnInterfaceBuilder createVpnInterface(String instanceName, String interfaceName,
+ Adjacencies adjacencies) {
+ VpnInterfaceBuilder einterfaceBuilder = new VpnInterfaceBuilder();
+ einterfaceBuilder.setVpnInstanceName(instanceName);
+ einterfaceBuilder.setName(interfaceName);
+ einterfaceBuilder.addAugmentation(Adjacencies.class, adjacencies);
+ return einterfaceBuilder;
+ }
+
+ private static Adjacencies buildInterfaceAdjacency(String ipAddress, String macAddress, boolean primary,
String nextHopIp) {
AdjacenciesBuilder builder = new AdjacenciesBuilder();
List<Adjacency> list = new ArrayList<>();
AdjacencyBuilder aBuilder = new AdjacencyBuilder();
aBuilder.setIpAddress(ipAddress);
if (macAddress != null) {
- aBuilder.setMacAddress(macAddress.getValue());
+ aBuilder.setMacAddress(macAddress);
}
aBuilder.setPrimaryAdjacency(primary);
if (nextHopIp != null) {
return builder.build();
}
- private static VpnInterfaceBuilder createVpnInterface(String instanceName, String interfaceName,
- Adjacencies adjacencies) {
- VpnInterfaceBuilder einterfaceBuilder = new VpnInterfaceBuilder();
- einterfaceBuilder.setVpnInstanceName(instanceName);
- einterfaceBuilder.setName(interfaceName);
- einterfaceBuilder.addAugmentation(Adjacencies.class, adjacencies);
- return einterfaceBuilder;
+ public static void removeVpnInterface(String interfaceName, WriteTransaction tx) {
+ synchronized (interfaceName.intern()) {
+ tx.delete(LogicalDatastoreType.CONFIGURATION, getVpnInterfaceInstanceIdentifier(interfaceName));
+ }
}
- private static InstanceIdentifier<VpnInstance> getVpnInstanceInstanceIdentifier(String instanceName) {
- return InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class, new VpnInstanceKey(instanceName))
- .build();
+ public static void removeVpnInterfaceAdjacencies(DataBroker dataBroker, String vpnName, String interfaceName) {
+ AdjacenciesBuilder builder = new AdjacenciesBuilder();
+ List<Adjacency> list = new ArrayList<>();
+ builder.setAdjacency(list);
+ VpnInterfaceBuilder einterfaceBuilder = createVpnInterface(vpnName, interfaceName, builder.build());
+
+ MdsalUtils.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ getVpnInterfaceInstanceIdentifier(interfaceName), einterfaceBuilder.build());
+
+ }
+
+ public static void removeVpnInterfaceAdjacency(DataBroker dataBroker, String interfaceName, IpPrefix ifPrefix) {
+ WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
+ String ipAddress = ipPrefixToString(ifPrefix);
+ removeVpnInterfaceAdjacency(interfaceName, ipAddress, tx);
+ MdsalUtils.commitTransaction(tx);
+ }
+
+ public static void removeVpnInterfaceAdjacency(DataBroker dataBroker, String interfaceName, IpAddress ifAddress) {
+ WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
+ String ifAddressStr = getAddressFromSubnet(ipAddressToString(ifAddress));
+ removeVpnInterfaceAdjacency(interfaceName, ifAddressStr, tx);
+ MdsalUtils.commitTransaction(tx);
+ }
+
+ private static void removeVpnInterfaceAdjacency(String interfaceName, String ipAddress, WriteTransaction tx) {
+ synchronized (interfaceName.intern()) {
+
+ InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class)
+ .child(VpnInterface.class, new VpnInterfaceKey(interfaceName)).augmentation(Adjacencies.class)
+ .child(Adjacency.class, new AdjacencyKey(ipAddress)).build();
+
+ tx.delete(LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
+ }
}
private static InstanceIdentifier<VpnInterface> getVpnInterfaceInstanceIdentifier(String interfaceName) {
public static void createVpnPortFixedIp(DataBroker dataBroker, String vpnName, String portName, IpPrefix ipAddress,
MacAddress macAddress) {
- String fixedIpPrefix = MefUtils.ipPrefixToString(ipAddress);
+ String fixedIpPrefix = ipPrefixToString(ipAddress);
String fixedIp = getIpAddressFromPrefix(fixedIpPrefix);
- createVpnPortFixedIp(dataBroker, vpnName, portName, fixedIp, macAddress);
+
+ WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
+ createVpnPortFixedIp(vpnName, portName, fixedIp, macAddress, tx);
+ MdsalUtils.commitTransaction(tx);
}
- public static void createVpnPortFixedIp(DataBroker dataBroker, String vpnName, String portName, IpAddress ipAddress,
- MacAddress macAddress) {
- String fixedIp = MefUtils.ipAddressToString(ipAddress);
- createVpnPortFixedIp(dataBroker, vpnName, portName, fixedIp, macAddress);
+ public static void createVpnPortFixedIp(String vpnName, String portName, IpPrefix ipAddress, MacAddress macAddress,
+ WriteTransaction tx) {
+ String fixedIpPrefix = ipPrefixToString(ipAddress);
+ String fixedIp = getIpAddressFromPrefix(fixedIpPrefix);
+ createVpnPortFixedIp(vpnName, portName, fixedIp, macAddress, tx);
}
- public static void createVpnPortFixedIp(DataBroker dataBroker, String vpnName, String portName, String fixedIp,
- MacAddress macAddress) {
+ private static void createVpnPortFixedIp(String vpnName, String portName, String fixedIp, MacAddress macAddress,
+ WriteTransaction tx) {
synchronized ((vpnName + fixedIp).intern()) {
- InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
+ InstanceIdentifier<VpnPortipToPort> id = getVpnPortipToPortIdentifier(vpnName, fixedIp);
VpnPortipToPortBuilder builder = new VpnPortipToPortBuilder()
.setKey(new VpnPortipToPortKey(fixedIp, vpnName)).setVpnName(vpnName).setPortFixedip(fixedIp)
.setPortName(portName).setMacAddress(macAddress.getValue()).setSubnetIp(true).setConfig(true)
.setLearnt(false);
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, id, builder.build());
+ tx.put(LogicalDatastoreType.OPERATIONAL, id, builder.build());
logger.debug(
"Interface to fixedIp added: {}, vpn {}, interface {}, mac {} added to " + "VpnPortipToPort DS",
fixedIp, vpnName, portName, macAddress);
}
}
- static InstanceIdentifier<NetworkMap> buildNetworkMapIdentifier(Uuid networkId) {
- InstanceIdentifier<NetworkMap> id = InstanceIdentifier.builder(NetworkMaps.class)
- .child(NetworkMap.class, new NetworkMapKey(networkId)).build();
- return id;
- }
-
- private static void createSubnetToNetworkMapping(DataBroker dataBroker, Uuid subnetId, Uuid networkId) {
- InstanceIdentifier<NetworkMap> networkMapIdentifier = buildNetworkMapIdentifier(networkId);
- Optional<NetworkMap> optionalNetworkMap = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- networkMapIdentifier);
- NetworkMapBuilder nwMapBuilder = null;
- if (optionalNetworkMap.isPresent()) {
- nwMapBuilder = new NetworkMapBuilder(optionalNetworkMap.get());
- } else {
- nwMapBuilder = new NetworkMapBuilder().setKey(new NetworkMapKey(networkId)).setNetworkId(networkId);
- logger.debug("Adding a new network node in NetworkMaps DS for network {}", networkId.getValue());
- }
- List<Uuid> subnetIdList = nwMapBuilder.getSubnetIdList();
- if (subnetIdList == null) {
- subnetIdList = new ArrayList<>();
- }
- subnetIdList.add(subnetId);
- nwMapBuilder.setSubnetIdList(subnetIdList);
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier, nwMapBuilder.build());
- logger.debug("Created subnet-network mapping for subnet {} network {}", subnetId.getValue(),
- networkId.getValue());
+ public static VpnPortipToPort getVpnPortFixedIp(DataBroker dataBroker, String vpnName, String fixedIp) {
+ InstanceIdentifier<VpnPortipToPort> id = getVpnPortipToPortIdentifier(vpnName, fixedIp);
+ Optional<VpnPortipToPort> opt = MdsalUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ return opt != null && opt.isPresent() ? opt.get() : null;
}
- private static InstanceIdentifier<VpnPortipToPort> buildVpnPortipToPortIdentifier(String vpnName, String fixedIp) {
- InstanceIdentifier<VpnPortipToPort> id = InstanceIdentifier.builder(NeutronVpnPortipPortData.class)
- .child(VpnPortipToPort.class, new VpnPortipToPortKey(fixedIp, vpnName)).build();
- return id;
+ public static void removeVpnPortFixedIp(String vpnName, IpPrefix ipAddress, WriteTransaction tx) {
+ String fixedIpPrefix = ipPrefixToString(ipAddress);
+ String fixedIp = getIpAddressFromPrefix(fixedIpPrefix);
+ InstanceIdentifier<VpnPortipToPort> id = getVpnPortipToPortIdentifier(vpnName, fixedIp);
+ tx.delete(LogicalDatastoreType.OPERATIONAL, id);
}
public static void addDirectSubnetToVpn(DataBroker dataBroker,
IpPrefix subnetIpPrefix, String interfaceName) {
InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class)
.child(ElanInstance.class, new ElanInstanceKey(subnetName)).build();
- Optional<ElanInstance> elanInstance = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ Optional<ElanInstance> elanInstance = MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
elanIdentifierId);
if (!elanInstance.isPresent()) {
logger.error("Trying to add invalid elan {} to vpn {}", subnetName, vpnName);
return;
}
- Long elanTag = elanInstance.get().getElanTag();
+ Long elanTag = elanInstance.get().getElanTag() != null ? elanInstance.get().getElanTag()
+ : elanInstance.get().getSegmentationId();
Uuid subnetId = new Uuid(subnetName);
- logger.info("Adding subnet {} {} to elan map", subnetId);
+ logger.info("Adding subnet {} {} to elan map", subnetId, subnetId);
createSubnetToNetworkMapping(dataBroker, subnetId, subnetId);
- String subnetIp = getSubnetFromPrefix(MefUtils.ipPrefixToString(subnetIpPrefix));
+ String subnetIp = getSubnetFromPrefix(ipPrefixToString(subnetIpPrefix));
logger.info("Adding subnet {} {} to vpn {}", subnetName, subnetIp, vpnName);
updateSubnetNode(dataBroker, new Uuid(vpnName), subnetId, subnetIp);
logger.info("Adding port {} to subnet {}", interfaceName, subnetName);
- updateSubnetmapNodeWithPorts(dataBroker, subnetId, new Uuid(interfaceName));
+ updateSubnetmapNodeWithPorts(dataBroker, subnetId, new Uuid(interfaceName), null);
logger.info("Publish subnet {}", subnetName);
publishSubnetAddNotification(notificationPublishService, subnetId, subnetIp, vpnName, elanTag);
}
+ public static void removeDirectSubnetFromVpn(DataBroker dataBroker,
+ final NotificationPublishService notificationPublishService, String vpnName, String subnetName,
+ String interfaceName) {
+ InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class)
+ .child(ElanInstance.class, new ElanInstanceKey(subnetName)).build();
+ Optional<ElanInstance> elanInstance = MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ elanIdentifierId);
+ if (!elanInstance.isPresent()) {
+ logger.error("Trying to add invalid elan {} to vpn {}", subnetName, vpnName);
+ return;
+ }
+ Long elanTag = elanInstance.get().getElanTag() != null ? elanInstance.get().getElanTag()
+ : elanInstance.get().getSegmentationId();
+ Uuid subnetId = new Uuid(subnetName);
+
+ logger.info("Publish subnet remove {}", subnetName);
+ publishSubnetRemoveNotification(notificationPublishService, subnetId, vpnName, elanTag);
+
+ logger.info("Removing port {} from subnet {}", interfaceName, subnetName);
+ updateSubnetmapNodeWithPorts(dataBroker, subnetId, null, new Uuid(interfaceName));
+
+ logger.info("Removing subnet {} from vpn {}", subnetName, vpnName);
+ removeSubnetNode(dataBroker, new Uuid(vpnName));
+
+ logger.info("Removing subnet {} to elan map", subnetId);
+ removeSubnetToNetworkMapping(dataBroker, subnetId);
+
+ logger.info("Finished Working on subnet {}", subnetName);
+ }
+
+ private static void createSubnetToNetworkMapping(DataBroker dataBroker, Uuid subnetId, Uuid networkId) {
+ InstanceIdentifier<NetworkMap> networkMapIdentifier = getNetworkMapIdentifier(networkId);
+ Optional<NetworkMap> optionalNetworkMap = MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ networkMapIdentifier);
+ NetworkMapBuilder nwMapBuilder = null;
+ if (optionalNetworkMap.isPresent()) {
+ nwMapBuilder = new NetworkMapBuilder(optionalNetworkMap.get());
+ } else {
+ nwMapBuilder = new NetworkMapBuilder().setKey(new NetworkMapKey(networkId)).setNetworkId(networkId);
+ logger.debug("Adding a new network node in NetworkMaps DS for network {}", networkId.getValue());
+ }
+ List<Uuid> subnetIdList = nwMapBuilder.getSubnetIdList();
+ if (subnetIdList == null) {
+ subnetIdList = new ArrayList<>();
+ }
+ subnetIdList.add(subnetId);
+ nwMapBuilder.setSubnetIdList(subnetIdList);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier, nwMapBuilder.build());
+ logger.debug("Created subnet-network mapping for subnet {} network {}", subnetId.getValue(),
+ networkId.getValue());
+ }
+
+ private static void removeSubnetToNetworkMapping(DataBroker dataBroker, Uuid networkId) {
+ InstanceIdentifier<NetworkMap> networkMapIdentifier = getNetworkMapIdentifier(networkId);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier);
+ logger.debug("Deleted subnet-network mapping for network {}", networkId.getValue());
+ }
+
protected static void updateSubnetNode(DataBroker dataBroker, Uuid vpnId, Uuid subnetId, String subnetIp) {
Subnetmap subnetmap = null;
SubnetmapBuilder builder = null;
.child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
synchronized (subnetId.getValue().intern()) {
- Optional<Subnetmap> sn = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<Subnetmap> sn = MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
if (sn.isPresent()) {
builder = new SubnetmapBuilder(sn.get());
logger.debug("updating existing subnetmap node for subnet ID {}", subnetId.getValue());
}
}
- private static void updateSubnetmapNodeWithPorts(DataBroker dataBroker, Uuid subnetId, Uuid portId) {
+ protected static void removeSubnetNode(DataBroker dataBroker, Uuid subnetId) {
+ InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class)
+ .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
+
+ synchronized (subnetId.getValue().intern()) {
+ logger.debug("Deleting subnetMap node: {} ", subnetId.getValue());
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ }
+ }
+
+ private static void updateSubnetmapNodeWithPorts(DataBroker dataBroker, Uuid subnetId, Uuid portIdToAdd,
+ Uuid portIdToRemove) {
Subnetmap subnetmap = null;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class)
.child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
synchronized (subnetId.getValue().intern()) {
- Optional<Subnetmap> sn = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<Subnetmap> sn = MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
if (sn.isPresent()) {
SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
- if (null != portId) {
+ if (null != portIdToAdd) {
List<Uuid> portList = builder.getPortList();
if (null == portList) {
portList = new ArrayList<>();
}
- portList.add(portId);
+ if (portIdToAdd != null) {
+ portList.add(portIdToAdd);
+ logger.debug("Updating subnetmap node {} with port {}", subnetId.getValue(),
+ portIdToAdd.getValue());
+
+ }
+ if (portIdToRemove != null) {
+ portList.remove(portIdToRemove);
+ logger.debug("Updating subnetmap node {} removing port {}", subnetId.getValue(),
+ portIdToRemove.getValue());
+
+ }
builder.setPortList(portList);
- logger.debug("Updating subnetmap node {} with port {}", subnetId.getValue(), portId.getValue());
}
subnetmap = builder.build();
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
}
}
+ private static InstanceIdentifier<NetworkMap> getNetworkMapIdentifier(Uuid networkId) {
+ InstanceIdentifier<NetworkMap> id = InstanceIdentifier.builder(NetworkMaps.class)
+ .child(NetworkMap.class, new NetworkMapKey(networkId)).build();
+ return id;
+ }
+
+ private static InstanceIdentifier<VpnPortipToPort> getVpnPortipToPortIdentifier(String vpnName, String fixedIp) {
+ InstanceIdentifier<VpnPortipToPort> id = InstanceIdentifier.builder(NeutronVpnPortipPortData.class)
+ .child(VpnPortipToPort.class, new VpnPortipToPortKey(fixedIp, vpnName)).build();
+ return id;
+ }
+
+ public static InstanceIdentifier<VpnPortipToPort> getVpnPortipToPortIdentifier() {
+ return InstanceIdentifier.builder(NeutronVpnPortipPortData.class).child(VpnPortipToPort.class).build();
+ }
+
private static void publishSubnetAddNotification(final NotificationPublishService notificationPublishService,
Uuid subnetId, String subnetIp, String vpnName, Long elanTag) {
SubnetAddedToVpnBuilder builder = new SubnetAddedToVpnBuilder();
- logger.info("publish notification called");
+ logger.info("publish notification called for network creation");
builder.setSubnetId(subnetId);
builder.setSubnetIp(subnetIp);
}
}
- private static String getIpAddressFromPrefix(String prefix) {
+ private static void publishSubnetRemoveNotification(final NotificationPublishService notificationPublishService,
+ Uuid subnetId, String vpnName, Long elanTag) {
+ SubnetDeletedFromVpnBuilder builder = new SubnetDeletedFromVpnBuilder();
+
+ logger.info("publish notification called for network deletion");
+
+ builder.setSubnetId(subnetId);
+ builder.setVpnName(vpnName);
+ builder.setExternalVpn(true);
+ builder.setElanTag(elanTag);
+
+ try {
+ notificationPublishService.putNotification(builder.build());
+ } catch (InterruptedException e) {
+ logger.error("Fail to publish notification {}", builder, e);
+ throw new RuntimeException(e.getMessage());
+ }
+ }
+
+ public static void sendArpRequest(OdlArputilService arpUtilService, IpAddress srcIpAddress, IpAddress dstIpAddress,
+ String interf) {
+ try {
+ List<InterfaceAddress> interfaceAddresses = new ArrayList<>();
+ interfaceAddresses
+ .add(new InterfaceAddressBuilder().setInterface(interf).setIpAddress(srcIpAddress).build());
+
+ SendArpRequestInput sendArpRequestInput = new SendArpRequestInputBuilder().setIpaddress(dstIpAddress)
+ .setInterfaceAddress(interfaceAddresses).build();
+ arpUtilService.sendArpRequest(sendArpRequestInput);
+ } catch (Exception e) {
+ logger.error("Failed to send ARP request to IP {} from interfaces {}",
+ dstIpAddress.getIpv4Address().getValue(), interf, e);
+ throw new RuntimeException(e.getMessage());
+ }
+ }
+
+ public static String getIpAddressFromPrefix(String prefix) {
return prefix.split(IP_MUSK_SEPARATOR)[0];
}
return prefix.split(IP_MUSK_SEPARATOR)[1];
}
- private static String getSubnetFromPrefix(String prefix) {
+ public static String getSubnetFromPrefix(String prefix) {
SubnetInfo subnet = new SubnetUtils(prefix).getInfo();
return subnet.getNetworkAddress() + IP_MUSK_SEPARATOR + getMaskFromPrefix(prefix);
}
- private static String getPrefixFromSubnet(String prefix) {
+ public static String getSubnetFromPrefix(IpPrefix prefix) {
+ String prefixStr = ipPrefixToString(prefix);
+ return getSubnetFromPrefix(prefixStr);
+ }
+
+ private static String getAddressFromSubnet(String prefix) {
String myAddress = getIpAddressFromPrefix(prefix);
return myAddress + IP_ADDR_SUFFIX;
}
return getUUidFromString(ELAN_PREFIX + portName);
}
- public static String getInterfaceNameForVlan(String interfaceName, Integer vlan) {
- final StringBuilder s = new StringBuilder();
- s.append(interfaceName);
- if (vlan != null) {
- s.append(VLAN_SEPARATOR).append(vlan);
- }
- s.append(TRUNK_SUFFIX);
- return getUUidFromString(s.toString());
- }
-
public static String getUUidFromString(String key) {
return java.util.UUID.nameUUIDFromBytes(key.getBytes()).toString();
}
- public static MacAddress resolveGwMac(DataBroker dataBroker, OdlArputilService arpUtilService, String vpnName,
- IpPrefix srcIpPrefix, IpAddress dstIpAddress, String interf) {
-
- String srcTpAddressStr = getIpAddressFromPrefix(MefUtils.ipPrefixToString(srcIpPrefix));
- IpAddress srcIpAddress = new IpAddress(srcTpAddressStr.toCharArray());
-
- if (srcIpAddress == null || dstIpAddress == null) {
- logger.error("Can't send ARP to srcIp {} dstIp {}", srcIpAddress, dstIpAddress);
- throw new RuntimeException("Can't send ARP for dstIp " + dstIpAddress);
+ public static String ipPrefixToString(IpPrefix ipAddress) {
+ if (ipAddress.getIpv4Prefix() != null) {
+ return ipAddress.getIpv4Prefix().getValue();
}
- MacAddress macAddress = null;
- int retries = MaxRetries;
- while (retries > 0 && macAddress == null) {
- logger.info("Sending ARP request to dstIp {} take {}", dstIpAddress, MaxRetries - retries + 1);
- sendArpRequest(arpUtilService, srcIpAddress, dstIpAddress, interf);
- macAddress = waitForArpReplyProcessing(dataBroker, vpnName, dstIpAddress, MaxRetries);
- retries--;
- }
- return macAddress;
+ return ipAddress.getIpv6Prefix().getValue();
}
- private static void sendArpRequest(OdlArputilService arpUtilService, IpAddress srcIpAddress, IpAddress dstIpAddress,
- String interf) {
- try {
- List<InterfaceAddress> interfaceAddresses = new ArrayList<>();
- interfaceAddresses
- .add(new InterfaceAddressBuilder().setInterface(interf).setIpAddress(srcIpAddress).build());
-
- SendArpRequestInput sendArpRequestInput = new SendArpRequestInputBuilder().setIpaddress(dstIpAddress)
- .setInterfaceAddress(interfaceAddresses).build();
- arpUtilService.sendArpRequest(sendArpRequestInput);
- } catch (Exception e) {
- logger.error("Failed to send ARP request to IP {} from interfaces {}",
- dstIpAddress.getIpv4Address().getValue(), interf, e);
- throw new RuntimeException(e.getMessage());
- }
- }
-
- public static MacAddress waitForArpReplyProcessing(DataBroker dataBroker, String vpnName, IpAddress dstIpAddress,
- int retries) {
- while (retries > 0) {
- logger.info("Waiting for ARP reply from dstIp {} take {}", dstIpAddress, MaxRetries - retries + 1);
- InstanceIdentifier<VpnPortipToPort> optionalPortIpId = buildVpnPortipToPortIdentifier(vpnName,
- MefUtils.ipAddressToString(dstIpAddress));
- Optional<VpnPortipToPort> optionalPortIp = MdsalUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- optionalPortIpId);
-
- if (optionalPortIp.isPresent()) {
- return new MacAddress(optionalPortIp.get().getMacAddress());
- } else {
- sleep();
- }
- retries--;
+ public static String ipAddressToString(IpAddress ipAddress) {
+ if (ipAddress.getIpv4Address() != null) {
+ return ipAddress.getIpv4Address().getValue();
}
- return null;
- }
- private static void sleep() {
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- }
+ return ipAddress.getIpv6Address().getValue();
}
}
Code Review / unimgr.git / blobdiff