public class ClientHandshakeManagerImpl implements ClientHandshakeManager {
  private enum State {
    PAUSED,
    STARTING,
    RUNNING
  }

  private static final TCLogger CONSOLE_LOGGER = CustomerLogging.getConsoleLogger();

  private final Collection<ClientHandshakeCallback> callBacks;
  private final ClientHandshakeMessageFactory chmf;
  private final TCLogger logger;
  private final SessionManager sessionManager;
  private final String clientVersion;

  private final String uuid;
  private final String name;

  private State state;
  private volatile boolean disconnected;
  private volatile boolean serverIsPersistent = false;
  private volatile boolean isShutdown = false;

  private final Lock lock = new ReentrantLock();
  private final ClusterInternalEventsGun clusterEventsGun;

  public ClientHandshakeManagerImpl(
      TCLogger logger,
      ClientHandshakeMessageFactory chmf,
      SessionManager sessionManager,
      ClusterInternalEventsGun clusterEventsGun,
      String uuid,
      String name,
      String clientVersion,
      Collection<ClientHandshakeCallback> callbacks) {
    this.logger = logger;
    this.chmf = chmf;
    this.sessionManager = sessionManager;
    this.clusterEventsGun = clusterEventsGun;
    this.uuid = uuid;
    this.name = name;
    this.clientVersion = clientVersion;
    this.callBacks = callbacks;
    this.state = State.PAUSED;
    this.disconnected = true;
    pauseCallbacks();
  }

  @Override
  public synchronized void shutdown(boolean fromShutdownHook) {
    isShutdown = true;
    notifyAll();
    shutdownCallbacks(fromShutdownHook);
  }

  @Override
  public boolean isShutdown() {
    return isShutdown;
  }

  private boolean checkShutdown() {
    if (isShutdown) {
      this.logger.warn("Drop handshaking due to client shutting down...");
    }
    return isShutdown;
  }

  private void initiateHandshake() {
    this.logger.debug("Initiating handshake...");
    ClientHandshakeMessage handshakeMessage;
    lock.lock();
    try {
      changeToStarting();
      handshakeMessage =
          this.chmf.newClientHandshakeMessage(
              this.uuid, this.name, this.clientVersion, isEnterpriseClient());
      notifyCallbackOnHandshake(handshakeMessage);
    } finally {
      lock.unlock();
    }
    this.logger.info("Sending handshake message");
    handshakeMessage.send();
  }

  protected boolean isEnterpriseClient() {
    return false;
  }

  @Override
  public void fireNodeError() {
    final String msg =
        "Reconnection was rejected from server. This client will never be able to join the cluster again.";
    logger.error(msg);
    CONSOLE_LOGGER.error(msg);
    clusterEventsGun.fireNodeError();
  }

  @Override
  public void disconnected() {
    // We ignore the disconnected call if we are shutting down.
    if (!checkShutdown()) {
      lock.lock();
      try {
        boolean isPaused = changeToPaused();
        if (isPaused) {
          pauseCallbacks();
          this.sessionManager.newSession();
          this.logger.info("ClientHandshakeManager moves to " + this.sessionManager.getSessionID());
        }
      } finally {
        lock.unlock();
      }
    }
  }

  @Override
  public void connected() {
    this.logger.info("Connected: Unpausing from " + getState());
    if (getState() != State.PAUSED) {
      this.logger.warn("Ignoring unpause while " + getState());
    } else if (!checkShutdown()) {
      // drop handshaking if shutting down
      initiateHandshake();
    }
  }

  @Override
  public void acknowledgeHandshake(ClientHandshakeAckMessage handshakeAck) {
    acknowledgeHandshake(
        handshakeAck.getPersistentServer(),
        handshakeAck.getThisNodeId(),
        handshakeAck.getAllNodes(),
        handshakeAck.getServerVersion());
  }

