Examples with InstanceIdentifier org.opendaylight.yangtools.yang.binding.InstanceIdentifier used on opensource projects

Example 96 with InstanceIdentifier

use of org.opendaylight.yangtools.yang.binding.InstanceIdentifier in project netvirt by opendaylight.

the class L3vpnPopulator method addToLabelMapper.

public void addToLabelMapper(Long label, BigInteger dpnId, String prefix, List<String> nextHopIpList, Long vpnId, String vpnInterfaceName, Long elanTag, boolean isSubnetRoute, String rd) {
    Preconditions.checkNotNull(label, "addToLabelMapper: label cannot be null or empty!");
    Preconditions.checkNotNull(prefix, "addToLabelMapper: prefix cannot be null or empty!");
    Preconditions.checkNotNull(vpnId, "addToLabelMapper: vpnId cannot be null or empty!");
    Preconditions.checkNotNull(rd, "addToLabelMapper: rd cannot be null or empty!");
    if (!isSubnetRoute) {
        // NextHop must be present for non-subnetroute entries
        Preconditions.checkNotNull(nextHopIpList, "addToLabelMapper: nextHopIp cannot be null or empty!");
    }
    synchronized (label.toString().intern()) {
        addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
            LOG.info("addToLabelMapper: label {} dpn {} prefix {} nexthoplist {} vpnid {} vpnIntfcName {} rd {}" + " elanTag {}", label, dpnId, prefix, nextHopIpList, vpnId, vpnInterfaceName, rd, elanTag);
            if (dpnId != null) {
                LabelRouteInfoBuilder lriBuilder = new LabelRouteInfoBuilder();
                lriBuilder.setLabel(label).setDpnId(dpnId).setPrefix(prefix).setNextHopIpList(nextHopIpList).setParentVpnid(vpnId).setIsSubnetRoute(isSubnetRoute);
                if (elanTag != null) {
                    lriBuilder.setElanTag(elanTag);
                } else {
                    LOG.warn("addToLabelMapper: elanTag is null for label {} prefix {} rd {} vpnId {}", label, prefix, rd, vpnId);
                }
                if (vpnInterfaceName != null) {
                    lriBuilder.setVpnInterfaceName(vpnInterfaceName);
                } else {
                    LOG.warn("addToLabelMapper: vpn interface is null for label {} prefix {} rd {} vpnId {}", label, prefix, rd, vpnId);
                }
                lriBuilder.setParentVpnRd(rd);
                VpnInstanceOpDataEntry vpnInstanceOpDataEntry = VpnUtil.getVpnInstanceOpData(broker, rd);
                if (vpnInstanceOpDataEntry != null) {
                    List<String> vpnInstanceNames = Collections.singletonList(vpnInstanceOpDataEntry.getVpnInstanceName());
                    lriBuilder.setVpnInstanceList(vpnInstanceNames);
                }
                LabelRouteInfo lri = lriBuilder.build();
                InstanceIdentifier<LabelRouteInfo> lriIid = InstanceIdentifier.builder(LabelRouteMap.class).child(LabelRouteInfo.class, new LabelRouteInfoKey(label)).build();
                tx.merge(LogicalDatastoreType.OPERATIONAL, lriIid, lri, true);
                LOG.info("addToLabelMapper: Added label route info to label {} prefix {} nextHopList {} vpnId {}" + " interface {} rd {} elantag {}", label, prefix, nextHopIpList, vpnId, vpnInterfaceName, rd, elanTag);
            } else {
                LOG.warn("addToLabelMapper: Can't add entry to label map for label {} prefix {} nextHopList {}" + " vpnId {} interface {} rd {} elantag {}, dpnId is null", label, prefix, nextHopIpList, vpnId, vpnInterfaceName, rd, elanTag);
            }
        }), LOG, "addToLabelMapper");
    }
}

Example 97 with InstanceIdentifier

use of org.opendaylight.yangtools.yang.binding.InstanceIdentifier in project netvirt by opendaylight.

the class DhcpServiceUtils method getSubnetIdsFromNetworkId.

public static List<Uuid> getSubnetIdsFromNetworkId(DataBroker broker, Uuid networkId) {
    InstanceIdentifier id = buildNetworkMapIdentifier(networkId);
    Optional<NetworkMap> optionalNetworkMap = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
    if (optionalNetworkMap.isPresent()) {
        return optionalNetworkMap.get().getSubnetIdList();
    }
    return null;
}

Example 98 with InstanceIdentifier

use of org.opendaylight.yangtools.yang.binding.InstanceIdentifier in project netvirt by opendaylight.

the class DhcpSubnetListener method getNodeConnectorIdForPortIntf.

private NodeConnectorId getNodeConnectorIdForPortIntf(Uuid interfaceName) {
    LOG.trace("DhcpSubnetListener getNodeConnectorIdForPortIntf  interfaceName: {}", interfaceName);
    NodeConnectorId nodeConnectorId = null;
    InstanceIdentifier.InstanceIdentifierBuilder<Interface> idBuilder = InstanceIdentifier.builder(InterfacesState.class).child(Interface.class, new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName.getValue()));
    InstanceIdentifier<Interface> ifStateId = idBuilder.build();
    Optional<Interface> ifStateOptional = MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker);
    Interface interfaceState = null;
    if (ifStateOptional.isPresent()) {
        interfaceState = ifStateOptional.get();
    }
    if (interfaceState != null) {
        List<String> ofportIds = interfaceState.getLowerLayerIf();
        nodeConnectorId = new NodeConnectorId(ofportIds.get(0));
        LOG.trace("DhcpSubnetListener getNodeConnectorIdForPortIntf returned nodeConnectorId {} for the interface {}", nodeConnectorId.getValue(), interfaceName);
    }
    return nodeConnectorId;
}

