Java 类org.projectfloodlight.openflow.protocol.OFControllerRole 实例源码

/**
 * Extract the role information from an OF1.3 Role Reply Message.
 *
 * @param rrmsg the role message
 * @return RoleReplyInfo object
 * @throws SwitchStateException if the role information could not be extracted.
 */
@Override
public RoleReplyInfo extractOFRoleReply(OFRoleReply rrmsg)
        throws SwitchStateException {
    OFControllerRole cr = rrmsg.getRole();
    RoleState role = null;
    switch (cr) {
    case ROLE_EQUAL:
        role = RoleState.EQUAL;
        break;
    case ROLE_MASTER:
        role = RoleState.MASTER;
        break;
    case ROLE_SLAVE:
        role = RoleState.SLAVE;
        break;
    case ROLE_NOCHANGE: // switch should send current role
    default:
        String msg = String.format("Unknown controller role %s "
                + "received from switch %s", cr, sw);
        throw new SwitchStateException(msg);
    }

    return new RoleReplyInfo(role, rrmsg.getGenerationId(), rrmsg.getXid());
}

@Override
@Test
public void moveToWaitInitialRole() throws Exception {
    moveToWaitAppHandshakeState();
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(WaitAppHandshakeState.class));

    reset(sw);
    expect(sw.getAttribute(IOFSwitchBackend.SWITCH_SUPPORTS_NX_ROLE)).andReturn(true).anyTimes();
    replay(sw);

    reset(roleManager);
    expect(roleManager.getOFControllerRole()).andReturn(OFControllerRole.ROLE_MASTER).anyTimes();
    roleManager.notifyControllerConnectionUpdate();
    expectLastCall().once();
    replay(roleManager);

    WaitAppHandshakeState state = (WaitAppHandshakeState) switchHandler.getStateForTesting();
    state.enterNextPlugin();

    // Expect wait initial role's enterState message to be written
    OFMessage msg = connection.retrieveMessage();
    assertThat(msg, CoreMatchers.instanceOf(OFRoleRequest.class));
    verifyUniqueXids(msg);

    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitInitialRoleState.class));
}

/**
 * Send a role request for the given role only if no other role
 * request is currently pending.
 * @param role The role to send to the switch.
 * @throws IOException
 */
synchronized void sendRoleRequestIfNotPending(OFControllerRole role, long xid)
        throws IOException {
    long now = System.nanoTime();
    if (now - lastAssertTimeNs < assertTimeIntervalNs) {
        return;
    }

    lastAssertTimeNs = now;
    if (assertTimeIntervalNs < MAX_ASSERT_TIME_INTERVAL_NS) { // 2 minutes max
        assertTimeIntervalNs <<= 1;
    } else if (role == OFControllerRole.ROLE_MASTER){
        log.warn("Reasserting master role on switch {}, " +
                "likely a switch config error with multiple masters",
                role, sw);
    }
    if (!requestPending)
        sendRoleRequest(role, xid);
    else
        switchManagerCounters.roleNotResentBecauseRolePending.increment();
}

/**
 * Send a role request with the given role to the switch.
 *
 * Send a role request with the given role to the switch and update
 * the pending request and timestamp.
 *
 * @param role
 * @throws IOException
 */
synchronized void sendRoleRequest(OFControllerRole role, long xid) throws IOException {
    /*
     * There are three cases to consider for SUPPORTS_NX_ROLE:
     *
     * 1) unset. We have neither received a role reply from the
     *    switch nor has a request timed out. Send a request.
     * 2) TRUE: We've already send a request earlier and received
     *    a reply. The switch supports role and we should send one.
     * 3) FALSE: We have already send a role and received an error.
     *    The switch does not support roles. Don't send a role request,
     *    set the switch's role directly.
     */
    Boolean supportsNxRole = (Boolean)
            sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE);
    if ((supportsNxRole != null) && !supportsNxRole) {
        setSwitchRole(role, RoleRecvStatus.UNSUPPORTED);
    } else {
        pendingXid = sendNiciraRoleRequest(role, xid);
        pendingRole = role;
        this.roleSubmitTimeNs = System.nanoTime();
        requestPending = true;
    }
}

/**
 * Set the role for this switch / channel.
 *
 * If the status indicates that we received a reply we set the role.
 * If the status indicates otherwise we disconnect the switch if
 * the role is SLAVE.
 *
 * "Setting a role" means setting the appropriate ChannelState,
 * setting the flags on the switch and
 * notifying Controller.java about new role of the switch
 *
 * @param role The role to set.
 * @param status How we derived at the decision to set this status.
 */
