@Override
public Stage getStage(String name) {
Stage stage = Mockito.mock(Stage.class);
if (name.equals(ServerConfigurationContext.INVALIDATE_OBJECTS_STAGE)) {
Mockito.when(stage.getSink()).thenReturn(inValidateSink);
return stage;
} else if (name.equals(ServerConfigurationContext.VALIDATE_OBJECTS_STAGE)) {
Mockito.when(stage.getSink()).thenReturn(validateSink);
return stage;
}
return null;
}
public void transition(
ConfigurationContext cxt, com.tc.util.State old, com.tc.util.State current) {
Set<String> leaving = states.get(old);
Set<String> coming = states.get(current);
if (leaving == null) {
leaving = Collections.emptySet();
}
if (coming == null) {
coming = Collections.emptySet();
}
for (String s : leaving) {
Stage<?> st = cxt.getStage(s, Object.class);
if (st != null && !coming.contains(s)) {
st.destroy();
}
}
for (String s : coming) {
Stage<?> st = cxt.getStage(s, Object.class);
if (st != null && !leaving.contains(s)) {
st.start(cxt);
st.unpause();
}
}
}
public synchronized void start() {
validateSecurityConfig();
final TCProperties tcProperties = TCPropertiesImpl.getProperties();
final int maxSize = tcProperties.getInt(TCPropertiesConsts.L1_SEDA_STAGE_SINK_CAPACITY);
final SessionManager sessionManager =
new SessionManagerImpl(
new SessionManagerImpl.SequenceFactory() {
@Override
public Sequence newSequence() {
return new SimpleSequence();
}
});
this.threadGroup.addCallbackOnExitDefaultHandler(
new CallbackOnExitHandler() {
@Override
public void callbackOnExit(CallbackOnExitState state) {
cluster.fireNodeError();
}
});
this.dumpHandler.registerForDump(new CallbackDumpAdapter(this.communicationStageManager));
final ReconnectConfig l1ReconnectConfig = getReconnectPropertiesFromServer();
final boolean useOOOLayer = l1ReconnectConfig.getReconnectEnabled();
final NetworkStackHarnessFactory networkStackHarnessFactory =
getNetworkStackHarnessFactory(useOOOLayer, l1ReconnectConfig);
this.counterManager = new CounterManagerImpl();
final MessageMonitor mm = MessageMonitorImpl.createMonitor(tcProperties, DSO_LOGGER);
final TCMessageRouter messageRouter = new TCMessageRouterImpl();
this.communicationsManager =
this.clientBuilder.createCommunicationsManager(
mm,
messageRouter,
networkStackHarnessFactory,
new NullConnectionPolicy(),
this.connectionComponents.createConnectionInfoConfigItemByGroup().length,
new HealthCheckerConfigClientImpl(
tcProperties.getPropertiesFor(TCPropertiesConsts.L1_L2_HEALTH_CHECK_CATEGORY),
"DSO Client"),
getMessageTypeClassMapping(),
ReconnectionRejectedHandlerL1.SINGLETON,
securityManager,
productId);
DSO_LOGGER.debug("Created CommunicationsManager.");
final ConnectionInfoConfig[] connectionInfoItems =
this.connectionComponents.createConnectionInfoConfigItemByGroup();
final ConnectionInfo[] connectionInfo = connectionInfoItems[0].getConnectionInfos();
final String serverHost = connectionInfo[0].getHostname();
final int serverPort = connectionInfo[0].getPort();
clusterEventsStage =
this.communicationStageManager.createStage(
ClientConfigurationContext.CLUSTER_EVENTS_STAGE,
ClusterInternalEventsContext.class,
new ClusterInternalEventsHandler<ClusterInternalEventsContext>(cluster),
1,
maxSize);
final int socketConnectTimeout =
tcProperties.getInt(TCPropertiesConsts.L1_SOCKET_CONNECT_TIMEOUT);
if (socketConnectTimeout < 0) {
throw new IllegalArgumentException("invalid socket time value: " + socketConnectTimeout);
}
this.channel =
this.clientBuilder.createClientMessageChannel(
this.communicationsManager,
this.connectionComponents,
sessionManager,
MAX_CONNECT_TRIES,
socketConnectTimeout,
this);
final ClientIDLoggerProvider cidLoggerProvider = new ClientIDLoggerProvider(this.channel);
this.communicationStageManager.setLoggerProvider(cidLoggerProvider);
DSO_LOGGER.debug("Created channel.");
this.clientEntityManager =
this.clientBuilder.createClientEntityManager(this.channel, this.communicationStageManager);
RequestReceiveHandler receivingHandler = new RequestReceiveHandler(this.clientEntityManager);
Stage<VoltronEntityResponse> entityResponseStage =
this.communicationStageManager.createStage(
ClientConfigurationContext.VOLTRON_ENTITY_RESPONSE_STAGE,
VoltronEntityResponse.class,
receivingHandler,
1,
maxSize);
Stage<Void> serverMessageStage =
this.communicationStageManager.createStage(
ClientConfigurationContext.SERVER_ENTITY_MESSAGE_STAGE,
Void.class,
new ServerMessageReceiveHandler<Void>(channel),
1,
maxSize);
TerracottaOperatorEventLogging.setNodeNameProvider(new ClientNameProvider(this.cluster));
final SampledRateCounterConfig sampledRateCounterConfig =
new SampledRateCounterConfig(1, 300, true);
this.counterManager.createCounter(sampledRateCounterConfig);
this.counterManager.createCounter(sampledRateCounterConfig);
// for SRA L1 Tx count
final SampledCounterConfig sampledCounterConfig = new SampledCounterConfig(1, 300, true, 0L);
this.counterManager.createCounter(sampledCounterConfig);
this.threadGroup.addCallbackOnExitDefaultHandler(
new CallbackDumpAdapter(this.clientEntityManager));
this.dumpHandler.registerForDump(new CallbackDumpAdapter(this.clientEntityManager));
final long timeOut =
TCPropertiesImpl.getProperties().getLong(TCPropertiesConsts.LOGGING_LONG_GC_THRESHOLD);
final LongGCLogger gcLogger = this.clientBuilder.createLongGCLogger(timeOut);
this.tcMemManager.registerForMemoryEvents(gcLogger);
// CDV-1181 warn if using CMS
this.tcMemManager.checkGarbageCollectors();
this.threadIDManager = new ThreadIDManagerImpl(this.threadIDMap);
// Setup the lock manager
this.lockManager =
this.clientBuilder.createLockManager(
this.channel,
new ClientIDLogger(this.channel, TCLogging.getLogger(ClientLockManager.class)),
sessionManager,
this.channel.getLockRequestMessageFactory(),
this.threadIDManager,
new ClientLockManagerConfigImpl(
tcProperties.getPropertiesFor(TCPropertiesConsts.L1_LOCK_MANAGER_CATEGORY)),
this.taskRunner);
final CallbackDumpAdapter lockDumpAdapter = new CallbackDumpAdapter(this.lockManager);
this.threadGroup.addCallbackOnExitDefaultHandler(lockDumpAdapter);
this.dumpHandler.registerForDump(lockDumpAdapter);
// Create the SEDA stages
final Stage<Void> lockResponse =
this.communicationStageManager.createStage(
ClientConfigurationContext.LOCK_RESPONSE_STAGE,
Void.class,
new LockResponseHandler<Void>(sessionManager),
1,
maxSize);
final Stage<HydrateContext> hydrateStage =
this.communicationStageManager.createStage(
ClientConfigurationContext.HYDRATE_MESSAGE_STAGE,
HydrateContext.class,
new HydrateHandler(),
1,
maxSize);
// By design this stage needs to be single threaded. If it wasn't then cluster membership
// messages could get
// processed before the client handshake ack, and this client would get a faulty view of the
// cluster at best, or
// more likely an AssertionError
final Stage<PauseContext> pauseStage =
this.communicationStageManager.createStage(
ClientConfigurationContext.CLIENT_COORDINATION_STAGE,
PauseContext.class,
new ClientCoordinationHandler<PauseContext>(),
1,
maxSize);
final Sink<PauseContext> pauseSink = pauseStage.getSink();
final Stage<Void> clusterMembershipEventStage =
this.communicationStageManager.createStage(
ClientConfigurationContext.CLUSTER_MEMBERSHIP_EVENT_STAGE,
Void.class,
new ClusterMembershipEventsHandler<Void>(cluster),
1,
maxSize);
final List<ClientHandshakeCallback> clientHandshakeCallbacks =
new ArrayList<ClientHandshakeCallback>();
clientHandshakeCallbacks.add(this.lockManager);
clientHandshakeCallbacks.add(this.clientEntityManager);
final ProductInfo pInfo = ProductInfo.getInstance();
this.clientHandshakeManager =
this.clientBuilder.createClientHandshakeManager(
new ClientIDLogger(this.channel, TCLogging.getLogger(ClientHandshakeManagerImpl.class)),
this.channel.getClientHandshakeMessageFactory(),
pauseSink,
sessionManager,
cluster,
this.uuid,
this.name,
pInfo.version(),
Collections.unmodifiableCollection(clientHandshakeCallbacks));
ClientChannelEventController.connectChannelEventListener(
channel, pauseSink, clientHandshakeManager);
this.shutdownManager = new ClientShutdownManager(this, connectionComponents);
final ClientConfigurationContext cc =
new ClientConfigurationContext(
this.communicationStageManager,
this.lockManager,
this.clientEntityManager,
this.clientHandshakeManager);
// DO NOT create any stages after this call
this.communicationStageManager.startAll(cc, Collections.<PostInit>emptyList());
initChannelMessageRouter(
messageRouter,
hydrateStage.getSink(),
lockResponse.getSink(),
pauseSink,
clusterMembershipEventStage.getSink(),
entityResponseStage.getSink(),
serverMessageStage.getSink());
new Thread(
threadGroup,
new Runnable() {
public void run() {
while (!clientStopped.isSet()) {
try {
openChannel(serverHost, serverPort);
waitForHandshake();
connectionMade();
break;
} catch (InterruptedException ie) {
// We are in the process of letting the thread terminate so we don't handle this
// in a special way.
}
}
// don't reset interrupted, thread is done
}
},
"Connection Establisher - " + uuid)
.start();
}
