Examples with MacAddress org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress used on opensource projects

Example 11 with MacAddress

use of org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress in project netvirt by opendaylight.

the class VpnInterfaceManager method updateVpnInterfaceOnTepAdd.

// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public void updateVpnInterfaceOnTepAdd(VpnInterfaceOpDataEntry vpnInterface, StateTunnelList stateTunnelList, WriteTransaction writeConfigTxn, WriteTransaction writeOperTxn) {
    String srcTepIp = String.valueOf(stateTunnelList.getSrcInfo().getTepIp().getValue());
    BigInteger srcDpnId = new BigInteger(stateTunnelList.getSrcInfo().getTepDeviceId());
    AdjacenciesOp adjacencies = vpnInterface.getAugmentation(AdjacenciesOp.class);
    List<Adjacency> adjList = adjacencies != null ? adjacencies.getAdjacency() : new ArrayList<>();
    if (adjList.isEmpty()) {
        LOG.trace("updateVpnInterfaceOnTepAdd: Adjacencies are empty for vpnInterface {} on dpn {}", vpnInterface, srcDpnId);
        return;
    }
    String prefix = null;
    long label = 0;
    List<Adjacency> value = new ArrayList<>();
    boolean isNextHopAddReqd = false;
    String vpnName = vpnInterface.getVpnInstanceName();
    long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
    String primaryRd = VpnUtil.getPrimaryRd(dataBroker, vpnName);
    LOG.info("updateVpnInterfaceOnTepAdd: AdjacencyList for interface {} on dpn {} vpn {} is {}", vpnInterface.getName(), vpnInterface.getDpnId(), vpnInterface.getVpnInstanceName(), adjList);
    for (Adjacency adj : adjList) {
        String rd = adj.getVrfId();
        rd = rd != null ? rd : vpnName;
        prefix = adj.getIpAddress();
        label = adj.getLabel();
        List<String> nhList = Collections.singletonList(srcTepIp);
        List<String> nextHopList = adj.getNextHopIpList();
        // Secondary adj nexthop is already pointing to primary adj IP address.
        if (nextHopList != null && !nextHopList.isEmpty() && nextHopList.get(0).equalsIgnoreCase(srcTepIp)) {
        /* everything right already */
        } else {
            isNextHopAddReqd = true;
        }
        if (adj.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
            value.add(new AdjacencyBuilder(adj).setNextHopIpList(nhList).build());
        } else {
            Optional<VrfEntry> vrfEntryOptional = FibHelper.getVrfEntry(dataBroker, primaryRd, prefix);
            if (!vrfEntryOptional.isPresent()) {
                continue;
            }
            nhList = FibHelper.getNextHopListFromRoutePaths(vrfEntryOptional.get());
            if (!nhList.contains(srcTepIp)) {
                nhList.add(srcTepIp);
                isNextHopAddReqd = true;
            }
            value.add(adj);
        }
        if (isNextHopAddReqd) {
            updateLabelMapper(label, nhList);
            LOG.info("updateVpnInterfaceOnTepAdd: Updated label mapper : label {} dpn {} prefix {} nexthoplist {}" + " vpn {} vpnid {} rd {} interface {}", label, srcDpnId, prefix, nhList, vpnInterface.getVpnInstanceName(), vpnId, rd, vpnInterface.getName());
            // Update the VRF entry with nextHop
            fibManager.updateRoutePathForFibEntry(primaryRd, prefix, srcTepIp, label, true, writeConfigTxn);
            // Get the list of VPN's importing this route(prefix) .
            // Then update the VRF entry with nhList
            List<VpnInstanceOpDataEntry> vpnsToImportRoute = VpnUtil.getVpnsImportingMyRoute(dataBroker, vpnName);
            for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
                String vpnRd = vpn.getVrfId();
                if (vpnRd != null) {
                    fibManager.updateRoutePathForFibEntry(vpnRd, prefix, srcTepIp, label, true, writeConfigTxn);
                    LOG.info("updateVpnInterfaceOnTepAdd: Exported route with rd {} prefix {} nhList {} label {}" + " interface {} dpn {} from vpn {} to VPN {} vpnRd {}", rd, prefix, nhList, label, vpnInterface.getName(), srcDpnId, vpnName, vpn.getVpnInstanceName(), vpnRd);
                }
            }
            // since there is a nexthop change.
            try {
                if (!rd.equalsIgnoreCase(vpnName)) {
                    bgpManager.advertisePrefix(rd, null, /*macAddress*/
                    prefix, nhList, VrfEntry.EncapType.Mplsgre, (int) label, 0, /*evi*/
                    0, /*l2vni*/
                    null);
                }
                LOG.info("updateVpnInterfaceOnTepAdd: Advertised rd {} prefix {} nhList {} label {}" + " for interface {} on dpn {} vpn {}", rd, prefix, nhList, label, vpnInterface.getName(), srcDpnId, vpnName);
            } catch (Exception ex) {
                LOG.error("updateVpnInterfaceOnTepAdd: Exception when advertising prefix {} nh {} label {}" + " on rd {} for interface {} on dpn {} vpn {}", prefix, nhList, label, rd, vpnInterface.getName(), srcDpnId, vpnName, ex);
            }
        }
    }
    AdjacenciesOp aug = VpnUtil.getVpnInterfaceOpDataEntryAugmentation(value);
    VpnInterfaceOpDataEntry opInterface = new VpnInterfaceOpDataEntryBuilder(vpnInterface).setKey(new VpnInterfaceOpDataEntryKey(vpnInterface.getName(), vpnName)).addAugmentation(AdjacenciesOp.class, aug).build();
    InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId = VpnUtil.getVpnInterfaceOpDataEntryIdentifier(vpnInterface.getName(), vpnName);
    writeOperTxn.put(LogicalDatastoreType.OPERATIONAL, interfaceId, opInterface, WriteTransaction.CREATE_MISSING_PARENTS);
    LOG.info("updateVpnInterfaceOnTepAdd: interface {} updated successully on tep add on dpn {} vpn {}", vpnInterface.getName(), srcDpnId, vpnName);
}

