Examples with RouterId org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId used on opensource projects

Example 81 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class NatUtil method getNetworkVpnIdFromRouterId.

public static Uint32 getNetworkVpnIdFromRouterId(DataBroker broker, Uint32 routerId) {
    // Get the external network ID from the ExternalRouter model
    Uuid networkId = NatUtil.getNetworkIdFromRouterId(broker, routerId);
    if (networkId == null) {
        LOG.error("getNetworkVpnIdFromRouterId : networkId is null");
        return NatConstants.INVALID_ID;
    }
    // Get the VPN ID from the ExternalNetworks model
    Uuid vpnUuid = NatUtil.getVpnIdfromNetworkId(broker, networkId);
    if (vpnUuid == null) {
        LOG.error("getNetworkVpnIdFromRouterId : vpnUuid is null");
        return NatConstants.INVALID_ID;
    }
    Uint32 vpnId = NatUtil.getVpnId(broker, vpnUuid.getValue());
    return vpnId;
}

Example 82 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class RouterDpnChangeListener method add.

@Override
public void add(final InstanceIdentifier<DpnVpninterfacesList> identifier, final DpnVpninterfacesList dpnInfo) {
    LOG.trace("add : key: {}, value: {}", dpnInfo.key(), dpnInfo);
    final String routerUuid = identifier.firstKeyOf(RouterDpnList.class).getRouterId();
    Uint64 dpnId = dpnInfo.getDpnId();
    // check router is associated to external network
    InstanceIdentifier<Routers> id = NatUtil.buildRouterIdentifier(routerUuid);
    Optional<Routers> routerData = SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
    if (routerData.isPresent()) {
        Routers router = routerData.get();
        Uuid networkId = router.getNetworkId();
        if (networkId != null) {
            if (natMode == NatMode.Conntrack) {
                Uint64 naptSwitch = NatUtil.getPrimaryNaptfromRouterName(dataBroker, router.getRouterName());
                if (naptSwitch == null || naptSwitch.equals(Uint64.ZERO)) {
                    LOG.warn("add : NAPT switch is not selected.");
                    return;
                }
                // If it is for NAPT switch skip as the flows would be already programmed.
                if (naptSwitch.equals(dpnId)) {
                    LOG.debug("Skipping the notification recived for NAPT switch {}", routerUuid);
                    return;
                }
                LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, confTx -> {
                    natServiceManager.notify(confTx, router, null, naptSwitch, dpnId, SnatServiceManager.Action.CNT_ROUTER_ENBL);
                    if (router.isEnableSnat()) {
                        natServiceManager.notify(confTx, router, null, naptSwitch, naptSwitch, SnatServiceManager.Action.SNAT_ROUTER_ENBL);
                    }
                }), LOG, "Error notifying NAT service manager");
            } else {
                Uint32 routerId = NatUtil.getVpnId(dataBroker, routerUuid);
                if (routerId == NatConstants.INVALID_ID) {
                    LOG.error("add : Invalid routerId returned for routerName {}", routerUuid);
                    return;
                }
                ProviderTypes extNwProvType = NatEvpnUtil.getExtNwProvTypeFromRouterName(dataBroker, routerUuid, networkId);
                if (extNwProvType == ProviderTypes.FLAT || extNwProvType == ProviderTypes.VLAN) {
                    coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + networkId, () -> {
                        extNetGroupInstaller.installExtNetGroupEntries(networkId, dpnId);
                        installDefaultNatRouteForRouterExternalSubnets(dpnId, NatUtil.getExternalSubnetIdsFromExternalIps(new ArrayList<ExternalIps>(router.nonnullExternalIps().values())));
                        return Collections.emptyList();
                    });
                }
                coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + router.getRouterName(), () -> {
                    LOG.debug("add : Router {} is associated with ext nw {}", routerUuid, networkId);
                    Uuid vpnName = NatUtil.getVpnForRouter(dataBroker, routerUuid);
                    return Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, confTx -> {
                        Uint32 vpnId;
                        if (vpnName == null) {
                            LOG.debug("add : Internal vpn associated to router {}", routerUuid);
                            vpnId = routerId;
                            if (vpnId == NatConstants.INVALID_ID) {
                                LOG.error("add : Invalid vpnId returned for routerName {}", routerUuid);
                                return;
                            }
                            LOG.debug("add : Retrieved vpnId {} for router {}", vpnId, routerUuid);
                            // Install default entry in FIB to SNAT table
                            LOG.info("add : Installing default route in FIB on dpn {} for router {} with vpn {}", dpnId, routerUuid, vpnId);
                            snatDefaultRouteProgrammer.installDefNATRouteInDPN(dpnId, vpnId, confTx);
                        } else {
                            LOG.debug("add : External BGP vpn associated to router {}", routerUuid);
                            vpnId = NatUtil.getVpnId(dataBroker, vpnName.getValue());
                            if (vpnId == NatConstants.INVALID_ID) {
                                LOG.error("add : Invalid vpnId returned for routerName {}", routerUuid);
                                return;
                            }
                            LOG.debug("add : Retrieved vpnId {} for router {}", vpnId, routerUuid);
                            // Install default entry in FIB to SNAT table
                            LOG.debug("add : Installing default route in FIB on dpn {} for routerId {} with " + "vpnId {}...", dpnId, routerUuid, vpnId);
                            snatDefaultRouteProgrammer.installDefNATRouteInDPN(dpnId, vpnId, routerId, confTx);
                        }
                        /* install V6 internet default fallback rule in FIB_TABLE if router
                                 * is having V6 subnet
                                 */
                        Uuid internetVpnId = NatUtil.getVpnIdfromNetworkId(dataBroker, networkId);
                        if (internetVpnId != null) {
                            nvpnManager.programV6InternetFallbackFlow(new Uuid(routerUuid), internetVpnId, NwConstants.ADD_FLOW);
                        }
                        if (router.isEnableSnat()) {
                            LOG.info("add : SNAT enabled for router {}", routerUuid);
                            if (extNwProvType == null) {
                                LOG.error("add : External Network Provider Type missing");
                                return;
                            }
                            NatUtil.handleSNATForDPN(dataBroker, mdsalManager, idManager, naptSwitchHA, dpnId, router, routerId, vpnId, confTx, extNwProvType, upgradeState);
                        } else {
                            LOG.info("add : SNAT is not enabled for router {} to handle addDPN event {}", routerUuid, dpnId);
                        }
                    }));
                }, NatConstants.NAT_DJC_MAX_RETRIES);
            }
        // end of controller based SNAT
        }
    } else {
        LOG.debug("add : Router {} is not associated with External network", routerUuid);
    }
}