  protected void acknowledgeHandshake(
      boolean persistentServer,
      ClientID thisNodeId,
      ClientID[] clusterMembers,
      String serverVersion) {
    this.logger.info("Received Handshake ack");
    if (getState() != State.STARTING) {
      this.logger.warn("Ignoring handshake acknowledgement while " + getState());
    } else {
      checkClientServerVersionCompatibility(serverVersion);
      this.serverIsPersistent = persistentServer;
      lock.lock();
      try {
        changeToRunning();
        unpauseCallbacks();
      } finally {
        lock.unlock();
      }

      clusterEventsGun.fireThisNodeJoined(thisNodeId, clusterMembers);
    }
  }

  protected void checkClientServerVersionCompatibility(String serverVersion) {
    final boolean check =
        TCPropertiesImpl.getProperties().getBoolean(TCPropertiesConsts.VERSION_COMPATIBILITY_CHECK);

    if (check
        && !new VersionCompatibility()
            .isCompatibleClientServer(new Version(clientVersion), new Version(serverVersion))) {
      final String msg =
          "Client/Server versions are not compatibile: Client Version: "
              + clientVersion
              + ", Server Version: "
              + serverVersion
              + ".  Terminating client now.";
      CONSOLE_LOGGER.error(msg);
      throw new IllegalStateException(msg);
    }
  }

  private void shutdownCallbacks(boolean fromShutdownHook) {
    // Now that the handshake manager has concluded that it is entering into a shutdown state,
    // anyone else wishing to use it
    // needs to be notified that they cannot.
    for (ClientHandshakeCallback c : this.callBacks) {
      c.shutdown(fromShutdownHook);
    }
  }

  private void pauseCallbacks() {
    for (ClientHandshakeCallback c : this.callBacks) {
      c.pause();
    }
  }

  private void notifyCallbackOnHandshake(ClientHandshakeMessage handshakeMessage) {
    for (ClientHandshakeCallback c : this.callBacks) {
      c.initializeHandshake(handshakeMessage);
    }
  }

  private void unpauseCallbacks() {
    for (ClientHandshakeCallback c : this.callBacks) {
      c.unpause();
    }
  }

  @Override
  public boolean serverIsPersistent() {
    return this.serverIsPersistent;
  }

  @Override
  public synchronized void waitForHandshake() {
    boolean isInterrupted = false;
    try {
      while (this.disconnected && !this.isShutdown()) {
        try {
          wait();
        } catch (InterruptedException e) {
          this.logger.error("Interrupted while waiting for handshake");
          isInterrupted = true;
        }
      }
    } finally {
      Util.selfInterruptIfNeeded(isInterrupted);
    }
  }

  // returns true if PAUSED else return false if already PAUSED
  private synchronized boolean changeToPaused() {
    final State old = this.state;
    boolean didChangeToPaused = false;
    if (old != State.PAUSED) {
      this.state = State.PAUSED;
      didChangeToPaused = true;

      this.logger.info(
          "Disconnected: Pausing from " + old + ". Disconnect count: " + this.disconnected);

      if (old == State.RUNNING) {
        this.disconnected = true;
        // A thread might be waiting for us to change whether or not we are disconnected.
        notifyAll();
      }

      this.clusterEventsGun.fireOperationsDisabled();
    }
    return didChangeToPaused;
  }

  private synchronized void changeToStarting() {
    Assert.assertEquals(state, State.PAUSED);
    state = State.STARTING;
  }

  private synchronized void changeToRunning() {
    Assert.assertEquals(state, State.STARTING);
    state = State.RUNNING;

    this.disconnected = false;
    notifyAll();
  }

  private synchronized State getState() {
    return this.state;
  }
}
/** This is the main point of entry into the DSO client. */
public class DistributedObjectClient implements TCClient {

  protected static final TCLogger DSO_LOGGER = CustomerLogging.getDSOGenericLogger();
  private static final TCLogger CONSOLE_LOGGER = CustomerLogging.getConsoleLogger();
  private static final int MAX_CONNECT_TRIES = -1;

