Example 26 with ServerInfo
use of com.linkedin.databus.client.pub.ServerInfo 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 27 with ServerInfo
use of com.linkedin.databus.client.pub.ServerInfo 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 28 with ServerInfo
use of com.linkedin.databus.client.pub.ServerInfo 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 29 with ServerInfo
use of com.linkedin.databus.client.pub.ServerInfo 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)
Example 30 with ServerInfo
use of com.linkedin.databus.client.pub.ServerInfo in project databus by linkedin.
the class MockBootstrapConnection method testServerSetChange_StartScnResponseSuccess.
@Test
public /** Test ServerSet change when in Start_Scn_Response_Success */
void testServerSetChange_StartScnResponseSuccess() throws Exception {
BootstrapPullThread bsPuller = createBootstrapPullThread(false, false, false);
Checkpoint cp = _ckptHandlerSource1.createInitialBootstrapCheckpoint(null, 0L);
bsPuller.getComponentStatus().start();
ConnectionState connState = bsPuller.getConnectionState();
connState.switchToBootstrap(cp);
testTransitionCase(bsPuller, StateId.BOOTSTRAP, StateId.REQUEST_START_SCN, cp);
bsPuller.getMessageQueue().clear();
testTransitionCase(bsPuller, StateId.REQUEST_START_SCN, StateId.START_SCN_RESPONSE_SUCCESS, null);
// ServerSetChange when New Set includes CurrentServer
{
Assert.assertEquals(bsPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
Assert.assertEquals(bsPuller.getCurentServer() != null, true, "Current Server not Null");
ServerInfo oldServer = bsPuller.getCurentServer();
Assert.assertEquals(bsPuller.getServers(), EXP_SERVERINFO_1, "Server Set");
Map<Long, List<RegisterResponseEntry>> entries = new HashMap<Long, List<RegisterResponseEntry>>();
entries.put(1L, new ArrayList<RegisterResponseEntry>());
connState.setSourcesSchemas(entries);
doExecuteAndChangeState(bsPuller, createSetServerMessage(true, bsPuller));
Assert.assertEquals(bsPuller.getCurrentServerIdx() != -1, true, "Current Server Index defined");
Assert.assertEquals(bsPuller.getCurentServer(), oldServer, "Current Server unchanged");
Assert.assertEquals(bsPuller.getServers(), EXP_SERVERINFO_2, "Server Set");
Assert.assertEquals(bsPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
Assert.assertEquals(connState.getStateId(), StateId.START_SCN_RESPONSE_SUCCESS, "ServerSetChange while START_SCN_RESPONSE_SUCCESS");
Assert.assertEquals(bsPuller.getQueueListString(), "RelayPuller queue: [START_SCN_RESPONSE_SUCCESS]", "Queue :ServerSetChange while START_SCN_RESPONSE_SUCCESS");
}
// ServerSetChange when New Set excludes CurrentServer and SuccessFul Response
{
int oldServerIndex = bsPuller.getCurrentServerIdx();
ServerInfo oldServer = bsPuller.getCurentServer();
Assert.assertEquals(bsPuller.getServers(), EXP_SERVERINFO_2, "Server Set");
Map<Long, List<RegisterResponseEntry>> entries = new HashMap<Long, List<RegisterResponseEntry>>();
entries.put(1L, new ArrayList<RegisterResponseEntry>());
connState.setSourcesSchemas(entries);
doExecuteAndChangeState(bsPuller, createSetServerMessage(false, bsPuller));
Assert.assertEquals(bsPuller.getCurrentServerIdx(), oldServerIndex, "Current Server Index unchanged");
Assert.assertEquals(bsPuller.getCurentServer(), oldServer, "Current Server unchanged");
Assert.assertEquals(bsPuller.getServers(), EXP_SERVERINFO_3, "Server Set");
Assert.assertEquals(bsPuller.toTearConnAfterHandlingResponse(), true, "Tear Conn After Handling Response");
Assert.assertEquals(connState.getStateId(), StateId.START_SCN_RESPONSE_SUCCESS, "ServerSetChange while START_SCN_RESPONSE_SUCCESS");
Assert.assertEquals(bsPuller.getQueueListString(), "RelayPuller queue: [START_SCN_RESPONSE_SUCCESS]", "Queue :ServerSetChange while START_SCN_RESPONSE_SUCCESS");
// Now Response arrives
connState.switchToStartScnSuccess(cp, null, null);
testTransitionCase(bsPuller, StateId.START_SCN_RESPONSE_SUCCESS, StateId.PICK_SERVER, null);
Assert.assertEquals(bsPuller.toTearConnAfterHandlingResponse(), false, "Tear Conn After Handling Response");
Assert.assertEquals(bsPuller.getCurrentServerIdx() == -1, true, "Current Server Index undefined");
Assert.assertEquals(bsPuller.getCurentServer() == null, true, "Current Server Null");
}
}
Also used :
Checkpoint(com.linkedin.databus.core.Checkpoint)
ServerInfo(com.linkedin.databus.client.pub.ServerInfo)
RegisterResponseEntry(com.linkedin.databus2.core.container.request.RegisterResponseEntry)
ArrayList(java.util.ArrayList)
ArrayList(java.util.ArrayList)
List(java.util.List)
HashMap(java.util.HashMap)
Map(java.util.Map)
Test(org.testng.annotations.Test)
Aggregations
ServerInfo (com.linkedin.databus.client.pub.ServerInfo)44
Checkpoint (com.linkedin.databus.core.Checkpoint)23
ArrayList (java.util.ArrayList)21
Test (org.testng.annotations.Test)19
HashMap (java.util.HashMap)16
List (java.util.List)16
RegisterResponseEntry (com.linkedin.databus2.core.container.request.RegisterResponseEntry)15
IdNamePair (com.linkedin.databus.core.util.IdNamePair)14
DbusEventBuffer (com.linkedin.databus.core.DbusEventBuffer)10
DatabusSubscription (com.linkedin.databus.core.data_model.DatabusSubscription)10
InetSocketAddress (java.net.InetSocketAddress)8
AtomicInteger (java.util.concurrent.atomic.AtomicInteger)7
HashSet (java.util.HashSet)6
RemoteExceptionHandler (com.linkedin.databus.client.netty.RemoteExceptionHandler)5
DatabusClientException (com.linkedin.databus.client.pub.DatabusClientException)5
ServerInfoBuilder (com.linkedin.databus.client.pub.ServerInfo.ServerInfoBuilder)5
DbusKeyCompositeFilterConfig (com.linkedin.databus2.core.filter.DbusKeyCompositeFilterConfig)5
ConditionCheck (com.linkedin.databus2.test.ConditionCheck)5
Properties (java.util.Properties)5
Logger (org.apache.log4j.Logger)5
