Java NodeCreator类代码示例

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testCreateNodeBean() {
        Topology topology = new Topology();
        Node node = NodeCreator.createOFNode(new Long(3));
        String description = "foo";

        NodeBean bean = topology.createNodeBean(description, node);

        assertNotNull(bean);
        assertEquals(bean.id, node.toString());
        assertEquals(bean.name, "foo");

        bean = topology.createNodeBean(null, node);

        assertNotNull(bean);
        assertEquals(bean.id, node.toString());
        assertEquals(bean.name, bean.id);

        bean = topology.createNodeBean("   ", node);

        assertNotNull(bean);
        assertEquals(bean.id, node.toString());
        assertEquals(bean.name, bean.id);
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testFlowEntryInstall() throws UnknownHostException {
    Node node = NodeCreator.createOFNode(1L);
    FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
    FlowEntry pol2 = new FlowEntry("polTest2", null, getSampleFlowV6(node), node);
    FlowEntryInstall fei = new FlowEntryInstall(pol.clone(), null);
    FlowEntryInstall fei2 = new FlowEntryInstall(pol.clone(), null);
    FlowEntryInstall fei3 = new FlowEntryInstall(pol2.clone(), null);
    Assert.assertTrue(fei.getOriginal().equals(pol));
    Assert.assertTrue(fei.getInstall().equals(pol));
    Assert.assertTrue(fei.getFlowName().equals(pol.getFlowName()));
    Assert.assertTrue(fei.getGroupName().equals(pol.getGroupName()));
    Assert.assertTrue(fei.getNode().equals(pol.getNode()));
    Assert.assertFalse(fei.isDeletePending());
    fei.toBeDeleted();
    Assert.assertTrue(fei.isDeletePending());
    Assert.assertNull(fei.getContainerFlow());
    Assert.assertTrue(fei.equalsByNodeAndName(pol.getNode(), pol.getFlowName()));

    Assert.assertTrue(fei.equals(fei2));
    Assert.assertFalse(fei.equals(null));
    Assert.assertTrue(fei.equals(fei3));

}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testFlowEntries() {
    Flow flow = new Flow();

    Match match = new Match();
    try {
        match.setField(MatchType.NW_DST, InetAddress.getByName("1.1.1.1"));
    } catch (UnknownHostException e) {
    }
    flow.setMatch(match);
    Action action = new Drop();

    List<Action> actions = new ArrayList<Action>();
    actions.add(action);
    flow.setActions(actions);

    Node node = NodeCreator.createOFNode(1L);
    FlowEntry fe = new FlowEntry("g1", "f1", flow, node);

    Status stat = manager.installFlowEntry(fe);

    // OF plugin is not there in integration testing mode
    Assert.assertTrue(stat.getCode() == StatusCode.NOSERVICE);
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testFlowActions() throws UnknownHostException {
    Node node = NodeCreator.createOFNode(55l);
    Flow flow = getSampleFlowV6(node);

    List<Action> actions = flow.getActions();
    actions.add(new Loopback());

    Assert.assertTrue(flow.getActions() != actions);
    Assert.assertTrue(!flow.getActions().equals(actions));

    flow.addAction(new Loopback());
    Assert.assertTrue(flow.getActions().equals(actions));

    actions.remove(new Loopback());
    flow.removeAction(new Loopback());
    Assert.assertTrue(flow.getActions().equals(actions));

    // Add a malformed action
    Assert.assertFalse(flow.addAction(new PushVlan(EtherTypes.CISCOQINQ, 3,
            3, 8000)));
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testNodeTableStatisticsMethods() {
    NodeTable nt = NodeTableCreator.createNodeTable(Byte.valueOf("2") , NodeCreator.createOFNode((long)20));
    NodeTableStatistics ntStats = new NodeTableStatistics();

    ntStats.setNodeTable(nt);
    ntStats.setActiveCount(100);
    ntStats.setLookupCount(200);
    ntStats.setMatchedCount(500);
    ntStats.setName("Test");

    Assert.assertTrue(ntStats.getNodeTable().equals(nt));
    Assert.assertTrue(ntStats.getActiveCount() == 100);
    Assert.assertTrue(ntStats.getLookupCount() == 200);
    Assert.assertTrue(ntStats.getMatchedCount() == 500);
    Assert.assertTrue(ntStats.getName().equals("Test"));
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testNodeTableOpenFlowOfWrongType() {
    try {
        Node node = NodeCreator.createOFNode((long) 20);
        NodeTable of1 = new NodeTable(NodeTable.NodeTableIDType.OPENFLOW, "name", node);

        // If we reach this point the exception was not raised
        // which should have been the case
        Assert.assertTrue(false);
    } catch (ConstructionException e) {
        // If we reach this point the exception has been raised
        // and so test passed
        System.out.println("Got exception as expected!:" + e);
        Assert.assertTrue(true);
    }
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testNodeTableOpenFlowOfCorrectType() {
    try {
        Node node = NodeCreator.createOFNode((long) 20);
        NodeTable of1 = new NodeTable(NodeTable.NodeTableIDType.OPENFLOW, Byte.valueOf("10"), node);

        // If we reach this point the exception has not been
        // raised so we passed the test
        System.out.println("Got node table:" + of1);
        Assert.assertTrue(true);
    } catch (ConstructionException e) {
        // If we reach this point the exception was raised
        // which is not expected
        Assert.assertTrue(false);
    }
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testNodeConnectorProperties() {
        Node node = NodeCreator.createOFNode(1L);
NodeConnector port = NodeConnectorCreator.createOFNodeConnector(
        (short) 24, node);

NodeConnectorProperties ncp= new NodeConnectorProperties(port, null);
        Assert.assertTrue(ncp.getProperties() == null);
        Assert.assertTrue(ncp.getNodeConnector().equals(port));

NodeConnector port2 = NodeConnectorCreator.createOFNodeConnector(
        (short) 33, node);
        ncp.setNodeConnector(port2);
        Assert.assertTrue(ncp.getNodeConnector().equals(port2));

        Set<Property> props = new HashSet<Property>();
        ncp.setProperties(props);
        Assert.assertTrue(ncp.getProperties().equals(props));
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Test
public void testFlowStatistics() {
    List<FlowOnNode> fon = new ArrayList<FlowOnNode>();
    Node node = NodeCreator.createOFNode(1L);
    FlowStatistics fs = new FlowStatistics(node, fon);
    Assert.assertTrue(fs.getNode().equals(node));
    Assert.assertTrue(fs.getFlowStats().equals(fon));

    Node node2 = NodeCreator.createOFNode(2L);
    fs.setNode(node2);
    Assert.assertTrue(fs.getNode().equals(node2));
    fs.setNode(node2);
    Assert.assertTrue(fs.getNode().equals(node2));
    fs.setFlowStats(null);
    Assert.assertTrue(fs.getFlowStats() == null);
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
/**
 * Filters a list of OFStatistics elements based on the container
 *
 * @param container
 * @param nodeId
 * @param list
 * @return
 */
public List<OFStatistics> filterPortListPerContainer(String container, long switchId, List<OFStatistics> list) {
    if (list == null) {
        return null;
    }

    // Create new filtered list of flows
    List<OFStatistics> newList = new ArrayList<OFStatistics>();

    for (OFStatistics stat : list) {
        OFPortStatisticsReply target = (OFPortStatisticsReply) stat;
        NodeConnector nc = NodeConnectorCreator.createOFNodeConnector(
                target.getPortNumber(), NodeCreator.createOFNode(switchId));
        if (containerOwnsNodeConnector(container, nc)) {
            newList.add(target);
        }
    }

    return newList;
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
public List<OFStatistics> filterTableListPerContainer(
        String container, long switchId, List<OFStatistics> list) {
    if (list == null) {
        return null;
    }

    // Create new filtered list of node tables
    List<OFStatistics> newList = new ArrayList<OFStatistics>();

    for (OFStatistics stat : list) {
        OFTableStatistics target = (OFTableStatistics) stat;
        NodeTable nt = NodeTableCreator.createOFNodeTable(target.getTableId(), NodeCreator.createOFNode(switchId));
        if (containerOwnsNodeTable(container, nt)) {
            newList.add(target);
        }
    }

    return newList;
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Override
public void flowStatisticsRefreshed(Long switchId, List<OFStatistics> flows) {
    String container;
    IReadFilterInternalListener listener;
    Node node = NodeCreator.createOFNode(switchId);
    for (Map.Entry<String, IReadFilterInternalListener> l : readFilterInternalListeners.entrySet()) {
        container = l.getKey();
        listener = l.getValue();

        // Convert and filter the statistics per container
        List<FlowOnNode> flowOnNodeList = new FlowStatisticsConverter(flows).getFlowOnNodeList(node);
        flowOnNodeList = filterFlowListPerContainer(container, node, flowOnNodeList);

        // notify listeners
        listener.nodeFlowStatisticsUpdated(node, flowOnNodeList);
    }
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Override
public void portStatisticsRefreshed(Long switchId, List<OFStatistics> ports) {
    String container;
    IReadFilterInternalListener listener;
    Node node = NodeCreator.createOFNode(switchId);
    for (Map.Entry<String, IReadFilterInternalListener> l : readFilterInternalListeners.entrySet()) {
        container = l.getKey();
        listener = l.getValue();

        // Convert and filter the statistics per container
        List<OFStatistics> filteredPorts = filterPortListPerContainer(container, switchId, ports);
        List<NodeConnectorStatistics> ncStatsList = new PortStatisticsConverter(switchId, filteredPorts)
                .getNodeConnectorStatsList();

        // notify listeners
        listener.nodeConnectorStatisticsUpdated(node, ncStatsList);
    }
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
@Override
public void tableStatisticsRefreshed(Long switchId, List<OFStatistics> tables) {
    String container;
    Node node = NodeCreator.createOFNode(switchId);
    for (Map.Entry<String, IReadFilterInternalListener> l : readFilterInternalListeners.entrySet()) {
        container = l.getKey();

        // Convert and filter the statistics per container
        List<OFStatistics> filteredList = filterTableListPerContainer(container, switchId, tables);
        List<NodeTableStatistics> tableStatsList = new TableStatisticsConverter(switchId, filteredList)
                .getNodeTableStatsList();

        // notify listeners
        l.getValue().nodeTableStatisticsUpdated(node, tableStatsList);
    }
}
 

import org.opendaylight.controller.sal.utils.NodeCreator; //导入依赖的package包/类
protected void handlePortStatusMessage(ISwitch sw, OFPortStatus m) {
    Node node = NodeCreator.createOFNode(sw.getId());
    NodeConnector nodeConnector = PortConverter.toNodeConnector(
        m.getDesc().getPortNumber(), node);
    // get node connector properties
    Set<Property> props = InventoryServiceHelper.OFPortToProps(m.getDesc());

    UpdateType type = null;
    if (m.getReason() == (byte) OFPortReason.OFPPR_ADD.ordinal()) {
        type = UpdateType.ADDED;
        nodeConnectorProps.put(nodeConnector, props);
    } else if (m.getReason() == (byte) OFPortReason.OFPPR_DELETE.ordinal()) {
        type = UpdateType.REMOVED;
        nodeConnectorProps.remove(nodeConnector);
    } else if (m.getReason() == (byte) OFPortReason.OFPPR_MODIFY.ordinal()) {
        type = UpdateType.CHANGED;
        nodeConnectorProps.put(nodeConnector, props);
    }

    logger.trace("handlePortStatusMessage {} type {}", nodeConnector, type);

    if (type != null) {
        notifyInventoryShimListener(nodeConnector, type, props);
    }
}