Merge pull request #2090 from ClickHouse/v2_reduce_init_time

[client-v2] Reduce client init time

Author: chernser

.github/workflows/build.yml

@@ -247,12 +247,6 @@ jobs:
           EOF
       - name: Install Java client
         run: mvn --also-make --batch-mode --no-transfer-progress -DskipTests install
-#      - name: Generate JWT
-#        env:
-#          JWT_K_PEM: ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_JWT_PRIVATE_KEY }}
-#        run: |
-#          npm install jsonwebtoken &&
-#          echo "CLIENT_JWT=$(node jwt-gen.js)" >> "$GITHUB_ENV"
       - name: Test http client
         env:
           CLICKHOUSE_CLOUD_HOST: ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_HOST_SMT }}

client-v2/src/main/java/com/clickhouse/client/api/Client.java

@@ -130,7 +130,7 @@ public class Client implements AutoCloseable {
     private static final Logger LOG = LoggerFactory.getLogger(Client.class);
     private final ExecutorService sharedOperationExecutor;
 
-    private final boolean isSharedOpExecuterorOwned;
+    private final boolean isSharedOpExecutorOwned;
 
     private final Map<String, ClientStatisticsHolder> globalClientStats = new ConcurrentHashMap<>();
 
@@ -141,39 +141,43 @@ public class Client implements AutoCloseable {
 
     // Server context
     private String serverVersion;
-    private Object metrics;
+    private Object metricsRegistry;
 
     private Client(Set<String> endpoints, Map<String,String> configuration, boolean useNewImplementation,
                    ExecutorService sharedOperationExecutor, ColumnToMethodMatchingStrategy columnToMethodMatchingStrategy) {
         this(endpoints, configuration, useNewImplementation, sharedOperationExecutor, columnToMethodMatchingStrategy, null);
     }
 
     private Client(Set<String> endpoints, Map<String,String> configuration, boolean useNewImplementation,
-                   ExecutorService sharedOperationExecutor, ColumnToMethodMatchingStrategy columnToMethodMatchingStrategy, Object metrics) {
+                   ExecutorService sharedOperationExecutor, ColumnToMethodMatchingStrategy columnToMethodMatchingStrategy, Object metricsRegistry) {
         this.endpoints = endpoints;
         this.configuration = configuration;
         this.readOnlyConfig = Collections.unmodifiableMap(this.configuration);
         this.endpoints.forEach(endpoint -> {
             this.serverNodes.add(ClickHouseNode.of(endpoint, this.configuration));
         });
-        this.metrics = metrics;
+        this.metricsRegistry = metricsRegistry;
         this.serializers = new ConcurrentHashMap<>();
         this.deserializers = new ConcurrentHashMap<>();
 
         boolean isAsyncEnabled = MapUtils.getFlag(this.configuration, ClientConfigProperties.ASYNC_OPERATIONS.getKey(), false);
         if (isAsyncEnabled && sharedOperationExecutor == null) {
-            this.isSharedOpExecuterorOwned = true;
+            this.isSharedOpExecutorOwned = true;
             this.sharedOperationExecutor = Executors.newCachedThreadPool(new DefaultThreadFactory("chc-operation"));
         } else {
-            this.isSharedOpExecuterorOwned = false;
+            this.isSharedOpExecutorOwned = false;
             this.sharedOperationExecutor = sharedOperationExecutor;
         }
-        this.httpClientHelper = new HttpAPIClientHelper(configuration, metrics);
+        boolean initSslContext = getEndpoints().stream().anyMatch(s -> s.toLowerCase().contains("https://"));
+        this.httpClientHelper = new HttpAPIClientHelper(configuration, metricsRegistry, initSslContext);
         this.columnToMethodMatchingStrategy = columnToMethodMatchingStrategy;
-        updateServerContext();
     }
 
-    private void updateServerContext() {
+    /**
+     * Loads essential information about a server. Should be called after client creation.
+     *
+     */
+    public void loadServerInfo() {
         try (QueryResponse response = this.query("SELECT currentUser() AS user, timezone() AS timezone, version() AS version LIMIT 1").get()) {
             try (ClickHouseBinaryFormatReader reader = this.newBinaryFormatReader(response)) {
                 if (reader.next() != null) {
@@ -183,13 +187,10 @@ private void updateServerContext() {
                 }
             }
         } catch (Exception e) {
-            LOG.error("Failed to get server info", e);
+            throw new ClientException("Failed to get server info", e);
         }
     }
 
-
-
-
     /**
      * Returns default database name that will be used by operations if not specified.
      *
@@ -208,7 +209,7 @@ public String getDefaultDatabase() {
      */
     @Override
     public void close() {
-        if (isSharedOpExecuterorOwned) {
+        if (isSharedOpExecutorOwned) {
             try {
                 if (sharedOperationExecutor != null && !sharedOperationExecutor.isShutdown()) {
                     this.sharedOperationExecutor.shutdownNow();
@@ -235,7 +236,7 @@ public static class Builder {
 
         private ExecutorService sharedOperationExecutor = null;
         private ColumnToMethodMatchingStrategy columnToMethodMatchingStrategy;
-        private Object metric = null;
+        private Object metricRegistry = null;
         public Builder() {
             this.endpoints = new HashSet<>();
             this.configuration = new HashMap<String, String>();
@@ -960,7 +961,7 @@ public Builder useBearerTokenAuth(String bearerToken) {
          * @return same instance of the builder
          */
         public Builder registerClientMetrics(Object registry, String name) {
-            this.metric = registry;
+            this.metricRegistry = registry;
             this.configuration.put(ClientConfigProperties.METRICS_GROUP_NAME.getKey(), name);
             return this;
         }
@@ -1024,7 +1025,7 @@ public Client build() {
             }
 
             return new Client(this.endpoints, this.configuration, this.useNewImplementation, this.sharedOperationExecutor,
-                this.columnToMethodMatchingStrategy, this.metric);
+                this.columnToMethodMatchingStrategy, this.metricRegistry);
         }
 
 

client-v2/src/main/java/com/clickhouse/client/api/internal/HttpAPIClientHelper.java

@@ -26,6 +26,7 @@
 import org.apache.hc.client5.http.io.HttpClientConnectionManager;
 import org.apache.hc.client5.http.protocol.HttpClientContext;
 import org.apache.hc.client5.http.socket.ConnectionSocketFactory;
+import org.apache.hc.client5.http.socket.LayeredConnectionSocketFactory;
 import org.apache.hc.client5.http.socket.PlainConnectionSocketFactory;
 import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
 import org.apache.hc.core5.http.ClassicHttpResponse;
@@ -44,6 +45,7 @@
 import org.apache.hc.core5.http.impl.io.DefaultHttpResponseParserFactory;
 import org.apache.hc.core5.http.io.SocketConfig;
 import org.apache.hc.core5.http.io.entity.EntityTemplate;
+import org.apache.hc.core5.http.protocol.HttpContext;
 import org.apache.hc.core5.io.CloseMode;
 import org.apache.hc.core5.io.IOCallback;
 import org.apache.hc.core5.net.URIBuilder;
@@ -62,6 +64,7 @@
 import java.net.ConnectException;
 import java.net.InetSocketAddress;
 import java.net.NoRouteToHostException;
+import java.net.Socket;
 import java.net.SocketTimeoutException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -97,10 +100,10 @@ public class HttpAPIClientHelper {
 
     private String defaultUserAgent;
     private Object metricsRegistry;
-    public HttpAPIClientHelper(Map<String, String> configuration, Object metricsRegistry) {
+    public HttpAPIClientHelper(Map<String, String> configuration, Object metricsRegistry, boolean initSslContext) {
         this.chConfiguration = configuration;
         this.metricsRegistry = metricsRegistry;
-        this.httpClient = createHttpClient();
+        this.httpClient = createHttpClient(initSslContext);
 
         RequestConfig.Builder reqConfBuilder = RequestConfig.custom();
         MapUtils.applyLong(chConfiguration, "connection_request_timeout",
@@ -175,11 +178,10 @@ private ConnectionConfig createConnectionConfig() {
         return connConfig.build();
     }
 
-    private HttpClientConnectionManager basicConnectionManager(SSLContext sslContext, SocketConfig socketConfig) {
+    private HttpClientConnectionManager basicConnectionManager(LayeredConnectionSocketFactory sslConnectionSocketFactory, SocketConfig socketConfig) {
         RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create();
         registryBuilder.register("http", PlainConnectionSocketFactory.getSocketFactory());
-        registryBuilder.register("https", new SSLConnectionSocketFactory(sslContext));
-
+        registryBuilder.register("https", sslConnectionSocketFactory);
 
         BasicHttpClientConnectionManager connManager = new BasicHttpClientConnectionManager(registryBuilder.build());
         connManager.setConnectionConfig(createConnectionConfig());
@@ -188,7 +190,7 @@ private HttpClientConnectionManager basicConnectionManager(SSLContext sslContext
         return connManager;
     }
 
-    private HttpClientConnectionManager poolConnectionManager(SSLContext sslContext, SocketConfig socketConfig) {
+    private HttpClientConnectionManager poolConnectionManager(LayeredConnectionSocketFactory sslConnectionSocketFactory, SocketConfig socketConfig) {
         PoolingHttpClientConnectionManagerBuilder connMgrBuilder = PoolingHttpClientConnectionManagerBuilder.create()
                 .setPoolConcurrencyPolicy(PoolConcurrencyPolicy.LAX);
 
@@ -221,7 +223,7 @@ private HttpClientConnectionManager poolConnectionManager(SSLContext sslContext,
                 DefaultHttpResponseParserFactory.INSTANCE);
 
         connMgrBuilder.setConnectionFactory(connectionFactory);
-        connMgrBuilder.setSSLSocketFactory(new SSLConnectionSocketFactory(sslContext));
+        connMgrBuilder.setSSLSocketFactory(sslConnectionSocketFactory);
         connMgrBuilder.setDefaultSocketConfig(socketConfig);
         PoolingHttpClientConnectionManager phccm = connMgrBuilder.build();
         if (metricsRegistry != null ) {
@@ -238,12 +240,12 @@ private HttpClientConnectionManager poolConnectionManager(SSLContext sslContext,
         return phccm;
     }
 
-    public CloseableHttpClient createHttpClient() {
-
+    public CloseableHttpClient createHttpClient(boolean initSslContext) {
         // Top Level builders
         HttpClientBuilder clientBuilder = HttpClientBuilder.create();
-        SSLContext sslContext = createSSLContext();
-
+        SSLContext sslContext = initSslContext ? createSSLContext() : null;
+        LayeredConnectionSocketFactory sslConnectionSocketFactory = sslContext == null ? new DummySSLConnectionSocketFactory()
+                : new SSLConnectionSocketFactory(sslContext);
         // Socket configuration
         SocketConfig.Builder soCfgBuilder = SocketConfig.custom();
         MapUtils.applyInt(chConfiguration, ClientConfigProperties.SOCKET_OPERATION_TIMEOUT.getKey(),
@@ -287,9 +289,9 @@ public CloseableHttpClient createHttpClient() {
         // Connection manager
         boolean isConnectionPooling = MapUtils.getFlag(chConfiguration, "connection_pool_enabled");
         if (isConnectionPooling) {
-            clientBuilder.setConnectionManager(poolConnectionManager(sslContext, socketConfig));
+            clientBuilder.setConnectionManager(poolConnectionManager(sslConnectionSocketFactory, socketConfig));
         } else {
-            clientBuilder.setConnectionManager(basicConnectionManager(sslContext, socketConfig));
+            clientBuilder.setConnectionManager(basicConnectionManager(sslConnectionSocketFactory, socketConfig));
         }
         long keepAliveTimeout = MapUtils.getLong(chConfiguration, ClientConfigProperties.HTTP_KEEP_ALIVE_TIMEOUT.getKey());
         if (keepAliveTimeout > 0) {
@@ -748,4 +750,26 @@ private  String buildDefaultUserAgent() {
     public void close() {
         httpClient.close(CloseMode.IMMEDIATE);
     }
+
+
+    /**
+     * This factory is used only when no ssl connections are required (no https endpoints).
+     * Internally http client would create factory and spend time if no supplied.
+     */
+    private static class DummySSLConnectionSocketFactory implements LayeredConnectionSocketFactory {
+        @Override
+        public Socket createLayeredSocket(Socket socket, String target, int port, HttpContext context) throws IOException {
+            return null;
+        }
+
+        @Override
+        public Socket createSocket(HttpContext context) throws IOException {
+            return null;
+        }
+
+        @Override
+        public Socket connectSocket(TimeValue connectTimeout, Socket socket, HttpHost host, InetSocketAddress remoteAddress, InetSocketAddress localAddress, HttpContext context) throws IOException {
+            return null;
+        }
+    }
 }

client-v2/src/test/java/com/clickhouse/client/ClientTests.java

@@ -1,7 +1,6 @@
 package com.clickhouse.client;
 
 import com.clickhouse.client.api.Client;
-import com.clickhouse.client.api.ClientConfigProperties;
 import com.clickhouse.client.api.ClientException;
 import com.clickhouse.client.api.enums.Protocol;
 import com.clickhouse.client.api.query.GenericRecord;
@@ -17,7 +16,6 @@
 
 import java.net.ConnectException;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ExecutorService;
@@ -153,6 +151,18 @@ public void testProvidedExecutor() throws Exception {
         Assert.assertFalse(flag.get());
     }
 
+    @Test
+    public void testLoadingServerContext() throws Exception {
+        long start = System.nanoTime();
+        try (Client client = newClient().build()) {
+            long initTime = (System.nanoTime() - start) / 1_000_000;
+            Assert.assertTrue(initTime < 100);
+            Assert.assertNull(client.getServerVersion());
+            client.loadServerInfo();
+            Assert.assertNotNull(client.getServerVersion());
+        }
+    }
+
     protected Client.Builder newClient() {
         ClickHouseNode node = getServer(ClickHouseProtocol.HTTP);
         boolean isSecure = isCloud();

client-v2/src/test/java/com/clickhouse/client/metrics/MetricsTest.java

@@ -49,6 +49,7 @@ public void testRegisterMetrics() throws Exception {
                 .registerClientMetrics(meterRegistry, "pool-test")
                 .build()) {
 
+            client.ping();
             Gauge totalMax = meterRegistry.get("httpcomponents.httpclient.pool.total.max").gauge();
             Gauge available = meterRegistry.get("httpcomponents.httpclient.pool.total.connections").tags("state", "available").gauge();
             Gauge leased = meterRegistry.get("httpcomponents.httpclient.pool.total.connections").tags("state", "leased").gauge();

jdbc-v2/src/main/java/com/clickhouse/jdbc/ConnectionImpl.java

@@ -1,15 +1,13 @@
 package com.clickhouse.jdbc;
 
 import com.clickhouse.client.api.Client;
-import com.clickhouse.client.api.ClientConfigProperties;
 import com.clickhouse.client.api.internal.ServerSettings;
 import com.clickhouse.client.api.query.GenericRecord;
 import com.clickhouse.client.api.query.QuerySettings;
 import com.clickhouse.data.ClickHouseDataType;
 import com.clickhouse.jdbc.internal.ClientInfoProperties;
 import com.clickhouse.jdbc.internal.JdbcConfiguration;
 import com.clickhouse.jdbc.internal.ExceptionUtils;
-import com.clickhouse.jdbc.internal.JdbcConfiguration;
 import com.clickhouse.jdbc.internal.JdbcUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -32,8 +30,6 @@
 import java.sql.ShardingKey;
 import java.sql.Statement;
 import java.sql.Struct;
-import java.sql.Types;
-import java.time.temporal.ChronoUnit;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -76,6 +72,7 @@ public ConnectionImpl(String url, Properties info) throws SQLException {
         this.client =  this.config.applyClientProperties(new Client.Builder())
                 .setClientName(clientName)
                 .build();
+        this.client.loadServerInfo();
         this.schema = client.getDefaultDatabase();
         this.defaultQuerySettings = new QuerySettings()
                 .serverSetting(ServerSettings.ASYNC_INSERT, "0")

jdbc-v2/src/test/java/com/clickhouse/jdbc/DriverTest.java

@@ -25,7 +25,7 @@ public void testConnect() {
             Driver driver = new Driver();
             Properties props = new Properties();
             props.put(ClientConfigProperties.USER.getKey(), ClientConfigProperties.USER.getDefaultValue());
-            props.put(ClientConfigProperties.PASSWORD.getKey(), ClientConfigProperties.PASSWORD.getDefaultValue());
+            props.put(ClientConfigProperties.PASSWORD.getKey(), getPassword());
             Assert.assertNotNull(driver.connect(getEndpointString(), props));
         } catch (SQLException e) {
             Assert.fail("Failed to connect to ClickHouse", e);