synchronized private void setSwitchRole(OFControllerRole role, RoleRecvStatus status) {
    requestPending = false;
    if (status == RoleRecvStatus.RECEIVED_REPLY)
        sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, true);
    else
        sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, false);
    sw.setControllerRole(role);

    if (role != OFControllerRole.ROLE_SLAVE) {
        OFSwitchHandshakeHandler.this.setState(new MasterState());
    } else {
        if (status != RoleRecvStatus.RECEIVED_REPLY) {
            if (log.isDebugEnabled()) {
                log.debug("Disconnecting switch {}. Doesn't support role"
                        + "({}) request and controller is now SLAVE",
                        getSwitchInfoString(), status);
            }
            // the disconnect will trigger a switch removed to
            // controller so no need to signal anything else
            sw.disconnect();
        } else {
            OFSwitchHandshakeHandler.this.setState(new SlaveState());
        }
    }
}

@Override
void enterState() {
    if (OFSwitchManager.clearTablesOnEachTransitionToMaster) {
        log.info("Clearing flow tables of {} on upcoming transition to MASTER.", sw.getId().toString());
        clearAllTables();
    } else if (OFSwitchManager.clearTablesOnInitialConnectAsMaster && initialRole == null) { /* don't do it if we were slave first */
        initialRole = OFControllerRole.ROLE_MASTER;
        log.info("Clearing flow tables of {} on upcoming initial role as MASTER.", sw.getId().toString());
        clearAllTables();
    }

    sendBarrier(); /* Need to make sure the tables are clear before adding default flows */
    addDefaultFlows();

    /*
     * We also need a barrier between adding flows and notifying modules of the
     * transition to master. Some modules might modify the flow tables and expect 
     * the clear/default flow operations above to have completed.
     */
    sendBarrier();

    setSwitchStatus(SwitchStatus.MASTER);
}

@Override
public synchronized void notifyPortChanged(IOFSwitchBackend sw,
        OFPortDesc port,
        PortChangeType changeType) {
    Preconditions.checkNotNull(sw, "switch must not be null");
    Preconditions.checkNotNull(port, "port must not be null");
    Preconditions.checkNotNull(changeType, "changeType must not be null");

    if (role != OFControllerRole.ROLE_MASTER) {
        counters.invalidPortsChanged.increment();
        return;
    }
    if (!this.switches.containsKey(sw.getId())) {
        counters.invalidPortsChanged.increment();
        return;
    }

    if(sw.getStatus().isVisible()) {
        // no need to count here. SwitchUpdate.dispatch will count
        // the portchanged
        SwitchUpdate update = new SwitchUpdate(sw.getId(),
                SwitchUpdateType.PORTCHANGED,
                port, changeType);
        addUpdateToQueue(update);
    }
}

@Override
@Test
public void moveToWaitInitialRole() throws Exception {
    moveToWaitAppHandshakeState();
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(WaitAppHandshakeState.class));

    reset(sw);
    expect(sw.getAttribute(IOFSwitchBackend.SWITCH_SUPPORTS_NX_ROLE)).andReturn(true).anyTimes();
    replay(sw);

    reset(roleManager);
    expect(roleManager.getOFControllerRole()).andReturn(OFControllerRole.ROLE_MASTER).anyTimes();
    roleManager.notifyControllerConnectionUpdate();
    expectLastCall().once();
    replay(roleManager);

    WaitAppHandshakeState state = (WaitAppHandshakeState) switchHandler.getStateForTesting();
    state.enterNextPlugin();

    // Expect wait initial role's enterState message to be written
    OFMessage msg = connection.retrieveMessage();
    assertThat(msg, CoreMatchers.instanceOf(OFRoleRequest.class));
    verifyUniqueXids(msg);

    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitInitialRoleState.class));
}

/**
 * This test ensures that the switch accurately determined if another master
 * exists in the cluster by examining the controller connections it has.
 */
