Examples with AcquireResult org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult used on opensource projects

Example 6 with AcquireResult

use of org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult in project netvirt by opendaylight.

the class NeutronBgpvpnNetworkAssociationChangeListener method add.

@Override
public void add(InstanceIdentifier<BgpvpnNetworkAssociation> identifier, BgpvpnNetworkAssociation input) {
    LOG.trace("Adding Bgpvpn network association : key: {}, value={}", identifier, input);
    Uuid vpnId = input.getBgpvpnId();
    String vpnName = vpnId.getValue();
    Uuid networkId = input.getNetworkId();
    List<Uuid> networks = new ArrayList<>();
    networks.add(networkId);
    NamedLocks<String> vpnLock = neutronBgpvpnUtils.getVpnLock();
    try (AcquireResult lock = vpnLock.tryAcquire(vpnName, NeutronConstants.LOCK_WAIT_TIME, TimeUnit.SECONDS)) {
        if (!lock.wasAcquired()) {
            LOG.error("Add network association: add association failed for vpn : {} and networkId: {} due to " + "failure in acquiring lock", vpnName, networkId.getValue());
            return;
        }
        VpnInstance vpnInstance = neutronvpnUtils.getVpnInstance(vpnId);
        if (vpnInstance != null) {
            List<String> errorMessages = nvpnManager.associateNetworksToVpn(vpnId, networks);
            if (!errorMessages.isEmpty()) {
                LOG.error("BgpvpnNetworkAssociation add: associate network id {} to vpn {} failed due to {}", networkId.getValue(), vpnId.getValue(), errorMessages);
            }
        } else {
            neutronBgpvpnUtils.addUnProcessedNetwork(vpnId, networkId);
        }
    }
}

Example 7 with AcquireResult

use of org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult in project netvirt by opendaylight.

the class NeutronFloatingToFixedIpMappingChangeListener method clearFromFloatingIpInfo.

// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
private void clearFromFloatingIpInfo(String routerName, String fixedNeutronPortName, String fixedIpAddress) {
    InstanceIdentifier.InstanceIdentifierBuilder<RouterPorts> routerPortsIdentifierBuilder = InstanceIdentifier.builder(FloatingIpInfo.class).child(RouterPorts.class, new RouterPortsKey(routerName));
    try {
        Optional<RouterPorts> optionalRouterPorts = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifierBuilder.build());
        if (optionalRouterPorts.isPresent()) {
            RouterPorts routerPorts = optionalRouterPorts.get();
            Map<PortsKey, Ports> keyPortsMap = routerPorts.nonnullPorts();
            Map<InternalToExternalPortMapKey, InternalToExternalPortMap> keyInternalToExternalPortMapMap = new HashMap<InternalToExternalPortMapKey, InternalToExternalPortMap>();
            for (Ports ports : keyPortsMap.values()) {
                if (Objects.equals(ports.getPortName(), fixedNeutronPortName)) {
                    keyInternalToExternalPortMapMap = ports.nonnullInternalToExternalPortMap();
                    break;
                }
            }
            if (keyInternalToExternalPortMapMap.size() == 1) {
                removeRouterPortsOrPortsNode(routerName, routerPortsIdentifierBuilder, new ArrayList<Ports>(keyPortsMap.values()), fixedNeutronPortName);
            } else {
                for (InternalToExternalPortMap intToExtMap : keyInternalToExternalPortMapMap.values()) {
                    if (Objects.equals(intToExtMap.getInternalIp(), fixedIpAddress)) {
                        InstanceIdentifier<InternalToExternalPortMap> intExtPortMapIdentifier = routerPortsIdentifierBuilder.child(Ports.class, new PortsKey(fixedNeutronPortName)).child(InternalToExternalPortMap.class, new InternalToExternalPortMapKey(fixedIpAddress)).build();
                        try (AcquireResult lock = tryRouterLock(fixedIpAddress)) {
                            if (!lock.wasAcquired()) {
                                // FIXME: why do we even bother with locking if we do not honor it?!
                                logTryLockFailure(fixedIpAddress);
                            }
                            // remove particular internal-to-external-port-map
                            LOG.debug("removing particular internal-to-external-port-map {}", keyInternalToExternalPortMapMap);
                            try {
                                MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, intExtPortMapIdentifier);
                            } catch (Exception e) {
                                LOG.error("Failure in deletion of internal-to-external-port-map {}", keyInternalToExternalPortMapMap, e);
                            }
                        }
                    }
                }
            }
            LOG.debug("Deletion from FloatingIpInfo DS successful for fixedIp {} ", fixedIpAddress);
        } else {
            LOG.warn("routerPorts for router {} - fixedIp {} not found", routerName, fixedIpAddress);
        }
    } catch (RuntimeException | ExecutionException | InterruptedException e) {
        LOG.error("Failed to delete internal-to-external-port-map from FloatingIpInfo DS for fixed Ip {}", fixedIpAddress, e);
    }
}

