/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.iotdb.session;

import org.apache.iotdb.common.rpc.thrift.TAggregationType;
import org.apache.iotdb.common.rpc.thrift.TEndPoint;
import org.apache.iotdb.common.rpc.thrift.TSStatus;
import org.apache.iotdb.isession.SessionConfig;
import org.apache.iotdb.isession.SessionDataSet;
import org.apache.iotdb.rpc.IoTDBConnectionException;
import org.apache.iotdb.rpc.RedirectException;
import org.apache.iotdb.rpc.RpcTransportFactory;
import org.apache.iotdb.rpc.RpcUtils;
import org.apache.iotdb.rpc.StatementExecutionException;
import org.apache.iotdb.service.rpc.thrift.IClientRPCService;
import org.apache.iotdb.service.rpc.thrift.TCreateTimeseriesUsingSchemaTemplateReq;
import org.apache.iotdb.service.rpc.thrift.TSAggregationQueryReq;
import org.apache.iotdb.service.rpc.thrift.TSAppendSchemaTemplateReq;
import org.apache.iotdb.service.rpc.thrift.TSBackupConfigurationResp;
import org.apache.iotdb.service.rpc.thrift.TSCloseSessionReq;
import org.apache.iotdb.service.rpc.thrift.TSConnectionInfoResp;
import org.apache.iotdb.service.rpc.thrift.TSCreateAlignedTimeseriesReq;
import org.apache.iotdb.service.rpc.thrift.TSCreateMultiTimeseriesReq;
import org.apache.iotdb.service.rpc.thrift.TSCreateSchemaTemplateReq;
import org.apache.iotdb.service.rpc.thrift.TSCreateTimeseriesReq;
import org.apache.iotdb.service.rpc.thrift.TSDeleteDataReq;
import org.apache.iotdb.service.rpc.thrift.TSDropSchemaTemplateReq;
import org.apache.iotdb.service.rpc.thrift.TSExecuteStatementReq;
import org.apache.iotdb.service.rpc.thrift.TSExecuteStatementResp;
import org.apache.iotdb.service.rpc.thrift.TSFastLastDataQueryForOneDeviceReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertRecordReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertRecordsOfOneDeviceReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertRecordsReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertStringRecordReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertStringRecordsOfOneDeviceReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertStringRecordsReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertTabletReq;
import org.apache.iotdb.service.rpc.thrift.TSInsertTabletsReq;
import org.apache.iotdb.service.rpc.thrift.TSLastDataQueryReq;
import org.apache.iotdb.service.rpc.thrift.TSOpenSessionReq;
import org.apache.iotdb.service.rpc.thrift.TSOpenSessionResp;
import org.apache.iotdb.service.rpc.thrift.TSPruneSchemaTemplateReq;
import org.apache.iotdb.service.rpc.thrift.TSQueryTemplateReq;
import org.apache.iotdb.service.rpc.thrift.TSQueryTemplateResp;
import org.apache.iotdb.service.rpc.thrift.TSRawDataQueryReq;
import org.apache.iotdb.service.rpc.thrift.TSSetSchemaTemplateReq;
import org.apache.iotdb.service.rpc.thrift.TSSetTimeZoneReq;
import org.apache.iotdb.service.rpc.thrift.TSUnsetSchemaTemplateReq;
import org.apache.iotdb.session.util.SessionUtils;
import org.apache.iotdb.tsfile.utils.Pair;

import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.security.SecureRandom;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringJoiner;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

public class SessionConnection {

  private static final Logger logger = LoggerFactory.getLogger(SessionConnection.class);
  public static final String MSG_RECONNECTION_FAIL =
      "Fail to reconnect to server. Please check server status.";
  private Session session;
  private TTransport transport;
  private IClientRPCService.Iface client;
  private long sessionId;
  private long statementId;
  private ZoneId zoneId;
  private TEndPoint endPoint;
  private List<TEndPoint> endPointList = new ArrayList<>();
  private boolean enableRedirect = false;