Example 83 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class NatRouterInterfaceListener method add.

@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public void add(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {
    LOG.trace("add : Add event - key: {}, value: {}", interfaceInfo.key(), interfaceInfo);
    final String routerId = identifier.firstKeyOf(RouterInterfaces.class).getRouterId().getValue();
    final String interfaceName = interfaceInfo.getInterfaceId();
    if (NatUtil.isRouterInterfacePort(dataBroker, interfaceName)) {
        LOG.info("ADD: Ignoring Router Interface Port {} for processing of router {}", interfaceName, routerId);
        return;
    }
    try {
        MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName), getRouterInterface(interfaceName, routerId));
    } catch (Exception e) {
        LOG.error("add: Unable to write data in RouterInterface model", e);
    }
    org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState = NatUtil.getInterfaceStateFromOperDS(dataBroker, interfaceName);
    if (interfaceState != null) {
        Uint64 dpId = NatUtil.getDpIdFromInterface(interfaceState);
        if (dpId.equals(Uint64.ZERO)) {
            LOG.warn("ADD : Could not retrieve dp id for interface {} to handle router {} association model", interfaceName, routerId);
            return;
        }
        final ReentrantLock lock = NatUtil.lockForNat(dpId);
        lock.lock();
        try {
            LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, operTx -> {
                NatUtil.addToNeutronRouterDpnsMap(routerId, interfaceName, dpId, operTx);
                NatUtil.addToDpnRoutersMap(routerId, interfaceName, dpId, operTx);
            }), LOG, "Error processing NAT router interface addition");
        } finally {
            lock.unlock();
        }
        LOG.info("ADD: Added neutron-router-dpns mapping for interface {} of router {}", interfaceName, routerId);
    } else {
        LOG.info("add : Interface {} not yet operational to handle router interface add event in router {}", interfaceName, routerId);
    }
}