Example 99 with InstanceIdentifier

use of org.opendaylight.yangtools.yang.binding.InstanceIdentifier in project netvirt by opendaylight.

the class ElanInterfaceManager method removeEntriesForElanInterface.

List<ListenableFuture<Void>> removeEntriesForElanInterface(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String interfaceName, boolean isLastElanInterface) {
    String elanName = elanInfo.getElanInstanceName();
    List<ListenableFuture<Void>> futures = new ArrayList<>();
    futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(flowTx -> {
        futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(interfaceTx -> {
            InstanceIdentifier<ElanInterfaceMac> elanInterfaceId = ElanUtils.getElanInterfaceMacEntriesOperationalDataPath(interfaceName);
            Optional<ElanInterfaceMac> existingElanInterfaceMac = interfaceTx.read(LogicalDatastoreType.OPERATIONAL, elanInterfaceId).checkedGet();
            LOG.debug("Removing the Interface:{} from elan:{}", interfaceName, elanName);
            if (interfaceInfo != null) {
                if (existingElanInterfaceMac.isPresent()) {
                    List<MacEntry> existingMacEntries = existingElanInterfaceMac.get().getMacEntry();
                    if (existingMacEntries != null) {
                        List<PhysAddress> macAddresses = new ArrayList<>();
                        for (MacEntry macEntry : existingMacEntries) {
                            PhysAddress macAddress = macEntry.getMacAddress();
                            LOG.debug("removing the  mac-entry:{} present on elanInterface:{}", macAddress.getValue(), interfaceName);
                            Optional<MacEntry> macEntryOptional = elanUtils.getMacEntryForElanInstance(interfaceTx, elanName, macAddress);
                            if (!isLastElanInterface && macEntryOptional.isPresent()) {
                                interfaceTx.delete(LogicalDatastoreType.OPERATIONAL, ElanUtils.getMacEntryOperationalDataPath(elanName, macAddress));
                            }
                            elanUtils.deleteMacFlows(elanInfo, interfaceInfo, macEntry, flowTx);
                            macAddresses.add(macAddress);
                        }
                        // to this ELAN
                        if (isVxlanNetworkOrVxlanSegment(elanInfo) && !macAddresses.isEmpty()) {
                            elanL2GatewayUtils.removeMacsFromElanExternalDevices(elanInfo, macAddresses);
                        }
                    }
                }
                removeDefaultTermFlow(interfaceInfo.getDpId(), interfaceInfo.getInterfaceTag());
                removeFilterEqualsTable(elanInfo, interfaceInfo, flowTx);
            } else if (existingElanInterfaceMac.isPresent()) {
                // Interface does not exist in ConfigDS, so lets remove everything
                // about that interface related to Elan
                List<MacEntry> macEntries = existingElanInterfaceMac.get().getMacEntry();
                if (macEntries != null) {
                    for (MacEntry macEntry : macEntries) {
                        PhysAddress macAddress = macEntry.getMacAddress();
                        if (elanUtils.getMacEntryForElanInstance(elanName, macAddress).isPresent()) {
                            interfaceTx.delete(LogicalDatastoreType.OPERATIONAL, ElanUtils.getMacEntryOperationalDataPath(elanName, macAddress));
                        }
                    }
                }
            }
            if (existingElanInterfaceMac.isPresent()) {
                interfaceTx.delete(LogicalDatastoreType.OPERATIONAL, elanInterfaceId);
            }
            unbindService(interfaceName, interfaceTx);
            deleteElanInterfaceFromConfigDS(interfaceName, interfaceTx);
        }));
    }));
    return futures;
}

Example 100 with InstanceIdentifier

use of org.opendaylight.yangtools.yang.binding.InstanceIdentifier in project netvirt by opendaylight.

the class L2GwValidateCli method fillNodesData.

private void fillNodesData(Map<InstanceIdentifier<Node>, Node> nodes, Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap) {
    for (Map.Entry<InstanceIdentifier<Node>, Node> entry : nodes.entrySet()) {
        InstanceIdentifier<Node> nodeId = entry.getKey();
        Node node = entry.getValue();
        Map<InstanceIdentifier, DataObject> map = new HashMap<>();
        dataMap.put(nodeId, map);
        if (node.getAugmentation(HwvtepGlobalAugmentation.class) != null) {
            for (MergeCommand command : globalCommands) {
                List<DataObject> data = command.getData(node.getAugmentation(HwvtepGlobalAugmentation.class));
                if (data != null) {
                    for (DataObject dataObject : data) {
                        map.put(command.generateId(nodeId, dataObject), dataObject);
                    }
                }
            }
        } else {
            for (MergeCommand command : physicalSwitchCommands) {
                List<DataObject> data = command.getData(node);
                if (data != null) {
                    for (DataObject dataObject : data) {
                        map.put(command.generateId(nodeId, dataObject), dataObject);
                    }
                }
            }
        }
    }
}