Examples with L3vpn org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn used on opensource projects

Example 21 with L3vpn

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn in project netvirt by opendaylight.

the class VPNServiceChainHandler method programScfToVpnPipeline.

/**
 * L3VPN Service chaining: It moves traffic from a ServiceChain to a L3VPN.
 *
 * @param vpnName Vpn Instance Name. Typicall the UUID
 * @param scfTag ServiceChainForwarding Tag
 * @param servChainTag ServiceChain Tag
 * @param dpnId DpnId in which the egress pseudo logical port belongs
 * @param vpnPseudoLportTag VpnPseudo Logical port tag
 * @param isLastServiceChain Flag stating if there is no other ServiceChain
 *        using this VpnPseudoPort
 * @param addOrRemove States if pipeline must be installed or removed
 */
public void programScfToVpnPipeline(String vpnName, long scfTag, int servChainTag, long dpnId, int vpnPseudoLportTag, boolean isLastServiceChain, int addOrRemove) {
    // These Flows must be installed in the DPN where the last SF in the ServiceChain is located
    // + ScForwardingTable (75):  (This one is created and maintained by ScHopManager)
    // - Match:  scfTag + servChainId + lportTagOfvVSF    Instr: VpnPseudoPortTag + SI=L3VPN + GOTO LPortDisp
    // And these 2 flows must be installed in all Dpns where the Vpn is present:
    // + LPortDisp (17):
    // - Match:  VpnPseudoPortTag + SI==L3VPN    Instr: setVpnTag + GOTO FIB
    // + FIB (21): (one entry per VrfEntry, and it is maintained by FibManager)
    // - Match:  vrfTag==vpnTag + eth_type=IPv4  + dst_ip   Instr:  Output DC-GW
    // 
    LOG.info("L3VPN: Service Chaining programScfToVpnPipeline [Started]: Parameters Vpn Name: {} ", vpnName);
    String rd = VpnServiceChainUtils.getVpnRd(dataBroker, vpnName);
    if (rd == null || rd.isEmpty()) {
        LOG.warn("programScfToVpnPipeline: Could not find Router-distinguisher for VPN {}. No further actions", vpnName);
        return;
    }
    VpnInstanceOpDataEntry vpnInstance = getVpnInstance(rd);
    LOG.debug("programScfToVpnPipeline: rd={}, lportTag={} ", rd, vpnPseudoLportTag);
    // Find out the set of DPNs for the given VPN ID
    if (vpnInstance != null) {
        if (addOrRemove == NwConstants.ADD_FLOW || addOrRemove == NwConstants.DEL_FLOW && isLastServiceChain) {
            Long vpnId = vpnInstance.getVpnId();
            List<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
            if (vpnToDpnList != null) {
                List<BigInteger> dpns = new ArrayList<>();
                for (VpnToDpnList dpnInVpn : vpnToDpnList) {
                    dpns.add(dpnInVpn.getDpnId());
                }
                if (!dpns.contains(BigInteger.valueOf(dpnId))) {
                    LOG.debug("Dpn {} is not included in the current VPN Footprint", dpnId);
                    dpns.add(BigInteger.valueOf(dpnId));
                }
                for (BigInteger dpn : dpns) {
                    VpnServiceChainUtils.programLPortDispatcherFlowForScfToVpn(mdsalManager, vpnId, dpn, vpnPseudoLportTag, addOrRemove);
                }
            } else {
                LOG.debug("Could not find VpnToDpn list for VPN {} with rd {}", vpnName, rd);
            }
        }
        // We need to keep a fake VpnInterface in the DPN where the last vSF (before the VpnPseudoPort) is
        // located, because in case the last real VpnInterface is removed from that DPN, we still need
        // the Fib table programmed there
        String intfName = VpnServiceChainUtils.buildVpnPseudoPortIfName(dpnId, scfTag, servChainTag, vpnPseudoLportTag);
        vpnFootprintService.updateVpnToDpnMapping(BigInteger.valueOf(dpnId), vpnName, rd, intfName, null, /*ipAddressSourceValuePair*/
        addOrRemove == NwConstants.ADD_FLOW);
    }
    LOG.info("L3VPN: Service Chaining programScfToVpnPipeline [End]");
}