@Test
public void testHasAnotherMaster() {
    URI cokeUri = URIUtil.createURI("1.2.3.4", 6653);
    InetSocketAddress address = (InetSocketAddress) sw.getConnection(OFAuxId.MAIN).getLocalInetAddress();
    URI pepsiUri = URIUtil.createURI(address.getHostName(), address.getPort());

    updateControllerConnections(sw, OFControllerRole.ROLE_SLAVE, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, cokeUri.toString(),
            OFControllerRole.ROLE_MASTER, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, pepsiUri.toString());

    // From the perspective of pepsi, the cluster currently does NOT have another master controller
    assertFalse(sw.hasAnotherMaster());

    // Switch the controller connections so that pepsi is no longer master
    updateControllerConnections(sw, OFControllerRole.ROLE_MASTER, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, cokeUri.toString(),
            OFControllerRole.ROLE_SLAVE, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, pepsiUri.toString());

    // From the perspective of pepsi, the cluster currently has another master controller
    assertTrue(sw.hasAnotherMaster());
}

/**
 * Setup the mock switch and write capture for a role request, set the
 * role and verify mocks.
 * @param supportsNxRole whether the switch supports role request messages
 * to setup the attribute. This must be null (don't yet know if roles
 * supported: send to check) or true.
 * @param role The role to send
 * @throws IOException
 */
private long setupSwitchSendRoleRequestAndVerify(Boolean supportsNxRole,
        OFControllerRole role) throws IOException {
    assertTrue("This internal test helper method most not be called " +
            "with supportsNxRole==false. Test setup broken",
            supportsNxRole == null || supportsNxRole == true);
    reset(sw);
    expect(sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
    .andReturn(supportsNxRole).atLeastOnce();
    replay(sw);

    switchHandler.sendRoleRequest(role);

    OFMessage msg = connection.retrieveMessage();
    verifyRoleRequest(msg, role);
    verify(sw);
    return msg.getXid();
}

@Override
@Test
public void moveToWaitInitialRole()
        throws Exception {
    moveToWaitAppHandshakeState();

    assertThat(switchHandler.getStateForTesting(),
               CoreMatchers.instanceOf(WaitAppHandshakeState.class));

    reset(sw);
    expect(sw.getAttribute(IOFSwitchBackend.SWITCH_SUPPORTS_NX_ROLE)).andReturn(true).anyTimes();
    replay(sw);

    reset(roleManager);
    expect(roleManager.getOFControllerRole()).andReturn(OFControllerRole.ROLE_MASTER).anyTimes();
    replay(roleManager);

    WaitAppHandshakeState state = (WaitAppHandshakeState) switchHandler.getStateForTesting();
    PluginResult result = new PluginResult(PluginResultType.CONTINUE);
    state.exitPlugin(result);

    assertThat(connection.retrieveMessage(), instanceOf(getRoleRequestClass()));
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitInitialRoleState.class));
}

private static OFControllerRole parseRole(String role) {
    if (role == null || role.isEmpty()) {
        return OFControllerRole.ROLE_NOCHANGE;
    } 

    role = role.toUpperCase();      

    if (role.contains(STR_ROLE_MASTER)) {
        return OFControllerRole.ROLE_MASTER;
    } else if (role.contains(STR_ROLE_SLAVE)) {
        return OFControllerRole.ROLE_SLAVE;
    } else if (role.contains(STR_ROLE_EQUAL) || role.contains(STR_ROLE_OTHER)) {
        return OFControllerRole.ROLE_EQUAL;
    } else {
        return OFControllerRole.ROLE_NOCHANGE;
    }
}

/**
 * Send a role request with the given role to the switch.
 *
 * Send a role request with the given role to the switch and update
 * the pending request and timestamp.
 *
 * @param role
 * @throws IOException
 */
synchronized void sendRoleRequest(OFControllerRole role, long xid) throws IOException {
    /*
     * There are three cases to consider for SUPPORTS_NX_ROLE:
     *
     * 1) unset. We have neither received a role reply from the
     *    switch nor has a request timed out. Send a request.
     * 2) TRUE: We've already send a request earlier and received
     *    a reply. The switch supports role and we should send one.
     * 3) FALSE: We have already send a role and received an error.
     *    The switch does not support roles. Don't send a role request,
     *    set the switch's role directly.
     */
    Boolean supportsNxRole = (Boolean)
            sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE);
    if ((supportsNxRole != null) && !supportsNxRole) {
        setSwitchRole(role, RoleRecvStatus.UNSUPPORTED);
    } else {
        pendingXid = sendNiciraRoleRequest(role, xid);
        pendingRole = role;
        this.roleSubmitTimeNs = System.nanoTime();
        requestPending = true;
    }
}