Example 12 with MacAddress

use of org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress in project netvirt by opendaylight.

the class VpnManagerImpl method installArpResponderFlowsToExternalNetworkIp.

private void installArpResponderFlowsToExternalNetworkIp(String macAddress, BigInteger dpnId, String extInterfaceName, int lportTag, String fixedIp) {
    // reset the split-horizon bit to allow traffic to be sent back to the
    // provider port
    List<Instruction> instructions = new ArrayList<>();
    instructions.add(new InstructionWriteMetadata(BigInteger.ZERO, MetaDataUtil.METADATA_MASK_SH_FLAG).buildInstruction(1));
    instructions.addAll(ArpResponderUtil.getExtInterfaceInstructions(interfaceManager, extInterfaceName, fixedIp, macAddress));
    ArpReponderInputBuilder builder = new ArpReponderInputBuilder().setDpId(dpnId).setInterfaceName(extInterfaceName).setSpa(fixedIp).setSha(macAddress).setLportTag(lportTag);
    builder.setInstructions(instructions);
    elanService.addArpResponderFlow(builder.buildForInstallFlow());
}

Example 13 with MacAddress

use of org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress in project netvirt by opendaylight.

the class VpnManagerImpl method removeArpResponderFlowsToExternalNetworkIps.

@Override
public void removeArpResponderFlowsToExternalNetworkIps(String id, Collection<String> fixedIps, String macAddress, BigInteger dpnId, Uuid extNetworkId) {
    if (dpnId == null || BigInteger.ZERO.equals(dpnId)) {
        LOG.warn("Failed to remove arp responder flows for router {}. DPN id is missing.", id);
        return;
    }
    String extInterfaceName = elanService.getExternalElanInterface(extNetworkId.getValue(), dpnId);
    if (extInterfaceName == null) {
        LOG.warn("Failed to remove responder flows for {}. No external interface found for DPN id {}", id, dpnId);
        return;
    }
    Interface extInterfaceState = InterfaceUtils.getInterfaceStateFromOperDS(dataBroker, extInterfaceName);
    if (extInterfaceState == null) {
        LOG.debug("No interface state found for interface {}. Delaying responder flows for {}", extInterfaceName, id);
        return;
    }
    Integer lportTag = extInterfaceState.getIfIndex();
    if (lportTag == null) {
        LOG.debug("No Lport tag found for interface {}. Delaying flows for router-id {}", extInterfaceName, id);
        return;
    }
    if (macAddress == null) {
        LOG.debug("Failed to remove arp responder flows for router-gateway-ip {} for router {}." + "External Gw MacAddress is missing.", fixedIps, id);
        return;
    }
    removeArpResponderFlowsToExternalNetworkIps(id, fixedIps, dpnId, extInterfaceName, lportTag);
}

Example 14 with MacAddress

use of org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress in project netvirt by opendaylight.

the class AclMatches method addEthMatch.