Example 84 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class NatVpnMapsChangeListener method onRouterAssociatedToVpn.

public void onRouterAssociatedToVpn(String vpnName, String routerName) {
    // check router is associated to external network
    String extNetwork = NatUtil.getAssociatedExternalNetwork(dataBroker, routerName);
    if (extNetwork != null) {
        try {
            LOG.debug("onRouterAssociatedToVpn : Router {} is associated with ext nw {}", routerName, extNetwork);
            handleDNATConfigurationForRouterAssociation(routerName, vpnName, extNetwork);
            Uuid extNetworkUuid = NatUtil.getNetworkIdFromRouterName(dataBroker, routerName);
            if (extNetworkUuid == null) {
                LOG.error("onRouterAssociatedToVpn : Unable to retrieve external network Uuid for router {}", routerName);
                return;
            }
            ProviderTypes extNwProvType = NatEvpnUtil.getExtNwProvTypeFromRouterName(dataBroker, routerName, extNetworkUuid);
            if (extNwProvType == null) {
                LOG.error("onRouterAssociatedToVpn : External Network Provider Type missing");
                return;
            }
            Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
            txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> externalRoutersListener.changeLocalVpnIdToBgpVpnId(routerName, routerId, extNetwork, vpnName, tx, extNwProvType)).get();
        } catch (InterruptedException | ExecutionException e) {
            LOG.error("Error changling local VPN identifier to BGP VPN identifier", e);
        }
    } else {
        LOG.debug("onRouterAssociatedToVpn : Ignoring the Router {} association with VPN {} " + "since it is not external router", routerName, vpnName);
    }
}

Example 85 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class NatVpnMapsChangeListener method update.

@Override
public void update(InstanceIdentifier<VpnMap> identifier, VpnMap original, VpnMap updated) {
    Uuid vpnUuid = updated.getVpnId();
    String vpnName = vpnUuid.getValue();
    List<RouterIds> updatedRouterIdList = new ArrayList<RouterIds>(updated.nonnullRouterIds().values());
    List<RouterIds> originalRouterIdList = new ArrayList<RouterIds>(original.nonnullRouterIds().values());
    List<RouterIds> routersAddedList = null;
    List<RouterIds> routersRemovedList = null;
    if (originalRouterIdList == null && updatedRouterIdList != null) {
        routersAddedList = updatedRouterIdList;
    } else if (originalRouterIdList != null && updatedRouterIdList != null) {
        routersAddedList = updatedRouterIdList.stream().filter(routerId -> (!originalRouterIdList.contains(routerId))).collect(Collectors.toList());
    }
    if (originalRouterIdList != null && updatedRouterIdList == null) {
        routersRemovedList = originalRouterIdList;
    } else if (originalRouterIdList != null && updatedRouterIdList != null) {
        routersRemovedList = originalRouterIdList.stream().filter(routerId -> (!updatedRouterIdList.contains(routerId))).collect(Collectors.toList());
    }
    if (routersAddedList != null) {
        routersAddedList.stream().filter(router -> !(Objects.equals(router.getRouterId(), updated.getVpnId()))).forEach(router -> {
            String routerName = router.getRouterId().getValue();
            onRouterAssociatedToVpn(vpnName, routerName);
        });
    }
    if (routersRemovedList != null) {
        routersRemovedList.stream().filter(router -> !(Objects.equals(router.getRouterId(), original.getVpnId()))).forEach(router -> {
            String routerName = router.getRouterId().getValue();
            onRouterDisassociatedFromVpn(vpnName, routerName);
        });
    }
}