Examples with TpId org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId used on opensource projects

Example 1 with TpId

use of org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId in project netvirt by opendaylight.

the class HwvtepHAUtil method convertLocatorRef.

/**
 * Trnaform locator reference to nodepath passed .
 *
 * @param src {@link HwvtepPhysicalLocatorRef} Logical Switch Ref which needs to be transformed
 * @param nodePath {@link InstanceIdentifier} src needs to be transformed to this path
 * @return physicalLocatorRef {@link HwvtepPhysicalLocatorRef} the transforrmed result
 */
public static HwvtepPhysicalLocatorRef convertLocatorRef(HwvtepPhysicalLocatorRef src, InstanceIdentifier<Node> nodePath) {
    InstanceIdentifier<TerminationPoint> srcTepPath = (InstanceIdentifier<TerminationPoint>) src.getValue();
    TpId tpId = srcTepPath.firstKeyOf(TerminationPoint.class).getTpId();
    InstanceIdentifier<TerminationPoint> tpPath = nodePath.child(TerminationPoint.class, new TerminationPointKey(tpId));
    HwvtepPhysicalLocatorRef physicalLocatorRef = new HwvtepPhysicalLocatorRef(tpPath);
    return physicalLocatorRef;
}

Example 2 with TpId

use of org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId in project netvirt by opendaylight.

the class TestBuilders method buildTerminationPoint.

public static TerminationPoint buildTerminationPoint(InstanceIdentifier<Node> nodeIid, String ip) {
    TerminationPointKey tpKey = new TerminationPointKey(new TpId("vxlan_over_ipv4:" + ip));
    TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
    if (nodeIid != null && tpKey != null) {
        tpBuilder.setKey(tpKey);
        tpBuilder.setTpId(tpKey.getTpId());
        InstanceIdentifier<TerminationPoint> tpPath = buildTpId(nodeIid, ip);
        HwvtepPhysicalLocatorAugmentationBuilder tpAugmentationBuilder = new HwvtepPhysicalLocatorAugmentationBuilder();
        tpAugmentationBuilder.setPhysicalLocatorUuid(getUUid(ip));
        tpAugmentationBuilder.setEncapsulationType(createEncapsulationType("vxlan_over_ipv4"));
        tpAugmentationBuilder.setDstIp(new IpAddress(ip.toCharArray()));
        tpBuilder.addAugmentation(HwvtepPhysicalLocatorAugmentation.class, tpAugmentationBuilder.build());
    }
    return tpBuilder.build();
}

Example 3 with TpId

use of org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId in project netvirt by opendaylight.

the class TestComparators method assertTerminationPoint.

