import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+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.interfaces.VpnInterface;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.NetworkKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.NetworkProviderExtension;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
.PortFixedipToPortName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data
.PortFixedipToPortNameKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data
- .PortNameToPortUuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data
- .PortNameToPortUuidKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.Subnetmap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-//import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.port.ext.rev151125.TrunkportExt;
-//import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.port.ext.rev151125.TrunkportTypeBase;
-//import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.port.ext.rev151125.TrunkportTypeSubport;
-
public class NeutronvpnUtils {
private static final Logger logger = LoggerFactory.getLogger(NeutronvpnUtils.class);
protected static Uuid getVpnForNetwork(DataBroker broker, Uuid network) {
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
- if (optionalVpnMaps.isPresent()) {
- VpnMaps vpnMaps = optionalVpnMaps.get();
- List<VpnMap> allMaps = vpnMaps.getVpnMap();
+ if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
+ List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
for (VpnMap vpnMap : allMaps) {
- if (vpnMap.getNetworkIds().contains(network)) {
+ List<Uuid> netIds = vpnMap.getNetworkIds();
+ if ((netIds != null) && (netIds.contains(network))) {
return vpnMap.getVpnId();
}
}
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION,
vpnMapsIdentifier);
- if (optionalVpnMaps.isPresent()) {
- VpnMaps vpnNets = optionalVpnMaps.get();
- List<VpnMap> allMaps = vpnNets.getVpnMap();
+ if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
+ List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
if (routerId != null) {
for (VpnMap vpnMap : allMaps) {
if (routerId.equals(vpnMap.getRouterId())) {
return null;
}
- protected static Uuid getNeutronPortIdfromPortName(DataBroker broker, String portname) {
- InstanceIdentifier id = buildPortNameToPortUuidIdentifier(portname);
- Optional<PortNameToPortUuid> portNameToPortUuidData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
- if (portNameToPortUuidData.isPresent()) {
- return portNameToPortUuidData.get().getPortId();
- }
- return null;
- }
-
protected static String getNeutronPortNamefromPortFixedIp(DataBroker broker, String fixedIp) {
InstanceIdentifier id = buildFixedIpToPortNameIdentifier(fixedIp);
Optional<PortFixedipToPortName> portFixedipToPortNameData = read(broker, LogicalDatastoreType.CONFIGURATION,
return null;
}
- //TODO
- //Will be done once integrated with TrunkPort Extensions
- protected static int getVlanFromNeutronPort(Port port) {
- int vlanId = 0;
- /*
- TrunkportExt trunkportExt = port.getAugmentation(TrunkportExt.class);
- if (trunkportExt != null) {
- Class<? extends TrunkportTypeBase> trunkportType = trunkportExt.getType();
- if (trunkportType != null && trunkportType.isAssignableFrom(TrunkportTypeSubport.class)) {
- vlanId = trunkportExt.getVid();
- }
- }
- */
- return vlanId;
- }
-
protected static Router getNeutronRouter(DataBroker broker, Uuid routerId) {
InstanceIdentifier<Router> inst = InstanceIdentifier.create(Neutron.class).child(Routers.class).child(Router
return null;
}
+ protected static String getSegmentationIdFromNeutronNetwork(Network network) {
+ String segmentationId = null;
+ NetworkProviderExtension providerExtension = network.getAugmentation(NetworkProviderExtension.class);
+ if (providerExtension != null) {
+ segmentationId = providerExtension.getSegmentationId();
+ }
+ return segmentationId;
+ }
+
protected static List<Uuid> getNeutronRouterSubnetIds(DataBroker broker, Uuid routerId) {
logger.info("getNeutronRouterSubnetIds for {}", routerId.getValue());
if (router != null) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router
.Interfaces> interfacesList = router.getInterfaces();
- if (!interfacesList.isEmpty()) {
+ if (interfacesList != null) {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers
.router.Interfaces interfaces : interfacesList) {
subnetIdList.add(interfaces.getSubnetId());
return subnetIdList;
}
+ protected static Port getNeutronPort(DataBroker broker, Uuid portId) {
+ logger.debug("getNeutronPort for {}", portId.getValue());
+ InstanceIdentifier<Port> inst = InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class,
+ new PortKey(portId));
+ Optional<Port> port = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
+ if (port.isPresent()) {
+ return port.get();
+ }
+ return null;
+ }
+
protected static String uuidToTapPortName(Uuid id) {
String tapId = id.getValue().substring(0, 11);
return new StringBuilder().append("tap").append(tapId).toString();
protected static boolean lock(LockManagerService lockManager, String lockName) {
TryLockInput input = new TryLockInputBuilder().setLockName(lockName).setTime(5L).setTimeUnit
(TimeUnits.Milliseconds).build();
- boolean islockAquired = false;
+ boolean islockAcquired = false;
try {
Future<RpcResult<Void>> result = lockManager.tryLock(input);
if ((result != null) && (result.get().isSuccessful())) {
logger.debug("Acquired lock for {}", lockName);
- islockAquired = true;
+ islockAcquired = true;
} else {
- throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName));
+ logger.error("Unable to acquire lock for {}", lockName);
}
} catch (InterruptedException | ExecutionException e) {
logger.error("Unable to acquire lock for {}", lockName);
- throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName), e
- .getCause());
+ throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName), e.getCause());
}
- return islockAquired;
+ return islockAcquired;
}
- protected static void unlock(LockManagerService lockManager, String lockName) {
+ protected static boolean unlock(LockManagerService lockManager, String lockName) {
UnlockInput input = new UnlockInputBuilder().setLockName(lockName).build();
+ boolean islockAcquired = false;
try {
Future<RpcResult<Void>> result = lockManager.unlock(input);
if ((result != null) && (result.get().isSuccessful())) {
logger.debug("Unlocked {}", lockName);
+ islockAcquired = true;
} else {
- logger.debug("Unable to unlock {}", lockName);
+ logger.error("Unable to unlock {}", lockName);
}
} catch (InterruptedException | ExecutionException e) {
logger.error("Unable to unlock {}", lockName);
- throw new RuntimeException(String.format("Unable to unlock %s", lockName), e
- .getCause());
+ throw new RuntimeException(String.format("Unable to unlock %s", lockName), e.getCause());
}
+ return islockAcquired;
}
protected static Short getIPPrefixFromPort(DataBroker broker, Port port) {
logger.trace("Unable to read on subnet datastore");
}
} catch (Exception e) {
- logger.trace("Failed to retrieve IP prefix from port : ", e);
+ logger.error("Failed to retrieve IP prefix from port : ", e);
System.out.println("Failed to retrieve IP prefix from port : " + e.getMessage());
}
return null;
}
- static InstanceIdentifier<PortNameToPortUuid> buildPortNameToPortUuidIdentifier(String portname) {
- InstanceIdentifier<PortNameToPortUuid> id = InstanceIdentifier.builder(NeutronPortData.class).child
- (PortNameToPortUuid.class, new PortNameToPortUuidKey(portname)).build();
- return id;
- }
-
static InstanceIdentifier<PortFixedipToPortName> buildFixedIpToPortNameIdentifier(String fixedIp) {
InstanceIdentifier<PortFixedipToPortName> id = InstanceIdentifier.builder(NeutronPortData.class).child
(PortFixedipToPortName.class, new PortFixedipToPortNameKey(fixedIp)).build();
return id;
}
+ static InstanceIdentifier<VpnInterface> buildVpnInterfaceIdentifier(String ifName) {
+ InstanceIdentifier<VpnInterface> id = InstanceIdentifier.builder(VpnInterfaces.class).
+ child(VpnInterface.class, new VpnInterfaceKey(ifName)).build();
+ return id;
+ }
+
static InstanceIdentifier<Subnetmap> buildSubnetMapIdentifier(Uuid subnetId) {
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class, new
SubnetmapKey(subnetId)).build();
Code Review / vpnservice.git / blobdiff