  private static final String L1VMShutdownHookName = "L1 VM Shutdown Hook";

  private final ClientBuilder clientBuilder;
  private final ClientConfig config;
  private final ClusterInternal cluster;
  private final TCThreadGroup threadGroup;
  private final ThreadIDMap threadIDMap;

  protected final PreparedComponentsFromL2Connection connectionComponents;
  private final ProductID productId;

  private ClientMessageChannel channel;
  private ClientLockManager lockManager;
  private CommunicationsManager communicationsManager;
  private ClientHandshakeManager clientHandshakeManager;

  private CounterManager counterManager;
  private ThreadIDManager threadIDManager;
  private final CallbackDumpHandler dumpHandler = new CallbackDumpHandler();
  private TCMemoryManagerImpl tcMemManager;

  private Stage<ClusterInternalEventsContext> clusterEventsStage;

  private final TCSecurityManager securityManager;

  private final String uuid;
  private final String name;

  private final TaskRunner taskRunner;

  private ClientShutdownManager shutdownManager;

  private final Thread shutdownAction;

  private final SetOnceFlag clientStopped = new SetOnceFlag();
  private final SetOnceFlag connectionMade = new SetOnceFlag();
  private ClientEntityManager clientEntityManager;
  private final StageManager communicationStageManager;

  public DistributedObjectClient(
      ClientConfig config,
      TCThreadGroup threadGroup,
      PreparedComponentsFromL2Connection connectionComponents,
      ClusterInternal cluster) {
    this(
        config,
        threadGroup,
        connectionComponents,
        cluster,
        null,
        UUID.NULL_ID.toString(),
        "",
        null);
  }

  public DistributedObjectClient(
      ClientConfig config,
      TCThreadGroup threadGroup,
      PreparedComponentsFromL2Connection connectionComponents,
      ClusterInternal cluster,
      TCSecurityManager securityManager,
      String uuid,
      String name,
      ProductID productId) {
    this.productId = productId;
    Assert.assertNotNull(config);
    this.config = config;
    this.securityManager = securityManager;
    this.connectionComponents = connectionComponents;
    this.cluster = cluster;
    this.threadGroup = threadGroup;
    this.threadIDMap = new ThreadIDMapImpl();
    this.clientBuilder = createClientBuilder();
    this.uuid = uuid;
    this.name = name;
    this.taskRunner = Runners.newDefaultCachedScheduledTaskRunner(threadGroup);
    this.shutdownAction = new Thread(new ShutdownAction(), L1VMShutdownHookName);
    Runtime.getRuntime().addShutdownHook(this.shutdownAction);

    // We need a StageManager to create the SEDA stages used for handling the messages.
    final SEDA<Void> seda = new SEDA<Void>(threadGroup);
    communicationStageManager = seda.getStageManager();
    this.tcMemManager = new TCMemoryManagerImpl(threadGroup);
  }

  protected ClientBuilder createClientBuilder() {
    return new StandardClientBuilder();
  }

  @Override
  public ThreadIDMap getThreadIDMap() {
    return this.threadIDMap;
  }

  @Override
  public void addAllLocksTo(LockInfoByThreadID lockInfo) {
    if (this.lockManager != null) {
      for (final ClientServerExchangeLockContext c : this.lockManager.getAllLockContexts()) {
        switch (c.getState().getType()) {
          case GREEDY_HOLDER:
          case HOLDER:
            lockInfo.addLock(LockState.HOLDING, c.getThreadID(), c.getLockID().toString());
            break;
          case WAITER:
            lockInfo.addLock(LockState.WAITING_ON, c.getThreadID(), c.getLockID().toString());
            break;
          case TRY_PENDING:
          case PENDING:
            lockInfo.addLock(LockState.WAITING_TO, c.getThreadID(), c.getLockID().toString());
            break;
          default:
            throw new AssertionError(c.getState().getType());
        }
      }
    } else {
      DSO_LOGGER.error("LockManager not initialised still. LockInfo for threads cannot be updated");
    }
  }