/**
 * Set the role for this switch / channel.
 *
 * If the status indicates that we received a reply we set the role.
 * If the status indicates otherwise we disconnect the switch if
 * the role is SLAVE.
 *
 * "Setting a role" means setting the appropriate ChannelState,
 * setting the flags on the switch and
 * notifying Controller.java about new role of the switch
 *
 * @param role The role to set.
 * @param status How we derived at the decision to set this status.
 */
synchronized private void setSwitchRole(OFControllerRole role, RoleRecvStatus status) {
    requestPending = false;
    if (status == RoleRecvStatus.RECEIVED_REPLY)
        sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, true);
    else
        sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, false);
    sw.setControllerRole(role);

    if (role != OFControllerRole.ROLE_SLAVE) {
        OFSwitchHandshakeHandler.this.setState(new MasterState());
    } else {
        if (status != RoleRecvStatus.RECEIVED_REPLY) {
            if (log.isDebugEnabled()) {
                log.debug("Disconnecting switch {}. Doesn't support role"
                        + "({}) request and controller is now SLAVE",
                        getSwitchInfoString(), status);
            }
            // the disconnect will trigger a switch removed to
            // controller so no need to signal anything else
            sw.disconnect();
        } else {
            OFSwitchHandshakeHandler.this.setState(new SlaveState());
        }
    }
}

/**
 * Test interaction with OFChannelHandler when the current role is
 * master.
 */
@Test
public void testChannelHandlerMaster() {
    OFSwitchHandshakeHandler h = createMock(OFSwitchHandshakeHandler.class);

    // Reassert the role.
    reset(h);
    h.sendRoleRequestIfNotPending(OFControllerRole.ROLE_MASTER);
    replay(h);
    controller.reassertRole(h, HARole.ACTIVE);
    verify(h);

    // reassert a different role: no-op
    reset(h);
    replay(h);
    controller.reassertRole(h, HARole.STANDBY);
    verify(h);
}

@Override
@LogMessageDoc(level="WARN",
message="Received PacketIn from switch {} while" +
        "being slave. Reasserting slave role.",
        explanation="The switch has receive a PacketIn despite being " +
                "in slave role indicating inconsistent controller roles",
                recommendation="This situation can occurs transiently during role" +
                        " changes. If, however, the condition persists or happens" +
                        " frequently this indicates a role inconsistency. " +
                        LogMessageDoc.CHECK_CONTROLLER )
void processOFPacketIn(OFPacketIn m) {
    // we don't expect packetIn while slave, reassert we are slave
    switchManagerCounters.packetInWhileSwitchIsSlave.increment();
    log.warn("Received PacketIn from switch {} while" +
            "being slave. Reasserting slave role.", sw);
    reassertRole(OFControllerRole.ROLE_SLAVE);
}

/**
 * This test ensures that the switch accurately determined if another master
 * exists in the cluster by examining the controller connections it has.
 */
@Test
public void testHasAnotherMaster() {
    URI cokeUri = URIUtil.createURI("1.2.3.4", 6653);
    InetSocketAddress address = (InetSocketAddress) sw.getConnection(OFAuxId.MAIN).getLocalInetAddress();
    URI pepsiUri = URIUtil.createURI(address.getHostName(), address.getPort());

    updateControllerConnections(sw, OFControllerRole.ROLE_SLAVE, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, cokeUri.toString(),
                                OFControllerRole.ROLE_MASTER, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, pepsiUri.toString());

    // From the perspective of pepsi, the cluster currently does NOT have another master controller
    assertFalse(sw.hasAnotherMaster());

    // Switch the controller connections so that pepsi is no longer master
    updateControllerConnections(sw, OFControllerRole.ROLE_MASTER, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, cokeUri.toString(),
                                OFControllerRole.ROLE_SLAVE, OFBsnControllerConnectionState.BSN_CONTROLLER_CONNECTION_STATE_CONNECTED, pepsiUri.toString());

    // From the perspective of pepsi, the cluster currently has another master controller
    assertTrue(sw.hasAnotherMaster());
}

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;
}

@Override
protected OFMessage getRoleReply(long xid, OFControllerRole role) {
    OFRoleReply roleReply = factory.buildRoleReply()
            .setXid(xid)
            .setRole(role)
            .build();
    return roleReply;
}

/** Move the channel from scratch to SLAVE state
 * Builds on doMoveToWaitInitialRole()
 * adds testing for WAIT_INITAL_ROLE state
 *
 * This method tests only the simple case that the switch supports roles
 * and transitions to SLAVE
 */