public static void assertTerminationPoint(List<String> terminationPointNames, InstanceIdentifier<Node> d1ps, InstanceIdentifier<Node> haPsa, ReadWriteTransaction readWriteTransaction, Node nodeD, Node nodeHa) throws ReadFailedException {
    for (String portName : terminationPointNames) {
        InstanceIdentifier<TerminationPoint> tpPathd = d1ps.child(TerminationPoint.class, new TerminationPointKey(new TpId(portName)));
        TerminationPoint tpNoded = readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, tpPathd).checkedGet().get();
        HwvtepPhysicalPortAugmentation hwvtepPhysicalPortAugmentationD = tpNoded.getAugmentation(HwvtepPhysicalPortAugmentation.class);
        InstanceIdentifier<TerminationPoint> tpPathha = haPsa.child(TerminationPoint.class, new TerminationPointKey(new TpId(portName)));
        TerminationPoint tpNodeha = readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, tpPathha).checkedGet().get();
        HwvtepPhysicalPortAugmentation hwvtepPhysicalPortAugmentationHa = tpNodeha.getAugmentation(HwvtepPhysicalPortAugmentation.class);
        assertEquals("Termination point hwvtep-node-name should be same", hwvtepPhysicalPortAugmentationD.getHwvtepNodeName(), hwvtepPhysicalPortAugmentationHa.getHwvtepNodeName());
        List<VlanBindings> vlanBindingsesD = hwvtepPhysicalPortAugmentationD.getVlanBindings();
        List<VlanBindings> vlanBindingsesHa = hwvtepPhysicalPortAugmentationHa.getVlanBindings();
        assertEquals("Size of VlanBindings should be same", vlanBindingsesD.size(), vlanBindingsesHa.size());
        List<Integer> vlanKeysD = new ArrayList<>();
        List<Integer> vlanKeysHa = new ArrayList<>();
        String logicalSwitchRefD = new String();
        String logicalSwitchRefHa = new String();
        List<String> logicalSwitchNameD = new ArrayList<>();
        List<String> logicalSwitchNameHa = new ArrayList<>();
        if (vlanBindingsesD.size() == vlanBindingsesHa.size()) {
            for (int i = 0; i < vlanBindingsesD.size(); i++) {
                vlanKeysD.add(vlanBindingsesD.get(i).getVlanIdKey().getValue());
                logicalSwitchRefD = vlanBindingsesD.get(i).getLogicalSwitchRef().getValue().firstKeyOf(Node.class).getNodeId().getValue();
                logicalSwitchNameD.add(vlanBindingsesD.get(i).getLogicalSwitchRef().getValue().firstKeyOf(LogicalSwitches.class).getHwvtepNodeName().getValue());
                vlanKeysHa.add(vlanBindingsesHa.get(i).getVlanIdKey().getValue());
                logicalSwitchRefHa = vlanBindingsesHa.get(i).getLogicalSwitchRef().getValue().firstKeyOf(Node.class).getNodeId().getValue();
                logicalSwitchNameHa.add(vlanBindingsesHa.get(i).getLogicalSwitchRef().getValue().firstKeyOf(LogicalSwitches.class).getHwvtepNodeName().getValue());
            }
            assertTrue(vlanKeysD.containsAll(vlanKeysHa));
            assertTrue(logicalSwitchRefD.equals(nodeD.getNodeId().getValue()));
            assertTrue(logicalSwitchRefHa.equals(nodeHa.getNodeId().getValue()));
            assertTrue(logicalSwitchNameD.containsAll(logicalSwitchNameHa));
        }
    }
}

Example 4 with TpId

use of org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId in project bgpcep by opendaylight.

the class NodeChangedListenerTest method testNodeChangedListener.