  private void validateSecurityConfig() {
    if (config.getSecurityInfo().isSecure() && securityManager == null) {
      throw new TCRuntimeException(
          "client configured as secure but was constructed without securityManager");
    }
    if (!config.getSecurityInfo().isSecure() && securityManager != null) {
      throw new TCRuntimeException(
          "client not configured as secure but was constructed with securityManager");
    }
  }

  private ReconnectConfig getReconnectPropertiesFromServer() {
    ReconnectConfig reconnectConfig =
        new ReconnectConfig() {

          @Override
          public boolean getReconnectEnabled() {
            return true;
          }

          @Override
          public int getReconnectTimeout() {
            return 5000;
          }

          @Override
          public int getSendQueueCapacity() {
            return 5000;
          }

          @Override
          public int getMaxDelayAcks() {
            return 16;
          }

          @Override
          public int getSendWindow() {
            return 32;
          }
        };
    return reconnectConfig;
  }

  private NetworkStackHarnessFactory getNetworkStackHarnessFactory(
      boolean useOOOLayer, ReconnectConfig l1ReconnectConfig) {
    if (useOOOLayer) {
      return new OOONetworkStackHarnessFactory(
          new OnceAndOnlyOnceProtocolNetworkLayerFactoryImpl(), l1ReconnectConfig);
    } else {
      return new PlainNetworkStackHarnessFactory();
    }
  }

  public Stage<ClusterInternalEventsContext> getClusterEventsStage() {
    return clusterEventsStage;
  }

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

  private synchronized void connectionMade() {
    connectionMade.attemptSet();
    notifyAll();
  }

  public synchronized boolean waitForConnection(long timeout, TimeUnit units)
      throws InterruptedException {
    long left = timeout > 0 ? units.toMillis(timeout) : Long.MAX_VALUE;
    while (!connectionMade.isSet() && left > 0) {
      long start = System.currentTimeMillis();
      this.wait(units.toMillis(timeout));
      left -= (System.currentTimeMillis() - start);
    }
    return connectionMade.isSet();
  }

  private synchronized void openChannel(String serverHost, int serverPort)
      throws InterruptedException {
    while (!clientStopped.isSet()) {
      try {
        DSO_LOGGER.debug("Trying to open channel....");
        final char[] pw;
        if (config.getSecurityInfo().hasCredentials()) {
          Assert.assertNotNull(securityManager);
          pw =
              securityManager.getPasswordForTC(
                  config.getSecurityInfo().getUsername(), serverHost, serverPort);
        } else {
          pw = null;
        }
        this.channel.open(pw);
        DSO_LOGGER.debug("Channel open");
        break;
      } catch (final TCTimeoutException tcte) {
        CONSOLE_LOGGER.warn("Timeout connecting to server: " + tcte.getMessage());
        this.wait(5000);
      } catch (final ConnectException e) {
        CONSOLE_LOGGER.warn("Connection refused from server: " + e);
        this.wait(5000);
      } catch (final MaxConnectionsExceededException e) {
        DSO_LOGGER.fatal(e.getMessage());
        CONSOLE_LOGGER.fatal(e.getMessage());
        throw new IllegalStateException(e.getMessage(), e);
      } catch (final CommStackMismatchException e) {
        DSO_LOGGER.fatal(e.getMessage());
        CONSOLE_LOGGER.fatal(e.getMessage());
        throw new IllegalStateException(e.getMessage(), e);
      } catch (final IOException ioe) {
        CONSOLE_LOGGER.warn(
            "IOException connecting to server: "
                + serverHost
                + ":"
                + serverPort
                + ". "
                + ioe.getMessage());
        this.wait(5000);
      }
    }
  }

  private synchronized void waitForHandshake() {
    this.clientHandshakeManager.waitForHandshake();
    if (this.channel != null) {
      final TCSocketAddress remoteAddress = this.channel.getRemoteAddress();
      final String infoMsg = "Connection successfully established to server at " + remoteAddress;
      CONSOLE_LOGGER.info(infoMsg);
      DSO_LOGGER.info(infoMsg);
    }
  }