@Test
public void testInitialMoveToSlaveWithRole() throws Exception {

    // first, move us to WAIT_INITIAL_ROLE_STATE
    moveToWaitInitialRole();
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitInitialRoleState.class));

    // Set the role
    long xid = setupSwitchSendRoleRequestAndVerify(null, OFControllerRole.ROLE_SLAVE);
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitInitialRoleState.class));

    // prepare mocks and inject the role reply message
    reset(sw);
    sw.setAttribute(IOFSwitchBackend.SWITCH_SUPPORTS_NX_ROLE, true);
    expectLastCall().once();
    sw.setControllerRole(OFControllerRole.ROLE_SLAVE);
    expectLastCall().once();
    expect(sw.getStatus()).andReturn(SwitchStatus.HANDSHAKE).once();
    sw.setStatus(SwitchStatus.SLAVE);
    expectLastCall().once();
    replay(sw);

    reset(switchManager);
    switchManager.switchStatusChanged(sw, SwitchStatus.HANDSHAKE, SwitchStatus.SLAVE);
    expectLastCall().once();
    replay(switchManager);

    OFMessage reply = getRoleReply(xid, OFControllerRole.ROLE_SLAVE);

    // sendMessageToHandler will verify and rest controller mock
    switchHandler.processOFMessage(reply);

    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.SlaveState.class));
}

public void serializeHarole(OFControllerRole role, JsonGenerator jGen)
        throws IOException, JsonProcessingException {
    if ( null == role )
        jGen.writeStringField("harole","null");
    else
        jGen.writeStringField("harole",HARole.ofOFRole(role).toString());
}

/** Move channel from scratch to WAIT_INITIAL_STATE, then MASTER,
 * then SLAVE for cases where the switch does not support roles.
 * I.e., the final SLAVE transition should disconnect the switch.
 */
@Test
public void testNoRoleInitialToMasterToSlave() throws Exception {
    int xid = 46;
    // First, lets move the state to MASTER without role support
    testInitialMoveToMasterNoRole();
    assertThat(switchHandler.getStateForTesting(),
            CoreMatchers.instanceOf(OFSwitchHandshakeHandler.MasterState.class));

    assertThat("Unexpected messages have been captured",
            connection.getMessages(),
             Matchers.empty());

    // try to set master role again. should be a no-op
    setupSwitchRoleChangeUnsupported(xid, OFControllerRole.ROLE_MASTER);
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.MasterState.class));

    assertThat("Unexpected messages have been captured",
            connection.getMessages(),
             Matchers.empty());

    setupSwitchRoleChangeUnsupported(xid, OFControllerRole.ROLE_SLAVE);
    assertThat(connection.isConnected(), equalTo(false));

    assertThat("Unexpected messages have been captured",
            connection.getMessages(),
             Matchers.empty());
}

/**
 * Deliver a received role reply and set SWITCH_SUPPORTS_NX_ROLE.
 *
 * Check if a request is pending and if the received reply matches the
 * the expected pending reply (we check both role and xid) we set
 * the role for the switch/channel.
 *
 * If a request is pending but doesn't match the reply we ignore it.
 *
 * If no request is pending we disconnect.
 *
 * @param xid
 * @param role
 * @throws SwitchStateException if no request is pending
 */
synchronized void deliverRoleReply(long xid, OFControllerRole role) {
    log.debug("DELIVERING ROLE REPLY {}", role.toString());
    if (!requestPending) {
        // Maybe don't disconnect if the role reply we received is
        // for the same role we are already in.
        String msg = String.format("Switch: [%s], State: [%s], "
                + "received unexpected RoleReply[%s]. "
                + "No roles are pending",
                OFSwitchHandshakeHandler.this.getSwitchInfoString(),
                OFSwitchHandshakeHandler.this.state.toString(),
                role);
        throw new SwitchStateException(msg);
    }

    if (pendingXid == xid && pendingRole == role) {
        log.debug("[{}] Received role reply message setting role to {}",
                getDpid(), role);
        switchManagerCounters.roleReplyReceived.increment();
        setSwitchRole(role, RoleRecvStatus.RECEIVED_REPLY);
    } else {
        log.debug("[{}] Received stale or unexpected role reply " +
                "{}, xid={}. Ignoring. " +
                "Waiting for {}, xid={}",
                new Object[] { getDpid(), role, xid,
                pendingRole, pendingXid });
    }
}