@Test
public void testNodeChangedListener() throws ReadFailedException, TransactionCommitFailedException {
    // add node -> create two nodes with TPs and link
    createNode(NODE1_ID, NODE1_IPV4, LSP1_NAME, LSP1_ID, NODE2_IPV4);
    final Topology tunnelTopo = readDataOperational(getDataBroker(), TUNNEL_TOPO_IID, tunnelTopo1 -> {
        assertNotNull(tunnelTopo1.getNode());
        assertEquals(2, tunnelTopo1.getNode().size());
        return tunnelTopo1;
    });
    final NodeId srcId = new NodeId("ip://" + new IpAddress(new Ipv4Address(NODE1_IPV4)));
    final NodeId dstId = new NodeId("ip://" + new IpAddress(new Ipv4Address(NODE2_IPV4)));
    final Node dst;
    final Node src;
    if (tunnelTopo.getNode().get(0).getNodeId().equals(srcId)) {
        src = tunnelTopo.getNode().get(0);
        dst = tunnelTopo.getNode().get(1);
    } else {
        src = tunnelTopo.getNode().get(1);
        dst = tunnelTopo.getNode().get(0);
    }
    Assert.assertEquals(srcId, src.getNodeId());
    Assert.assertEquals(dstId, dst.getNodeId());
    Assert.assertEquals(1, dst.getTerminationPoint().size());
    Assert.assertEquals(1, src.getTerminationPoint().size());
    final TerminationPoint dstTp = dst.getTerminationPoint().get(0);
    final TerminationPoint srcTp = src.getTerminationPoint().get(0);
    final TpId dstNodeTpId = new TpId(dstId.getValue());
    final TpId srcNodeTpId = new TpId(srcId.getValue());
    Assert.assertEquals(dstNodeTpId, dstTp.getTpId());
    Assert.assertEquals(srcNodeTpId, srcTp.getTpId());
    Assert.assertEquals(1, src.getSupportingNode().size());
    Assert.assertNull(dst.getSupportingNode());
    final SupportingNode sNode = src.getSupportingNode().get(0);
    Assert.assertEquals(NODE1_ID, sNode.getKey().getNodeRef());
    Assert.assertEquals(1, tunnelTopo.getLink().size());
    final Link link = tunnelTopo.getLink().get(0);
    Assert.assertEquals(srcId, link.getSource().getSourceNode());
    Assert.assertEquals(srcNodeTpId, link.getSource().getSourceTp());
    Assert.assertEquals(dstId, link.getDestination().getDestNode());
    Assert.assertEquals(dstNodeTpId, link.getDestination().getDestTp());
    // update second node -> adds supporting node and second link
    createNode(NODE2_ID, NODE2_IPV4, LSP2_NAME, LSP2_ID, NODE1_IPV4);
    readDataOperational(getDataBroker(), TUNNEL_TOPO_IID, updatedNodeTopo -> {
        assertNotNull(updatedNodeTopo.getNode());
        Assert.assertEquals(2, updatedNodeTopo.getNode().size());
        final Node updatedNode;
        if (updatedNodeTopo.getNode().get(0).getNodeId().equals(srcId)) {
            updatedNode = updatedNodeTopo.getNode().get(1);
        } else {
            updatedNode = updatedNodeTopo.getNode().get(0);
        }
        assertNotNull(updatedNode.getSupportingNode());
        Assert.assertEquals(1, updatedNode.getSupportingNode().size());
        final SupportingNode sNode2 = updatedNode.getSupportingNode().get(0);
        Assert.assertEquals(NODE2_ID, sNode2.getNodeRef());
        Assert.assertEquals(2, updatedNodeTopo.getLink().size());
        return updatedNodeTopo;
    });
    readDataOperational(getDataBroker(), TUNNEL_TOPO_IID, updatedNodeTopo -> {
        final Link link2;
        if (updatedNodeTopo.getLink().get(0).getSource().getSourceNode().equals(srcId)) {
            link2 = updatedNodeTopo.getLink().get(1);
        } else {
            link2 = updatedNodeTopo.getLink().get(0);
        }
        assertEquals(dstId, link2.getSource().getSourceNode());
        assertEquals(dstNodeTpId, link2.getSource().getSourceTp());
        assertEquals(srcId, link2.getDestination().getDestNode());
        assertEquals(srcNodeTpId, link2.getDestination().getDestTp());
        return updatedNodeTopo;
    });
    // remove nodes -> remove link
    removeNode(NODE1_ID);
    removeNode(NODE2_ID);
    readDataOperational(getDataBroker(), TUNNEL_TOPO_IID, removedNodeTopo -> {
        assertEquals(0, removedNodeTopo.getNode().size());
        assertEquals(0, removedNodeTopo.getLink().size());
        return removedNodeTopo;
    });
}

Example 5 with TpId

use of org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId in project bgpcep by opendaylight.

the class NodeChangedListener method remove.

