LogicalDatastoreType logicalDatastoreType;
DataWaitGetter<D> getData;
private final long waitMillisec = 1000;
-
public DataWaitListener(final DataBroker dataBroker, final InstanceIdentifier<D> objectIdentifierId,
int maxRetiries, LogicalDatastoreType logicalDatastoreType, final DataWaitGetter<D> getData) {
super(dataBroker);
this.objectIdentifierId = objectIdentifierId;
this.maxRetries = maxRetiries;
- this.logicalDatastoreType = logicalDatastoreType;
+ this.logicalDatastoreType = logicalDatastoreType;
this.getData = getData;
registerListener();
}
@SuppressWarnings("unchecked")
public void registerListener() {
try {
- final DataTreeIdentifier<D> dataTreeIid = new DataTreeIdentifier<D>(
- LogicalDatastoreType.CONFIGURATION, objectIdentifierId);
+ final DataTreeIdentifier<D> dataTreeIid = new DataTreeIdentifier<D>(logicalDatastoreType,
+ objectIdentifierId);
dataWaitListenerRegistration = dataBroker.registerDataTreeChangeListener(dataTreeIid, this);
Log.info("DataWaitListener created and registered");
} catch (final Exception e) {
}
private boolean dataAvailable() {
- Optional<D> objectInstance = MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- objectIdentifierId);
- if (!objectInstance.isPresent()) {
- Log.debug("Data for {} doesn't exist, waiting more", objectIdentifierId);
- return false;
- }
- if (getData.get(objectInstance.get()) != null) {
+ if (getData() != null) {
return true;
}
return false;
}
- public boolean waitForData () {
+ public boolean waitForData() {
return waitForData(maxRetries);
}
-
-
+
+ public Object getData() {
+ Optional<D> objectInstance = MdsalUtils.read(dataBroker, logicalDatastoreType, objectIdentifierId);
+ if (!objectInstance.isPresent()) {
+ Log.debug("Data for {} doesn't exist, waiting more", objectIdentifierId);
+ return null;
+ }
+ return getData.get(objectInstance.get());
+ }
+
public boolean waitForData(int retry) {
synchronized (dataAvailable) {
dataAvailable = dataAvailable();
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.unimgr.api.UnimgrDataTreeChangeListener;
-
+import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.services.rev150526.mef.services.MefService;
import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.services.rev150526.mef.services.mef.service.mef.service.choice.evc.choice.Evc;
import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.services.rev150526.mef.services.mef.service.mef.service.choice.evc.choice.evc.unis.Uni;
import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.services.rev150526.mef.services.mef.service.mef.service.choice.evc.choice.evc.unis.uni.EvcUniCeVlans;
: Collections.emptyList();
synchronized (data.getEvcId().getValue().intern()) {
+ updateQos(uniToRemove);
EvcElan evcElan = getOperEvcElan(evcId);
if (evcElan == null) {
log.error("Evc {} has not been created as required. Nothing to remove", data.getEvcId().getValue());
+ return;
}
String instanceName = evcElan.getElanId();
for (Uni uni : uniToRemove) {
removeUniElanInterfaces(evcId, instanceName, uni);
}
- updateQos(uniToRemove);
log.info("Removing elan instance: " + instanceName);
NetvirtUtils.deleteElanInstance(dataBroker, instanceName);
if (evcUniCeVlan.isEmpty()) {
String interfaceName = uniPortManager.getUniVlanInterface(uni.getUniId().getValue(), Long.valueOf(0));
+ if (interfaceName == null) {
+ String errorMessage = String.format("Uni %s Interface for vlan %d is not operational ", uni.getUniId(),
+ 0);
+ Log.error(errorMessage);
+ throw new UnsupportedOperationException(errorMessage);
+ }
if (isOperEvcElanPort(evcId, interfaceName)) {
log.info("elan interface for elan {} vlan {} interface {} exists already", instanceName, 0,
interfaceName);
for (EvcUniCeVlan ceVlan : evcUniCeVlan) {
Long vlan = safeCastVlan(ceVlan.getVid());
String interfaceName = uniPortManager.getUniVlanInterface(uni.getUniId().getValue(), vlan);
+ if (interfaceName == null) {
+ String errorMessage = String.format("Uni %s Interface for vlan %d is not operational ",
+ uni.getUniId(), 0);
+ Log.error(errorMessage);
+ throw new UnsupportedOperationException(errorMessage);
+ }
if (isOperEvcElanPort(evcId, interfaceName)) {
log.info("elan interface for elan {} vlan {} interface {} exists already", instanceName, 0,
interfaceName);
}
private void removeOperEvcElan(InstanceIdentifier<Evc> identifier) {
- InstanceIdentifier<EvcElan> path = identifier.augmentation(EvcElan.class);
- MdsalUtils.delete(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
+ final InstanceIdentifier<MefService> serviceId = identifier.firstIdentifierOf(MefService.class);
+ MdsalUtils.delete(dataBroker, LogicalDatastoreType.OPERATIONAL, serviceId);
}
private boolean isOperEvcElanPort(InstanceIdentifier<Evc> identifier, String elanPort) {
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInterface.EtreeInterfaceType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
private void addIpvc(DataTreeModification<Ipvc> newDataObject) {
try {
- WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
Ipvc ipvc = newDataObject.getRootNode().getDataAfter();
String instanceName = ipvc.getIpvcId().getValue();
final String vpnName = NetvirtVpnUtils.getUUidFromString(instanceName);
InstanceIdentifier<Ipvc> ipvcId = newDataObject.getRootPath().getRootIdentifier();
List<Uni> unis = new ArrayList<>();
+ String rd = null;
synchronized (vpnName.intern()) {
+ WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
Log.info("Adding vpn instance: " + instanceName);
NetvirtVpnUtils.createVpnInstance(vpnName, tx);
MefServicesUtils.addOperIpvcVpnElan(ipvcId, vpnName, tx);
- if (ipvc.getUnis() != null && ipvc.getUnis() != null) {
- unis = ipvc.getUnis().getUni();
- }
- Log.info("Number of UNI's: " + unis.size());
+ MdsalUtils.commitTransaction(tx);
- // Create elan/vpn interfaces
- for (Uni uni : unis) {
- createInterfaces(vpnName, uni, ipvcId, tx);
+ InstanceIdentifier<VpnInstance> vpnId = NetvirtVpnUtils.getVpnInstanceToVpnIdIdentifier(vpnName);
+ DataWaitListener<VpnInstance> vpnInstanceWaiter = new DataWaitListener<VpnInstance>(dataBroker, vpnId,
+ 5, LogicalDatastoreType.CONFIGURATION, vpn -> vpn.getVrfId());
+ if (!vpnInstanceWaiter.waitForData()) {
+ String errorMessage = String.format("Fail to wait for vrfId for vpn %s", vpnName);
+ Log.error(errorMessage);
+ throw new UnsupportedOperationException(errorMessage);
}
- MdsalUtils.commitTransaction(tx);
+ rd = (String) vpnInstanceWaiter.getData();
+ }
+
+ if (ipvc.getUnis() != null && ipvc.getUnis() != null) {
+ unis = ipvc.getUnis().getUni();
}
+ Log.info("Number of UNI's: " + unis.size());
+
+ // Create elan/vpn interfaces
+ for (Uni uni : unis) {
+ createInterfaces(vpnName, uni, ipvcId, rd);
+ }
+
createUnis(ipvcId, unis);
} catch (final Exception e) {
Log.error("Add ipvc failed !", e);
return;
}
String vpnName = operIpvcVpn.getVpnId();
+ InstanceIdentifier<VpnInstance> vpnId = NetvirtVpnUtils.getVpnInstanceToVpnIdIdentifier(vpnName);
+ @SuppressWarnings("resource")
+ DataWaitListener<VpnInstance> vpnInstanceWaiter = new DataWaitListener<VpnInstance>(dataBroker, vpnId, 5,
+ LogicalDatastoreType.CONFIGURATION, vpn -> vpn.getVrfId());
+ if (!vpnInstanceWaiter.waitForData()) {
+ String errorMessage = String.format("Fail to wait for vrfId for vpn %s", vpnName);
+ Log.error(errorMessage);
+ throw new UnsupportedOperationException(errorMessage);
+ }
+ String rd = (String) vpnInstanceWaiter.getData();
List<Uni> originalUni = origIpvc.getUnis() != null && origIpvc.getUnis().getUni() != null
? origIpvc.getUnis().getUni() : Collections.emptyList();
removeUnis(ipvcId, operIpvcVpn, uniToRemove, txRemove);
MdsalUtils.commitTransaction(txRemove);
- WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
List<Uni> uniToCreate = new ArrayList<>(updateUni);
uniToCreate.removeAll(originalUni);
for (Uni uni : uniToCreate) {
- createInterfaces(vpnName, uni, ipvcId, tx);
+ createInterfaces(vpnName, uni, ipvcId, rd);
}
- MdsalUtils.commitTransaction(tx);
-
createUnis(ipvcId, uniToCreate);
}
}
}
- private void createInterfaces(String vpnName, Uni uniInService, InstanceIdentifier<Ipvc> ipvcId,
- WriteTransaction tx) {
+ private void createInterfaces(String vpnName, Uni uniInService, InstanceIdentifier<Ipvc> ipvcId, String rd) {
+
+ WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
String uniId = uniInService.getUniId().getValue();
String ipUniId = uniInService.getIpUniId().getValue();
org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.interfaces.rev150526.mef.interfaces.unis.Uni uni = MefInterfaceUtils
throw new UnsupportedOperationException(errorMessage);
}
- Long vlan = ipUni.getVlan() != null ? Long.valueOf(ipUni.getVlan().getValue()) : null;
- String elanName = NetvirtVpnUtils.getElanNameForVpnPort(uniId, ipUniId);
+ String interfaceName = null;
+ synchronized (vpnName.intern()) {
+ Long vlan = ipUni.getVlan() != null ? Long.valueOf(ipUni.getVlan().getValue()) : null;
+ String elanName = NetvirtVpnUtils.getElanNameForVpnPort(uniId, ipUniId);
+
+ String srcIpAddressStr = NetvirtVpnUtils
+ .getIpAddressFromPrefix(NetvirtVpnUtils.ipPrefixToString(ipUni.getIpAddress()));
+ IpAddress ipAddress = new IpAddress(srcIpAddressStr.toCharArray());
+
+ interfaceName = createElanInterface(vpnName, ipvcId, uniId, elanName, vlan, ipAddress, tx,
+ ipUni.getSegmentationId());
+ uniQosManager.mapUniPortBandwidthLimits(uniId, interfaceName, uniInService.getIngressBwProfile());
+ createVpnInterface(vpnName, uni, ipUni, interfaceName, elanName, tx);
+ MefServicesUtils.addOperIpvcVpnElan(ipvcId, vpnName, uniInService.getUniId(), uniInService.getIpUniId(),
+ elanName, interfaceName, null, tx);
+ MdsalUtils.commitTransaction(tx);
+ }
- String srcIpAddressStr = NetvirtVpnUtils
- .getIpAddressFromPrefix(NetvirtVpnUtils.ipPrefixToString(ipUni.getIpAddress()));
- IpAddress ipAddress = new IpAddress(srcIpAddressStr.toCharArray());
+ InstanceIdentifier<VpnInstanceOpDataEntry> vpnId = NetvirtVpnUtils.getVpnInstanceOpDataIdentifier(rd);
+ @SuppressWarnings("resource")
+ DataWaitListener<VpnInstanceOpDataEntry> vpnInstanceWaiter = new DataWaitListener<VpnInstanceOpDataEntry>(
+ dataBroker, vpnId, 5, LogicalDatastoreType.OPERATIONAL, vpn -> vpn.getVpnToDpnList());
+ if (!vpnInstanceWaiter.waitForData()) {
+ String errorMessage = String.format("Fail to wait for vpn to dpn list %s", vpnName);
+ Log.error(errorMessage);
+ throw new UnsupportedOperationException(errorMessage);
+ }
- String interfaceName = createElanInterface(vpnName, ipvcId, uniId, elanName, vlan, ipAddress, tx,
- ipUni.getSegmentationId());
- uniQosManager.mapUniPortBandwidthLimits(uniId, interfaceName, uniInService.getIngressBwProfile());
- createVpnInterface(vpnName, uni, ipUni, interfaceName, elanName, tx);
- MefServicesUtils.addOperIpvcVpnElan(ipvcId, vpnName, uniInService.getUniId(), uniInService.getIpUniId(),
- elanName, interfaceName, null, tx);
+ NetvirtVpnUtils.createVpnPortFixedIp(dataBroker, vpnName, interfaceName, ipUni.getIpAddress(),
+ uni.getMacAddress());
}
private String createElanInterface(String vpnName, InstanceIdentifier<Ipvc> ipvcId, String uniId, String elanName,
IpUni ipUni, String interfaceName, String elanName, WriteTransaction tx) {
Log.info("Adding vpn interface: " + interfaceName);
+
NetvirtVpnUtils.createUpdateVpnInterface(vpnName, interfaceName, ipUni.getIpAddress(),
uni.getMacAddress().getValue(), true, null, elanName, tx);
- NetvirtVpnUtils.createVpnPortFixedIp(vpnName, interfaceName, ipUni.getIpAddress(), uni.getMacAddress(), tx);
- Log.info("Finished working on vpn instance: " + vpnName);
+
+ Log.info("Finished working on vpn instance {} interface () ", vpnName, interfaceName);
}
private void createDirectSubnet(Uni uni, IpUni ipUni) {
return null;
}
-
public static IpvcVpn getOperIpvcVpn(DataBroker dataBroker, InstanceIdentifier<Ipvc> identifier) {
InstanceIdentifier<IpvcVpn> path = identifier.augmentation(IpvcVpn.class);
Optional<IpvcVpn> ipvcVpn = MdsalUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
}
public static void removeOperIpvcVpn(InstanceIdentifier<Ipvc> identifier, WriteTransaction tx) {
- InstanceIdentifier<IpvcVpn> path = identifier.augmentation(IpvcVpn.class);
- tx.delete(LogicalDatastoreType.OPERATIONAL, path);
+ final InstanceIdentifier<MefService> serviceId = identifier.firstIdentifierOf(MefService.class);
+ tx.delete(LogicalDatastoreType.OPERATIONAL, serviceId);
}
public static void removeOperIpvcSubnet(DataBroker dataBroker, InstanceIdentifier<Ipvc> identifier, String vpnId,
vpnElansEx.remove(vpnElans);
VpnElansBuilder vpnElansB = new VpnElansBuilder(vpnElans);
List<Subnets> exSubnets = vpnElansB.getSubnets();
- List<Subnets> newSubnets = exSubnets.stream().filter(s -> ! s.getSubnet().equals(deleteSubnet)).collect(Collectors.toList());
+ List<Subnets> newSubnets = exSubnets.stream().filter(s -> !s.getSubnet().equals(deleteSubnet))
+ .collect(Collectors.toList());
vpnElansB.setSubnets(newSubnets);
vpnElansEx.add(vpnElansB.build());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId;
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.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
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;
.build();
}
+ static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> getVpnInstanceToVpnIdIdentifier(
+ String vpnName) {
+ return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
+ .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance.class,
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey(
+ vpnName))
+ .build();
+ }
+
+ public static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
+ return InstanceIdentifier.builder(VpnInstanceOpData.class)
+ .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
+ }
+
public static void createUpdateVpnInterface(DataBroker dataBroker, String vpnName, String interfaceName,
String ifAddr, String macAddress, boolean primary, String gwIpAddress, String directSubnetId) {
WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
MdsalUtils.commitTransaction(tx);
}
- 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);
- }
-
private static void createVpnPortFixedIp(String vpnName, String portName, String fixedIp, MacAddress macAddress,
WriteTransaction tx) {
synchronized ((vpnName + fixedIp).intern()) {
InstanceIdentifier<ElanInstance> elanIdentifierId = NetvirtUtils.getElanInstanceInstanceIdentifier(subnetName);
@SuppressWarnings("resource") // AutoCloseable
- DataWaitListener<ElanInstance> elanTagWaiter = new DataWaitListener<>(
- dataBroker, elanIdentifierId, 10, LogicalDatastoreType.CONFIGURATION, el -> el.getElanTag());
- if ( !elanTagWaiter.waitForData()) {
+ DataWaitListener<ElanInstance> elanTagWaiter = new DataWaitListener<ElanInstance>(dataBroker, elanIdentifierId,
+ 10, LogicalDatastoreType.CONFIGURATION, el -> el.getElanTag());
+ if (!elanTagWaiter.waitForData()) {
logger.error("Trying to add invalid elan {} to vpn {}", subnetName, vpnName);
return;
}