Java OFError.setErrorCode方法代码示例

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包/类
@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包/类
/** 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;
}
 

import org.openflow.protocol.OFError; //导入方法依赖的package包/类
@Test
 public void testErrorEPERM() throws Exception {
     // Check behavior with a BAD_REQUEST/EPERM error
     // Ensure controller attempts to reset switch role.
     OFChannelState state = new OFChannelState();
     state.hsState = HandshakeState.READY;
     Controller.OFChannelHandler chdlr = controller.new OFChannelHandler(state);
     OFError error = new OFError();
     error.setErrorType(OFErrorType.OFPET_BAD_REQUEST);
     error.setErrorCode(OFBadRequestCode.OFPBRC_EPERM);
     IOFSwitch sw = createMock(IOFSwitch.class);
     chdlr.sw = sw;
     controller.activeSwitches.put(1L, sw);

     // prepare the switch and lock expectations
     Lock lock = createNiceMock(Lock.class);
     expect(sw.getListenerReadLock()).andReturn(lock).anyTimes();
     expect(sw.isConnected()).andReturn(true).anyTimes();
     expect(sw.getHARole()).andReturn(Role.MASTER).anyTimes();
     expect(sw.getId()).andReturn(1L).anyTimes();

     // Make sure controller attempts to reset switch master
     expect(sw.getAttribute("supportsNxRole")).andReturn(true).anyTimes();
     expect(sw.getNextTransactionId()).andReturn(0).anyTimes();
     sw.write(EasyMock.<List<OFMessage>> anyObject(),
              (ListenerContext)anyObject());

     // test
     replay(sw, lock);
     chdlr.processOFMessage(error);
     // Verify there is a pending role change request
     assertTrue(controller.roleChanger.pendingTasks.peek() != null);
}
 

import org.openflow.protocol.OFError; //导入方法依赖的package包/类
@Test
public void testRoleNotSupportedError() throws Exception {
    int xid = 424242;
    OFChannelState state = new OFChannelState();
    state.hsState = HandshakeState.READY;
    Controller.OFChannelHandler chdlr = controller.new OFChannelHandler(state);
    chdlr.sw = createMock(OFSwitchImpl.class);
    Channel ch = createMock(Channel.class);
    
    // the error returned when role request message is not supported by sw
    OFError msg = new OFError();
    msg.setType(OFType.ERROR);
    msg.setXid(xid);
    msg.setErrorType(OFErrorType.OFPET_BAD_REQUEST);
    msg.setErrorCode(OFBadRequestCode.OFPBRC_BAD_VENDOR);
    
    // the switch connection should get disconnected when the controller is
    // in SLAVE mode and the switch does not support role-request messages
    state.firstRoleReplyReceived = false;
    controller.role = Role.SLAVE;
    expect(chdlr.sw.checkFirstPendingRoleRequestXid(xid)).andReturn(true);
    chdlr.sw.deliverRoleRequestNotSupported(xid);
    expect(chdlr.sw.getChannel()).andReturn(ch).anyTimes();
    expect(ch.close()).andReturn(null);
    
    replay(ch, chdlr.sw);
    chdlr.processOFMessage(msg);
    verify(ch, chdlr.sw);
    assertTrue("state.firstRoleReplyReceived must be true", 
               state.firstRoleReplyReceived);
    assertTrue("activeSwitches must be empty",
               controller.activeSwitches.isEmpty());
    reset(ch, chdlr.sw);
          
    
    // a different error message - should also reject role request
    msg.setErrorType(OFErrorType.OFPET_BAD_REQUEST);
    msg.setErrorCode(OFBadRequestCode.OFPBRC_EPERM);
    state.firstRoleReplyReceived = false;
    controller.role = Role.SLAVE;
    expect(chdlr.sw.checkFirstPendingRoleRequestXid(xid)).andReturn(true);
    chdlr.sw.deliverRoleRequestNotSupported(xid);
    expect(chdlr.sw.getChannel()).andReturn(ch).anyTimes();
    expect(ch.close()).andReturn(null);
    replay(ch, chdlr.sw);
    
    chdlr.processOFMessage(msg);
    verify(ch, chdlr.sw);
    assertTrue("state.firstRoleReplyReceived must be True even with EPERM",
               state.firstRoleReplyReceived);
    assertTrue("activeSwitches must be empty", 
               controller.activeSwitches.isEmpty());
    reset(ch, chdlr.sw);

    
    // We are MASTER, the switch should be added to the list of active
    // switches.
    state.firstRoleReplyReceived = false;
    controller.role = Role.MASTER;
    expect(chdlr.sw.checkFirstPendingRoleRequestXid(xid)).andReturn(true);
    chdlr.sw.deliverRoleRequestNotSupported(xid);
    setupSwitchForAddSwitch(chdlr.sw, 0L);
    chdlr.sw.clearAllFlowMods();
    replay(ch, chdlr.sw);
    
    chdlr.processOFMessage(msg);
    verify(ch, chdlr.sw);
    assertTrue("state.firstRoleReplyReceived must be true", 
               state.firstRoleReplyReceived);
    assertSame("activeSwitches must contain this switch",
               chdlr.sw, controller.activeSwitches.get(0L));
    reset(ch, chdlr.sw);

}
 

import org.openflow.protocol.OFError; //导入方法依赖的package包/类
@Test
 public void testErrorEPERM() throws Exception {
     // Check behavior with a BAD_REQUEST/EPERM error
     // Ensure controller attempts to reset switch role.
     OFChannelState state = new OFChannelState();
     state.hsState = HandshakeState.READY;
     Controller.OFChannelHandler chdlr = controller.new OFChannelHandler(state);
     OFError error = new OFError();
     error.setErrorType(OFErrorType.OFPET_BAD_REQUEST);
     error.setErrorCode(OFBadRequestCode.OFPBRC_EPERM);
     IOFSwitch sw = createMock(IOFSwitch.class);
     chdlr.sw = sw;
     controller.activeSwitches.put(1L, sw);

     // prepare the switch and lock expectations
     Lock lock = createNiceMock(Lock.class);
     expect(sw.getListenerReadLock()).andReturn(lock).anyTimes();
     expect(sw.isConnected()).andReturn(true).anyTimes();
     expect(sw.getHARole()).andReturn(Role.MASTER).anyTimes();
     expect(sw.getId()).andReturn(1L).anyTimes();

     // Make sure controller attempts to reset switch master
     expect(sw.getAttribute("supportsNxRole")).andReturn(true).anyTimes();
     expect(sw.getNextTransactionId()).andReturn(0).anyTimes();
     sw.write(EasyMock.<List<OFMessage>> anyObject(),
              (FloodlightContext)anyObject());

     // test
     replay(sw, lock);
     chdlr.processOFMessage(error);
     DelayQueue<RoleChangeTask> pendingTasks =
             controller.roleChanger.pendingTasks;
     synchronized (pendingTasks) {
         RoleChangeTask t;
         while ((t = pendingTasks.peek()) == null ||
                 RoleChanger.RoleChangeTask.Type.TIMEOUT != t.type) {
             pendingTasks.wait();
         }
     }
     // Now there should be exactly one timeout task pending
     assertEquals(1, pendingTasks.size());
}