private void remove(final ReadWriteTransaction trans, final InstanceIdentifier<ReportedLsp> identifier, final ReportedLsp value) throws ReadFailedException {
    final InstanceIdentifier<Link> li = linkForLsp(linkIdForLsp(identifier, value));
    final Optional<Link> ol = trans.read(LogicalDatastoreType.OPERATIONAL, li).checkedGet();
    if (!ol.isPresent()) {
        return;
    }
    final Link l = ol.get();
    LOG.debug("Removing link {} (was {})", li, l);
    trans.delete(LogicalDatastoreType.OPERATIONAL, li);
    LOG.debug("Searching for orphan links/nodes");
    final Optional<Topology> ot = trans.read(LogicalDatastoreType.OPERATIONAL, this.target).checkedGet();
    Preconditions.checkState(ot.isPresent());
    final Topology topology = ot.get();
    final NodeId srcNode = l.getSource().getSourceNode();
    final NodeId dstNode = l.getDestination().getDestNode();
    final TpId srcTp = l.getSource().getSourceTp();
    final TpId dstTp = l.getDestination().getDestTp();
    boolean orphSrcNode = true;
    boolean orphDstNode = true;
    boolean orphDstTp = true;
    boolean orphSrcTp = true;
    for (final Link lw : topology.getLink()) {
        LOG.trace("Checking link {}", lw);
        final NodeId sn = lw.getSource().getSourceNode();
        final NodeId dn = lw.getDestination().getDestNode();
        final TpId st = lw.getSource().getSourceTp();
        final TpId dt = lw.getDestination().getDestTp();
        // Source node checks
        if (srcNode.equals(sn)) {
            if (orphSrcNode) {
                LOG.debug("Node {} held by source of link {}", srcNode, lw);
                orphSrcNode = false;
            }
            if (orphSrcTp && srcTp.equals(st)) {
                LOG.debug("TP {} held by source of link {}", srcTp, lw);
                orphSrcTp = false;
            }
        }
        if (srcNode.equals(dn)) {
            if (orphSrcNode) {
                LOG.debug("Node {} held by destination of link {}", srcNode, lw);
                orphSrcNode = false;
            }
            if (orphSrcTp && srcTp.equals(dt)) {
                LOG.debug("TP {} held by destination of link {}", srcTp, lw);
                orphSrcTp = false;
            }
        }
        // Destination node checks
        if (dstNode.equals(sn)) {
            if (orphDstNode) {
                LOG.debug("Node {} held by source of link {}", dstNode, lw);
                orphDstNode = false;
            }
            if (orphDstTp && dstTp.equals(st)) {
                LOG.debug("TP {} held by source of link {}", dstTp, lw);
                orphDstTp = false;
            }
        }
        if (dstNode.equals(dn)) {
            if (orphDstNode) {
                LOG.debug("Node {} held by destination of link {}", dstNode, lw);
                orphDstNode = false;
            }
            if (orphDstTp && dstTp.equals(dt)) {
                LOG.debug("TP {} held by destination of link {}", dstTp, lw);
                orphDstTp = false;
            }
        }
    }
    if (orphSrcNode && !orphSrcTp) {
        LOG.warn("Orphan source node {} but not TP {}, retaining the node", srcNode, srcTp);
        orphSrcNode = false;
    }
    if (orphDstNode && !orphDstTp) {
        LOG.warn("Orphan destination node {} but not TP {}, retaining the node", dstNode, dstTp);
        orphDstNode = false;
    }
    if (orphSrcNode) {
        LOG.debug("Removing orphan node {}", srcNode);
        trans.delete(LogicalDatastoreType.OPERATIONAL, nodeIdentifier(srcNode));
    } else if (orphSrcTp) {
        LOG.debug("Removing orphan TP {} on node {}", srcTp, srcNode);
        trans.delete(LogicalDatastoreType.OPERATIONAL, tpIdentifier(srcNode, srcTp));
    }
    if (orphDstNode) {
        LOG.debug("Removing orphan node {}", dstNode);
        trans.delete(LogicalDatastoreType.OPERATIONAL, nodeIdentifier(dstNode));
    } else if (orphDstTp) {
        LOG.debug("Removing orphan TP {} on node {}", dstTp, dstNode);
        trans.delete(LogicalDatastoreType.OPERATIONAL, tpIdentifier(dstNode, dstTp));
    }
}