Examples with VpnToDpnList org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList used on opensource projects

Example 11 with VpnToDpnList

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList in project netvirt by opendaylight.

the class VpnUtil method getDpnsOnVpn.

@Nonnull
public static List<BigInteger> getDpnsOnVpn(DataBroker dataBroker, String vpnInstanceName) {
    List<BigInteger> result = new ArrayList<>();
    String rd = getVpnRd(dataBroker, vpnInstanceName);
    if (rd == null) {
        LOG.debug("getDpnsOnVpn: Could not find Route-Distinguisher for VpnName={}", vpnInstanceName);
        return result;
    }
    VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(dataBroker, rd);
    if (vpnInstanceOpData == null) {
        LOG.debug("getDpnsOnVpn: Could not find OpState for VpnName={}", vpnInstanceName);
        return result;
    }
    List<VpnToDpnList> vpnToDpnList = vpnInstanceOpData.getVpnToDpnList();
    if (vpnToDpnList == null) {
        LOG.debug("getDpnsOnVpn: Could not find DPN footprint for VpnName={}", vpnInstanceName);
        return result;
    }
    for (VpnToDpnList vpnToDpn : vpnToDpnList) {
        result.add(vpnToDpn.getDpnId());
    }
    return result;
}

Example 12 with VpnToDpnList

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList in project netvirt by opendaylight.

the class ShowVpnInstanceOpData method doExecute.

@Override
protected Object doExecute() {
    if (detail == null) {
        getVpnInstanceOpData();
        session.getConsole().println("For following vpnInstances vpnInstanceOpDataEntry is present: \n");
        for (VpnInstance vpnInstance : vpnInstanceList) {
            VpnInstanceOpDataEntry check = vpnInstanceOpDataEntryMap.get(vpnInstance.getVpnInstanceName());
            if (check != null) {
                session.getConsole().println(vpnInstance.getVpnInstanceName() + "\n");
            }
        }
        session.getConsole().println("\n\nFor following vpnInstances vpnInstanceOpDataEntry is not present: \n");
        for (VpnInstance vpnInstance : vpnInstanceList) {
            VpnInstanceOpDataEntry check = vpnInstanceOpDataEntryMap.get(vpnInstance.getVpnInstanceName());
            if (check == null) {
                session.getConsole().println(vpnInstance.getVpnInstanceName() + "\n");
            }
        }
        session.getConsole().println(getshowVpnCLIHelp());
    } else {
        getVpnInstanceOpData();
        session.getConsole().println("Fetching details of given vpnInstance\n");
        session.getConsole().println("------------------------------------------------------------------------------");
        VpnInstanceOpDataEntry check = vpnInstanceOpDataEntryMap.get(detail);
        Long intfCount = 0L;
        List<VpnToDpnList> dpnToVpns = check.getVpnToDpnList();
        if (dpnToVpns != null) {
            for (VpnToDpnList dpn : dpnToVpns) {
                if (dpn.getVpnInterfaces() != null) {
                    intfCount = intfCount + dpn.getVpnInterfaces().size();
                }
            }
        }
        session.getConsole().println("VpnInstanceName: " + check.getVpnInstanceName() + "\nVpnId: " + check.getVpnId() + "\nVrfId: " + check.getVrfId() + "\nKey: " + check.getKey() + "\nVpnInterfaceCount: " + intfCount + "\nVpnToDpnList: " + check.getVpnToDpnList() + "\n");
        session.getConsole().println("------------------------------------------------------------------------------");
    }
    return null;
}

Example 13 with VpnToDpnList

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList in project netvirt by opendaylight.

the class VrfListener method programLabelInAllVpnDpns.

/**
 * Adds or Removes a VPN's route in all the DPNs where the VPN has footprint.
 *
 * @param vpnRd Route-Distinguisher of the VPN
 * @param vrfEntry The route to add or remove
 * @param addOrRemove States if the route must be added or removed
 */