private void addEthMatch() {
    AceEth aceEth = (AceEth) matches.getAceType();
    if (aceEth.getSourceMacAddress() != null) {
        EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
        EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
        ethSourceBuilder.setAddress(new MacAddress(aceEth.getSourceMacAddress()));
        ethernetMatch.setEthernetSource(ethSourceBuilder.build());
        matchBuilder.setEthernetMatch(mergeEthernetMatch(matchBuilder, ethernetMatch));
    }
    if (aceEth.getDestinationMacAddress() != null) {
        EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
        EthernetDestinationBuilder ethDestBuilder = new EthernetDestinationBuilder();
        ethDestBuilder.setAddress(new MacAddress(aceEth.getDestinationMacAddress()));
        ethernetMatch.setEthernetDestination(ethDestBuilder.build());
        matchBuilder.setEthernetMatch(mergeEthernetMatch(matchBuilder, ethernetMatch));
    }
}

Example 15 with MacAddress

use of org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress in project netvirt by opendaylight.

the class AclMatches method invertMatches.

public static Matches invertMatches(Matches matches) {
    LOG.trace("Invert matches: {}", matches);
    MatchesBuilder matchesBuilder = new MatchesBuilder(matches);
    if (matches.getAceType() instanceof AceIp) {
        AceIp aceIp = (AceIp) matches.getAceType();
        AceIpBuilder aceIpBuilder = new AceIpBuilder(aceIp);
        aceIpBuilder.setDestinationPortRange(null);
        aceIpBuilder.setSourcePortRange(null);
        SourcePortRange sourcePortRange = aceIp.getSourcePortRange();
        DestinationPortRange destinationPortRange = aceIp.getDestinationPortRange();
        if (sourcePortRange != null) {
            DestinationPortRangeBuilder destinationPortRangeBuilder = new DestinationPortRangeBuilder();
            destinationPortRangeBuilder.setLowerPort(sourcePortRange.getLowerPort());
            destinationPortRangeBuilder.setUpperPort(sourcePortRange.getUpperPort());
            aceIpBuilder.setDestinationPortRange(destinationPortRangeBuilder.build());
        }
        if (destinationPortRange != null) {
            SourcePortRangeBuilder sourcePortRangeBuilder = new SourcePortRangeBuilder();
            sourcePortRangeBuilder.setLowerPort(destinationPortRange.getLowerPort());
            sourcePortRangeBuilder.setUpperPort(destinationPortRange.getUpperPort());
            aceIpBuilder.setSourcePortRange(sourcePortRangeBuilder.build());
        }
        if (aceIp.getAceIpVersion() instanceof AceIpv4) {
            AceIpv4 aceIpv4 = (AceIpv4) aceIp.getAceIpVersion();
            Ipv4Prefix destinationIpv4Network = aceIpv4.getDestinationIpv4Network();
            Ipv4Prefix sourceIpv4Network = aceIpv4.getSourceIpv4Network();
            AceIpv4Builder aceIpv4Builder = new AceIpv4Builder(aceIpv4);
            aceIpv4Builder.setDestinationIpv4Network(sourceIpv4Network);
            aceIpv4Builder.setSourceIpv4Network(destinationIpv4Network);
            aceIpBuilder.setAceIpVersion(aceIpv4Builder.build());
        } else if (aceIp.getAceIpVersion() instanceof AceIpv6) {
            AceIpv6 aceIpv6 = (AceIpv6) aceIp.getAceIpVersion();
            Ipv6Prefix destinationIpv6Network = aceIpv6.getDestinationIpv6Network();
            Ipv6Prefix sourceIpv6Network = aceIpv6.getSourceIpv6Network();
            AceIpv6Builder aceIpv6Builder = new AceIpv6Builder(aceIpv6);
            aceIpv6Builder.setDestinationIpv6Network(sourceIpv6Network);
            aceIpv6Builder.setSourceIpv6Network(destinationIpv6Network);
            aceIpBuilder.setAceIpVersion(aceIpv6Builder.build());
        }
        matchesBuilder.setAceType(aceIpBuilder.build());
    } else if (matches.getAceType() instanceof AceEth) {
        AceEth aceEth = (AceEth) matches.getAceType();
        MacAddress destinationMacAddress = aceEth.getDestinationMacAddress();
        MacAddress destinationMacAddressMask = aceEth.getDestinationMacAddressMask();
        MacAddress sourceMacAddress = aceEth.getSourceMacAddress();
        MacAddress sourceMacAddressMask = aceEth.getSourceMacAddressMask();
        AceEthBuilder aceEthBuilder = new AceEthBuilder(aceEth);
        aceEthBuilder.setDestinationMacAddress(sourceMacAddress);
        aceEthBuilder.setDestinationMacAddressMask(sourceMacAddressMask);
        aceEthBuilder.setSourceMacAddress(destinationMacAddress);
        aceEthBuilder.setSourceMacAddressMask(destinationMacAddressMask);
        matchesBuilder.setAceType(aceEthBuilder.build());
    }
    Matches invertedMatches = matchesBuilder.build();
    LOG.trace("Inverted matches: {}", invertedMatches);
    return invertedMatches;
}