  private Map<TCMessageType, Class<? extends TCMessage>> getMessageTypeClassMapping() {
    final Map<TCMessageType, Class<? extends TCMessage>> messageTypeClassMapping =
        new HashMap<TCMessageType, Class<? extends TCMessage>>();

    messageTypeClassMapping.put(TCMessageType.LOCK_REQUEST_MESSAGE, LockRequestMessage.class);
    messageTypeClassMapping.put(TCMessageType.LOCK_RESPONSE_MESSAGE, LockResponseMessage.class);
    messageTypeClassMapping.put(TCMessageType.LOCK_RECALL_MESSAGE, LockResponseMessage.class);
    messageTypeClassMapping.put(
        TCMessageType.LOCK_QUERY_RESPONSE_MESSAGE, LockResponseMessage.class);
    messageTypeClassMapping.put(
        TCMessageType.CLIENT_HANDSHAKE_MESSAGE, ClientHandshakeMessageImpl.class);
    messageTypeClassMapping.put(
        TCMessageType.CLIENT_HANDSHAKE_ACK_MESSAGE, ClientHandshakeAckMessageImpl.class);
    messageTypeClassMapping.put(
        TCMessageType.CLIENT_HANDSHAKE_REFUSED_MESSAGE, ClientHandshakeRefusedMessageImpl.class);
    messageTypeClassMapping.put(
        TCMessageType.CLUSTER_MEMBERSHIP_EVENT_MESSAGE, ClusterMembershipMessage.class);
    messageTypeClassMapping.put(
        TCMessageType.LIST_REGISTERED_SERVICES_MESSAGE, ListRegisteredServicesMessage.class);
    messageTypeClassMapping.put(
        TCMessageType.LIST_REGISTERED_SERVICES_RESPONSE_MESSAGE,
        ListRegisteredServicesResponseMessage.class);
    messageTypeClassMapping.put(
        TCMessageType.INVOKE_REGISTERED_SERVICE_MESSAGE, InvokeRegisteredServiceMessage.class);
    messageTypeClassMapping.put(
        TCMessageType.INVOKE_REGISTERED_SERVICE_RESPONSE_MESSAGE,
        InvokeRegisteredServiceResponseMessage.class);
    messageTypeClassMapping.put(
        TCMessageType.VOLTRON_ENTITY_MESSAGE, NetworkVoltronEntityMessageImpl.class);
    messageTypeClassMapping.put(
        TCMessageType.VOLTRON_ENTITY_RECEIVED_RESPONSE, VoltronEntityReceivedResponseImpl.class);
    messageTypeClassMapping.put(
        TCMessageType.VOLTRON_ENTITY_APPLIED_RESPONSE, VoltronEntityAppliedResponseImpl.class);
    messageTypeClassMapping.put(
        TCMessageType.VOLTRON_ENTITY_RETIRED_RESPONSE, VoltronEntityRetiredResponseImpl.class);
    messageTypeClassMapping.put(TCMessageType.SERVER_ENTITY_MESSAGE, ServerEntityMessageImpl.class);
    messageTypeClassMapping.put(
        TCMessageType.SERVER_ENTITY_RESPONSE_MESSAGE, ServerEntityResponseMessageImpl.class);
    return messageTypeClassMapping;
  }