protected void programLabelInAllVpnDpns(String vpnRd, VrfEntry vrfEntry, int addOrRemove) {
    Long vpnPseudoLPortTag = vpnPseudoPortCache.get(vpnRd);
    if (vpnPseudoLPortTag == null) {
        LOG.debug("Vpn with rd={} not related to any VpnPseudoPort", vpnRd);
        return;
    }
    Optional<VpnInstanceOpDataEntry> vpnOpData = VpnServiceChainUtils.getVpnInstanceOpData(broker, vpnRd);
    if (!vpnOpData.isPresent()) {
        if (addOrRemove == NwConstants.ADD_FLOW) {
            LOG.error("VrfEntry added: Could not find operational data for VPN with RD={}", vpnRd);
        } else {
            LOG.warn("VrfEntry removed: No Operational data found for VPN with RD={}. No further action", vpnRd);
        }
        return;
    }
    Collection<VpnToDpnList> vpnToDpnList = vpnOpData.get().getVpnToDpnList();
    if (vpnToDpnList == null || vpnToDpnList.isEmpty()) {
        LOG.warn("Empty VpnToDpnlist found in Operational for VPN with RD={}. No label will be {}", vpnRd, addOrRemove == NwConstants.ADD_FLOW ? "programmed" : "cleaned");
        return;
    }
    for (VpnToDpnList dpnInVpn : vpnToDpnList) {
        BigInteger dpnId = dpnInVpn.getDpnId();
        VpnServiceChainUtils.programLFibEntriesForSCF(mdsalMgr, dpnId, Collections.singletonList(vrfEntry), (int) vpnPseudoLPortTag.longValue(), addOrRemove);
    }
}

Example 14 with VpnToDpnList

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList in project netvirt by opendaylight.

the class VPNServiceChainHandler method programVpnToScfPipeline.

/**
 * Programs the necessary flows in LFIB and LPortDispatcher table so that
 * the packets coming from a given VPN are delivered to a given
 * ServiceChain Pipeline.
 *
 * @param vpnName Name of the VPN. Typically the UUID
 * @param tableId Table to which the LPortDispatcher table sends the packet
 *                 to (Uplink or Downlink Subsc table)
 * @param scfTag Scf tag to the SCF to which the Vpn is linked to.
 * @param lportTag VpnPseudo Port lportTag
 * @param addOrRemove States if the VPN2SCF Pipeline must be installed or
 *        removed
 */
public void programVpnToScfPipeline(String vpnName, short tableId, long scfTag, int lportTag, int addOrRemove) {
    // This entries must be created in the DPN where the CGNAT is installed. Since it is not possible
    // to know where CGNAT is located, this entries are installed in all the VPN footprint.
    // LFIB:
    // - Match: cgnatLabel   Instr: lportTag=vpnPseudoPortTag + SI=SCF  +  GOTO 17
    // LportDisp:
    // - Match: vpnPseudoPortTag + SI==SCF   Instr:  scfTag  +  GOTO 70
    LOG.info("programVpnToScfPipeline ({}) : Parameters VpnName:{} tableId:{} scftag:{}  lportTag:{}", addOrRemove == NwConstants.ADD_FLOW ? "Creation" : "Removal", vpnName, tableId, scfTag, lportTag);
    String rd = VpnServiceChainUtils.getVpnRd(dataBroker, vpnName);
    LOG.debug("Router distinguisher (rd):{}", rd);
    if (rd == null || rd.isEmpty()) {
        LOG.warn("programVpnToScfPipeline: Could not find Router-distinguisher for VPN {}. No further actions", vpnName);
        return;
    }
    VpnInstanceOpDataEntry vpnInstance = getVpnInstance(rd);
    if (vpnInstance == null) {
        LOG.warn("Could not find a suitable VpnInstance for Route-Distinguisher={}", rd);
        return;
    }
    // Find out the set of DPNs for the given VPN ID
    Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
    List<VrfEntry> vrfEntries = VpnServiceChainUtils.getAllVrfEntries(dataBroker, rd);
    if (vrfEntries != null) {
        if (addOrRemove == NwConstants.ADD_FLOW) {
            AddVpnPseudoPortDataJob updateVpnToPseudoPortTask = new AddVpnPseudoPortDataJob(dataBroker, rd, lportTag, tableId, (int) scfTag);
            jobCoordinator.enqueueJob(updateVpnToPseudoPortTask.getDsJobCoordinatorKey(), updateVpnToPseudoPortTask);
        } else {
            RemoveVpnPseudoPortDataJob removeVpnPseudoPortDataTask = new RemoveVpnPseudoPortDataJob(dataBroker, rd);
            jobCoordinator.enqueueJob(removeVpnPseudoPortDataTask.getDsJobCoordinatorKey(), removeVpnPseudoPortDataTask);
        }
        for (VpnToDpnList dpnInVpn : vpnToDpnList) {
            BigInteger dpnId = dpnInVpn.getDpnId();
            programVpnToScfPipelineOnDpn(dpnId, vrfEntries, tableId, (int) scfTag, lportTag, addOrRemove);
            if (dpnInVpn.getVpnInterfaces() != null) {
                long vpnId = vpnInstance.getVpnId();
                Flow flow = VpnServiceChainUtils.buildLPortDispFromScfToL3VpnFlow(vpnId, dpnId, lportTag, NwConstants.ADD_FLOW);
                if (addOrRemove == NwConstants.ADD_FLOW) {
                    mdsalManager.installFlow(dpnId, flow);
                } else {
                    mdsalManager.removeFlow(dpnId, flow);
                }
                dpnInVpn.getVpnInterfaces().forEach(vpnIf -> {
                    if (addOrRemove == NwConstants.ADD_FLOW) {
                        bindScfOnVpnInterface(vpnIf.getInterfaceName(), (int) scfTag);
                    } else {
                        unbindScfOnVpnInterface(vpnIf.getInterfaceName());
                    }
                });
            }
        }
    }
}

