Examples with IdNamePair - com.linkedin.databus.core.util.IdNamePair

Example 46 with IdNamePair

use of com.linkedin.databus.core.util.IdNamePair in project databus by linkedin.

the class MockRemoteExceptionHandler method testRelayTransition.

@Test(groups = { "small", "functional" })
public void testRelayTransition() throws Exception {
    final Logger log = Logger.getLogger("TestRelayPullThread.testRelayTransition");
    log.info("---------- start ---------------");
    // Test Case : Initial State Check
    {
        RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
        //RelayPullThread relayPuller = createRelayPullThread(false, false);
        RelayPullThread relayPuller = bldr.createRelayPullThread();
        Assert.assertEquals(relayPuller.getConnectionState().getStateId(), StateId.INITIAL, "Initial State Check");
        //Let the show begin
        Thread relayPullerThread = new Thread(relayPuller);
        relayPullerThread.setDaemon(false);
        relayPullerThread.start();
        relayPuller.enqueueMessage(LifecycleMessage.createStartMessage());
        try {
            Thread.sleep(500);
        } catch (InterruptedException ie) {
        }
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(5);
                Assert.assertTrue(relayPuller.getConnectionState().getStateId() != StateId.INITIAL, "StateId can never be INITIAL once started");
            } catch (InterruptedException ie) {
            }
        }
        //EasyMock.verify(mockConnFactory);
        relayPuller.enqueueMessage(LifecycleMessage.createShutdownMessage());
        relayPuller.awaitShutdown();
    }
    // Main Transition Test (Without Server-Set Change)
    {
        // PICK_SERVER - Happy Path
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
        }
        // PICK_SERVER  - Relays exhausted
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(true, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.PICK_SERVER, "SUSPEND_ON_ERROR");
        }
        // PICK_SERVER  - No Servers
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            relayPuller.getServers().clear();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.PICK_SERVER, "SUSPEND_ON_ERROR");
        }
        // Request_Sources to Re Sources_Request_Sent
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
        }
        // Request_Sources to Sources_Response_Success
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
        }
        // Sources_Response_Success - Happy Path
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            validateConnState(connState);
            String expSubsListStr = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"ANY\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":1,\"name\":\"source1\"},\"id\":-1}}]";
            String expSourcesIdListStr = "1";
            Assert.assertEquals(connState.getSourcesIdListString(), expSourcesIdListStr, "SourcesId Added");
            String subsListStr = connState.getSubsListString();
            Assert.assertEquals(subsListStr, expSubsListStr);
        }
        // Sources_Response_Success - When source not found in server
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            connState.getSourcesNameMap().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.PICK_SERVER);
            validateConnState(connState);
        }
        // Request_Register to Register_Request_Sent
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            validateConnState(connState);
        }
        // Request_Register to Register_Response_success
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
        }
        // Register_Response_Success : Error Case
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            connState.getSourcesSchemas().clear();
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.PICK_SERVER);
        }
        // Register_Response_Success to Request Stream
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            Assert.assertEquals(relayPuller.getConnectionState().isSCNRegress(), false, "SCN Regress check");
        }
        // Register_Response_Success to Request Stream, when partially consumed window
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            Checkpoint cp = new Checkpoint();
            cp.setConsumptionMode(DbusClientMode.ONLINE_CONSUMPTION);
            cp.setWindowScn(100L);
            cp.setWindowOffset(20);
            cp.setPrevScn(80L);
            relayPuller.getConnectionState().setCheckpoint(cp);
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            Assert.assertEquals(relayPuller.getConnectionState().getCheckpoint().getWindowScn(), 80L, "WindowSCN check");
            Assert.assertEquals(relayPuller.getConnectionState().getCheckpoint().getWindowOffset(), new Long(-1), "WindowOffset check");
            Assert.assertEquals(relayPuller.getConnectionState().isSCNRegress(), true, "SCN Regress check");
        }
        // Register_Response_Success, No PrevSCN for partially consumed window
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            Checkpoint cp = new Checkpoint();
            cp.setConsumptionMode(DbusClientMode.ONLINE_CONSUMPTION);
            cp.setWindowScn(100L);
            cp.setWindowOffset(20);
            relayPuller.getConnectionState().setCheckpoint(cp);
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REGISTER_RESPONSE_SUCCESS, "SUSPEND_ON_ERROR");
        }
        // Register_Response_Success to Bootstrap ( when checkpoint is Bootstrap_SnapShot
        {
            //RelayPullThread relayPuller = createRelayPullThread(false, false, true);
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Is Relay FellOff");
            Checkpoint cp = new Checkpoint();
            cp.setConsumptionMode(DbusClientMode.BOOTSTRAP_SNAPSHOT);
            connState.setCheckpoint(cp);
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.BOOTSTRAP);
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            Assert.assertEquals(relayPuller.getConnectionState().isSCNRegress(), false, "SCN Regress check");
        }
        // Register_Response_Success to Bootstrap ( when checkpoint is Bootstrap_Catchup
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Is Relay FellOff");
            Checkpoint cp = new Checkpoint();
            cp.setConsumptionMode(DbusClientMode.BOOTSTRAP_CATCHUP);
            connState.setCheckpoint(cp);
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.BOOTSTRAP);
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            Assert.assertEquals(relayPuller.getConnectionState().isSCNRegress(), false, "SCN Regress check");
        }
        // Request_Stream to Request_Stream_Sent
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            relayPuller.getMessageQueue().clear();
            MockRelayConnection conn = (MockRelayConnection) connState.getRelayConnection();
            connState.switchToRegisterSuccess(conn.getRegisterResponse(), conn.getRegisterResponse(), conn.getRegisterMetadataResponse());
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SENT, "");
            validateConnState(connState);
        }
        // Request_Stream to Stream_Response_Success
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
        }
        //Stream_Request_Success to Stream_Request_Done
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_RESPONSE_DONE);
        }
        //Stream_Request_Success : ScnNotFoundException but retries set to 5 and  bootstrap enabled
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName()).setNumRetriesOnFellOff(5);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            for (int i = 1; i <= 6; i++) {
                System.out.println("Iteration :" + i);
                testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
                relayPuller.getMessageQueue().clear();
                if (i < 6) {
                    testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.PICK_SERVER);
                    Assert.assertEquals(relayPuller.getRetryonFallOff().getRemainingRetriesNum(), 6 - i, "Retry State");
                } else {
                    testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
                    //reset
                    Assert.assertEquals(relayPuller.getRetryonFallOff().getRemainingRetriesNum(), 5, "Retry State");
                }
                relayPuller.getMessageQueue().clear();
            }
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "RelayFellOff State");
        }
        //Stream_Request_Success : ScnNotFoundException and  bootstrap enabled
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
        }
        //Stream_Request_Success : ScnNotFoundException but retries set to 5, bootstrap disabled and readLatestScnOnFallOff enabled.
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(false).setReadLatestScnEnabled(true).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName()).setNumRetriesOnFellOff(5);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            for (int i = 1; i <= 6; i++) {
                testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
                relayPuller.getMessageQueue().clear();
                if (i < 6) {
                    testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.PICK_SERVER);
                    Assert.assertEquals(relayPuller.getRetryonFallOff().getRemainingRetriesNum(), 6 - i, "Retry State");
                } else {
                    testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_RESPONSE_DONE);
                    //reset
                    Assert.assertEquals(relayPuller.getRetryonFallOff().getRemainingRetriesNum(), 5, "Retry State");
                }
                relayPuller.getMessageQueue().clear();
            }
            MockRelayConnection conn = (MockRelayConnection) connState.getRelayConnection();
            Assert.assertEquals(conn.isReadFromLatestScn(), true, "ReadFromLatestScn set");
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "RelayFellOff State");
        }
        //Stream_Request_Success : ScnNotFoundException, bootstrap disabled and readLatestScnOnFallOff enabled.
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(false).setReadLatestScnEnabled(true).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_RESPONSE_DONE);
            MockRelayConnection conn = (MockRelayConnection) connState.getRelayConnection();
            Assert.assertEquals(conn.isReadFromLatestScn(), true, "ReadFromLatestScn set");
        }
        //Stream_Request_Success : ScnNotFoundException but retries set to 5, bootstrap disabled and readLatestScnOnFallOff disabled.
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(false).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName()).setNumRetriesOnFellOff(5);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            for (int i = 1; i <= 6; i++) {
                testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
                relayPuller.getMessageQueue().clear();
                testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
                relayPuller.getMessageQueue().clear();
                if (i < 6) {
                    testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.PICK_SERVER);
                    Assert.assertEquals(relayPuller.getRetryonFallOff().getRemainingRetriesNum(), 6 - i, "Retry State");
                } else {
                    testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_REQUEST_SUCCESS, "SUSPEND_ON_ERROR");
                    //reset
                    Assert.assertEquals(relayPuller.getRetryonFallOff().getRemainingRetriesNum(), 5, "Retry State");
                }
                relayPuller.getMessageQueue().clear();
            }
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "RelayFellOff State");
        }
        //Stream_Request_Success : ScnNotFoundException, bootstrap disabled and readLatestScnOnFallOff disabled.
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(false).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_REQUEST_SUCCESS, "SUSPEND_ON_ERROR");
        }
        //Stream_Request_Success : Non-ScnNotFoundException
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName("DummyError");
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_RESPONSE_ERROR);
        }
        //Stream_Request_Done to Request_Stream
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_RESPONSE_DONE);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_RESPONSE_DONE, StateId.REQUEST_STREAM);
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Is Relay FellOff");
        }
        // Bootstrap to Bootstrap_Requested
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            testTransitionCase(relayPuller, StateId.BOOTSTRAP, StateId.BOOTSTRAP_REQUESTED, "");
        }
        //Exception while doBootstrap()
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(true).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Is Relay FellOff");
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            testTransitionCase(relayPuller, StateId.BOOTSTRAP, StateId.BOOTSTRAP, "SUSPEND_ON_ERROR");
        }
        // Bootstrap Failed : Case 1
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            testTransitionCase(relayPuller, StateId.BOOTSTRAP, StateId.BOOTSTRAP_REQUESTED, "");
            BootstrapResultMessage msg = BootstrapResultMessage.createBootstrapFailedMessage(new Exception("Dummy"));
            doExecuteAndChangeState(relayPuller, msg);
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            Assert.assertEquals(connState.getStateId(), StateId.BOOTSTRAP, "BOOTSTRAP_REQUESTED to BOOTSTRAP");
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [BOOTSTRAP]", "Queue :BOOTSTRAP_REQUESTED to BOOTSTRAP");
        }
        // Bootstrap Failed : Case 2
        {
            //RelayPullThread relayPuller = createRelayPullThread(false, false, true, false, false, true, ScnNotFoundException.class.getName());
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            testTransitionCase(relayPuller, StateId.BOOTSTRAP, StateId.BOOTSTRAP_REQUESTED, "");
            BootstrapResultMessage msg = BootstrapResultMessage.createBootstrapCompleteMessage(null);
            doExecuteAndChangeState(relayPuller, msg);
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            Assert.assertEquals(connState.getStateId(), StateId.BOOTSTRAP, "BOOTSTRAP_REQUESTED to BOOTSTRAP");
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [BOOTSTRAP]", "Queue :BOOTSTRAP_REQUESTED to BOOTSTRAP");
        }
        // Bootstrap Success
        {
            //RelayPullThread relayPuller = createRelayPullThread(false, false, true, false, false, true, ScnNotFoundException.class.getName());
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            relayPuller.getMessageQueue().clear();
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Is Relay FellOff");
            testTransitionCase(relayPuller, StateId.BOOTSTRAP, StateId.BOOTSTRAP_REQUESTED, "");
            BootstrapResultMessage msg = BootstrapResultMessage.createBootstrapCompleteMessage(new Checkpoint());
            doExecuteAndChangeState(relayPuller, msg);
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Is Relay FellOff");
            Assert.assertEquals(connState.getStateId(), StateId.REQUEST_STREAM, "BOOTSTRAP_REQUESTED to REQUEST_STREAM");
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [REQUEST_STREAM]", "Queue :BOOTSTRAP_REQUESTED to REQUEST_STREAM");
        }
        // Error States to Pick_Server
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            connState.switchToSourcesRequestError();
            testTransitionCase(relayPuller, StateId.SOURCES_REQUEST_ERROR, StateId.PICK_SERVER);
            relayPuller.getMessageQueue().clear();
            connState.switchToSourcesResponseError();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_ERROR, StateId.PICK_SERVER);
            relayPuller.getMessageQueue().clear();
            connState.switchToRegisterRequestError();
            testTransitionCase(relayPuller, StateId.REGISTER_REQUEST_ERROR, StateId.PICK_SERVER);
            relayPuller.getMessageQueue().clear();
            connState.switchToRegisterResponseError();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_ERROR, StateId.PICK_SERVER);
            relayPuller.getMessageQueue().clear();
            connState.switchToStreamRequestError();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_ERROR, StateId.PICK_SERVER);
            relayPuller.getMessageQueue().clear();
            connState.switchToStreamResponseError();
            testTransitionCase(relayPuller, StateId.STREAM_RESPONSE_ERROR, StateId.PICK_SERVER);
        }
    }
    log.info("--------- end -------------");
}