@Override
void processOFExperimenter(OFExperimenter m) {
    OFControllerRole role = extractNiciraRoleReply(m);
    // If role == null it means the message wasn't really a
    // Nicira role reply. We ignore just dispatch it to the
    // OFMessage listenersa in this case.
    if (role != null) {
        roleChanger.deliverRoleReply(m.getXid(), role);
    } else {
        dispatchMessage(m);
    }
}

@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());
}

@Override
void enterState() {
    setSwitchStatus(SwitchStatus.SLAVE);
    if (initialRole == null) {
        initialRole = OFControllerRole.ROLE_SLAVE;
    }
}

@Override
void processOFExperimenter(OFExperimenter m) {
    OFControllerRole role = extractNiciraRoleReply(m);
    // If role == null it means the message wasn't really a
    // Nicira role reply. We ignore it.
    if (role != null) {
        roleChanger.deliverRoleReply(m.getXid(), role);
    } else {
        unhandledMessageReceived(m);
    }
}

@Override
void processOFPacketIn(OFPacketIn m) {
    // we don't expect packetIn while slave, reassert we are slave
    switchManagerCounters.packetInWhileSwitchIsSlave.increment();
    log.warn("Received PacketIn from switch {} while" +
            "being slave. Reasserting slave role.", sw);
    reassertRole(OFControllerRole.ROLE_SLAVE);
}

/**
 * Forwards to RoleChanger. See there.
 * @param role
 */
void sendRoleRequestIfNotPending(OFControllerRole role) {
    try {
        roleChanger.sendRoleRequestIfNotPending(role, 0);
    } catch (IOException e) {
        log.error("Disconnecting switch {} due to IO Error: {}",
                getSwitchInfoString(), e.getMessage());
        mainConnection.disconnect();
    }
}

/**
 * Forwards to RoleChanger. See there.
 * @param role
 */
void sendRoleRequest(OFControllerRole role) {
    try {
        roleChanger.sendRoleRequest(role, 0);
    } catch (IOException e) {
        log.error("Disconnecting switch {} due to IO Error: {}",
                getSwitchInfoString(), e.getMessage());
        mainConnection.disconnect();
    }
}

public static OFControllerRole niciraToOFRole(OFNiciraControllerRoleReply roleReply) {
    switch(roleReply.getRole()) {
        case ROLE_MASTER:
            return OFControllerRole.ROLE_MASTER;
        case ROLE_OTHER:
            return OFControllerRole.ROLE_EQUAL;
        case ROLE_SLAVE:
            return OFControllerRole.ROLE_SLAVE;
        default:
            throw new IllegalArgumentException("unknown Nicira role value: " + roleReply.getRole());
    }
}

/** Move the channel to SLAVE state
 * Expects that the channel is in MASTER or SLAVE state.
 *
 */
public void changeRoleToSlaveWithRequest() throws Exception {
    assertTrue("This method can only be called when handler is in " +
               "MASTER or SLAVE role", switchHandler.isHandshakeComplete());

    // Set the role
    long xid = setupSwitchSendRoleRequestAndVerify(true, OFControllerRole.ROLE_SLAVE);

    // prepare mocks and inject the role reply message
    reset(sw);
    sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, true);
    expectLastCall().once();
    sw.setControllerRole(OFControllerRole.ROLE_SLAVE);
    expectLastCall().once();
    expect(sw.getStatus()).andReturn(SwitchStatus.MASTER).once();
    sw.setStatus(SwitchStatus.SLAVE);
    expectLastCall().once();
    replay(sw);

    reset(switchManager);
    switchManager.switchStatusChanged(sw, SwitchStatus.MASTER, SwitchStatus.SLAVE);
    expectLastCall().once();
    replay(switchManager);

    OFMessage reply = getRoleReply(xid, OFControllerRole.ROLE_SLAVE);
    connection.getListener().messageReceived(connection, reply);

    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.SlaveState.class));
}

/**
    * Setup the mock switch for a role change request where the switch
    * does not support roles.
    *
    * Needs to verify and reset the controller since we need to set
    * an expectation
    */
   @SuppressWarnings("unchecked")