Example 8 with AcquireResult

use of org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult in project netvirt by opendaylight.

the class NeutronFloatingToFixedIpMappingChangeListener method removeRouterPortsOrPortsNode.

private void removeRouterPortsOrPortsNode(String routerName, InstanceIdentifier.InstanceIdentifierBuilder<RouterPorts> routerPortsIdentifierBuilder, List<Ports> portsList, String fixedNeutronPortName) {
    if (portsList.size() == 1) {
        // remove entire routerPorts node
        try (AcquireResult lock = tryRouterLock(routerName)) {
            if (!lock.wasAcquired()) {
                // FIXME: why do we even bother with locking if we do not honor it?!
                logTryLockFailure(routerName);
            }
            LOG.debug("removing routerPorts node: {} ", routerName);
            MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifierBuilder.build());
        }
    } else {
        // remove entire ports node under this routerPorts node
        try (AcquireResult lock = tryRouterLock(fixedNeutronPortName)) {
            if (!lock.wasAcquired()) {
                // FIXME: why do we even bother with locking if we do not honor it?!
                logTryLockFailure(fixedNeutronPortName);
            }
            LOG.debug("removing ports node {} under routerPorts node {}", fixedNeutronPortName, routerName);
            MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifierBuilder.child(Ports.class, new PortsKey(fixedNeutronPortName)).build());
        }
    }
}

Example 9 with AcquireResult

use of org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult in project netvirt by opendaylight.

the class NeutronFloatingToFixedIpMappingChangeListener method addToFloatingIpInfo.

// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
private void addToFloatingIpInfo(String routerName, Uuid extNetworkId, String fixedNeutronPortName, String fixedIpAddress, String floatingIpAddress, Uuid floatingIpId) {
    RouterPortsBuilder routerPortsBuilder;
    InstanceIdentifier<RouterPorts> routerPortsIdentifier = InstanceIdentifier.builder(FloatingIpInfo.class).child(RouterPorts.class, new RouterPortsKey(routerName)).build();
    try {
        Optional<RouterPorts> optionalRouterPorts = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifier);
        if (optionalRouterPorts.isPresent()) {
            LOG.debug("Updating routerPorts node {} in floatingIpInfo DS for floating IP {} on fixed " + "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
            routerPortsBuilder = new RouterPortsBuilder(optionalRouterPorts.get());
        } else {
            LOG.debug("Creating new routerPorts node {} in floatingIpInfo DS for floating IP {} on fixed " + "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
            routerPortsBuilder = new RouterPortsBuilder().withKey(new RouterPortsKey(routerName)).setRouterId(routerName);
        }
        if (extNetworkId != null) {
            routerPortsBuilder.setExternalNetworkId(extNetworkId);
        }
        if (fixedNeutronPortName != null) {
            List<Ports> portsList = routerPortsBuilder.getPorts() != null ? new ArrayList<Ports>(routerPortsBuilder.getPorts().values()) : new ArrayList<Ports>();
            PortsBuilder fixedNeutronPortBuilder = null;
            for (Ports neutronPort : portsList) {
                if (neutronPort.getPortName().equals(fixedNeutronPortName)) {
                    fixedNeutronPortBuilder = new PortsBuilder(neutronPort);
                    break;
                }
            }
            if (fixedNeutronPortBuilder == null) {
                fixedNeutronPortBuilder = new PortsBuilder().withKey(new PortsKey(fixedNeutronPortName)).setPortName(fixedNeutronPortName);
            }
            if (fixedIpAddress != null) {
                Collection<InternalToExternalPortMap> intExtPortMapCollection = fixedNeutronPortBuilder.getInternalToExternalPortMap() != null ? fixedNeutronPortBuilder.getInternalToExternalPortMap().values() : null;
                List<InternalToExternalPortMap> intExtPortMapList = new ArrayList<InternalToExternalPortMap>(intExtPortMapCollection != null ? intExtPortMapCollection : Collections.emptyList());
                InternalToExternalPortMap intExtPortMap = new InternalToExternalPortMapBuilder().withKey(new InternalToExternalPortMapKey(fixedIpAddress)).setInternalIp(fixedIpAddress).setExternalIp(floatingIpAddress).setExternalId(floatingIpId).build();
                intExtPortMapList.add(intExtPortMap);
                fixedNeutronPortBuilder.setInternalToExternalPortMap(intExtPortMapList);
            }
            portsList.add(fixedNeutronPortBuilder.build());
            routerPortsBuilder.setPorts(portsList);
        }
        try (AcquireResult lock = tryRouterLock(routerName)) {
            if (!lock.wasAcquired()) {
                // FIXME: why do we even bother with locking if we do not honor it?!
                logTryLockFailure(routerName);
            }
            LOG.debug("Creating/Updating routerPorts node {} in floatingIpInfo DS for floating IP {} on fixed " + "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
            MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifier, routerPortsBuilder.build());
            LOG.debug("FloatingIpInfo DS updated for floating IP {} ", floatingIpAddress);
        }
    } catch (RuntimeException | ExecutionException | InterruptedException e) {
        LOG.error("addToFloatingIpInfo failed for floating IP: {} ", floatingIpAddress, e);
    }
}

Example 10 with AcquireResult

use of org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult in project netvirt by opendaylight.

the class NeutronBgpvpnChangeListener method add.

@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public void add(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
    LOG.trace("Adding Bgpvpn : key: {}, value={}", identifier, input);
    String vpnName = input.getUuid().getValue();
    if (!isBgpvpnTypeL3(input.getType())) {
        LOG.warn("BGPVPN type for VPN {} is not L3", vpnName);
        return;
    }
    NamedLocks<String> vpnLock = neutronBgpvpnUtils.getVpnLock();
    try (AcquireResult lock = vpnLock.tryAcquire(vpnName, NeutronConstants.LOCK_WAIT_TIME, TimeUnit.SECONDS)) {
        if (!lock.wasAcquired()) {
            LOG.error("Add BGPVPN: add bgpvpn failed for vpn : {} due to failure in acquiring lock", vpnName);
            return;
        }
        // handle route-target(s)
        List<String> inputRouteList = input.getRouteTargets();
        List<String> inputImportRouteList = input.getImportTargets();
        List<String> inputExportRouteList = input.getExportTargets();
        Set<String> inputImportRouteSet = new HashSet<>();
        Set<String> inputExportRouteSet = new HashSet<>();
        if (inputRouteList != null && !inputRouteList.isEmpty()) {
            inputImportRouteSet.addAll(inputRouteList);
            inputExportRouteSet.addAll(inputRouteList);
        }
        if (inputImportRouteList != null && !inputImportRouteList.isEmpty()) {
            inputImportRouteSet.addAll(inputImportRouteList);
        }
        if (inputExportRouteList != null && !inputExportRouteList.isEmpty()) {
            inputExportRouteSet.addAll(inputExportRouteList);
        }
        List<String> importRouteTargets = new ArrayList<>(inputImportRouteSet);
        List<String> exportRouteTargets = new ArrayList<>(inputExportRouteSet);
        boolean rdIrtErtStringsValid;
        List<String> rdList = input.getRouteDistinguishers();
        if (rdList != null && !rdList.isEmpty()) {
            // get the primary RD for vpn instance, if exist
            rdIrtErtStringsValid = !(input.getRouteDistinguishers().stream().anyMatch(rdStr -> rdStr.contains(" ")));
            rdIrtErtStringsValid = rdIrtErtStringsValid && !(importRouteTargets.stream().anyMatch(irtStr -> irtStr.contains(" ")));
            rdIrtErtStringsValid = rdIrtErtStringsValid && !(exportRouteTargets.stream().anyMatch(ertStr -> ertStr.contains(" ")));
            if (!rdIrtErtStringsValid) {
                LOG.error("Error encountered for BGPVPN {} with RD {} as RD/iRT/eRT contains whitespace " + "characters", vpnName, input.getRouteDistinguishers());
                return;
            }
            String primaryRd = neutronvpnUtils.getVpnRd(vpnName);
            if (primaryRd == null) {
                primaryRd = rdList.get(0);
            }
            String[] rdParams = primaryRd.split(":");
            if (rdParams[0].trim().equals(adminRDValue)) {
                LOG.error("AS specific part of RD should not be same as that defined by DC Admin. Error " + "encountered for BGPVPN {} with RD {}", vpnName, primaryRd);
                return;
            }
            String vpnWithSameRd = neutronvpnUtils.getVpnForRD(primaryRd);
            if (vpnWithSameRd != null) {
                LOG.error("Creation of L3VPN failed for VPN {} as another VPN {} with the same RD {} " + "is already configured", vpnName, vpnWithSameRd, primaryRd);
                return;
            }
            String existingOperationalVpn = neutronvpnUtils.getExistingOperationalVpn(primaryRd);
            if (existingOperationalVpn != null) {
                LOG.error("checkVpnCreation: Creation of L3VPN failed for VPN {} as another VPN {} with the " + "same RD {} is still available.", vpnName, existingOperationalVpn, primaryRd);
                return;
            }
            List<Uuid> unpRtrs = neutronBgpvpnUtils.getUnprocessedRoutersForBgpvpn(input.getUuid());
            List<Uuid> unpNets = neutronBgpvpnUtils.getUnprocessedNetworksForBgpvpn(input.getUuid());
            // TODO: Currently handling routers and networks for backward compatibility. Below logic needs to be
            // removed once updated to latest BGPVPN API's.
            List<Uuid> inputRouters = input.getRouters();
            if (inputRouters != null && !inputRouters.isEmpty()) {
                if (unpRtrs != null) {
                    unpRtrs.addAll(inputRouters);
                } else {
                    unpRtrs = new ArrayList<>(inputRouters);
                }
            }
            if (unpRtrs != null && unpRtrs.size() > NeutronConstants.MAX_ROUTERS_PER_BGPVPN) {
                LOG.error("Creation of BGPVPN for rd {} failed: maximum allowed number of associated " + "routers is {}.", rdList, NeutronConstants.MAX_ROUTERS_PER_BGPVPN);
                return;
            }
            List<Uuid> inputNetworks = input.getNetworks();
            if (inputNetworks != null && !inputNetworks.isEmpty()) {
                if (unpNets != null) {
                    unpNets.addAll(inputNetworks);
                } else {
                    unpNets = new ArrayList<>(inputNetworks);
                }
            }
            try {
                nvpnManager.createVpn(input.getUuid(), input.getName(), input.getTenantId(), rdList, importRouteTargets, exportRouteTargets, unpRtrs, unpNets, false, /* isL2Vpn */
                0);
                neutronBgpvpnUtils.getUnProcessedRoutersMap().remove(input.getUuid());
                neutronBgpvpnUtils.getUnProcessedNetworksMap().remove(input.getUuid());
            } catch (Exception e) {
                LOG.error("Creation of BGPVPN {} failed with error ", vpnName, e);
            }
        } else {
            LOG.error("add: RD is absent for BGPVPN {}", vpnName);
        }
    }
}