Also used : ArrayList(java.util.ArrayList) Logger(org.apache.log4j.Logger) Checkpoint(com.linkedin.databus.core.Checkpoint) InvalidEventException(com.linkedin.databus.core.InvalidEventException) ScnNotFoundException(com.linkedin.databus.core.ScnNotFoundException) DatabusException(com.linkedin.databus2.core.DatabusException) IOException(java.io.IOException) Checkpoint(com.linkedin.databus.core.Checkpoint) ScnNotFoundException(com.linkedin.databus.core.ScnNotFoundException) IdNamePair(com.linkedin.databus.core.util.IdNamePair) Test(org.testng.annotations.Test)

Example 47 with IdNamePair

use of com.linkedin.databus.core.util.IdNamePair in project databus by linkedin.

the class MockRemoteExceptionHandler method testRelayFailOver.

@Test(groups = { "small", "functional" })
public void testRelayFailOver() throws Exception {
    final Logger log = Logger.getLogger("TestRelayPullThread.testRelayFailOver");
    log.setLevel(Level.INFO);
    log.info("-------------- start -------------------");
    List<String> sources = Arrays.asList("source1");
    Properties clientProps = new Properties();
    clientProps.setProperty("client.runtime.bootstrap.enabled", "false");
    clientProps.setProperty("client.runtime.relay(1).name", "relay1");
    clientProps.setProperty("client.runtime.relay(1).port", "10001");
    clientProps.setProperty("client.runtime.relay(1).sources", "source1");
    clientProps.setProperty("client.runtime.relay(2).name", "relay2");
    clientProps.setProperty("client.runtime.relay(2).port", "10002");
    clientProps.setProperty("client.runtime.relay(2).sources", "source1");
    clientProps.setProperty("client.runtime.relay(3).name", "relay3");
    clientProps.setProperty("client.runtime.relay(3).port", "10003");
    clientProps.setProperty("client.runtime.relay(3).sources", "source1");
    clientProps.setProperty("client.connectionDefaults.eventBuffer.maxSize", "100000");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.maxRetryNum", "9");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.sleepIncFactor", "1.0");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.sleepIncDelta", "1");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.initSleep", "1");
    DatabusHttpClientImpl client = new DatabusHttpClientImpl("client.", clientProps);
    Assert.assertNotNull(client, "client instantiation ok");
    final DatabusHttpClientImpl.StaticConfig clientConf = client.getClientStaticConfig();
    final DatabusSourcesConnection.StaticConfig srcConnConf = clientConf.getConnectionDefaults();
    DatabusHttpClientImpl.RuntimeConfig clientRtConf = clientConf.getRuntime().build();
    DbusEventBuffer.StaticConfig bufferConf = clientConf.getConnectionDefaults().getEventBuffer();
    DbusEventBuffer relayBuffer = new DbusEventBuffer(bufferConf);
    DbusEventBuffer bootstrapBuffer = new DbusEventBuffer(bufferConf);
    //we keep the index of the next server we expect to see
    AtomicInteger serverIdx = new AtomicInteger(-1);
    Set<ServerInfo> relays = clientRtConf.getRelaysSet();
    //generate the order in which we should see the servers
    List<ServerInfo> relayOrder = new ArrayList<ServerInfo>(relays);
    if (log.isInfoEnabled()) {
        StringBuilder sb = new StringBuilder();
        for (ServerInfo serverInfo : relayOrder) {
            sb.append(serverInfo.getName());
            sb.append(" ");
        }
        log.info("Relay order:" + sb.toString());
    }
    //This guy always fails on /sources
    final MockRelayConnection mockFailConn = new MockRelayConnection(null, null, null, serverIdx);
    List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
    sourcesResponse.add(new IdNamePair(1L, "source1"));
    //This guy succeeds on /sources but fails on /register
    final MockRelayConnection mockSuccessConn = new MockRelayConnection(sourcesResponse, null, null, serverIdx);
    DatabusRelayConnectionFactory mockConnFactory = EasyMock.createMock("mockRelayFactory", DatabusRelayConnectionFactory.class);
    //each server should be tried MAX_RETRIES time until all retries are exhausted
    for (int i = 0; i < clientConf.getConnectionDefaults().getPullerRetries().getMaxRetryNum() / 3; ++i) {
        EasyMock.expect(mockConnFactory.createRelayConnection(serverNameMatcher(serverIdx, relayOrder), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andReturn(mockFailConn);
        EasyMock.expect(mockConnFactory.createRelayConnection(serverNameMatcher(serverIdx, relayOrder), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andReturn(mockFailConn);
        EasyMock.expect(mockConnFactory.createRelayConnection(serverNameMatcher(serverIdx, relayOrder), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andReturn(mockSuccessConn);
    }
    EasyMock.replay(mockConnFactory);
    List<DatabusSubscription> sourcesSubList = DatabusSubscription.createSubscriptionList(sources);
    //Dummy connection object as expected by the puller thread
    // Note that in this case, it is ok to pass Set<relays> as all the relays serve the same source
    //"source1"
    ConnectionStateFactory connStateFactory = new ConnectionStateFactory(sources);
    DatabusSourcesConnection sourcesConn = new DatabusSourcesConnection(srcConnConf, sourcesSubList, relays, null, null, null, relayBuffer, bootstrapBuffer, Executors.newCachedThreadPool(), null, null, null, null, null, null, null, mockConnFactory, null, null, null, null, new DbusEventV1Factory(), connStateFactory);
    final RelayPullThread relayPuller = new RelayPullThread("RelayPuller", sourcesConn, relayBuffer, connStateFactory, relays, new ArrayList<DbusKeyCompositeFilterConfig>(), !clientConf.getRuntime().getBootstrap().isEnabled(), clientConf.isReadLatestScnOnErrorEnabled(), clientConf.getPullerBufferUtilizationPct(), Integer.MAX_VALUE, ManagementFactory.getPlatformMBeanServer(), new DbusEventV1Factory(), null);
    RemoteExceptionHandler mockRemoteExceptionHandler = new MockRemoteExceptionHandler(sourcesConn, relayBuffer, relayPuller);
    Field field = relayPuller.getClass().getDeclaredField("_remoteExceptionHandler");
    field.setAccessible(true);
    field.set(relayPuller, mockRemoteExceptionHandler);
    mockFailConn.setCallback(relayPuller);
    mockSuccessConn.setCallback(relayPuller);
    //Let the show begin
    Thread relayPullerThread = new Thread(relayPuller);
    relayPullerThread.setDaemon(true);
    relayPullerThread.start();
    relayPuller.enqueueMessage(LifecycleMessage.createStartMessage());
    TestUtil.assertWithBackoff(new ConditionCheck() {

        @Override
        public boolean check() {
            return mockFailConn.getSourcesCallCounter() == 6;
        }
    }, "failConn: correct number of /sources", 500, log);
    Assert.assertEquals(mockFailConn.getRegisterCallCounter(), 0, "failConn: correct number of /register");
    Assert.assertEquals(mockFailConn.getStreamCallCounter(), 0, "failConn: correct number of /stream");
    TestUtil.assertWithBackoff(new ConditionCheck() {

        @Override
        public boolean check() {
            return mockSuccessConn.getSourcesCallCounter() == 3;
        }
    }, "successConn: correct number of /sources", 500, log);
    Assert.assertEquals(mockSuccessConn.getRegisterCallCounter(), 3, "successConn: correct number of /register");
    Assert.assertEquals(mockSuccessConn.getStreamCallCounter(), 0, "successConn: correct number of /stream");
    TestUtil.assertWithBackoff(new ConditionCheck() {

        @Override
        public boolean check() {
            return relayPuller.getComponentStatus().getStatus() == DatabusComponentStatus.Status.SUSPENDED_ON_ERROR;
        }
    }, "puller suspended because of out of retries", 500, log);
    EasyMock.verify(mockConnFactory);
    relayPuller.enqueueMessage(LifecycleMessage.createShutdownMessage());
    relayPuller.awaitShutdown();
    log.info("------------ done --------------");
}

Also used : ServerInfo(com.linkedin.databus.client.pub.ServerInfo) ArrayList(java.util.ArrayList) Logger(org.apache.log4j.Logger) Properties(java.util.Properties) Field(java.lang.reflect.Field) IdNamePair(com.linkedin.databus.core.util.IdNamePair) RemoteExceptionHandler(com.linkedin.databus.client.netty.RemoteExceptionHandler) ConditionCheck(com.linkedin.databus2.test.ConditionCheck) DbusKeyCompositeFilterConfig(com.linkedin.databus2.core.filter.DbusKeyCompositeFilterConfig) DatabusSubscription(com.linkedin.databus.core.data_model.DatabusSubscription) Checkpoint(com.linkedin.databus.core.Checkpoint) DbusEventBuffer(com.linkedin.databus.core.DbusEventBuffer) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) DbusEventV1Factory(com.linkedin.databus.core.DbusEventV1Factory) Test(org.testng.annotations.Test)

Example 48 with IdNamePair

use of com.linkedin.databus.core.util.IdNamePair in project databus by linkedin.

the class MockRemoteExceptionHandler method createRelayPullThread.

private static RelayPullThread createRelayPullThread(boolean failRelayConnection, boolean muteTransition, boolean bootstrapEnabled, boolean readLatestScnEnabled, boolean readDataThrowException, boolean readDataException, String exceptionName, int numRetriesOnFellOff, DbusKeyCompositeFilterConfig filterConfig) throws Exception {
    List<String> sources = Arrays.asList("source1");
    Properties clientProps = new Properties();
    if (bootstrapEnabled) {
        clientProps.setProperty("client.runtime.bootstrap.enabled", "true");
        clientProps.setProperty("client.runtime.bootstrap.service(1).name", "bs1");
        clientProps.setProperty("client.runtime.bootstrap.service(1).port", "10001");
        clientProps.setProperty("client.runtime.bootstrap.service(1).sources", "source1");
    } else {
        clientProps.setProperty("client.runtime.bootstrap.enabled", "false");
    }
    clientProps.setProperty("client.container.jmx.rmiEnabled", "false");
    clientProps.setProperty("client.runtime.relay(1).name", "relay1");
    clientProps.setProperty("client.runtime.relay(1).port", "10001");
    clientProps.setProperty("client.runtime.relay(1).sources", "source1");
    clientProps.setProperty("client.runtime.relay(2).name", "relay2");
    clientProps.setProperty("client.runtime.relay(2).port", "10002");
    clientProps.setProperty("client.runtime.relay(2).sources", "source1");
    clientProps.setProperty("client.runtime.relay(3).name", "relay3");
    clientProps.setProperty("client.runtime.relay(3).port", "10003");
    clientProps.setProperty("client.runtime.relay(3).sources", "source1");
    if (readLatestScnEnabled)
        clientProps.setProperty("client.enableReadLatestOnRelayFallOff", "true");
    clientProps.setProperty("client.connectionDefaults.eventBuffer.maxSize", "100000");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.maxRetryNum", "9");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.sleepIncFactor", "1.0");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.sleepIncDelta", "1");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.initSleep", "1");
    clientProps.setProperty("client.connectionDefaults.numRetriesOnFallOff", "" + numRetriesOnFellOff);
    DatabusHttpClientImpl.Config clientConfBuilder = new DatabusHttpClientImpl.Config();
    ConfigLoader<DatabusHttpClientImpl.StaticConfig> configLoader = new ConfigLoader<DatabusHttpClientImpl.StaticConfig>("client.", clientConfBuilder);
    configLoader.loadConfig(clientProps);
    DatabusHttpClientImpl.StaticConfig clientConf = clientConfBuilder.build();
    DatabusSourcesConnection.StaticConfig srcConnConf = clientConf.getConnectionDefaults();
    DatabusHttpClientImpl client = new DatabusHttpClientImpl(clientConf);
    if (bootstrapEnabled)
        client.registerDatabusBootstrapListener(new LoggingConsumer(), null, "source1");
    Assert.assertNotNull(client, "client instantiation ok");
    DatabusHttpClientImpl.RuntimeConfig clientRtConf = clientConf.getRuntime().build();
    //we keep the index of the next server we expect to see
    AtomicInteger serverIdx = new AtomicInteger(-1);
    //generate the order in which we should see the servers
    List<ServerInfo> relayOrder = new ArrayList<ServerInfo>(clientRtConf.getRelays());
    if (LOG.isInfoEnabled()) {
        StringBuilder sb = new StringBuilder();
        for (ServerInfo serverInfo : relayOrder) {
            sb.append(serverInfo.getName());
            sb.append(" ");
        }
        LOG.info("Relay order:" + sb.toString());
    }
    List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
    sourcesResponse.add(new IdNamePair(1L, "source1"));
    Map<Long, List<RegisterResponseEntry>> registerSourcesResponse = new HashMap<Long, List<RegisterResponseEntry>>();
    List<RegisterResponseEntry> regResponse = new ArrayList<RegisterResponseEntry>();
    regResponse.add(new RegisterResponseEntry(1L, (short) 1, SCHEMA$.toString()));
    registerSourcesResponse.put(1L, regResponse);
    ChunkedBodyReadableByteChannel channel = EasyMock.createMock(ChunkedBodyReadableByteChannel.class);
    if (!readDataException) {
        EasyMock.expect(channel.getMetadata(EasyMock.<String>notNull())).andReturn(null).anyTimes();
    } else {
        EasyMock.expect(channel.getMetadata(EasyMock.<String>notNull())).andReturn(exceptionName).anyTimes();
    }
    EasyMock.replay(channel);
    DbusEventBuffer dbusBuffer = EasyMock.createMock(DbusEventBuffer.class);
    EasyMock.expect(dbusBuffer.readEvents(EasyMock.<ReadableByteChannel>notNull(), EasyMock.<List<InternalDatabusEventsListener>>notNull(), EasyMock.<DbusEventsStatisticsCollector>isNull())).andReturn(1).anyTimes();
    EasyMock.expect(dbusBuffer.getSeenEndOfPeriodScn()).andReturn(1L).anyTimes();
    EasyMock.expect(dbusBuffer.getEventSerializationVersion()).andReturn(DbusEventFactory.DBUS_EVENT_V1).anyTimes();
    if (readDataThrowException) {
        EasyMock.expect(dbusBuffer.readEvents(EasyMock.<ReadableByteChannel>notNull())).andThrow(new RuntimeException("dummy")).anyTimes();
    } else {
        EasyMock.expect(dbusBuffer.readEvents(EasyMock.<ReadableByteChannel>notNull())).andReturn(1).anyTimes();
    }
    EasyMock.expect(dbusBuffer.acquireIterator(EasyMock.<String>notNull())).andReturn(null).anyTimes();
    dbusBuffer.waitForFreeSpace((int) (clientConf.getConnectionDefaults().getFreeBufferThreshold() * 100.0 / clientConf.getPullerBufferUtilizationPct()));
    EasyMock.expectLastCall().anyTimes();
    EasyMock.expect(dbusBuffer.getBufferFreeReadSpace()).andReturn(0).anyTimes();
    EasyMock.replay(dbusBuffer);
    //This guy succeeds on /sources but fails on /register  [FIXME:  it does? why?]
    Map<Long, List<RegisterResponseEntry>> registerKeysResponse = null;
    List<RegisterResponseMetadataEntry> registerMetadataResponse = null;
    MockRelayConnection mockSuccessConn = new MockRelayConnection(sourcesResponse, registerSourcesResponse, registerKeysResponse, registerMetadataResponse, channel, serverIdx, muteTransition);
    DatabusRelayConnectionFactory mockConnFactory = EasyMock.createMock("mockRelayFactory", DatabusRelayConnectionFactory.class);
    if (failRelayConnection) {
        EasyMock.expect(mockConnFactory.createRelayConnection(EasyMock.<ServerInfo>notNull(), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andThrow(new RuntimeException("Mock Error")).anyTimes();
    } else {
        EasyMock.expect(mockConnFactory.createRelayConnection(EasyMock.<ServerInfo>notNull(), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andReturn(mockSuccessConn).anyTimes();
    }
    List<DatabusSubscription> sourcesSubList = DatabusSubscription.createSubscriptionList(sources);
    // Mock Bootstrap Puller
    BootstrapPullThread mockBsPuller = EasyMock.createMock("bpt", BootstrapPullThread.class);
    mockBsPuller.enqueueMessage(EasyMock.notNull());
    EasyMock.expectLastCall().anyTimes();
    // Mock Relay Dispatcher
    RelayDispatcher mockDispatcher = EasyMock.createMock("rd", RelayDispatcher.class);
    mockDispatcher.enqueueMessage(EasyMock.notNull());
    EasyMock.expectLastCall().anyTimes();
    DatabusSourcesConnection sourcesConn2 = EasyMock.createMock(DatabusSourcesConnection.class);
    DatabusSourcesConnection.SourcesConnectionStatus scs = sourcesConn2.new SourcesConnectionStatus();
    EasyMock.expect(sourcesConn2.getSourcesNames()).andReturn(Arrays.asList("source1")).anyTimes();
    EasyMock.expect(sourcesConn2.getSubscriptions()).andReturn(sourcesSubList).anyTimes();
    EasyMock.expect(sourcesConn2.getConnectionConfig()).andReturn(srcConnConf).anyTimes();
    EasyMock.expect(sourcesConn2.getConnectionStatus()).andReturn(scs).anyTimes();
    EasyMock.expect(sourcesConn2.getLocalRelayCallsStatsCollector()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getInboundEventsStatsCollector()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getRelayCallsStatsCollector()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getUnifiedClientStats()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getRelayConnFactory()).andReturn(mockConnFactory).anyTimes();
    EasyMock.expect(sourcesConn2.loadPersistentCheckpoint()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getDataEventsBuffer()).andReturn(dbusBuffer).anyTimes();
    if (bootstrapEnabled)
        EasyMock.expect(sourcesConn2.isBootstrapEnabled()).andReturn(true).anyTimes();
    else
        EasyMock.expect(sourcesConn2.isBootstrapEnabled()).andReturn(false).anyTimes();
    EasyMock.expect(sourcesConn2.getBootstrapRegistrations()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getBootstrapServices()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getBootstrapPuller()).andReturn(mockBsPuller).anyTimes();
    EasyMock.expect(sourcesConn2.getRelayDispatcher()).andReturn(mockDispatcher).anyTimes();
    EasyMock.makeThreadSafe(mockConnFactory, true);
    EasyMock.makeThreadSafe(mockDispatcher, true);
    EasyMock.makeThreadSafe(mockBsPuller, true);
    EasyMock.makeThreadSafe(sourcesConn2, true);
    EasyMock.replay(mockConnFactory);
    EasyMock.replay(sourcesConn2);
    EasyMock.replay(mockDispatcher);
    EasyMock.replay(mockBsPuller);
    ConnectionStateFactory connStateFactory = new ConnectionStateFactory(sources);
    ArrayList<DbusKeyCompositeFilterConfig> filters = new ArrayList<DbusKeyCompositeFilterConfig>();
    if (filterConfig != null)
        filters.add(filterConfig);
    RelayPullThread relayPuller = new RelayPullThread("RelayPuller", sourcesConn2, dbusBuffer, connStateFactory, clientRtConf.getRelaysSet(), filters, srcConnConf.getConsumeCurrent(), srcConnConf.getReadLatestScnOnError(), srcConnConf.getPullerUtilizationPct(), // no threshold for noEventsRest set
    0, ManagementFactory.getPlatformMBeanServer(), new DbusEventV1Factory(), null);
    RemoteExceptionHandler mockRemoteExceptionHandler = new MockRemoteExceptionHandler(sourcesConn2, dbusBuffer, relayPuller);
    Field field = relayPuller.getClass().getDeclaredField("_remoteExceptionHandler");
    field.setAccessible(true);
    field.set(relayPuller, mockRemoteExceptionHandler);
    mockSuccessConn.setCallback(relayPuller);
    return relayPuller;
}

Also used : ReadableByteChannel(java.nio.channels.ReadableByteChannel) HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) DbusEventsStatisticsCollector(com.linkedin.databus.core.monitoring.mbean.DbusEventsStatisticsCollector) List(java.util.List) ArrayList(java.util.ArrayList) RemoteExceptionHandler(com.linkedin.databus.client.netty.RemoteExceptionHandler) DbusKeyCompositeFilterConfig(com.linkedin.databus2.core.filter.DbusKeyCompositeFilterConfig) DatabusSubscription(com.linkedin.databus.core.data_model.DatabusSubscription) DbusEventBuffer(com.linkedin.databus.core.DbusEventBuffer) LoggingConsumer(com.linkedin.databus.client.consumer.LoggingConsumer) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) RegisterResponseEntry(com.linkedin.databus2.core.container.request.RegisterResponseEntry) DbusKeyCompositeFilterConfig(com.linkedin.databus2.core.filter.DbusKeyCompositeFilterConfig) ServerInfo(com.linkedin.databus.client.pub.ServerInfo) Properties(java.util.Properties) Field(java.lang.reflect.Field) IdNamePair(com.linkedin.databus.core.util.IdNamePair) ConfigLoader(com.linkedin.databus.core.util.ConfigLoader) AbstractActorMessageQueue(com.linkedin.databus.core.async.AbstractActorMessageQueue) ActorMessageQueue(com.linkedin.databus.core.async.ActorMessageQueue) RegisterResponseMetadataEntry(com.linkedin.databus2.core.container.request.RegisterResponseMetadataEntry) DbusEventV1Factory(com.linkedin.databus.core.DbusEventV1Factory)

Example 49 with IdNamePair

use of com.linkedin.databus.core.util.IdNamePair in project databus by linkedin.

the class MockRemoteExceptionHandler method testServerSetChanges.

@Test
public void testServerSetChanges() throws Exception {
    // Server-Set Change TestCases
    {
        Set<ServerInfo> expServerInfo = new TreeSet<ServerInfo>();
        expServerInfo.add(new ServerInfo("relay1", "ONLINE", new InetSocketAddress("localhost", 10001), "source1"));
        expServerInfo.add(new ServerInfo("relay2", "ONLINE", new InetSocketAddress("localhost", 10002), "source1"));
        expServerInfo.add(new ServerInfo("relay3", "ONLINE", new InetSocketAddress("localhost", 10003), "source1"));
        Set<ServerInfo> expServerInfo2 = new TreeSet<ServerInfo>(expServerInfo);
        expServerInfo2.add(new ServerInfo("relay4", "ONLINE", new InetSocketAddress("localhost", 10000), "source1"));
        Set<ServerInfo> expServerInfo3 = new TreeSet<ServerInfo>();
        expServerInfo3.add(new ServerInfo("relay4", "ONLINE", new InetSocketAddress("localhost", 10000), "source1"));
        // when on PICK_SERVER
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            relayPuller.enqueueMessage(connState);
            // ServerSetChange
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), -1, "Current Server Index");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), -1, "Current Server Index");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "ServerSetChange while Pick_Server");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :ServerSetChange while Pick_Server");
            }
        }
        // When on Request_Sources
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REQUEST_SOURCES, "ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [REQUEST_SOURCES]", "Queue :ServerSetChange while REQUEST_SOURCES");
            }
            // ServerSetChange when New Set excludes CurrentServer
            {
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on SOURCES-REQUEST-SENT and Response Successful
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.SOURCES_REQUEST_SENT, "ServerSetChange while SOURCES_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while SOURCES_REQUEST_SENT");
            }
            // ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.SOURCES_REQUEST_SENT, "ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff Check");
                // Now Response arrives
                List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
                sourcesResponse.add(new IdNamePair(1L, "source1"));
                connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
                testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
                validateConnState(connState);
            }
        }
        // When on SOURCES-REQUEST-SENT and SOURCES_RESPONSE_ERROR
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.SOURCES_REQUEST_SENT, "ServerSetChange while SOURCES_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while SOURCES_REQUEST_SENT");
            }
            // ServerSetChange when New Set excludes CurrentServer and SOURCES_RESPONSE_ERROR
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.SOURCES_REQUEST_SENT, "ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
                sourcesResponse.add(new IdNamePair(1L, "source1"));
                connState.switchToSourcesResponseError();
                testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_ERROR, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on SOURCES-REQUEST-SENT and SOURCES_REQUEST_ERROR
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.SOURCES_REQUEST_SENT, "ServerSetChange while SOURCES_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while SOURCES_REQUEST_SENT");
            }
            // ServerSetChange when New Set excludes CurrentServer and SOURCES_REQUEST_ERROR
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.SOURCES_REQUEST_SENT, "ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_SOURCES");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
                sourcesResponse.add(new IdNamePair(1L, "source1"));
                connState.switchToSourcesRequestError();
                testTransitionCase(relayPuller, StateId.SOURCES_REQUEST_ERROR, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on Request Register
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            validateConnState(connState);
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REQUEST_REGISTER, "ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [REQUEST_REGISTER]", "Queue :ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer
            {
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on REGISTER-REQUEST-SENT and REGISTER_RESPONSE_ERROR
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REGISTER_REQUEST_SENT, "ServerSetChange while REGISTER_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REGISTER_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REGISTER_REQUEST_SENT, "ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                connState.switchToRegisterResponseError();
                testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_ERROR, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on REGISTER-REQUEST-SENT and REGISTER_REQUEST_ERROR
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REGISTER_REQUEST_SENT, "ServerSetChange while REGISTER_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REGISTER_REQUEST_SENT");
            }
            // ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REGISTER_REQUEST_SENT, "ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                connState.switchToSourcesRequestError();
                testTransitionCase(relayPuller, StateId.REGISTER_REQUEST_ERROR, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on REGISTER-REQUEST-SENT and Response Successful
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            validateConnState(connState);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REGISTER_REQUEST_SENT, "ServerSetChange while REGISTER_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REGISTER_REQUEST_SENT");
            }
            // ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REGISTER_REQUEST_SENT, "ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_REGISTER");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                MockRelayConnection conn = (MockRelayConnection) connState.getRelayConnection();
                connState.switchToRegisterSuccess(conn.getRegisterResponse(), conn.getRegisterResponse(), conn.getRegisterMetadataResponse());
                testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // when on REQUEST_STREAM
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.REQUEST_STREAM, "ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [REQUEST_STREAM]", "Queue :ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer
            {
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on STREAM_REQUEST_SENT and response successful
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            relayPuller.getMessageQueue().clear();
            MockRelayConnection conn = (MockRelayConnection) connState.getRelayConnection();
            connState.switchToRegisterSuccess(conn.getRegisterResponse(), conn.getRegisterResponse(), conn.getRegisterMetadataResponse());
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.STREAM_REQUEST_SENT, "ServerSetChange while STREAM_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while STREAM_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.STREAM_REQUEST_SENT, "ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                conn = (MockRelayConnection) connState.getRelayConnection();
                connState.switchToStreamSuccess(conn.getStreamResponse());
                testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on STREAM_REQUEST_SENT and STREAM_RESPONSE_ERROR
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            relayPuller.getMessageQueue().clear();
            MockRelayConnection conn = (MockRelayConnection) connState.getRelayConnection();
            connState.switchToRegisterSuccess(conn.getRegisterResponse(), conn.getRegisterResponse(), conn.getRegisterMetadataResponse());
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.STREAM_REQUEST_SENT, "ServerSetChange while STREAM_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while STREAM_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer and StreamResponse Error
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.STREAM_REQUEST_SENT, "ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                connState.switchToStreamResponseError();
                testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When on STREAM_REQUEST_SENT and STREAM_REQUEST_ERROR
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, true);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_REQUEST_SENT, "");
            List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
            sourcesResponse.add(new IdNamePair(1L, "source1"));
            connState.switchToSourcesSuccess(sourcesResponse, _HOSTNAME, _SVCNAME);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            validateConnState(connState);
            relayPuller.getMessageQueue().clear();
            String subsListString = "[{\"physicalSource\":{\"uri\":\"databus:physical-source:ANY\",\"role\":\"MASTER\"},\"physicalPartition\":{\"id\":-1,\"name\":\"*\"},\"logicalPartition\":{\"source\":{\"id\":0,\"name\":\"source1\"},\"id\":-1}}]";
            String sourcesIdListString = "1";
            connState.switchToRequestSourcesSchemas(sourcesIdListString, subsListString);
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_REQUEST_SENT, "");
            relayPuller.getMessageQueue().clear();
            MockRelayConnection conn = (MockRelayConnection) connState.getRelayConnection();
            connState.switchToRegisterSuccess(conn.getRegisterResponse(), conn.getRegisterResponse(), conn.getRegisterMetadataResponse());
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SENT, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.STREAM_REQUEST_SENT, "ServerSetChange while STREAM_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while STREAM_REQUEST_SENT");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer and StreamRequest Error
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.STREAM_REQUEST_SENT, "ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while REQUEST_STREAM");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                connState.switchToStreamRequestError();
                testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.PICK_SERVER);
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // when Stream_Response_done
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            RelayPullThread relayPuller = bldr.createFellOffRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.STREAM_RESPONSE_DONE);
            Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            relayPuller.getConnectionState().setRelayFellOff(true);
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.STREAM_RESPONSE_DONE, "ServerSetChange while STREAM_RESPONSE_DONE");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [STREAM_RESPONSE_DONE]", "Queue :ServerSetChange while STREAM_RESPONSE_DONE");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer
            {
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "ServerSetChange while STREAM_RESPONSE_DONE");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :ServerSetChange while STREAM_RESPONSE_DONE");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When doBootstrap
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.BOOTSTRAP, "ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [BOOTSTRAP]", "Queue :ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer
            {
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When doBootstrapRequested and bootstrap Successful
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.BOOTSTRAP, StateId.BOOTSTRAP_REQUESTED, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.BOOTSTRAP_REQUESTED, "ServerSetChange while BOOTSTRAP_REQUESTED");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while BOOTSTRAP_REQUESTED");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.BOOTSTRAP_REQUESTED, "ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                BootstrapResultMessage msg = BootstrapResultMessage.createBootstrapCompleteMessage(new Checkpoint());
                doExecuteAndChangeState(relayPuller, msg);
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "BOOTSTRAP_REQUESTED to PICK_SERVER");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :BOOTSTRAP_REQUESTED to REQUEST_STREAM");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // When doBootstrapRequested and bootstrap failed
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.SOURCES_RESPONSE_SUCCESS, StateId.REQUEST_REGISTER);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_REGISTER, StateId.REGISTER_RESPONSE_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REGISTER_RESPONSE_SUCCESS, StateId.REQUEST_STREAM);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_STREAM, StateId.STREAM_REQUEST_SUCCESS);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.STREAM_REQUEST_SUCCESS, StateId.BOOTSTRAP);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.BOOTSTRAP, StateId.BOOTSTRAP_REQUESTED, "");
            // ServerSetChange when New Set includes CurrentServer
            {
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(true, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.BOOTSTRAP_REQUESTED, "ServerSetChange while BOOTSTRAP_REQUESTED");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while BOOTSTRAP_REQUESTED");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
            }
            // ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
            {
                int oldServerIndex = relayPuller.getCurrentServerIdx();
                ServerInfo oldServer = relayPuller.getCurentServer();
                Assert.assertEquals(relayPuller.getServers(), expServerInfo2, "Server Set");
                doExecuteAndChangeState(relayPuller, createSetServerMessage(false, relayPuller));
                Assert.assertEquals(relayPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
                Assert.assertEquals(relayPuller.getCurentServer(), oldServer, "Current Server unchanged");
                Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
                Assert.assertEquals(connState.getStateId(), StateId.BOOTSTRAP_REQUESTED, "ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange while BOOTSTRAP");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), true, "Relay FellOff CHeck");
                // Now Response arrives
                BootstrapResultMessage msg = BootstrapResultMessage.createBootstrapFailedMessage(new RuntimeException("dummy"));
                doExecuteAndChangeState(relayPuller, msg);
                Assert.assertEquals(connState.getStateId(), StateId.PICK_SERVER, "BOOTSTRAP_REQUESTED to PICK_SERVER");
                Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :BOOTSTRAP_REQUESTED to REQUEST_STREAM");
                Assert.assertEquals(relayPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
                Assert.assertEquals(relayPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
                Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server Null");
                Assert.assertEquals(relayPuller.getConnectionState().isRelayFellOff(), false, "Relay FellOff CHeck");
            }
        }
        // Server-Set-Change message when suspended_due_to_error
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName()).setNumRetriesOnFellOff(5);
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            ServerSetChangeMessage msg = createSetServerMessage(false, relayPuller);
            relayPuller.enqueueMessage(msg);
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [SOURCES_RESPONSE_SUCCESS, SET_SERVERS]", "Queue :ServerSetChange");
            doExecuteAndChangeState(relayPuller, LifecycleMessage.createSuspendOnErroMessage(new RuntimeException("null")));
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [SET_SERVERS]", "Queue :ServerSetChange");
            Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
            Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
            Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
            Assert.assertEquals(relayPuller.getComponentStatus().getStatus(), Status.SUSPENDED_ON_ERROR, "Suspended state check");
            connState.switchToRequestSourcesSchemas(null, null);
            relayPuller.getMessageQueue().clear();
            doExecuteAndChangeState(relayPuller, msg);
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [RESUME]", "Queue :ServerSetChange");
            Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server null");
            Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
            // on doResume verify if PICK_SERVER happens
            doExecuteAndChangeState(relayPuller, relayPuller.getMessageQueue().poll());
            Assert.assertEquals(relayPuller.getComponentStatus().getStatus(), Status.RUNNING, " state check");
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [PICK_SERVER]", "Queue :ServerSetChange");
        }
        // Server-Set-Change message when PAUSED
        {
            RelayPullThreadBuilder bldr = new RelayPullThreadBuilder(false, false);
            bldr.setBootstrapEnabled(true).setReadLatestScnEnabled(false).setReadDataThrowException(false).setReadDataException(true).setExceptionName(ScnNotFoundException.class.getName());
            RelayPullThread relayPuller = bldr.createRelayPullThread();
            relayPuller.getComponentStatus().start();
            ConnectionState connState = relayPuller.getConnectionState();
            connState.switchToPickServer();
            testTransitionCase(relayPuller, StateId.PICK_SERVER, StateId.REQUEST_SOURCES);
            relayPuller.getMessageQueue().clear();
            testTransitionCase(relayPuller, StateId.REQUEST_SOURCES, StateId.SOURCES_RESPONSE_SUCCESS);
            ServerSetChangeMessage msg = createSetServerMessage(false, relayPuller);
            relayPuller.enqueueMessage(msg);
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [SOURCES_RESPONSE_SUCCESS, SET_SERVERS]", "Queue :ServerSetChange");
            doExecuteAndChangeState(relayPuller, LifecycleMessage.createPauseMessage());
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: [SET_SERVERS]", "Queue :ServerSetChange");
            Assert.assertEquals(relayPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
            Assert.assertEquals(relayPuller.getCurentServer() != null, true, "Current Server not Null");
            Assert.assertEquals(relayPuller.getServers(), expServerInfo, "Server Set");
            Assert.assertEquals(relayPuller.getComponentStatus().getStatus(), Status.PAUSED, "PAUSED state check");
            connState.switchToRequestSourcesSchemas(null, null);
            relayPuller.getMessageQueue().clear();
            doExecuteAndChangeState(relayPuller, msg);
            Assert.assertEquals(relayPuller.getQueueListString(), "RelayPuller queue: []", "Queue :ServerSetChange");
            Assert.assertEquals(relayPuller.getCurentServer() == null, true, "Current Server null");
            Assert.assertEquals(relayPuller.getServers(), expServerInfo3, "Server Set");
        }
    }
}