  private void initChannelMessageRouter(
      TCMessageRouter messageRouter,
      Sink<HydrateContext> hydrateSink,
      Sink<Void> lockResponseSink,
      Sink<PauseContext> pauseSink,
      Sink<Void> clusterMembershipEventSink,
      Sink<VoltronEntityResponse> responseSink,
      Sink<Void> serverEntityMessageSink) {
    messageRouter.routeMessageType(
        TCMessageType.LOCK_RESPONSE_MESSAGE, lockResponseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.LOCK_QUERY_RESPONSE_MESSAGE, lockResponseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.LOCK_RECALL_MESSAGE, lockResponseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.CLIENT_HANDSHAKE_ACK_MESSAGE, pauseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.CLIENT_HANDSHAKE_REFUSED_MESSAGE, pauseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.CLUSTER_MEMBERSHIP_EVENT_MESSAGE, clusterMembershipEventSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.VOLTRON_ENTITY_RECEIVED_RESPONSE, responseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.VOLTRON_ENTITY_APPLIED_RESPONSE, responseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.VOLTRON_ENTITY_RETIRED_RESPONSE, responseSink, hydrateSink);
    messageRouter.routeMessageType(
        TCMessageType.SERVER_ENTITY_MESSAGE, serverEntityMessageSink, hydrateSink);
    DSO_LOGGER.debug("Added message routing types.");
  }

  public ClientLockManager getLockManager() {
    return this.lockManager;
  }

  public ClientEntityManager getEntityManager() {
    return this.clientEntityManager;
  }

  public CommunicationsManager getCommunicationsManager() {
    return this.communicationsManager;
  }

  public ClientMessageChannel getChannel() {
    return this.channel;
  }

  public ClientHandshakeManager getClientHandshakeManager() {
    return this.clientHandshakeManager;
  }

  @Override
  public void dump() {
    this.dumpHandler.dump();
  }

  protected ClientConfig getClientConfigHelper() {
    return this.config;
  }

  public void shutdown() {
    shutdown(false, false);
  }

  void shutdownResources() {
    final TCLogger logger = DSO_LOGGER;

    if (this.counterManager != null) {
      try {
        this.counterManager.shutdown();
      } catch (final Throwable t) {
        logger.error("error shutting down counter manager", t);
      } finally {
        this.counterManager = null;
      }
    }

    if (this.tcMemManager != null) {
      try {
        this.tcMemManager.shutdown();
      } catch (final Throwable t) {
        logger.error("Error stopping memory manager", t);
      } finally {
        this.tcMemManager = null;
      }
    }

    if (this.lockManager != null) {
      try {
        this.lockManager.shutdown(false);
      } catch (final Throwable t) {
        logger.error("Error stopping lock manager", t);
      } finally {
        this.lockManager = null;
      }
    }

    try {
      this.communicationStageManager.stopAll();
    } catch (final Throwable t) {
      logger.error("Error stopping stage manager", t);
    }

    if (this.channel != null) {
      try {
        this.channel.close();
      } catch (final Throwable t) {
        logger.error("Error closing channel", t);
      } finally {
        this.channel = null;
      }
    }

    if (this.communicationsManager != null) {
      try {
        this.communicationsManager.shutdown();
      } catch (final Throwable t) {
        logger.error("Error shutting down communications manager", t);
      } finally {
        this.communicationsManager = null;
      }
    }

    if (taskRunner != null) {
      logger.info("Shutting down TaskRunner");
      taskRunner.shutdown();
    }

    CommonShutDownHook.shutdown();
    this.cluster.shutdown();

    if (this.threadGroup != null) {
      boolean interrupted = false;

      try {
        final long end =
            System.currentTimeMillis()
                + TCPropertiesImpl.getProperties()
                    .getLong(TCPropertiesConsts.L1_SHUTDOWN_THREADGROUP_GRACETIME);

        int threadCount = this.threadGroup.activeCount();
        Thread[] t = new Thread[threadCount];
        threadCount = this.threadGroup.enumerate(t);
        final long time = System.currentTimeMillis();
        for (int x = 0; x < threadCount; x++) {
          long start = System.currentTimeMillis();
          while (System.currentTimeMillis() < end && t[x].isAlive()) {
            t[x].join(1000);
          }
          logger.info(
              "Destroyed thread "
                  + t[x].getName()
                  + " time to destroy:"
                  + (System.currentTimeMillis() - start)
                  + " millis");
        }
        logger.info(
            "time to destroy thread group:"
                + TimeUnit.SECONDS.convert(System.currentTimeMillis() - time, TimeUnit.MILLISECONDS)
                + " seconds");

        if (this.threadGroup.activeCount() > 0) {
          logger.warn(
              "Timed out waiting for TC thread group threads to die - probable shutdown memory leak\n"
                  + "Live threads: "
                  + getLiveThreads(this.threadGroup));

          Thread threadGroupCleanerThread =
              new Thread(
                  this.threadGroup.getParent(),
                  new TCThreadGroupCleanerRunnable(threadGroup),
                  "TCThreadGroup last chance cleaner thread");
          threadGroupCleanerThread.setDaemon(true);
          threadGroupCleanerThread.start();
          logger.warn("Spawning TCThreadGroup last chance cleaner thread");
        } else {
          logger.info("Destroying TC thread group");
          this.threadGroup.destroy();
        }
      } catch (final Throwable t) {
        logger.error("Error destroying TC thread group", t);
      } finally {
        if (interrupted) {
          Thread.currentThread().interrupt();
        }
      }
    }

    if (TCPropertiesImpl.getProperties()
        .getBoolean(TCPropertiesConsts.L1_SHUTDOWN_FORCE_FINALIZATION)) System.runFinalization();
  }

