Examples with Uint32 org.opendaylight.yangtools.yang.common.Uint32 used on opensource projects

Example 71 with Uint32

use of org.opendaylight.yangtools.yang.common.Uint32 in project netvirt by opendaylight.

the class RouterPortsListener method add.

@Override
public void add(final InstanceIdentifier<RouterPorts> identifier, final RouterPorts routerPorts) {
    LOG.trace("add : key:{}  value:{}", routerPorts.key(), routerPorts);
    Optional<RouterPorts> optRouterPorts = SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier);
    if (optRouterPorts.isPresent()) {
        RouterPorts ports = optRouterPorts.get();
        String routerName = ports.getRouterId();
        MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier, new RouterPortsBuilder().withKey(new RouterPortsKey(routerName)).setRouterId(routerName).setExternalNetworkId(routerPorts.getExternalNetworkId()).build());
    } else {
        String routerName = routerPorts.getRouterId();
        MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier, new RouterPortsBuilder().withKey(new RouterPortsKey(routerName)).setRouterId(routerName).setExternalNetworkId(routerPorts.getExternalNetworkId()).build());
    }
    // Check if the router is associated with any BGP VPN and update the association
    String routerName = routerPorts.getRouterId();
    Uuid vpnName = NatUtil.getVpnForRouter(dataBroker, routerName);
    if (vpnName != null) {
        InstanceIdentifier<Routermapping> routerMappingId = NatUtil.getRouterVpnMappingId(routerName);
        Optional<Routermapping> optRouterMapping = SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, LogicalDatastoreType.OPERATIONAL, routerMappingId);
        if (!optRouterMapping.isPresent()) {
            Uint32 vpnId = NatUtil.getVpnId(dataBroker, vpnName.getValue());
            LOG.debug("add : Updating router {} to VPN {} association with Id {}", routerName, vpnName, vpnId);
            Routermapping routerMapping = new RoutermappingBuilder().withKey(new RoutermappingKey(routerName)).setRouterName(routerName).setVpnName(vpnName.getValue()).setVpnId(vpnId).build();
            MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, routerMappingId, routerMapping);
        }
    }
}

Example 72 with Uint32

use of org.opendaylight.yangtools.yang.common.Uint32 in project netvirt by opendaylight.

the class NatSwitchCacheListenerImpl method switchAddedToCache.

public void switchAddedToCache(SwitchInfo switchInfo) {
    ExternalSubnets externalSubnets = NatUtil.getExternalSubnets(dataBroker);
    if (externalSubnets != null) {
        for (Subnets externalSubnet : externalSubnets.nonnullSubnets().values()) {
            Uuid externalNetworkUuid = externalSubnet.getExternalNetworkId();
            String providerNet = NatUtil.getElanInstancePhysicalNetwok(externalNetworkUuid.getValue(), dataBroker);
            if (switchInfo.getProviderNets().contains(providerNet)) {
                Uint32 vpnid = NatUtil.getVpnId(dataBroker, externalNetworkUuid.getValue());
                snatDefaultRouteProgrammer.addOrDelDefaultFibRouteToSNATForSubnetInDpn(externalSubnet, externalNetworkUuid.getValue(), NwConstants.ADD_FLOW, vpnid, switchInfo.getDpnId());
            }
        }
    }
}

Example 73 with Uint32

use of org.opendaylight.yangtools.yang.common.Uint32 in project netvirt by opendaylight.

the class VxlanGreConntrackBasedSnatService method removeSnatSpecificEntriesForNaptSwitch.

@Override
protected void removeSnatSpecificEntriesForNaptSwitch(TypedReadWriteTransaction<Configuration> confTx, Routers routers, Uint64 dpnId) throws ExecutionException, InterruptedException {
    LOG.info("installSnatSpecificEntriesForNaptSwitch for router {}", routers.getRouterName());
    String routerName = routers.getRouterName();
    Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
    /* Remove Outbound NAT entries */
    removeSnatMissEntryForPrimrySwch(confTx, dpnId, routerId);
    removeTerminatingServiceTblEntryForVxlanGre(confTx, dpnId, routerId);
    // Long extNetVpnId = NatUtil.getNetworkVpnIdFromRouterId(dataBroker, routerId);
    Uuid vpnUuid = NatUtil.getVpnIdfromNetworkId(dataBroker, routers.getNetworkId());
    if (vpnUuid == null) {
        LOG.error("installSnatSpecificEntriesForNaptSwitch: Unable to retrieve external vpn_id for " + "external network {} with routerId {}", routers.getNetworkId(), routerId);
        return;
    }
    Uint32 extNetVpnId = NatUtil.getVpnId(dataBroker, vpnUuid.getValue());
    LOG.info("installSnatSpecificEntriesForNaptSwitch: external network vpn_id {} for router {}", extNetVpnId, routers.getRouterName());
    Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = routers.nonnullExternalIps();
    removeOutboundTblTrackEntryForVxlanGre(confTx, dpnId, routerId);
    removeOutboundTblEntryForVxlanGre(confTx, dpnId, routerId, new ArrayList<ExternalIps>(keyExternalIpsMap.values()));
    removeNaptPfibFlowForVxlanGre(confTx, routers, dpnId, extNetVpnId);
    removeNaptPfibEntry(confTx, dpnId, routerId);
    // Install Inbound NAT entries
    removeInboundEntryForVxlanGre(confTx, dpnId, routerId, new ArrayList<ExternalIps>(keyExternalIpsMap.values()));
    if (keyExternalIpsMap.isEmpty()) {
        LOG.error("installSnatSpecificEntriesForNaptSwitch: No externalIP present for router {}", routerName);
        return;
    }
    // The logic now handle only one external IP per router, others if present will be ignored.
    String externalIp = NatUtil.validateAndAddNetworkMask(new ArrayList<ExternalIps>(keyExternalIpsMap.values()).get(0).getIpAddress());
    externalRouterListener.clearFibTsAndReverseTraffic(dpnId, routerId, routers.getNetworkId(), Collections.singletonList(externalIp), null, routers.getExtGwMacAddress(), confTx);
}

Example 74 with Uint32

use of org.opendaylight.yangtools.yang.common.Uint32 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 75 with Uint32

use of org.opendaylight.yangtools.yang.common.Uint32 in project netvirt by opendaylight.

the class RouterDpnChangeListener method installDefaultNatRouteForRouterExternalSubnets.

private void installDefaultNatRouteForRouterExternalSubnets(Uint64 dpnId, Collection<Uuid> externalSubnetIds) {
    if (externalSubnetIds == null) {
        LOG.error("installDefaultNatRouteForRouterExternalSubnets : No external subnets for router");
        return;
    }
    for (Uuid subnetId : externalSubnetIds) {
        Uint32 vpnIdForSubnet = NatUtil.getExternalSubnetVpnId(dataBroker, subnetId);
        if (vpnIdForSubnet != NatConstants.INVALID_ID) {
            LOG.info("installDefaultNatRouteForRouterExternalSubnets : Installing default routes in FIB on dpn {} " + "for subnetId {} with vpnId {}", dpnId, subnetId, vpnIdForSubnet);
            snatDefaultRouteProgrammer.installDefNATRouteInDPN(dpnId, vpnIdForSubnet, subnetId.getValue());
        } else {
            LOG.debug("installDefaultNatRouteForRouterExternalSubnets : No vpnID for subnet {} found", subnetId);
        }
    }
}