Also used : Set(java.util.Set) TreeSet(java.util.TreeSet) HashSet(java.util.HashSet) ServerInfo(com.linkedin.databus.client.pub.ServerInfo) InetSocketAddress(java.net.InetSocketAddress) ArrayList(java.util.ArrayList) Checkpoint(com.linkedin.databus.core.Checkpoint) ScnNotFoundException(com.linkedin.databus.core.ScnNotFoundException) IdNamePair(com.linkedin.databus.core.util.IdNamePair) List(java.util.List) ArrayList(java.util.ArrayList) Test(org.testng.annotations.Test)

Example 50 with IdNamePair

use of com.linkedin.databus.core.util.IdNamePair in project databus by linkedin.

the class MockRemoteExceptionHandler method testRelayPendingEvent.

@Test(groups = { "small", "functional" })
public void testRelayPendingEvent() throws Exception {
    final Logger log = Logger.getLogger("TestRelayPullThread.testRelayPendingEvent");
    log.setLevel(Level.INFO);
    log.info("-------------- start -------------------");
    //set a clientReadBufferSize equal to maxSize ; this is also used to generate an event larger than what can fit in buffer
    final int clientReadBufferSize = 100000;
    //set initReadBufferSize to a value greater than default averageEventSize which is 20K but lesser than 0.25*maxSize.
    //See DbsuEventBuffer.Config.DEFAULT_AVERAGE_EVENT_SIZE
    final int averageEventSize = 22500;
    List<String> sources = Arrays.asList("source1");
    Properties clientProps = new Properties();
    clientProps.setProperty("client.runtime.bootstrap.enabled", "false");
    clientProps.setProperty("client.runtime.relay(1).name", "relay1");
    clientProps.setProperty("client.runtime.relay(1).port", "10001");
    clientProps.setProperty("client.runtime.relay(1).sources", "source1");
    clientProps.setProperty("client.connectionDefaults.eventBuffer.maxSize", Integer.toString(clientReadBufferSize));
    //this setting should have no effect
    clientProps.setProperty("client.connectionDefaults.eventBuffer.readBufferSize", Integer.toString(clientReadBufferSize));
    //readBufferSize init size will be set to this value
    clientProps.setProperty("client.connectionDefaults.eventBuffer.averageEventSize", Integer.toString(averageEventSize));
    //set a high value of freeBufferThreshold which is unsafe; this setting should fail
    clientProps.setProperty("client.connectionDefaults.freeBufferThreshold", "100000");
    DatabusHttpClientImpl client = new DatabusHttpClientImpl("client.", clientProps);
    Assert.assertNotNull(client, "client instantiation ok");
    final DatabusHttpClientImpl.StaticConfig clientConf = client.getClientStaticConfig();
    final DatabusSourcesConnection.StaticConfig srcConnConf = clientConf.getConnectionDefaults();
    DatabusHttpClientImpl.RuntimeConfig clientRtConf = clientConf.getRuntime().build();
    DbusEventBuffer.StaticConfig bufferConf = clientConf.getConnectionDefaults().getEventBuffer();
    log.info("Buffer size=" + bufferConf.getMaxSize() + " readBufferSize=" + bufferConf.getReadBufferSize() + " maxEventSize=" + bufferConf.getMaxEventSize());
    Assert.assertEquals(bufferConf.getReadBufferSize(), averageEventSize);
    //This should be equal to the maxEventSize if defaults are used for maxEventSize
    Assert.assertTrue(bufferConf.getReadBufferSize() < bufferConf.getMaxEventSize());
    Assert.assertEquals(clientConf.getConnectionDefaults().getFreeBufferThreshold(), clientConf.getConnectionDefaults().getFreeBufferThreshold());
    DbusEventBuffer relayBuffer = new DbusEventBuffer(bufferConf);
    AtomicInteger serverIdx = new AtomicInteger(-1);
    // just one relay defined in our clientProps
    Set<ServerInfo> relays = clientRtConf.getRelaysSet();
    List<ServerInfo> relayOrder = new ArrayList<ServerInfo>(relays);
    List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
    sourcesResponse.add(new IdNamePair(1L, "source1"));
    RegisterResponseEntry rre1 = new RegisterResponseEntry(1L, (short) 1, SCHEMA$.toString());
    final HashMap<Long, List<RegisterResponseEntry>> registerResponseSources = // mapping of sourceId to list of schema versions for that ID
    new HashMap<Long, List<RegisterResponseEntry>>();
    registerResponseSources.put(1L, Arrays.asList(rre1));
    ChunkedBodyReadableByteChannel channel = new MockChunkedBodyReadableByteChannel(clientReadBufferSize + 10);
    final MockRelayConnection mockConn = new MockRelayConnection(sourcesResponse, registerResponseSources, channel, serverIdx);
    DatabusRelayConnectionFactory mockConnFactory = EasyMock.createMock("mockRelayFactory", DatabusRelayConnectionFactory.class);
    EasyMock.expect(mockConnFactory.createRelayConnection(serverNameMatcher(serverIdx, relayOrder), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andReturn(mockConn).times(1);
    EasyMock.replay(mockConnFactory);
    List<DatabusSubscription> sourcesSubList = DatabusSubscription.createSubscriptionList(sources);
    //Dummy connection object as expected by the puller thread
    // Note that in this case, it is ok to pass Set<relays> as all the relays serve the same source
    //"source1"
    ConnectionStateFactory connStateFactory = new ConnectionStateFactory(sources);
    DatabusSourcesConnection sourcesConn = new DatabusSourcesConnection(srcConnConf, sourcesSubList, relays, null, null, null, relayBuffer, null, Executors.newCachedThreadPool(), null, null, null, null, null, null, null, mockConnFactory, null, null, null, null, new DbusEventV1Factory(), connStateFactory);
    final RelayPullThread relayPuller = new RelayPullThread("RelayPuller", sourcesConn, relayBuffer, connStateFactory, relays, new ArrayList<DbusKeyCompositeFilterConfig>(), !clientConf.getRuntime().getBootstrap().isEnabled(), clientConf.isReadLatestScnOnErrorEnabled(), clientConf.getPullerBufferUtilizationPct(), Integer.MAX_VALUE, ManagementFactory.getPlatformMBeanServer(), new DbusEventV1Factory(), null);
    final MockRemoteExceptionHandler mockRemoteExceptionHandler = new MockRemoteExceptionHandler(sourcesConn, relayBuffer, relayPuller);
    Field field = relayPuller.getClass().getDeclaredField("_remoteExceptionHandler");
    field.setAccessible(true);
    field.set(relayPuller, mockRemoteExceptionHandler);
    mockConn.setCallback(relayPuller);
    //Let the show begin
    Thread relayPullerThread = new Thread(relayPuller);
    relayPullerThread.setDaemon(true);
    relayPullerThread.start();
    relayPuller.enqueueMessage(LifecycleMessage.createStartMessage());
    // We will try the same relay 3 times and then our remote exception handler will be invoked.
    TestUtil.assertWithBackoff(new ConditionCheck() {

        @Override
        public boolean check() {
            return relayPuller.getComponentStatus().getStatus() == Status.SUSPENDED_ON_ERROR;
        }
    }, "Reached SUSPEND_ON_ERROR state ", 500, log);
    EasyMock.verify(mockConnFactory);
    relayPuller.enqueueMessage(LifecycleMessage.createShutdownMessage());
    relayPuller.awaitShutdown();
    log.info("------------ done --------------");
}

Also used : HashMap(java.util.HashMap) ServerInfo(com.linkedin.databus.client.pub.ServerInfo) ArrayList(java.util.ArrayList) Logger(org.apache.log4j.Logger) Properties(java.util.Properties) Field(java.lang.reflect.Field) IdNamePair(com.linkedin.databus.core.util.IdNamePair) List(java.util.List) ArrayList(java.util.ArrayList) RemoteExceptionHandler(com.linkedin.databus.client.netty.RemoteExceptionHandler) ConditionCheck(com.linkedin.databus2.test.ConditionCheck) DbusKeyCompositeFilterConfig(com.linkedin.databus2.core.filter.DbusKeyCompositeFilterConfig) AbstractActorMessageQueue(com.linkedin.databus.core.async.AbstractActorMessageQueue) ActorMessageQueue(com.linkedin.databus.core.async.ActorMessageQueue) DatabusSubscription(com.linkedin.databus.core.data_model.DatabusSubscription) Checkpoint(com.linkedin.databus.core.Checkpoint) DbusEventBuffer(com.linkedin.databus.core.DbusEventBuffer) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) RegisterResponseEntry(com.linkedin.databus2.core.container.request.RegisterResponseEntry) DbusEventV1Factory(com.linkedin.databus.core.DbusEventV1Factory) Test(org.testng.annotations.Test)

Aggregations

IdNamePair (com.linkedin.databus.core.util.IdNamePair)77 ArrayList (java.util.ArrayList)66 HashMap (java.util.HashMap)60 Test (org.testng.annotations.Test)56 List (java.util.List)51 Checkpoint (com.linkedin.databus.core.Checkpoint)48 RegisterResponseEntry (com.linkedin.databus2.core.container.request.RegisterResponseEntry)47 DatabusSubscription (com.linkedin.databus.core.data_model.DatabusSubscription)25 AtomicInteger (java.util.concurrent.atomic.AtomicInteger)24 Logger (org.apache.log4j.Logger)21 DatabusStreamConsumer (com.linkedin.databus.client.pub.DatabusStreamConsumer)18 DbusEvent (com.linkedin.databus.core.DbusEvent)18 Hashtable (java.util.Hashtable)18 DbusEventBuffer (com.linkedin.databus.core.DbusEventBuffer)17 DatabusV2ConsumerRegistration (com.linkedin.databus.client.consumer.DatabusV2ConsumerRegistration)16 MultiConsumerCallback (com.linkedin.databus.client.consumer.MultiConsumerCallback)16 StreamConsumerCallbackFactory (com.linkedin.databus.client.consumer.StreamConsumerCallbackFactory)16 UncaughtExceptionTrackingThread (com.linkedin.databus.core.util.UncaughtExceptionTrackingThread)16 SelectingDatabusCombinedConsumer (com.linkedin.databus.client.consumer.SelectingDatabusCombinedConsumer)14 ServerInfo (com.linkedin.databus.client.pub.ServerInfo)14