  private static List<Thread> getLiveThreads(ThreadGroup group) {
    final int estimate = group.activeCount();

    Thread[] threads = new Thread[estimate + 1];

    while (true) {
      final int count = group.enumerate(threads);

      if (count < threads.length) {
        final List<Thread> l = new ArrayList<Thread>(count);
        for (final Thread t : threads) {
          if (t != null) {
            l.add(t);
          }
        }
        return l;
      } else {
        threads = new Thread[threads.length * 2];
      }
    }
  }

  @Override
  public String[] processArguments() {
    return null;
  }

  @Override
  public String getUUID() {
    return uuid;
  }

  private static class TCThreadGroupCleanerRunnable implements Runnable {
    private final TCThreadGroup threadGroup;

    public TCThreadGroupCleanerRunnable(TCThreadGroup threadGroup) {
      this.threadGroup = threadGroup;
    }

    @Override
    public void run() {
      while (threadGroup.activeCount() > 0) {
        for (Thread liveThread : getLiveThreads(threadGroup)) {
          liveThread.interrupt();
        }
        try {
          Thread.sleep(1000);
        } catch (final InterruptedException e) {
          // ignore
        }
      }
      try {
        threadGroup.destroy();
      } catch (Exception e) {
        // the logger is closed by now so we can't even log that
      }
    }
  }

  public Cluster getCluster() {
    return this.cluster;
  }

  private void shutdownClient(boolean fromShutdownHook, boolean forceImmediate) {
    if (this.shutdownManager != null) {
      try {
        this.shutdownManager.execute(fromShutdownHook, forceImmediate);
      } finally {
        // If we're not being called as a result of the shutdown hook, de-register the hook
        if (Thread.currentThread() != this.shutdownAction) {
          try {
            Runtime.getRuntime().removeShutdownHook(this.shutdownAction);
          } catch (final Exception e) {
            // ignore
          }
        }
      }
    }
  }

  private void shutdown(boolean fromShutdownHook, boolean forceImmediate) {
    if (clientStopped.attemptSet()) {
      DSO_LOGGER.info(
          "shuting down Terracotta Client hook=" + fromShutdownHook + " force=" + forceImmediate);
      shutdownClient(fromShutdownHook, forceImmediate);
    } else {
      DSO_LOGGER.info("Client already shutdown.");
    }
    synchronized (this) {
      //  notify in case the connection establisher is waiting for something
      notifyAll();
    }
  }

  private class ShutdownAction implements Runnable {
    @Override
    public void run() {
      DSO_LOGGER.info("Running L1 VM shutdown hook");
      shutdown(true, false);
    }
  }
}