private void setupSwitchRoleChangeUnsupported(int xid,
                                                 OFControllerRole role) {
       SwitchStatus newStatus = role != OFControllerRole.ROLE_SLAVE ? SwitchStatus.MASTER : SwitchStatus.SLAVE;
       boolean supportsNxRole = false;
       verify(switchManager);
       reset(sw, switchManager);
       expect(sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
               .andReturn(supportsNxRole).atLeastOnce();
       // TODO: hmmm. While it's not incorrect that we set the attribute
       // again it looks odd. Maybe change
       expect(sw.getOFFactory()).andReturn(factory).anyTimes();
       sw.write(anyObject(OFMessage.class));
       expectLastCall().anyTimes();
       sw.write(anyObject(Iterable.class));
       expectLastCall().anyTimes();
       expect(sw.getTables()).andStubReturn((short)0);
       sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, supportsNxRole);
       expectLastCall().anyTimes();
       sw.setControllerRole(role);
       expectLastCall().once();

       if (role == OFControllerRole.ROLE_SLAVE) {
           sw.disconnect();
           expectLastCall().once();
       } else {
           expect(sw.getStatus()).andReturn(SwitchStatus.HANDSHAKE).once();
           sw.setStatus(newStatus);
           expectLastCall().once();
           switchManager.switchStatusChanged(sw, SwitchStatus.HANDSHAKE, newStatus);
       }
       replay(sw, switchManager);

       switchHandler.sendRoleRequest(role);

       verify(sw, switchManager);
   }

@Test
public void testMasterSlaveWrites() {
    OFFactory factory = OFFactories.getFactory(OFVersion.OF_13);
    OFFlowAdd fa = factory.buildFlowAdd().build();
    OFFlowStatsRequest fsr = factory.buildFlowStatsRequest().build();
    List<OFMessage> msgList = new ArrayList<OFMessage>();
    msgList.add(fa);
    msgList.add(fsr);

    reset(switchManager);
       expect(switchManager.isCategoryRegistered(LogicalOFMessageCategory.MAIN)).andReturn(true).times(6);
       switchManager.handleOutgoingMessage(sw, fa);
       expectLastCall().times(2);
       switchManager.handleOutgoingMessage(sw, fsr);
       expectLastCall().times(4);
       replay(switchManager);

    /* test master -- both messages should be written */
    sw.setControllerRole(OFControllerRole.ROLE_MASTER);
    assertTrue(sw.write(fa));
    assertTrue(sw.write(fsr));
    assertEquals(Collections.<OFMessage>emptyList(), sw.write(msgList));

    /* test slave -- flow-add (mod op) should fail each time; flow stats (read op) should pass */
    sw.setControllerRole(OFControllerRole.ROLE_SLAVE);
    assertFalse(sw.write(fa)); /* flow-add should be stopped (mod op) */
    assertTrue(sw.write(fsr)); /* stats request makes it (read op) */
    assertEquals(Collections.<OFMessage>singletonList(fa), sw.write(msgList)); /* return bad flow-add */
}

@Override
protected OFMessage getRoleReply(long xid, OFControllerRole role) {
    OFRoleReply roleReply = factory.buildRoleReply()
            .setXid(xid)
            .setRole(role)
            .build();
    return roleReply;
}

/** Move the channel from scratch to SLAVE state
 * Builds on doMoveToWaitInitialRole()
 * adds testing for WAIT_INITAL_ROLE state
 *
 * We let the initial role request time out. The switch should be
 * disconnected
 */
@Test
public void testInitialMoveToSlaveTimeout() throws Exception {
    int timeout = 50;
    switchHandler.useRoleChangerWithOtherTimeoutForTesting(timeout);

    // first, move us to WAIT_INITIAL_ROLE_STATE
    moveToWaitInitialRole();
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitInitialRoleState.class));

    // Set the role
    setupSwitchSendRoleRequestAndVerify(null, OFControllerRole.ROLE_SLAVE);
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitInitialRoleState.class));

    // prepare mocks and inject the role reply message
    reset(sw);
    sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, false);
    expectLastCall().once();
    sw.setControllerRole(OFControllerRole.ROLE_SLAVE);
    expectLastCall().once();
    sw.disconnect(); // Make sure we disconnect
    expectLastCall().once();
    replay(sw);

    // Apparently this can be any type of message for this test?!
    OFMessage m = factory.buildBarrierReply().build();

    Thread.sleep(timeout+5);
    switchHandler.processOFMessage(m);
}

/**
 * Start as SLAVE then set role to MASTER
 * Tests normal role change transition. Check that connected channels
 * receive a setRole request
 */