Example 22 with L3vpn

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn in project netvirt by opendaylight.

the class NatUtil method addToDpnRoutersMap.

public static void addToDpnRoutersMap(DataBroker broker, String routerName, String interfaceName, BigInteger dpId, WriteTransaction writeOperTxn) {
    if (dpId.equals(BigInteger.ZERO)) {
        LOG.error("addToDpnRoutersMap : Could not retrieve dp id for interface {} to handle router {} " + "association model", interfaceName, routerName);
        return;
    }
    LOG.debug("addToDpnRoutersMap : Adding the DPN {} and router {} for the Interface {} in the ODL-L3VPN : " + "DPNRouters map", dpId, routerName, interfaceName);
    InstanceIdentifier<DpnRoutersList> dpnRoutersListIdentifier = getDpnRoutersId(dpId);
    Optional<DpnRoutersList> optionalDpnRoutersList = SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier);
    if (optionalDpnRoutersList.isPresent()) {
        RoutersList routersList = new RoutersListBuilder().setKey(new RoutersListKey(routerName)).setRouter(routerName).build();
        List<RoutersList> routersListFromDs = optionalDpnRoutersList.get().getRoutersList();
        if (!routersListFromDs.contains(routersList)) {
            LOG.debug("addToDpnRoutersMap : Router {} not present for the DPN {}" + " in the ODL-L3VPN : DPNRouters map", routerName, dpId);
            writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier.child(RoutersList.class, new RoutersListKey(routerName)), routersList, true);
        } else {
            LOG.debug("addToDpnRoutersMap : Router {} already mapped to the DPN {} in the ODL-L3VPN : " + "DPNRouters map", routerName, dpId);
        }
    } else {
        LOG.debug("addToDpnRoutersMap : Building new DPNRoutersList for the Router {} present in the DPN {} " + "ODL-L3VPN : DPNRouters map", routerName, dpId);
        DpnRoutersListBuilder dpnRoutersListBuilder = new DpnRoutersListBuilder();
        dpnRoutersListBuilder.setDpnId(dpId);
        RoutersListBuilder routersListBuilder = new RoutersListBuilder();
        routersListBuilder.setRouter(routerName);
        dpnRoutersListBuilder.setRoutersList(Collections.singletonList(routersListBuilder.build()));
        writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, getDpnRoutersId(dpId), dpnRoutersListBuilder.build(), true);
    }
}

Example 23 with L3vpn

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn in project netvirt by opendaylight.

the class NeutronvpnManager method getL3VPN.

/**
 * It handles the invocations to the neutronvpn:getL3VPN RPC method.
 */