Example 15 with VpnToDpnList

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList in project netvirt by opendaylight.

the class VpnFootprintService method removeOrUpdateVpnToDpnListForIpAddress.

private void removeOrUpdateVpnToDpnListForIpAddress(long vpnId, String rd, BigInteger dpnId, ImmutablePair<IpAddresses.IpAddressSource, String> ipAddressSourceValuePair, String vpnName) {
    Boolean lastDpnOnVpn = Boolean.FALSE;
    synchronized (vpnName.intern()) {
        InstanceIdentifier<VpnToDpnList> id = VpnUtil.getVpnToDpnListIdentifier(rd, dpnId);
        VpnToDpnList dpnInVpn = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id).orNull();
        if (dpnInVpn == null) {
            LOG.error("removeOrUpdateVpnToDpnList: Could not find DpnToVpn map for VPN=[name={} rd={} id={}]" + " and dpnId={}", vpnName, rd, id, dpnId);
            return;
        }
        List<IpAddresses> ipAddresses = dpnInVpn.getIpAddresses();
        if (ipAddresses == null) {
            LOG.info("Could not find ipAddresses for DpnInVpn map for VPN=[name={} rd={} id={}] and dpnId={}", vpnName, rd, id, dpnId);
            return;
        }
        IpAddresses currIpAddress = new IpAddressesBuilder().setKey(new IpAddressesKey(ipAddressSourceValuePair.getValue())).setIpAddressSource(ipAddressSourceValuePair.getKey()).build();
        if (ipAddresses.remove(currIpAddress)) {
            WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
            if (ipAddresses.isEmpty()) {
                List<VpnInterfaces> vpnInterfaces = dpnInVpn.getVpnInterfaces();
                VpnToDpnListBuilder dpnInVpnBuilder = new VpnToDpnListBuilder(dpnInVpn).setIpAddresses(null);
                if (vpnInterfaces == null || vpnInterfaces.isEmpty()) {
                    dpnInVpnBuilder.setDpnState(VpnToDpnList.DpnState.Inactive);
                    lastDpnOnVpn = Boolean.TRUE;
                } else {
                    LOG.warn("ip addresses are empty but vpn interfaces are present for the vpn {} in dpn {}", vpnName, dpnId);
                }
                writeTxn.put(LogicalDatastoreType.OPERATIONAL, id, dpnInVpnBuilder.build(), true);
            } else {
                writeTxn.delete(LogicalDatastoreType.OPERATIONAL, id.child(IpAddresses.class, new IpAddressesKey(ipAddressSourceValuePair.getValue())));
            }
            try {
                writeTxn.submit().get();
            } catch (InterruptedException | ExecutionException e) {
                LOG.error("Error removing from dpnToVpnList for vpn {} Ipaddress {} dpn {}", vpnName, ipAddressSourceValuePair.getValue(), dpnId, e);
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    }
    if (lastDpnOnVpn) {
        LOG.debug("Sending cleanup event for dpn {} in VPN {}", dpnId, vpnName);
        fibManager.cleanUpDpnForVpn(dpnId, vpnId, rd, new DpnEnterExitVpnWorker(dpnId, vpnName, rd, false));
    }
}