Java 类org.projectfloodlight.openflow.types.U64 实例源码

@Test
public void testDeleteLink() throws Exception {
    LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();

    Link lt = new Link(DatapathId.of(1L), OFPort.of(2), DatapathId.of(2L), OFPort.of(1), U64.ZERO);
    LinkInfo info = new LinkInfo(new Date(),
            new Date(), null);
    linkDiscovery.addOrUpdateLink(lt, info);
    linkDiscovery.deleteLinks(Collections.singletonList(lt), "Test");

    // check invariants hold
    assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
    assertNull(linkDiscovery.switchLinks.get(lt.getDst()));
    assertNull(linkDiscovery.portLinks.get(lt.getSrc()));
    assertNull(linkDiscovery.portLinks.get(lt.getDst()));
    assertTrue(linkDiscovery.links.isEmpty());
}

default OFFlowAdd oneSwitchPopFlowMod(int inputPort, int outputPort, int inputVlan, long meterId, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlan(inputVlan))
                    .build())
            .setInstructions(Arrays.asList(
                    ofFactory.instructions().buildMeter().setMeterId(meterId).build(),
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().popVlan(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();
}

@Test
public void testRemovedSwitchSelf() {
    LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
    IOFSwitch sw1 = createMockSwitch(1L);
    replay(sw1);
    Link lt = new Link(DatapathId.of(1L), OFPort.of(2), DatapathId.of(1L), OFPort.of(3), U64.ZERO);
    LinkInfo info = new LinkInfo(new Date(),
                                 new Date(), null);
    linkDiscovery.addOrUpdateLink(lt, info);

    // Mock up our expected behavior
    linkDiscovery.switchRemoved(sw1.getId());

    verify(sw1);
    // check invariants hold
    assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
    assertNull(linkDiscovery.portLinks.get(lt.getSrc()));
    assertNull(linkDiscovery.portLinks.get(lt.getDst()));
    assertTrue(linkDiscovery.links.isEmpty());
}

@Override
public OFFlowAdd buildFlowAdd() {
    Match match = buildMatch();
    List<OFAction> actions = buildActions();

    long cookie = flowRule().id().value();


    OFFlowAdd fm = factory().buildFlowAdd()
            .setXid(xid)
            .setCookie(U64.of(cookie))
            .setBufferId(OFBufferId.NO_BUFFER)
            .setActions(actions)
            .setMatch(match)
            .setFlags(Collections.singleton(OFFlowModFlags.SEND_FLOW_REM))
            .setPriority(flowRule().priority())
            .build();

    return fm;
}

@Override
public OFFlowDelete buildFlowDel() {
    Match match = buildMatch();

    long cookie = flowRule().id().value();

    OFFlowDelete fm = factory().buildFlowDelete()
            .setXid(xid)
            .setCookie(U64.of(cookie))
            .setBufferId(OFBufferId.NO_BUFFER)
            .setMatch(match)
            .setFlags(Collections.singleton(OFFlowModFlags.SEND_FLOW_REM))
            .setPriority(flowRule().priority())
            .build();

    return fm;
}

private OFFlowMod createFRESCOFlowMod(IOFSwitch sw, Match match, List<OFAction> actions, int priority){
    OFFlowMod.Builder fmb = sw.getOFFactory().buildFlowAdd();;

    fmb.setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT);
    fmb.setHardTimeout(FlowModUtils.INFINITE_TIMEOUT);
    fmb.setBufferId(OFBufferId.NO_BUFFER);
    fmb.setOutPort(OFPort.ANY);
    fmb.setCookie(U64.of(0));  

    fmb.setPriority(U16.t(priority));
    fmb.setMatch(match);
    fmb.setActions(actions);

    return fmb.build();

}

@Test
public void testRemovedSwitch() {
    LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();

    Link lt = new Link(DatapathId.of(1L), OFPort.of(2), DatapathId.of(2L), OFPort.of(1), U64.ZERO);
    NodePortTuple srcNpt = new NodePortTuple(DatapathId.of(1L), OFPort.of(2));
    NodePortTuple dstNpt = new NodePortTuple(DatapathId.of(2L), OFPort.of(1));
    LinkInfo info = new LinkInfo(new Date(),
            new Date(), null);
    linkDiscovery.addOrUpdateLink(lt, info);

    IOFSwitch sw1 = getMockSwitchService().getSwitch(DatapathId.of(1L));
    IOFSwitch sw2 = getMockSwitchService().getSwitch(DatapathId.of(2L));
    // Mock up our expected behavior
    linkDiscovery.switchRemoved(sw1.getId());
    verify(sw1, sw2);

    // check invariants hold
    assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
    assertNull(linkDiscovery.switchLinks.get(lt.getDst()));
    assertNull(linkDiscovery.portLinks.get(srcNpt));
    assertNull(linkDiscovery.portLinks.get(dstNpt));
    assertTrue(linkDiscovery.links.isEmpty());
}

protected Route getRoute(DatapathId srcId, DatapathId dstId, U64 cookie) {
    // Return null route if srcId equals dstId
    if (srcId.equals(dstId)) return null;


    RouteId id = new RouteId(srcId, dstId);
    Route result = null;

    try {
        result = pathcache.get(id);
    } catch (Exception e) {
        log.error("{}", e);
    }

    if (log.isTraceEnabled()) {
        log.trace("getRoute: {} -> {}", id, result);
    }
    return result;
}

/**
 * Retrieve the current latency, and if necessary
 * compute and replace the current latency with an
 * updated latency based on the historical average.
 * @return the most up-to-date latency as permitted by algorithm
 */
private U64 getLatency() {
    U64 newLatency = getLatencyHistoryAverage();
    if (newLatency != null) {
        /* check threshold */
        if ((((double) Math.abs(newLatency.getValue() - currentLatency.getValue())) 
                / (currentLatency.getValue() == 0 ? 1 : currentLatency.getValue())
                ) 
                >= latencyUpdateThreshold) {
            /* perform update */
            log.debug("Updating link latency from {} to {}", currentLatency.getValue(), newLatency.getValue());
            currentLatency = newLatency;
        }
    }
    return currentLatency;
}

public void addOrUpdateLink(DatapathId srcId, OFPort srcPort, DatapathId dstId,
        OFPort dstPort, U64 latency, LinkType type) {
    Link link = new Link(srcId, srcPort, dstId, dstPort, latency);

    if (type.equals(LinkType.MULTIHOP_LINK)) {
        addPortToSwitch(srcId, srcPort);
        addPortToSwitch(dstId, dstPort);
        addLinkToStructure(switchPortLinks, link);

        addLinkToStructure(portBroadcastDomainLinks, link);
        dtLinksUpdated = removeLinkFromStructure(directLinks, link);
        linksUpdated = true;
    } else if (type.equals(LinkType.DIRECT_LINK)) {
        addPortToSwitch(srcId, srcPort);
        addPortToSwitch(dstId, dstPort);
        addLinkToStructure(switchPortLinks, link);

        addLinkToStructure(directLinks, link);
        removeLinkFromStructure(portBroadcastDomainLinks, link);
        dtLinksUpdated = true;
        linksUpdated = true;
    } else if (type.equals(LinkType.TUNNEL)) {
        addOrUpdateTunnelLink(srcId, srcPort, dstId, dstPort, latency);
    }
}

@Test
public void testDeleteLinkToSelf() throws Exception {
    LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();

    Link lt = new Link(DatapathId.of(1L), OFPort.of(2), DatapathId.of(1L), OFPort.of(3), U64.ZERO);
    NodePortTuple srcNpt = new NodePortTuple(DatapathId.of(1L), OFPort.of(2));
    NodePortTuple dstNpt = new NodePortTuple(DatapathId.of(2L), OFPort.of(3));

    LinkInfo info = new LinkInfo(new Date(),
            new Date(), null);
    linkDiscovery.addOrUpdateLink(lt, info);
    linkDiscovery.deleteLinks(Collections.singletonList(lt), "Test to self");

    // check invariants hold
    assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
    assertNull(linkDiscovery.switchLinks.get(lt.getDst()));
    assertNull(linkDiscovery.portLinks.get(srcNpt));
    assertNull(linkDiscovery.portLinks.get(dstNpt));
    assertTrue(linkDiscovery.links.isEmpty());
}

protected OFTableFeaturesStatsReply createTableFeaturesStatsReply() {
    OFTableFeaturesStatsReply statsReply = factory.buildTableFeaturesStatsReply()
            .setEntries(Collections.singletonList(factory.buildTableFeatures()
                    .setConfig(0)
                    .setMaxEntries(100)
                    .setMetadataMatch(U64.NO_MASK)
                    .setMetadataWrite(U64.NO_MASK)
                    .setName("MyTable")
                    .setTableId(TableId.of(1))
                    .setProperties(Collections.singletonList((OFTableFeatureProp)factory.buildTableFeaturePropMatch()
                            .setOxmIds(Collections.singletonList(U32.of(100)))
                            .build())
                            ).build()
                    )

                    ).build();
    return statsReply;
}

public OFConnection(@Nonnull DatapathId dpid,
        @Nonnull OFFactory factory,
        @Nonnull Channel channel,
        @Nonnull OFAuxId auxId,
        @Nonnull IDebugCounterService debugCounters,
        @Nonnull Timer timer) {
    Preconditions.checkNotNull(dpid, "dpid");
    Preconditions.checkNotNull(factory, "factory");
    Preconditions.checkNotNull(channel, "channel");
    Preconditions.checkNotNull(timer, "timer");
    Preconditions.checkNotNull(debugCounters);

    this.listener = NullConnectionListener.INSTANCE;
    this.dpid = dpid;
    this.factory = factory;
    this.channel = channel;
    this.auxId = auxId;
    this.connectedSince = new Date();
    this.xidDeliverableMap = new ConcurrentHashMap<>();
    this.counters = new OFConnectionCounters(debugCounters, dpid, this.auxId);
    this.timer = timer;
    this.latency = U64.ZERO;
}

/**
 * {@inheritDoc}
 */
@Override
public ImmutablePair<Long, Boolean> deleteFlow(final DatapathId dpid, final String flowId, final Long cookie) {
    logger.info("deleting flows {} from switch {}", flowId, dpid.toString());

    IOFSwitch sw = ofSwitchService.getSwitch(dpid);
    OFFactory ofFactory = sw.getOFFactory();
    OFFlowDelete flowDelete = ofFactory.buildFlowDelete()
            .setCookie(U64.of(cookie))
            .setCookieMask(NON_SYSTEM_MASK)
            .build();

    boolean response = sw.write(flowDelete);
    return new ImmutablePair<>(flowDelete.getXid(), response);
}

default OFFlowAdd oneSwitchReplaceFlowMod(int inputPort, int outputPort, int inputVlan, int outputVlan,
                                          long meterId, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlan(inputVlan))
                    .build())
            .setInstructions(Arrays.asList(
                    ofFactory.instructions().buildMeter().setMeterId(meterId).build(),
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().buildSetField()
                                    .setField(ofFactory.oxms().buildVlanVid()
                                            .setValue(OFVlanVidMatch.ofVlan(outputVlan))
                                            .build())
                                    .build(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();
}

default OFFlowAdd oneSwitchPushFlowMod(int inputPort, int outputPort, int outputVlan, long meterId, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .build())
            .setInstructions(Arrays.asList(
                    ofFactory.instructions().buildMeter().setMeterId(meterId).build(),
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().buildPushVlan()
                                    .setEthertype(EthType.of(ETH_TYPE))
                                    .build(),
                            ofFactory.actions().buildSetField()
                                    .setField(ofFactory.oxms().buildVlanVid()
                                            .setValue(OFVlanVidMatch.ofVlan(outputVlan))
                                            .build())
                                    .build(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();
}

@Override
public OFFlowAdd ingressMatchVlanIdFlowMod(int inputPort, int outputPort, int inputVlan, int transitVlan,
                                           long meterId, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlan(inputVlan))
                    .build())
            .setInstructions(Arrays.asList(
                    ofFactory.instructions().buildMeter().setMeterId(meterId).build(),
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().buildSetField()
                                    .setField(ofFactory.oxms().buildVlanVid()
                                            .setValue(OFVlanVidMatch.ofVlan(transitVlan))
                                            .build())
                                    .build(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();

}

@Override
public OFFlowAdd egressPushFlowMod(int inputPort, int outputPort, int transitVlan, int outputVlan, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlan(transitVlan))
                    .build())
            .setInstructions(singletonList(
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().buildSetField()
                                    .setField(ofFactory.oxms().buildVlanVid()
                                            .setValue(OFVlanVidMatch.ofVlan(outputVlan))
                                            .build())
                                    .build(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();
}

@Override
public OFFlowAdd ingressNoMatchVlanIdFlowMod(int inputPort, int outputPort, int transitVlan,
                                             long meterId, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .build())
            .setInstructions(Arrays.asList(
                    ofFactory.instructions().buildMeter().setMeterId(meterId).build(),
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().buildPushVlan()
                                    .setEthertype(EthType.of(ETH_TYPE))
                                    .build(),
                            ofFactory.actions().buildSetField()
                                    .setField(ofFactory.oxms().buildVlanVid()
                                            .setValue(OFVlanVidMatch.ofVlan(transitVlan))
                                            .build())
                                    .build(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();

}

@Override
public OFFlowAdd egressPushFlowMod(int inputPort, int outputPort, int transitVlan, int outputVlan, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlan(transitVlan))
                    .build())
            .setInstructions(singletonList(
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().popVlan(),
                            ofFactory.actions().buildPushVlan()
                                    .setEthertype(EthType.of(ETH_TYPE))
                                    .build(),
                            ofFactory.actions().buildSetField()
                                    .setField(ofFactory.oxms().buildVlanVid()
                                            .setValue(OFVlanVidMatch.ofVlan(outputVlan))
                                            .build())
                                    .build(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();
}

/**
 * Encapsulate an application ID and a user block of stuff into a cookie
 *
 * @param application An ID to identify the application
 * @param user Some application specific data
 * @return a cookie for use in OFFlowMod.setCookie()
 * @throws IllegalStateException if the application has not been registered
 */

static public U64 makeCookie(int application, int user) {
    if (!appIdMap.containsKey(application)) {
        throw new AppIDNotRegisteredException(application);
    }
    long longApp = application;
    long longUser = user & USER_MASK; // mask to prevent sign extend
    return U64.of((longApp << APP_ID_SHIFT) | longUser);
}

@Override
public OFFlowAdd egressReplaceFlowMod(int inputPort, int outputPort, int inputVlan, int outputVlan, long cookie) {
    return ofFactory.buildFlowAdd()
            .setCookie(U64.of(cookie & FLOW_COOKIE_MASK))
            .setHardTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT)
            .setBufferId(OFBufferId.NO_BUFFER)
            .setPriority(FlowModUtils.PRIORITY_VERY_HIGH)
            .setMatch(ofFactory.buildMatch()
                    .setExact(MatchField.IN_PORT, OFPort.of(inputPort))
                    .setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlan(inputVlan))
                    .build())
            .setInstructions(singletonList(
                    ofFactory.instructions().applyActions(Arrays.asList(
                            ofFactory.actions().popVlan(),
                            ofFactory.actions().buildSetField()
                                    .setField(ofFactory.oxms().buildVlanVid()
                                            .setValue(OFVlanVidMatch.ofVlan(outputVlan))
                                            .build())
                                    .build(),
                            ofFactory.actions().buildOutput()
                                    .setMaxLen(0xFFFFFFFF)
                                    .setPort(OFPort.of(outputPort))
                                    .build()))
                            .createBuilder()
                            .build()))
            .setXid(0L)
            .build();
}

private int sendOF13RoleRequest(RoleState role) throws IOException {
    // Convert the role enum to the appropriate role to send
    OFControllerRole roleToSend = OFControllerRole.ROLE_NOCHANGE;
    switch (role) {
    case EQUAL:
        roleToSend = OFControllerRole.ROLE_EQUAL;
        break;
    case MASTER:
        roleToSend = OFControllerRole.ROLE_MASTER;
        break;
    case SLAVE:
        roleToSend = OFControllerRole.ROLE_SLAVE;
        break;
    default:
        log.warn("Sending default role.noChange to switch {}."
                + " Should only be used for queries.", sw);
    }

    int xid = sw.getNextTransactionId();
    OFRoleRequest rrm = OFFactories.getFactory(OFVersion.OF_13)
            .buildRoleRequest()
            .setRole(roleToSend)
            .setXid(xid)
            //FIXME fix below when we actually use generation ids
            .setGenerationId(U64.ZERO)
            .build();

    sw.sendRoleRequest(rrm);
    return xid;
}

protected void doDropFlow(IOFSwitch sw, OFPacketIn pi, IRoutingDecision decision, FloodlightContext cntx) {
    OFPort inPort = (pi.getVersion().compareTo(OFVersion.OF_12) < 0 ? pi.getInPort() : pi.getMatch().get(MatchField.IN_PORT));
    Match m = createMatchFromPacket(sw, inPort, cntx);
    OFFlowMod.Builder fmb = sw.getOFFactory().buildFlowAdd(); // this will be a drop-flow; a flow that will not output to any ports
    List<OFAction> actions = new ArrayList<OFAction>(); // set no action to drop
    U64 cookie = AppCookie.makeCookie(FORWARDING_APP_ID, 0);
    log.info("Droppingggg");
    fmb.setCookie(cookie)
    .setHardTimeout(FLOWMOD_DEFAULT_HARD_TIMEOUT)
    .setIdleTimeout(FLOWMOD_DEFAULT_IDLE_TIMEOUT)
    .setBufferId(OFBufferId.NO_BUFFER)
    .setMatch(m)
    .setPriority(FLOWMOD_DEFAULT_PRIORITY);

    FlowModUtils.setActions(fmb, actions, sw);

    try {
        if (log.isDebugEnabled()) {
            log.debug("write drop flow-mod sw={} match={} flow-mod={}",
                    new Object[] { sw, m, fmb.build() });
        }
        boolean dampened = messageDamper.write(sw, fmb.build());
        log.debug("OFMessage dampened: {}", dampened);
    } catch (IOException e) {
        log.error("Failure writing drop flow mod", e);
    }
}

@Get("json")
public List<NodePortTuple> retrieve() {
    IRoutingService routing = 
            (IRoutingService)getContext().getAttributes().
                get(IRoutingService.class.getCanonicalName());

    String srcDpid = (String) getRequestAttributes().get("src-dpid");
    String srcPort = (String) getRequestAttributes().get("src-port");
    String dstDpid = (String) getRequestAttributes().get("dst-dpid");
    String dstPort = (String) getRequestAttributes().get("dst-port");

    log.debug( srcDpid + "--" + srcPort + "--" + dstDpid + "--" + dstPort);

    DatapathId longSrcDpid = DatapathId.of(srcDpid);
    OFPort shortSrcPort = OFPort.of(Integer.parseInt(srcPort));
    DatapathId longDstDpid = DatapathId.of(dstDpid);
    OFPort shortDstPort = OFPort.of(Integer.parseInt(dstPort));

    Route result = routing.getRoute(longSrcDpid, shortSrcPort, longDstDpid, shortDstPort, U64.of(0));

    if (result != null) {
        return routing.getRoute(longSrcDpid, shortSrcPort, longDstDpid, shortDstPort, U64.of(0)).getPath();
    }
    else {
        log.debug("ERROR! no route found");
        return null;
    }
}

/**
 * Writes a FlowMod to a switch that inserts a drop flow.
 * @param sw The switch to write the FlowMod to.
 * @param pi The corresponding OFPacketIn. Used to create the OFMatch structure.
 * @param cntx The FloodlightContext that gets passed to the switch.
 */
protected void doDropFlow(IOFSwitch sw, OFPacketIn pi, FloodlightContext cntx) {
    if (log.isTraceEnabled()) {
        log.trace("doDropFlow pi={} srcSwitch={}",
                new Object[] { pi, sw });
    }

    if (sw == null) {
        log.warn("Switch is null, not installing drop flowmod for PacketIn {}", pi);
        return;
    }

    // Create flow-mod based on packet-in and src-switch
    OFFlowMod.Builder fmb = sw.getOFFactory().buildFlowModify();
    List<OFAction> actions = new ArrayList<OFAction>(); // no actions = drop
    U64 cookie = AppCookie.makeCookie(APP_ID, 0);
    fmb.setCookie(cookie)
    .setIdleTimeout(ForwardingBase.FLOWMOD_DEFAULT_IDLE_TIMEOUT)
    .setHardTimeout(ForwardingBase.FLOWMOD_DEFAULT_HARD_TIMEOUT)
    .setBufferId(OFBufferId.NO_BUFFER)
    .setMatch(pi.getMatch())
    .setActions(actions);

    if (log.isTraceEnabled()) {
        log.trace("write drop flow-mod srcSwitch={} match={} " +
                "pi={} flow-mod={}",
                new Object[] {sw, pi.getMatch(), pi, fmb.build()});
    }
    sw.write(fmb.build());
    return;
}

public LinkInfo(Date firstSeenTime, Date lastLldpReceivedTime, Date lastBddpReceivedTime) {
    this.firstSeenTime = firstSeenTime;
    this.lastLldpReceivedTime = lastLldpReceivedTime;
    this.lastBddpReceivedTime = lastBddpReceivedTime;
    this.currentLatency = null;
    this.latencyHistory = new ArrayDeque<U64>(LinkDiscoveryManager.LATENCY_HISTORY_SIZE);
    this.latencyHistoryWindow = LinkDiscoveryManager.LATENCY_HISTORY_SIZE;
    this.latencyUpdateThreshold = LinkDiscoveryManager.LATENCY_UPDATE_THRESHOLD;
}

public LinkInfo(LinkInfo fromLinkInfo) {
    this.firstSeenTime = fromLinkInfo.getFirstSeenTime();
    this.lastLldpReceivedTime = fromLinkInfo.getUnicastValidTime();
    this.lastBddpReceivedTime = fromLinkInfo.getMulticastValidTime();
    this.currentLatency = fromLinkInfo.currentLatency;
    this.latencyHistory = new ArrayDeque<U64>(fromLinkInfo.getLatencyHistory());
    this.latencyHistoryWindow = fromLinkInfo.getLatencyHistoryWindow();
    this.latencyUpdateThreshold = fromLinkInfo.getLatencyUpdateThreshold();
}

private U64 getLatencyHistoryAverage() {
    if (!isLatencyHistoryFull()) {
        return null;
    } else { /* guaranteed to be at latencyHistoryWindow capacity */
        double avg = 0;
        for (U64 l : latencyHistory) {
            avg = avg + l.getValue();
        }
        avg = avg / latencyHistoryWindow;
        return U64.of((long) avg);
    }
}

/**
 * Append a new (presumably most recent) latency
 * to the list. Sets the current latency if this
 * is the first latency update performed. Note
 * the latter serves as a latency initializer.
 * 
 * @param latency
 * @return latency to use for the link; either initial or historical average
 */
public U64 addObservedLatency(U64 latency) {
    if (isLatencyHistoryFull()) {
        latencyHistory.removeFirst();
    }
    latencyHistory.addLast(latency);

    if (currentLatency == null) {
        currentLatency = latency;
        return currentLatency;
    } else {
        return getLatency();
    }
}

/**
 * Processes a flow removed message. We will delete the learned MAC/VLAN mapping from
 * the switch's table.
 * @param sw The switch that sent the flow removed message.
 * @param flowRemovedMessage The flow removed message.
 * @return Whether to continue processing this message or stop.
 */
private Command processFlowRemovedMessage(IOFSwitch sw, OFFlowRemoved flowRemovedMessage) {
    if (!flowRemovedMessage.getCookie().equals(U64.of(LearningSwitch.LEARNING_SWITCH_COOKIE))) {
        return Command.CONTINUE;
    }
    if (log.isTraceEnabled()) {
        log.trace("{} flow entry removed {}", sw, flowRemovedMessage);
    }
    Match match = flowRemovedMessage.getMatch();
    // When a flow entry expires, it means the device with the matching source
    // MAC address and VLAN either stopped sending packets or moved to a different
    // port.  If the device moved, we can't know where it went until it sends
    // another packet, allowing us to re-learn its port.  Meanwhile we remove
    // it from the macVlanToPortMap to revert to flooding packets to this device.
    this.removeFromPortMap(sw, match.get(MatchField.ETH_SRC), 
            match.get(MatchField.VLAN_VID) == null 
            ? VlanVid.ZERO 
            : match.get(MatchField.VLAN_VID).getVlanVid());

    // Also, if packets keep coming from another device (e.g. from ping), the
    // corresponding reverse flow entry will never expire on its own and will
    // send the packets to the wrong port (the matching input port of the
    // expired flow entry), so we must delete the reverse entry explicitly.
    Match.Builder mb = sw.getOFFactory().buildMatch();
    mb.setExact(MatchField.ETH_SRC, match.get(MatchField.ETH_DST))                         
    .setExact(MatchField.ETH_DST, match.get(MatchField.ETH_SRC));
    if (match.get(MatchField.VLAN_VID) != null) {
        mb.setExact(MatchField.VLAN_VID, match.get(MatchField.VLAN_VID));                    
    }
    this.writeFlowMod(sw, OFFlowModCommand.DELETE, OFBufferId.NO_BUFFER, mb.build(), match.get(MatchField.IN_PORT));
    return Command.CONTINUE;
}

/**
 * Convert an OFInstructionMetadata to string form. The string will be formatted
 * in a dpctl/ofctl-style syntax.
 * @param inst; The instruction to convert to a string
 * @param log
 * @return
 */
public static String writeMetadataToString(OFInstructionWriteMetadata inst, Logger log) {
    /* 
     * U64.toString() formats with a leading 0x
     */
    if (inst.getMetadataMask().equals(U64.NO_MASK)) { // don't give the mask if it's all 1's --> omit "/"
        return inst.getMetadata().toString();
    } else {
        return inst.getMetadata().toString() + "/" + inst.getMetadataMask().toString();
    }
}

/**
 * Writes a FlowMod to a switch that inserts a drop flow.
 * @param sw The switch to write the FlowMod to.
 * @param pi The corresponding OFPacketIn. Used to create the OFMatch structure.
 * @param cntx The FloodlightContext that gets passed to the switch.
 */
protected void doDropFlow(IOFSwitch sw, OFPacketIn pi, FloodlightContext cntx) {
    if (log.isTraceEnabled()) {
        log.trace("doDropFlow pi={} srcSwitch={}",
                new Object[] { pi, sw });
    }

    if (sw == null) {
        log.warn("Switch is null, not installing drop flowmod for PacketIn {}", pi);
        return;
    }

    // Create flow-mod based on packet-in and src-switch
    OFFlowMod.Builder fmb = sw.getOFFactory().buildFlowModify();
    List<OFAction> actions = new ArrayList<OFAction>(); // no actions = drop
    U64 cookie = AppCookie.makeCookie(APP_ID, 0);
    fmb.setCookie(cookie)
    .setIdleTimeout(ForwardingBase.FLOWMOD_DEFAULT_IDLE_TIMEOUT)
    .setHardTimeout(ForwardingBase.FLOWMOD_DEFAULT_HARD_TIMEOUT)
    .setBufferId(OFBufferId.NO_BUFFER)
    .setMatch(pi.getMatch())
    .setActions(actions);

    if (log.isTraceEnabled()) {
        log.trace("write drop flow-mod srcSwitch={} match={} " +
                "pi={} flow-mod={}",
                new Object[] {sw, pi.getMatch(), pi, fmb.build()});
    }
    sw.write(fmb.build());
    return;
}

@Override
public ArrayList<Route> getRoutes(DatapathId srcDpid, DatapathId dstDpid,
        boolean tunnelEnabled) {
    // Floodlight supports single path routing now

    // return single path now
    ArrayList<Route> result=new ArrayList<Route>();
    result.add(getRoute(srcDpid, dstDpid, U64.of(0), tunnelEnabled));
    return result;
}

private SwitchPortBandwidth(DatapathId d, OFPort p, U64 rx, U64 tx, U64 rxValue, U64 txValue) {
    id = d;
    pt = p;
    this.rx = rx;
    this.tx = tx;
    time = new Date();
    this.rxValue = rxValue;
    this.txValue = txValue;
}

@Override
void processOFNiciraControllerRoleRequest(OFNiciraControllerRoleRequest m) {
    OFControllerRole role;
    switch (m.getRole()) {
    case ROLE_MASTER:
        role = OFControllerRole.ROLE_MASTER;
        break;
    case ROLE_SLAVE:
        role = OFControllerRole.ROLE_SLAVE;
        break;
    case ROLE_OTHER:
        role = OFControllerRole.ROLE_EQUAL;
        break;
    default:
        log.error("Attempted to change to invalid Nicira role {}.", m.getRole().toString());
        return;
    }
    /* 
     * This will get converted back to the correct factory of the switch later.
     * We will use OFRoleRequest though to simplify the API between OF versions.
     */
    sendRoleRequest(OFFactories.getFactory(OFVersion.OF_13).buildRoleRequest()
            .setGenerationId(U64.ZERO)
            .setXid(m.getXid())
            .setRole(role)
            .build());
}

/**
 * This function generates a random hash for the bottom half of the cookie
 * 
 * @param fm
 * @param userCookie
 * @param name
 * @return A cookie that encodes the application ID and a hash
 */
public static U64 computeEntryCookie(int userCookie, String name) {
    // flow-specific hash is next 20 bits LOOK! who knows if this 
    int prime = 211;
    int flowHash = 2311;
    for (int i=0; i < name.length(); i++) {
        flowHash = flowHash * prime + (int)name.charAt(i);
    }

    return AppCookie.makeCookie(StaticFlowEntryPusher.STATIC_FLOW_APP_ID, flowHash);
}

@Test
public void testLinkLatency() throws Exception {
    LinkDiscoveryManager.LATENCY_HISTORY_SIZE = 5;
    LinkDiscoveryManager.LATENCY_UPDATE_THRESHOLD = 0.25;

    LinkInfo info = new LinkInfo(new Date(), new Date(), null);

    /*
     * Should retain initial latency until LATENCY_HISTORY_SIZE
     * data points are accumulated.
     */
    assertEquals(U64.of(0), info.addObservedLatency(U64.of(0)));
    assertEquals(U64.of(0), info.addObservedLatency(U64.of(10)));
    assertEquals(U64.of(0), info.addObservedLatency(U64.of(20)));
    assertEquals(U64.of(0), info.addObservedLatency(U64.of(30)));
    assertEquals(U64.of(20), info.addObservedLatency(U64.of(40)));

    /*
     * LATENCY_HISTORY_SIZE is maintained. Oldest value is evicted
     * per new value added. New average should be computed each
     * addition, but latency should not change until current latency
     * versus historical average latency differential threshold is
     * exceeded again.
     */
    assertEquals(U64.of(20), info.addObservedLatency(U64.of(20))); /* avg = 24; diff = 4; 4/24 = 1/6 = 17% !>= 25% --> no update */
    assertEquals(U64.of(26), info.addObservedLatency(U64.of(20))); /* avg = 26; diff = 6; 6/20 = 3/10 = 33% >= 25% --> update */
    assertEquals(U64.of(26), info.addObservedLatency(U64.of(20))); /* avg = 26; diff = 0; 0/20 = 0/10 = 0% !>= 25% --> no update */
}

@Test
public void testBasic1() throws Exception {
    tm.addOrUpdateLink(DatapathId.of(1), OFPort.of(1), DatapathId.of(2), OFPort.of(1), U64.ZERO, ILinkDiscovery.LinkType.DIRECT_LINK);
    assertTrue(tm.getSwitchPorts().size() == 2);  // for two nodes.
    assertTrue(tm.getSwitchPorts().get(DatapathId.of(1)).size()==1);
    assertTrue(tm.getSwitchPorts().get(DatapathId.of(2)).size()==1);
    assertTrue(tm.getSwitchPortLinks().size()==2);
    assertTrue(tm.getPortBroadcastDomainLinks().size()==0);
    assertTrue(tm.getTunnelPorts().size()==0);

    tm.addOrUpdateLink(DatapathId.of(1), OFPort.of(2), DatapathId.of(2), OFPort.of(2), U64.ZERO, ILinkDiscovery.LinkType.MULTIHOP_LINK);
    assertTrue(tm.getSwitchPorts().size() == 2);  // for two nodes.
    assertTrue(tm.getSwitchPorts().get(DatapathId.of(1)).size()==2);
    assertTrue(tm.getSwitchPorts().get(DatapathId.of(2)).size()==2);
    assertTrue(tm.getSwitchPortLinks().size()==4);
    assertTrue(tm.getPortBroadcastDomainLinks().size()==2);
    assertTrue(tm.getTunnelPorts().size()==0);

    tm.removeLink(DatapathId.of(1), OFPort.of(2), DatapathId.of(2), OFPort.of(2));
    assertTrue(tm.getSwitchPorts().get(DatapathId.of(1)).size()==1);
    assertTrue(tm.getSwitchPorts().get(DatapathId.of(2)).size()==1);
    assertTrue(tm.getSwitchPorts().size() == 2);
    assertTrue(tm.getSwitchPortLinks().size()==2);
    assertTrue(tm.getPortBroadcastDomainLinks().size()==0);

    tm.removeLink(DatapathId.of(1), OFPort.of(1), DatapathId.of(2), OFPort.of(1));
    assertTrue(tm.getSwitchPorts().size() == 0);
    assertTrue(tm.getSwitchPortLinks().size()==0);
    assertTrue(tm.getPortBroadcastDomainLinks().size()==0);
}

@Override
void processOFNiciraControllerRoleRequest(OFNiciraControllerRoleRequest m) {
    OFControllerRole role;
    switch (m.getRole()) {
    case ROLE_MASTER:
        role = OFControllerRole.ROLE_MASTER;
        break;
    case ROLE_SLAVE:
        role = OFControllerRole.ROLE_SLAVE;
        break;
    case ROLE_OTHER:
        role = OFControllerRole.ROLE_EQUAL;
        break;
    default:
        log.error("Attempted to change to invalid Nicira role {}.", m.getRole().toString());
        return;
    }
    /* 
     * This will get converted back to the correct factory of the switch later.
     * We will use OFRoleRequest though to simplify the API between OF versions.
     */
    sendRoleRequest(OFFactories.getFactory(OFVersion.OF_13).buildRoleRequest()
            .setGenerationId(U64.ZERO)
            .setXid(m.getXid())
            .setRole(role)
            .build());
}