@Override
public Future<RpcResult<GetL3VPNOutput>> getL3VPN(GetL3VPNInput input) {
    GetL3VPNOutputBuilder opBuilder = new GetL3VPNOutputBuilder();
    SettableFuture<RpcResult<GetL3VPNOutput>> result = SettableFuture.create();
    Uuid inputVpnId = input.getId();
    List<VpnInstance> vpns = new ArrayList<>();
    List<L3vpnInstances> l3vpnList = new ArrayList<>();
    try {
        if (inputVpnId == null) {
            // get all vpns
            InstanceIdentifier<VpnInstances> vpnsIdentifier = InstanceIdentifier.builder(VpnInstances.class).build();
            Optional<VpnInstances> optionalVpns = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnsIdentifier);
            if (optionalVpns.isPresent() && !optionalVpns.get().getVpnInstance().isEmpty()) {
                for (VpnInstance vpn : optionalVpns.get().getVpnInstance()) {
                    // from getL3VPN output
                    if (vpn.getIpv4Family().getRouteDistinguisher() != null) {
                        vpns.add(vpn);
                    }
                }
            } else {
                // No VPN present
                opBuilder.setL3vpnInstances(l3vpnList);
                result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
                return result;
            }
        } else {
            String name = inputVpnId.getValue();
            InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class, new VpnInstanceKey(name)).build();
            // read VpnInstance Info
            Optional<VpnInstance> optionalVpn = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
            // getL3VPN output
            if (optionalVpn.isPresent() && optionalVpn.get().getIpv4Family().getRouteDistinguisher() != null) {
                vpns.add(optionalVpn.get());
            } else {
                result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", formatAndLog(LOG::error, "GetL3VPN failed because VPN {} is not present", name)).build());
            }
        }
        for (VpnInstance vpnInstance : vpns) {
            Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
            // create VpnMaps id
            L3vpnInstancesBuilder l3vpn = new L3vpnInstancesBuilder();
            List<String> rd = vpnInstance.getIpv4Family().getRouteDistinguisher();
            List<String> ertList = new ArrayList<>();
            List<String> irtList = new ArrayList<>();
            if (vpnInstance.getIpv4Family().getVpnTargets() != null) {
                List<VpnTarget> vpnTargetList = vpnInstance.getIpv4Family().getVpnTargets().getVpnTarget();
                for (VpnTarget vpnTarget : vpnTargetList) {
                    if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
                        ertList.add(vpnTarget.getVrfRTValue());
                    }
                    if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ImportExtcommunity) {
                        irtList.add(vpnTarget.getVrfRTValue());
                    }
                    if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.Both) {
                        ertList.add(vpnTarget.getVrfRTValue());
                        irtList.add(vpnTarget.getVrfRTValue());
                    }
                }
            }
            l3vpn.setId(vpnId).setRouteDistinguisher(rd).setImportRT(irtList).setExportRT(ertList);
            if (vpnInstance.getL3vni() != null) {
                l3vpn.setL3vni(vpnInstance.getL3vni());
            }
            InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap.class, new VpnMapKey(vpnId)).build();
            Optional<VpnMap> optionalVpnMap = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
            if (optionalVpnMap.isPresent()) {
                VpnMap vpnMap = optionalVpnMap.get();
                l3vpn.setRouterId(vpnMap.getRouterId()).setNetworkIds(vpnMap.getNetworkIds()).setTenantId(vpnMap.getTenantId()).setName(vpnMap.getName());
            }
            l3vpnList.add(l3vpn.build());
        }
        opBuilder.setL3vpnInstances(l3vpnList);
        result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
    } catch (ReadFailedException ex) {
        result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION, formatAndLog(LOG::error, "GetVPN failed due to {}", ex.getMessage())).build());
    }
    return result;
}

Example 24 with L3vpn

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn in project netvirt by opendaylight.

the class NeutronvpnManager method createL3VPN.