@Test
public void testSetRole() throws Exception {
    doSetUp(HARole.STANDBY);
    RoleInfo info = controller.getRoleInfo();
    assertEquals(HARole.STANDBY, info.getRole());
    assertEquals(HARole.STANDBY, controller.getRole());


    OFSwitchHandshakeHandler h = createMock(OFSwitchHandshakeHandler.class);

    // Reassert the role.
    reset(h);
    h.sendRoleRequestIfNotPending(OFControllerRole.ROLE_SLAVE);
    replay(h);
    controller.reassertRole(h, HARole.STANDBY);
    verify(h);

    // reassert a different role: no-op
    reset(h);
    replay(h);
    controller.reassertRole(h, HARole.ACTIVE);
    verify(h);

    IHAListener listener = createMock(IHAListener.class);
    expect(listener.getName()).andReturn("foo").anyTimes();
    setupListenerOrdering(listener);
    listener.transitionToActive();
    expectLastCall().once();
    replay(listener);
    controller.addHAListener(listener);
    controller.setRole(HARole.ACTIVE, "FooBar");
    controller.processUpdateQueueForTesting();
    verify(listener);
    info = controller.getRoleInfo();
    assertEquals(HARole.ACTIVE, info.getRole());
    assertEquals("FooBar", info.getRoleChangeDescription());
    assertEquals(HARole.ACTIVE, controller.getRole());
}

/** write a request which triggers an OFErrorMsg response */
@Test(timeout = 5000)
public void testWriteRequestOFErrorMsg() throws InterruptedException, ExecutionException {
    Capture<List<OFMessage>> cMsgList = prepareChannelForWriteList();

    OFRoleRequest roleRequest = factory.buildRoleRequest().setRole(OFControllerRole.ROLE_MASTER).build();
    ListenableFuture<OFRoleReply> future = conn.writeRequest(roleRequest);
    assertThat("Connection should have 1 pending request",
            conn.getPendingRequestIds().size(), equalTo(1));

    eventLoop.runTasks();
    assertThat("Should have captured MsgList", cMsgList.getValue(),
            Matchers.<OFMessage> contains(roleRequest));

    assertThat("Future should not be complete yet", future.isDone(), equalTo(false));
    OFRoleRequestFailedErrorMsg roleError = factory.errorMsgs().buildRoleRequestFailedErrorMsg()
        .setXid(roleRequest.getXid())
        .setCode(OFRoleRequestFailedCode.STALE)
        .build();

    assertThat("Connection should have accepted the response",
            conn.deliverResponse(roleError),
            equalTo(true));

    OFErrorMsgException e =
            FutureTestUtils.assertFutureFailedWithException(future,
                    OFErrorMsgException.class);
    assertThat(e.getErrorMessage(), CoreMatchers.<OFErrorMsg>equalTo(roleError));
}

@Test
public void testSetHARoleReply() {
    sw.setControllerRole(OFControllerRole.ROLE_MASTER);
    assertEquals(OFControllerRole.ROLE_MASTER, sw.getControllerRole());

    sw.setControllerRole(OFControllerRole.ROLE_EQUAL);
    assertEquals(OFControllerRole.ROLE_EQUAL, sw.getControllerRole());

    sw.setControllerRole(OFControllerRole.ROLE_SLAVE);
    assertEquals(OFControllerRole.ROLE_SLAVE, sw.getControllerRole());
}

/**
 * Helper to load controller connection messages into a switch for testing.
 * @param sw the switch to insert the message on
 * @param role the role for the controller connection message
 * @param state the state for the controller connection message
 * @param uri the URI for the controller connection message
 */
public void updateControllerConnections(IOFSwitchBackend sw, OFControllerRole role1, OFBsnControllerConnectionState state1, String uri1
        ,  OFControllerRole role2, OFBsnControllerConnectionState state2, String uri2) {
    OFBsnControllerConnection connection1 = factory.buildBsnControllerConnection()
            .setAuxiliaryId(OFAuxId.MAIN)
            .setRole(role1)
            .setState(state1)
            .setUri(uri1)
            .build();

    OFBsnControllerConnection connection2 = factory.buildBsnControllerConnection()
            .setAuxiliaryId(OFAuxId.MAIN)
            .setRole(role2)
            .setState(state2)
            .setUri(uri2)
            .build();

    List<OFBsnControllerConnection> connections = new ArrayList<OFBsnControllerConnection>();
    connections.add(connection1);
    connections.add(connection2);

    OFBsnControllerConnectionsReply reply = factory.buildBsnControllerConnectionsReply()
            .setConnections(connections)
            .build();

    sw.updateControllerConnections(reply);
}