  private final Supplier<List<TEndPoint>> availableNodes;

  private final int maxRetryCount;

  private final long retryIntervalInMs;

  // TestOnly
  public SessionConnection() {
    availableNodes = Collections::emptyList;
    this.maxRetryCount = Math.max(0, SessionConfig.MAX_RETRY_COUNT);
    this.retryIntervalInMs = Math.max(0, SessionConfig.RETRY_INTERVAL_IN_MS);
  }

  public SessionConnection(
      Session session,
      TEndPoint endPoint,
      ZoneId zoneId,
      Supplier<List<TEndPoint>> availableNodes,
      int maxRetryCount,
      long retryIntervalInMs)
      throws IoTDBConnectionException {
    this.session = session;
    this.endPoint = endPoint;
    endPointList.add(endPoint);
    this.zoneId = zoneId == null ? ZoneId.systemDefault() : zoneId;
    this.availableNodes = availableNodes;
    this.maxRetryCount = Math.max(0, maxRetryCount);
    this.retryIntervalInMs = Math.max(0, retryIntervalInMs);
    try {
      init(endPoint, session.useSSL, session.trustStore, session.trustStorePwd);
    } catch (IoTDBConnectionException e) {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  public SessionConnection(
      Session session,
      ZoneId zoneId,
      Supplier<List<TEndPoint>> availableNodes,
      int maxRetryCount,
      long retryIntervalInMs)
      throws IoTDBConnectionException {
    this.session = session;
    this.zoneId = zoneId == null ? ZoneId.systemDefault() : zoneId;
    this.endPointList = SessionUtils.parseSeedNodeUrls(session.nodeUrls);
    this.availableNodes = availableNodes;
    this.maxRetryCount = Math.max(0, maxRetryCount);
    this.retryIntervalInMs = Math.max(0, retryIntervalInMs);
    initClusterConn();
  }

  private void init(TEndPoint endPoint, boolean useSSL, String trustStore, String trustStorePwd)
      throws IoTDBConnectionException {
    RpcTransportFactory.setDefaultBufferCapacity(session.thriftDefaultBufferSize);
    RpcTransportFactory.setThriftMaxFrameSize(session.thriftMaxFrameSize);
    try {
      if (useSSL) {
        transport =
            RpcTransportFactory.INSTANCE.getTransport(
                endPoint.getIp(),
                endPoint.getPort(),
                session.connectionTimeoutInMs,
                trustStore,
                trustStorePwd);
      } else {
        transport =
            RpcTransportFactory.INSTANCE.getTransport(
                // as there is a try-catch already, we do not need to use TSocket.wrap
                endPoint.getIp(), endPoint.getPort(), session.connectionTimeoutInMs);
      }
      if (!transport.isOpen()) {
        transport.open();
      }
    } catch (TTransportException e) {
      throw new IoTDBConnectionException(e);
    }

    if (session.enableRPCCompression) {
      client = new IClientRPCService.Client(new TCompactProtocol(transport));
    } else {
      client = new IClientRPCService.Client(new TBinaryProtocol(transport));
    }
    client = RpcUtils.newSynchronizedClient(client);

    TSOpenSessionReq openReq = new TSOpenSessionReq();
    openReq.setUsername(session.username);
    openReq.setPassword(session.password);
    openReq.setZoneId(zoneId.toString());
    openReq.putToConfiguration("version", session.version.toString());

    try {
      TSOpenSessionResp openResp = client.openSession(openReq);

      RpcUtils.verifySuccess(openResp.getStatus());

      if (Session.protocolVersion.getValue() != openResp.getServerProtocolVersion().getValue()) {
        logger.warn(
            "Protocol differ, Client version is {}}, but Server version is {}",
            Session.protocolVersion.getValue(),
            openResp.getServerProtocolVersion().getValue());
        // less than 0.10
        if (openResp.getServerProtocolVersion().getValue() == 0) {
          throw new TException(
              String.format(
                  "Protocol not supported, Client version is %s, but Server version is %s",
                  Session.protocolVersion.getValue(),
                  openResp.getServerProtocolVersion().getValue()));
        }
      }

      sessionId = openResp.getSessionId();
      statementId = client.requestStatementId(sessionId);

    } catch (Exception e) {
      transport.close();
      throw new IoTDBConnectionException(e);
    }
  }

  @SuppressWarnings({"squid:S1751"}) // Loops with at most one iteration should be refactored
  private void initClusterConn() throws IoTDBConnectionException {
    for (TEndPoint tEndPoint : endPointList) {
      try {
        session.defaultEndPoint = tEndPoint;
        init(tEndPoint, session.useSSL, session.trustStore, session.trustStorePwd);
      } catch (IoTDBConnectionException e) {
        if (!reconnect()) {
          logger.error("Cluster has no nodes to connect");
          throw new IoTDBConnectionException(logForReconnectionFailure());
        }
      }
      break;
    }
  }

  public void close() throws IoTDBConnectionException {
    TSCloseSessionReq req = new TSCloseSessionReq(sessionId);
    try {
      client.closeSession(req);
    } catch (TException e) {
      throw new IoTDBConnectionException(
          "Error occurs when closing session at server. Maybe server is down.", e);
    } finally {
      if (transport != null) {
        transport.close();
      }
    }
  }

  protected IClientRPCService.Iface getClient() {
    return client;
  }

  protected void setTimeZone(String zoneId)
      throws StatementExecutionException, IoTDBConnectionException {
    TSSetTimeZoneReq req = new TSSetTimeZoneReq(sessionId, zoneId);
    TSStatus resp;
    try {
      resp = client.setTimeZone(req);
    } catch (TException e) {
      if (reconnect()) {
        try {
          req.setSessionId(sessionId);
          resp = client.setTimeZone(req);
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
    RpcUtils.verifySuccess(resp);
    setTimeZoneOfSession(zoneId);
  }

  protected void setTimeZoneOfSession(String zoneId) {
    this.zoneId = ZoneId.of(zoneId);
  }

  protected String getTimeZone() {
    if (zoneId == null) {
      zoneId = ZoneId.systemDefault();
    }
    return zoneId.toString();
  }

  protected void setStorageGroup(String storageGroup)
      throws IoTDBConnectionException, StatementExecutionException {
    try {
      RpcUtils.verifySuccess(client.setStorageGroup(sessionId, storageGroup));
    } catch (TException e) {
      if (reconnect()) {
        try {
          RpcUtils.verifySuccess(client.setStorageGroup(sessionId, storageGroup));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void deleteStorageGroups(List<String> storageGroups)
      throws IoTDBConnectionException, StatementExecutionException {
    try {
      RpcUtils.verifySuccess(client.deleteStorageGroups(sessionId, storageGroups));
    } catch (TException e) {
      if (reconnect()) {
        try {
          RpcUtils.verifySuccess(client.deleteStorageGroups(sessionId, storageGroups));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void createTimeseries(TSCreateTimeseriesReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.createTimeseries(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.createTimeseries(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void createAlignedTimeseries(TSCreateAlignedTimeseriesReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.createAlignedTimeseries(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.createAlignedTimeseries(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void createMultiTimeseries(TSCreateMultiTimeseriesReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.createMultiTimeseries(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.createMultiTimeseries(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected boolean checkTimeseriesExists(String path, long timeout)
      throws IoTDBConnectionException, StatementExecutionException {
    SessionDataSet dataSet = null;
    try {
      try {
        dataSet = executeQueryStatement(String.format("SHOW TIMESERIES %s", path), timeout);
      } catch (RedirectException e) {
        throw new StatementExecutionException("need to redirect query, should not see this.", e);
      }
      return dataSet.hasNext();
    } finally {
      if (dataSet != null) {
        dataSet.closeOperationHandle();
      }
    }
  }

  protected SessionDataSet executeQueryStatement(String sql, long timeout)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSExecuteStatementReq execReq = new TSExecuteStatementReq(sessionId, sql, statementId);
    execReq.setFetchSize(session.fetchSize);
    execReq.setTimeout(timeout);
    TSExecuteStatementResp execResp;
    try {
      execReq.setEnableRedirectQuery(enableRedirect);
      execResp = client.executeQueryStatementV2(execReq);
      RpcUtils.verifySuccessWithRedirection(execResp.getStatus());
    } catch (TException e) {
      if (reconnect()) {
        try {
          execReq.setSessionId(sessionId);
          execReq.setStatementId(statementId);
          execResp = client.executeQueryStatementV2(execReq);
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }

    RpcUtils.verifySuccess(execResp.getStatus());
    return new SessionDataSet(
        sql,
        execResp.getColumns(),
        execResp.getDataTypeList(),
        execResp.columnNameIndexMap,
        execResp.getQueryId(),
        statementId,
        client,
        sessionId,
        execResp.queryResult,
        execResp.isIgnoreTimeStamp(),
        timeout,
        execResp.moreData,
        session.fetchSize);
  }

  protected void executeNonQueryStatement(String sql)
      throws IoTDBConnectionException, StatementExecutionException {

    TSExecuteStatementReq request = new TSExecuteStatementReq(sessionId, sql, statementId);

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = executeNonQueryStatementInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        RpcUtils.verifySuccess(status);
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus executeNonQueryStatementInternal(TSExecuteStatementReq request)
      throws TException {
    request.setSessionId(sessionId);
    request.setStatementId(statementId);
    return client.executeUpdateStatementV2(request).status;
  }

  protected SessionDataSet executeRawDataQuery(
      List<String> paths, long startTime, long endTime, long timeOut)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSRawDataQueryReq execReq =
        new TSRawDataQueryReq(sessionId, paths, startTime, endTime, statementId);
    execReq.setFetchSize(session.fetchSize);
    execReq.setTimeout(timeOut);
    TSExecuteStatementResp execResp;
    try {
      execReq.setEnableRedirectQuery(enableRedirect);
      execResp = client.executeRawDataQueryV2(execReq);
      RpcUtils.verifySuccessWithRedirection(execResp.getStatus());
    } catch (TException e) {
      if (reconnect()) {
        try {
          execReq.setSessionId(sessionId);
          execReq.setStatementId(statementId);
          execResp = client.executeRawDataQueryV2(execReq);
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }

    RpcUtils.verifySuccess(execResp.getStatus());
    return new SessionDataSet(
        "",
        execResp.getColumns(),
        execResp.getDataTypeList(),
        execResp.columnNameIndexMap,
        execResp.getQueryId(),
        statementId,
        client,
        sessionId,
        execResp.queryResult,
        execResp.isIgnoreTimeStamp(),
        execResp.moreData);
  }

  protected Pair<SessionDataSet, TEndPoint> executeLastDataQueryForOneDevice(
      String db, String device, List<String> sensors, boolean isLegalPathNodes, long timeOut)
      throws StatementExecutionException, IoTDBConnectionException {
    TSFastLastDataQueryForOneDeviceReq req =
        new TSFastLastDataQueryForOneDeviceReq(sessionId, db, device, sensors, statementId);
    req.setFetchSize(session.fetchSize);
    req.setEnableRedirectQuery(enableRedirect);
    req.setLegalPathNodes(isLegalPathNodes);
    req.setTimeout(timeOut);
    TSExecuteStatementResp tsExecuteStatementResp = null;
    TEndPoint redirectedEndPoint = null;
    try {
      tsExecuteStatementResp = client.executeFastLastDataQueryForOneDeviceV2(req);
      RpcUtils.verifySuccessWithRedirection(tsExecuteStatementResp.getStatus());
    } catch (RedirectException e) {
      redirectedEndPoint = e.getEndPoint();
    } catch (TException e) {
      if (reconnect()) {
        try {
          req.setSessionId(sessionId);
          req.setStatementId(statementId);
          tsExecuteStatementResp = client.executeFastLastDataQueryForOneDeviceV2(req);
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }

    RpcUtils.verifySuccess(tsExecuteStatementResp.getStatus());
    return new Pair<>(
        new SessionDataSet(
            "",
            tsExecuteStatementResp.getColumns(),
            tsExecuteStatementResp.getDataTypeList(),
            tsExecuteStatementResp.columnNameIndexMap,
            tsExecuteStatementResp.getQueryId(),
            statementId,
            client,
            sessionId,
            tsExecuteStatementResp.queryResult,
            tsExecuteStatementResp.isIgnoreTimeStamp(),
            tsExecuteStatementResp.moreData),
        redirectedEndPoint);
  }

  protected SessionDataSet executeLastDataQuery(List<String> paths, long time, long timeOut)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSLastDataQueryReq tsLastDataQueryReq =
        new TSLastDataQueryReq(sessionId, paths, time, statementId);
    tsLastDataQueryReq.setFetchSize(session.fetchSize);
    tsLastDataQueryReq.setEnableRedirectQuery(enableRedirect);
    tsLastDataQueryReq.setTimeout(timeOut);
    TSExecuteStatementResp tsExecuteStatementResp;
    try {
      tsExecuteStatementResp = client.executeLastDataQueryV2(tsLastDataQueryReq);
      RpcUtils.verifySuccessWithRedirection(tsExecuteStatementResp.getStatus());
    } catch (TException e) {
      if (reconnect()) {
        try {
          tsLastDataQueryReq.setSessionId(sessionId);
          tsLastDataQueryReq.setStatementId(statementId);
          tsExecuteStatementResp = client.executeLastDataQueryV2(tsLastDataQueryReq);
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }

    RpcUtils.verifySuccess(tsExecuteStatementResp.getStatus());
    return new SessionDataSet(
        "",
        tsExecuteStatementResp.getColumns(),
        tsExecuteStatementResp.getDataTypeList(),
        tsExecuteStatementResp.columnNameIndexMap,
        tsExecuteStatementResp.getQueryId(),
        statementId,
        client,
        sessionId,
        tsExecuteStatementResp.queryResult,
        tsExecuteStatementResp.isIgnoreTimeStamp(),
        tsExecuteStatementResp.moreData);
  }

  protected SessionDataSet executeAggregationQuery(
      List<String> paths, List<TAggregationType> aggregations)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSAggregationQueryReq req = createAggregationQueryReq(paths, aggregations);
    return executeAggregationQuery(req);
  }

  protected SessionDataSet executeAggregationQuery(
      List<String> paths, List<TAggregationType> aggregations, long startTime, long endTime)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSAggregationQueryReq req = createAggregationQueryReq(paths, aggregations);
    req.setStartTime(startTime);
    req.setEndTime(endTime);
    return executeAggregationQuery(req);
  }

  protected SessionDataSet executeAggregationQuery(
      List<String> paths,
      List<TAggregationType> aggregations,
      long startTime,
      long endTime,
      long interval)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSAggregationQueryReq req = createAggregationQueryReq(paths, aggregations);
    req.setStartTime(startTime);
    req.setEndTime(endTime);
    req.setInterval(interval);
    return executeAggregationQuery(req);
  }

  protected SessionDataSet executeAggregationQuery(
      List<String> paths,
      List<TAggregationType> aggregations,
      long startTime,
      long endTime,
      long interval,
      long slidingStep)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSAggregationQueryReq req = createAggregationQueryReq(paths, aggregations);
    req.setStartTime(startTime);
    req.setEndTime(endTime);
    req.setInterval(interval);
    req.setSlidingStep(slidingStep);
    return executeAggregationQuery(req);
  }

  private SessionDataSet executeAggregationQuery(TSAggregationQueryReq tsAggregationQueryReq)
      throws StatementExecutionException, IoTDBConnectionException, RedirectException {
    TSExecuteStatementResp tsExecuteStatementResp;
    try {
      tsExecuteStatementResp = client.executeAggregationQueryV2(tsAggregationQueryReq);
      RpcUtils.verifySuccessWithRedirection(tsExecuteStatementResp.getStatus());
    } catch (TException e) {
      if (reconnect()) {
        try {
          tsAggregationQueryReq.setSessionId(sessionId);
          tsAggregationQueryReq.setStatementId(statementId);
          tsExecuteStatementResp = client.executeAggregationQuery(tsAggregationQueryReq);
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }

    RpcUtils.verifySuccess(tsExecuteStatementResp.getStatus());
    return new SessionDataSet(
        "",
        tsExecuteStatementResp.getColumns(),
        tsExecuteStatementResp.getDataTypeList(),
        tsExecuteStatementResp.columnNameIndexMap,
        tsExecuteStatementResp.getQueryId(),
        statementId,
        client,
        sessionId,
        tsExecuteStatementResp.queryResult,
        tsExecuteStatementResp.isIgnoreTimeStamp(),
        tsExecuteStatementResp.moreData);
  }

  private TSAggregationQueryReq createAggregationQueryReq(
      List<String> paths, List<TAggregationType> aggregations) {
    TSAggregationQueryReq req =
        new TSAggregationQueryReq(sessionId, statementId, paths, aggregations);
    req.setFetchSize(session.getFetchSize());
    req.setTimeout(session.getQueryTimeout());
    return req;
  }

  protected void insertRecord(TSInsertRecordReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {
    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertRecordInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirection(status);
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertRecordInternal(TSInsertRecordReq request) throws TException {
    request.setSessionId(sessionId);
    return client.insertRecord(request);
  }

  protected void insertRecord(TSInsertStringRecordReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {
    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertRecordInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirection(status);
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertRecordInternal(TSInsertStringRecordReq request) throws TException {
    request.setSessionId(sessionId);
    return client.insertStringRecord(request);
  }

  protected void insertRecords(TSInsertRecordsReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {
    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertRecordsInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirectionForMultiDevices(status, request.getPrefixPaths());
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertRecordsInternal(TSInsertRecordsReq request) throws TException {
    request.setSessionId(sessionId);
    return client.insertRecords(request);
  }

  protected void insertRecords(TSInsertStringRecordsReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertRecordsInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirectionForMultiDevices(status, request.getPrefixPaths());
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertRecordsInternal(TSInsertStringRecordsReq request) throws TException {
    request.setSessionId(sessionId);
    return client.insertStringRecords(request);
  }

  protected void insertRecordsOfOneDevice(TSInsertRecordsOfOneDeviceReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertRecordsOfOneDeviceInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirection(status);
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertRecordsOfOneDeviceInternal(TSInsertRecordsOfOneDeviceReq request)
      throws TException {
    request.setSessionId(sessionId);
    return client.insertRecordsOfOneDevice(request);
  }

  protected void insertStringRecordsOfOneDevice(TSInsertStringRecordsOfOneDeviceReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertStringRecordsOfOneDeviceInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirection(status);
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertStringRecordsOfOneDeviceInternal(
      TSInsertStringRecordsOfOneDeviceReq request) throws TException {
    request.setSessionId(sessionId);
    return client.insertStringRecordsOfOneDevice(request);
  }

  protected void insertTablet(TSInsertTabletReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertTabletInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirection(status);
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertTabletInternal(TSInsertTabletReq request) throws TException {
    request.setSessionId(sessionId);
    return client.insertTablet(request);
  }

  protected void insertTablets(TSInsertTabletsReq request)
      throws IoTDBConnectionException, StatementExecutionException, RedirectException {

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = insertTabletsInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        if (i == 0) {
          // first time succeed, take account for redirection info
          RpcUtils.verifySuccessWithRedirectionForMultiDevices(status, request.getPrefixPaths());
        } else {
          // if it's retry, just ignore redirection info
          RpcUtils.verifySuccess(status);
        }
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus insertTabletsInternal(TSInsertTabletsReq request) throws TException {
    request.setSessionId(sessionId);
    return client.insertTablets(request);
  }

  protected void deleteTimeseries(List<String> paths)
      throws IoTDBConnectionException, StatementExecutionException {

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = client.deleteTimeseries(sessionId, paths);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        RpcUtils.verifySuccess(status);
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  public void deleteData(TSDeleteDataReq request)
      throws IoTDBConnectionException, StatementExecutionException {

    TException lastTException = null;
    TSStatus status = null;
    for (int i = 0; i <= maxRetryCount; i++) {
      if (i > 0) {
        // re-init the TException and TSStatus
        lastTException = null;
        status = null;
        // not first time, we need to sleep and then reconnect
        try {
          TimeUnit.MILLISECONDS.sleep(retryIntervalInMs);
        } catch (InterruptedException e) {
          // just ignore
        }
        if (!reconnect()) {
          // reconnect failed, just continue to make another retry.
          continue;
        }
      }
      try {
        status = deleteDataInternal(request);
        // need retry
        if (status.isSetNeedRetry() && status.isNeedRetry()) {
          continue;
        }
        // succeed or don't need to retry
        RpcUtils.verifySuccess(status);
        return;
      } catch (TException e) {
        // all network exception need retry until reaching maxRetryCount
        lastTException = e;
      }
    }

    if (status != null) {
      RpcUtils.verifySuccess(status);
    } else if (lastTException != null) {
      throw new IoTDBConnectionException(lastTException);
    } else {
      throw new IoTDBConnectionException(logForReconnectionFailure());
    }
  }

  private TSStatus deleteDataInternal(TSDeleteDataReq request) throws TException {
    request.setSessionId(sessionId);
    return client.deleteData(request);
  }

  protected void testInsertRecord(TSInsertStringRecordReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.testInsertStringRecord(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.testInsertStringRecord(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void testInsertRecord(TSInsertRecordReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.testInsertRecord(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.testInsertRecord(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  public void testInsertRecords(TSInsertStringRecordsReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.testInsertStringRecords(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.testInsertStringRecords(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  public void testInsertRecords(TSInsertRecordsReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.testInsertRecords(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.testInsertRecords(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void testInsertTablet(TSInsertTabletReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.testInsertTablet(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.testInsertTablet(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void testInsertTablets(TSInsertTabletsReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.testInsertTablets(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.testInsertTablets(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  @SuppressWarnings({
    "squid:S3776"
  }) // ignore Cognitive Complexity of methods should not be too high
  private boolean reconnect() {
    boolean connectedSuccess = false;
    SecureRandom random = new SecureRandom();
    for (int i = 1; i <= SessionConfig.RETRY_NUM; i++) {
      if (transport != null) {
        transport.close();
        endPointList = availableNodes.get();
        int currHostIndex = random.nextInt(endPointList.size());
        int tryHostNum = 0;
        for (int j = currHostIndex; j < endPointList.size(); j++) {
          if (tryHostNum == endPointList.size()) {
            break;
          }
          this.endPoint = endPointList.get(j);
          if (j == endPointList.size() - 1) {
            j = -1;
          }
          tryHostNum++;
          try {
            init(endPoint, session.useSSL, session.trustStore, session.trustStorePwd);
            connectedSuccess = true;
          } catch (IoTDBConnectionException e) {
            logger.warn("The current node may have been down {},try next node", endPoint);
            continue;
          }
          break;
        }
      }
      if (connectedSuccess) {
        // remove the broken end point
        session.removeBrokenSessionConnection(this);
        session.defaultEndPoint = this.endPoint;
        session.defaultSessionConnection = this;
        session.endPointToSessionConnection.put(session.defaultEndPoint, this);
        break;
      }
    }
    return connectedSuccess;
  }

  protected void createSchemaTemplate(TSCreateSchemaTemplateReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.createSchemaTemplate(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.createSchemaTemplate(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void appendSchemaTemplate(TSAppendSchemaTemplateReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.appendSchemaTemplate(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.appendSchemaTemplate(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void pruneSchemaTemplate(TSPruneSchemaTemplateReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.pruneSchemaTemplate(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.pruneSchemaTemplate(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected TSQueryTemplateResp querySchemaTemplate(TSQueryTemplateReq req)
      throws StatementExecutionException, IoTDBConnectionException {
    TSQueryTemplateResp execResp;
    req.setSessionId(sessionId);
    try {
      execResp = client.querySchemaTemplate(req);
      RpcUtils.verifySuccess(execResp.getStatus());
    } catch (TException e) {
      if (reconnect()) {
        try {
          execResp = client.querySchemaTemplate(req);
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }

    RpcUtils.verifySuccess(execResp.getStatus());
    return execResp;
  }

  protected void setSchemaTemplate(TSSetSchemaTemplateReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.setSchemaTemplate(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.setSchemaTemplate(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void unsetSchemaTemplate(TSUnsetSchemaTemplateReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.unsetSchemaTemplate(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.unsetSchemaTemplate(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void dropSchemaTemplate(TSDropSchemaTemplateReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.dropSchemaTemplate(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.dropSchemaTemplate(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  protected void createTimeseriesUsingSchemaTemplate(
      TCreateTimeseriesUsingSchemaTemplateReq request)
      throws IoTDBConnectionException, StatementExecutionException {
    request.setSessionId(sessionId);
    try {
      RpcUtils.verifySuccess(client.createTimeseriesUsingSchemaTemplate(request));
    } catch (TException e) {
      if (reconnect()) {
        try {
          request.setSessionId(sessionId);
          RpcUtils.verifySuccess(client.createTimeseriesUsingSchemaTemplate(request));
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(MSG_RECONNECTION_FAIL);
      }
    }
  }

  protected TSBackupConfigurationResp getBackupConfiguration()
      throws IoTDBConnectionException, StatementExecutionException {
    TSBackupConfigurationResp execResp;
    try {
      execResp = client.getBackupConfiguration();
      RpcUtils.verifySuccess(execResp.getStatus());
    } catch (TException e) {
      if (reconnect()) {
        try {
          execResp = client.getBackupConfiguration();
          RpcUtils.verifySuccess(execResp.getStatus());
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
    return execResp;
  }

  public TSConnectionInfoResp fetchAllConnections() throws IoTDBConnectionException {
    try {
      return client.fetchAllConnectionsInfo();
    } catch (TException e) {
      if (reconnect()) {
        try {
          return client.fetchAllConnectionsInfo();
        } catch (TException tException) {
          throw new IoTDBConnectionException(tException);
        }
      } else {
        throw new IoTDBConnectionException(logForReconnectionFailure());
      }
    }
  }

  public boolean isEnableRedirect() {
    return enableRedirect;
  }

  public void setEnableRedirect(boolean enableRedirect) {
    this.enableRedirect = enableRedirect;
  }

  public TEndPoint getEndPoint() {
    return endPoint;
  }

  public void setEndPoint(TEndPoint endPoint) {
    this.endPoint = endPoint;
  }

  // error log for connection failure
  private String logForReconnectionFailure() {
    if (endPointList == null) {
      return MSG_RECONNECTION_FAIL;
    }
    StringJoiner urls = new StringJoiner(",");
    for (TEndPoint end : endPointList) {
      StringJoiner url = new StringJoiner(":");
      url.add(end.getIp());
      url.add(String.valueOf(end.getPort()));
      urls.add(url.toString());
    }
    return MSG_RECONNECTION_FAIL.concat(urls.toString());
  }

  @Override
  public String toString() {
    return "SessionConnection{" + " endPoint=" + endPoint + "}";
  }
}