/**
 * It handles the invocations to the createVPN RPC method.
 */
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<CreateL3VPNOutput>> createL3VPN(CreateL3VPNInput input) {
    CreateL3VPNOutputBuilder opBuilder = new CreateL3VPNOutputBuilder();
    SettableFuture<RpcResult<CreateL3VPNOutput>> result = SettableFuture.create();
    List<RpcError> errorList = new ArrayList<>();
    int failurecount = 0;
    int warningcount = 0;
    List<L3vpn> vpns = input.getL3vpn();
    for (L3vpn vpn : vpns) {
        if (neutronvpnUtils.doesVpnExist(vpn.getId())) {
            errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} due to VPN with the same ID already present", vpn.getId().getValue())));
            warningcount++;
            continue;
        }
        if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) {
            errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} due to absence of RD/iRT/eRT input", vpn.getId().getValue())));
            warningcount++;
            continue;
        }
        VpnInstance.Type vpnInstanceType = VpnInstance.Type.L3;
        long l3vni = 0;
        if (vpn.getL3vni() != null) {
            l3vni = vpn.getL3vni();
        }
        List<String> existingRDs = neutronvpnUtils.getExistingRDs();
        if (existingRDs.contains(vpn.getRouteDistinguisher().get(0))) {
            errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} as another VPN with the same RD {} " + "is already configured", vpn.getId().getValue(), vpn.getRouteDistinguisher().get(0))));
            warningcount++;
            continue;
        }
        Optional<String> operationalVpn = getExistingOperationalVpn(vpn.getRouteDistinguisher().get(0));
        if (operationalVpn.isPresent()) {
            errorList.add(RpcResultBuilder.newError(ErrorType.APPLICATION, "application-error", formatAndLog(LOG::error, "Creation of L3VPN failed for VPN {} as another VPN {} with the same RD {} " + "is still available. Please retry creation of a new vpn with the same RD" + " after a couple of minutes.", vpn.getId().getValue(), operationalVpn.get(), vpn.getRouteDistinguisher().get(0))));
            warningcount++;
            continue;
        }
        if (vpn.getRouterId() != null) {
            if (neutronvpnUtils.getNeutronRouter(vpn.getRouterId()) == null) {
                errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} due to router not found {}", vpn.getId().getValue(), vpn.getRouterId().getValue())));
                warningcount++;
                continue;
            }
            Uuid vpnId = neutronvpnUtils.getVpnForRouter(vpn.getRouterId(), true);
            if (vpnId != null) {
                errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} due to router {} already associated to " + "another VPN {}", vpn.getId().getValue(), vpn.getRouterId().getValue(), vpnId.getValue())));
                warningcount++;
                continue;
            }
        }
        if (vpn.getNetworkIds() != null) {
            int initialWarningCount = warningcount;
            for (Uuid nw : vpn.getNetworkIds()) {
                Network network = neutronvpnUtils.getNeutronNetwork(nw);
                Uuid vpnId = neutronvpnUtils.getVpnForNetwork(nw);
                if (network == null) {
                    errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} due to network not found {}", vpn.getId().getValue(), nw.getValue())));
                    warningcount++;
                } else if (vpnId != null) {
                    errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} due to network {} already associated" + " to another VPN {}", vpn.getId().getValue(), nw.getValue(), vpnId.getValue())));
                    warningcount++;
                }
            }
            if (warningcount != initialWarningCount) {
                continue;
            }
        }
        try {
            createVpn(vpn.getId(), vpn.getName(), vpn.getTenantId(), vpn.getRouteDistinguisher(), vpn.getImportRT(), vpn.getExportRT(), vpn.getRouterId(), vpn.getNetworkIds(), vpnInstanceType, l3vni);
        } catch (Exception ex) {
            errorList.add(RpcResultBuilder.newError(ErrorType.APPLICATION, formatAndLog(LOG::error, "Creation of VPN failed for VPN {}", vpn.getId().getValue(), ex), ex.getMessage()));
            failurecount++;
        }
    }
    // if none succeeds; result is failure
    if (failurecount + warningcount == vpns.size()) {
        result.set(RpcResultBuilder.<CreateL3VPNOutput>failed().withRpcErrors(errorList).build());
    } else {
        List<String> errorResponseList = new ArrayList<>();
        if (!errorList.isEmpty()) {
            for (RpcError rpcError : errorList) {
                errorResponseList.add("ErrorType: " + rpcError.getErrorType() + ", ErrorTag: " + rpcError.getTag() + ", ErrorMessage: " + rpcError.getMessage());
            }
        } else {
            errorResponseList.add("Operation successful with no errors");
        }
        opBuilder.setResponse(errorResponseList);
        result.set(RpcResultBuilder.<CreateL3VPNOutput>success().withResult(opBuilder.build()).build());
    }
    return result;
}

Example 25 with L3vpn

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn in project netvirt by opendaylight.

the class NeutronRouterChangeListener method remove.

@Override
protected void remove(InstanceIdentifier<Router> identifier, Router input) {
    LOG.trace("Removing router : key: {}, value={}", identifier, input);
    Uuid routerId = input.getUuid();
    /*External Router and networks is handled before deleting the internal VPN, as there is dependency
        on vpn operational data to release Lport tag in case of L3VPN over VxLAN*/
    if (input.getExternalGatewayInfo() != null) {
        Uuid extNetId = input.getExternalGatewayInfo().getExternalNetworkId();
        List<ExternalFixedIps> externalFixedIps = input.getExternalGatewayInfo().getExternalFixedIps();
        nvpnNatManager.removeExternalNetworkFromRouter(extNetId, input, externalFixedIps);
    }
    // NOTE: Pass an empty routerSubnetIds list, as router interfaces
    // will be removed from VPN by invocations from NeutronPortChangeListener
    List<Uuid> routerSubnetIds = new ArrayList<>();
    nvpnManager.handleNeutronRouterDeleted(routerId, routerSubnetIds);
    neutronvpnUtils.removeFromRouterCache(input);
}