Java OFError类代码示例

import org.openflow.protocol.OFError; //导入依赖的package包/类
/**
 * Log an OpenFlow error message from a switch
 * @param sw The switch that sent the error
 * @param error The error message
 */
@LogMessageDoc(level="ERROR",
        message="Error {error type} {error code} from {switch} " +
                "in state {state}",
        explanation="The switch responded with an unexpected error" +
                "to an OpenFlow message from the controller",
        recommendation="This could indicate improper network operation. " +
                "If the problem persists restarting the switch and " +
                "controller may help."
        )
protected void logError(OFChannelHandler h, OFError error) {
    log.error("{} from switch {} in state {}",
              new Object[] {
                  getErrorString(error),
                  h.getSwitchInfoString(),
                  this.toString()});
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
/**
 * Test re-assert MASTER
 *
 */
@Test
public void testReassertMaster() throws Exception {
    testInitialMoveToMasterWithRole();

    OFError err = (OFError)
            BasicFactory.getInstance().getMessage(OFType.ERROR);
    err.setXid(42);
    err.setErrorType(OFErrorType.OFPET_BAD_REQUEST);
    err.setErrorCode(OFBadRequestCode.OFPBRC_EPERM);

    reset(controller);
    controller.reassertRole(handler, Role.MASTER);
    expectLastCall().once();
    controller.handleMessage(sw, err, null);
    expectLastCall().once();

    sendMessageToHandlerNoControllerReset(
            Collections.<OFMessage>singletonList(err));

    verify(sw);
    verify(controller);
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
@Override
public Command receive(IOFSwitch sw, OFMessage msg, FloodlightContext cntx) {
    switch (msg.getType()) {
        case PACKET_IN:
            return this.processPacketInMessage(sw, (OFPacketIn) msg, cntx);
        case FLOW_REMOVED:
            return this.processFlowRemovedMessage(sw, (OFFlowRemoved) msg);
        case ERROR:
            log.info("received an error {} from switch {}", (OFError) msg, sw);
            return Command.CONTINUE;
        default:
        	break;
    }
    log.error("received an unexpected message {} from switch {}", msg, sw);
    return Command.CONTINUE;
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
@Override
void processOFError(final SwitchChannelHandler h, final OFError m) {
    try {
        if (m.getOffendingMsg().getType() != OFType.BARRIER_REQUEST) {
            h.log.error(
                    "Error waiting for features (type:{}, code:{})",
                    m.getErrorType(), m.getErrorCode());
            if (h.channel.isOpen()) {
                h.channel.close();
            }
        } else {
            h.log.warn(
                    "Barrier Request message not understood by switch {}; "
                            + "if it's an HP switch you are probably ok.",
                            HexString.toHexString(h.featuresReply
                                    .getDatapathId()));
        }

    } catch (MessageParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
@Override
public Command receive(IOFSwitch sw, OFMessage msg, ListenerContext cntx) {
    switch (msg.getType()) {
        case PACKET_IN:
            return this.processPacketInMessage(sw, (OFPacketIn) msg, cntx);
        case FLOW_REMOVED:
            return this.processFlowRemovedMessage(sw, (OFFlowRemoved) msg);
        case ERROR:
            log.info("received an error {} from switch {}", (OFError) msg, sw);
            return Command.CONTINUE;
        default:
        	break;
    }
    log.error("received an unexpected message {} from switch {}", msg, sw);
    return Command.CONTINUE;
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
protected void handleErrorMessage(OFError err, long dpid, int xid) {
    short errorType = err.getErrorType();
    short errorCode = err.getErrorCode();
    if (errorType == OFError.OFErrorType.OFPET_BAD_REQUEST.getValue() &&
            errorCode == (short)OFError.OFBadRequestCode.OFPBRC_EPERM.ordinal()) {
        Set<Integer> xids = sentIPRequests.get(dpid);

        if (xids != null && xids.contains(xid)) {
            logger.warn("Switch {} not configured with tunnel-endpoint " +
                    "information (missing /etc/bsn_tunnel_interface file)",
                    HexString.toHexString(dpid));
            xids.remove(xid);
            return;
        }
    } else {
        // ignoring all other error messages
    }
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
@Test
public void testDeliverRoleRequestError() {
    // normal case. xid is pending 
    int xid = (int) System.currentTimeMillis();
    long cookie = System.nanoTime();
    Role role = Role.MASTER;
    OFSwitchImpl sw = new OFSwitchImpl();
    Channel ch = createMock(Channel.class);
    SocketAddress sa = new InetSocketAddress(42);
    expect(ch.getRemoteAddress()).andReturn(sa).anyTimes();
    sw.setChannel(ch);
    setupPendingRoleRequest(sw, xid, role, cookie);
    OFError error = new OFError();
    error.setErrorType(OFErrorType.OFPET_BAD_REQUEST);
    error.setXid(xid);
    replay(ch);
    roleChanger.deliverRoleRequestError(sw, error);
    verify(ch);
    assertEquals(false, sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE));
    assertEquals(role, sw.getHARole());
    assertEquals(0, roleChanger.pendingRequestMap.get(sw).size());
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
@Test
public void testDeliverRoleRequestErrorNonePending() {
    // nothing pending 
    OFSwitchImpl sw = new OFSwitchImpl();
    Channel ch = createMock(Channel.class);
    SocketAddress sa = new InetSocketAddress(42);
    expect(ch.getRemoteAddress()).andReturn(sa).anyTimes();
    sw.setChannel(ch);
    OFError error = new OFError();
    error.setErrorType(OFErrorType.OFPET_BAD_REQUEST);
    error.setXid(1);
    replay(ch);
    roleChanger.deliverRoleRequestError(sw, error);
    verify(ch);
    assertEquals(null, sw.getHARole());
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
@Test
public void testDeliverRoleRequestErrorWrongXid() {
    // wrong xid received 
    // wrong xid received 
    int xid = (int) System.currentTimeMillis();
    long cookie = System.nanoTime();
    Role role = Role.MASTER;
    OFSwitchImpl sw = new OFSwitchImpl();
    setupPendingRoleRequest(sw, xid, role, cookie);
    Channel ch = createMock(Channel.class);
    SocketAddress sa = new InetSocketAddress(42);
    expect(ch.getRemoteAddress()).andReturn(sa).anyTimes();
    expect(ch.close()).andReturn(null);
    sw.setChannel(ch);
    replay(ch);
    OFError error = new OFError();
    error.setErrorCode(OFError.OFErrorType.OFPET_BAD_REQUEST.getValue());
    error.setXid(xid + 1);
    roleChanger.deliverRoleRequestError(sw, error);
    verify(ch);
    assertEquals(null, sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE));
    assertEquals(1, roleChanger.pendingRequestMap.get(sw).size());
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
/**
 * Convert various result into Status
 *
 * @param result
 *            The returned result from previous action
 * @param action
 *            add/modify/delete flow action
 * @param rid
 *            The Request ID associated with the flow message
 * @return Status
 */
private Status getStatusInternal(Object result, String action, long rid) {
    if (result instanceof Boolean) {
        return ((Boolean) result == Boolean.TRUE) ? new Status(
                StatusCode.SUCCESS, rid) : new Status(
                StatusCode.TIMEOUT, errorString(null, action,
                        "Request Timed Out"));
    } else if (result instanceof Status) {
        return (Status) result;
    } else if (result instanceof OFError) {
        OFError res = (OFError) result;
        return new Status(StatusCode.INTERNALERROR, errorString(
                "program", action, Utils.getOFErrorString(res)));
    } else {
        return new Status(StatusCode.INTERNALERROR, errorString(
                "send", action, "Internal Error"));
    }
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
private void processErrorReply(OFError errorMsg) {
    OFMessage offendingMsg = errorMsg.getOffendingMsg();
    Integer xid;
    if (offendingMsg != null) {
        xid = offendingMsg.getXid();
    } else {
        xid = errorMsg.getXid();
    }
    /*
     * the error can be a reply to a synchronous message or to a statistic
     * request message
     */
    Callable<?> worker = messageWaitingDone.remove(xid);
    if (worker == null) {
        return;
    }
    if (worker instanceof SynchronousMessage) {
        ((SynchronousMessage) worker).wakeup(errorMsg);
    } else {
        ((StatisticsCollector) worker).wakeup(errorMsg);
    }
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
@Override
void processOFError(OFChannelHandler h, OFError m) {
    if (m.getErrorType() == OFErrorType.OFPET_BAD_REQUEST.getValue()
            && m.getErrorCode() ==
                OFBadRequestCode.OFPBRC_BAD_VENDOR.ordinal()) {
        log.debug("Switch {} has multiple tables but does not " +
                "support L2 table extension",
                h.getSwitchInfoString());
        return;
    }
    logErrorDisconnect(h, m);
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
/**
 * Get a useable error string from the OFError.
 * @param error
 * @return
 */
public static String getErrorString(OFError error) {
    // TODO: this really should be OFError.toString. Sigh.
    int etint = 0xffff & error.getErrorType();
    if (etint < 0 || etint >= OFErrorType.values().length) {
        return String.format("Unknown error type %d", etint);
    }
    OFErrorType et = OFErrorType.values()[etint];
    switch (et) {
        case OFPET_HELLO_FAILED:
            OFHelloFailedCode hfc =
                OFHelloFailedCode.values()[0xffff & error.getErrorCode()];
            return String.format("Error %s %s", et, hfc);
        case OFPET_BAD_REQUEST:
            OFBadRequestCode brc =
                OFBadRequestCode.values()[0xffff & error.getErrorCode()];
            return String.format("Error %s %s", et, brc);
        case OFPET_BAD_ACTION:
            OFBadActionCode bac =
                OFBadActionCode.values()[0xffff & error.getErrorCode()];
            return String.format("Error %s %s", et, bac);
        case OFPET_FLOW_MOD_FAILED:
            OFFlowModFailedCode fmfc =
                OFFlowModFailedCode.values()[0xffff & error.getErrorCode()];
            return String.format("Error %s %s", et, fmfc);
        case OFPET_PORT_MOD_FAILED:
            OFPortModFailedCode pmfc =
                OFPortModFailedCode.values()[0xffff & error.getErrorCode()];
            return String.format("Error %s %s", et, pmfc);
        case OFPET_QUEUE_OP_FAILED:
            OFQueueOpFailedCode qofc =
                OFQueueOpFailedCode.values()[0xffff & error.getErrorCode()];
            return String.format("Error %s %s", et, qofc);
        case OFPET_VENDOR_ERROR:
            // no codes known for vendor error
            return String.format("Error %s", et);
    }
    return null;
}
 

import org.openflow.protocol.OFError; //导入依赖的package包/类
/** Return an OFError of the given type with the given xid */
private OFMessage getErrorMessage(OFErrorType type,
                                  int i,
                                  int xid) {
    OFError e = (OFError) BasicFactory.getInstance()
            .getMessage(OFType.ERROR);
    e.setErrorType(type);
    e.setErrorCode((short)i);
    e.setXid(xid);
    return e;
}