Merge pull request #1070 from zhicwu/develop

zhicwu · web-flow · commit fedb15101e67 · 2022-09-07T14:29:47.000+08:00
Respect custom Authorization header in clickhouse-http-client
diff --git a/clickhouse-client/src/test/java/com/clickhouse/client/BaseIntegrationTest.java b/clickhouse-client/src/test/java/com/clickhouse/client/BaseIntegrationTest.java
@@ -19,6 +19,10 @@ protected ClickHouseNode getSecureServer(ClickHouseProtocol protocol) {
         return ClickHouseServerForTest.getClickHouseNode(protocol, true, ClickHouseNode.builder().build());
     }
 
+    protected ClickHouseNode getSecureServer(ClickHouseProtocol protocol, ClickHouseNode base) {
+        return ClickHouseServerForTest.getClickHouseNode(protocol, true, base);
+    }
+
     protected ClickHouseNode getServer(ClickHouseProtocol protocol) {
         return ClickHouseServerForTest.getClickHouseNode(protocol, false, ClickHouseNode.builder().build());
     }
diff --git a/clickhouse-client/src/test/java/com/clickhouse/client/ClientIntegrationTest.java b/clickhouse-client/src/test/java/com/clickhouse/client/ClientIntegrationTest.java
@@ -101,12 +101,14 @@ protected ClickHouseClientBuilder initClient(ClickHouseClientBuilder builder) {
         return builder;
     }
 
-    protected ClickHouseClient getClient() {
-        return initClient(ClickHouseClient.builder()).nodeSelector(ClickHouseNodeSelector.of(getProtocol())).build();
+    protected ClickHouseClient getClient(ClickHouseConfig... configs) {
+        return initClient(ClickHouseClient.builder()).config(new ClickHouseConfig(configs))
+                .nodeSelector(ClickHouseNodeSelector.of(getProtocol())).build();
     }
 
-    protected ClickHouseClient getSecureClient() {
+    protected ClickHouseClient getSecureClient(ClickHouseConfig... configs) {
         return initClient(ClickHouseClient.builder())
+                .config(new ClickHouseConfig(configs))
                 .nodeSelector(ClickHouseNodeSelector.of(getProtocol()))
                 .option(ClickHouseClientOption.SSL, true)
                 .option(ClickHouseClientOption.SSL_MODE, ClickHouseSslMode.STRICT)
@@ -117,14 +119,22 @@ protected ClickHouseClient getSecureClient() {
                 .build();
     }
 
-    protected ClickHouseNode getServer() {
-        return getServer(getProtocol());
+    protected ClickHouseNode getSecureServer(ClickHouseNode base) {
+        return getSecureServer(getProtocol(), base);
     }
 
     protected ClickHouseNode getSecureServer() {
         return getSecureServer(getProtocol());
     }
 
+    protected ClickHouseNode getServer(ClickHouseNode base) {
+        return getServer(getProtocol(), base);
+    }
+
+    protected ClickHouseNode getServer() {
+        return getServer(getProtocol());
+    }
+
     @DataProvider(name = "compressionMatrix")
     protected Object[][] getCompressionMatrix() {
         ClickHouseFormat[] formats = new ClickHouseFormat[] {
@@ -1402,7 +1412,11 @@ public void testTempTable() throws Exception {
             request.query("drop temporary table if exists my_temp_table").execute().get();
             request.query("create temporary table my_temp_table(a Int8)").execute().get();
             request.query("insert into my_temp_table values(2)").execute().get();
-            request.write().table("my_temp_table").data(new ByteArrayInputStream(new byte[] { 3 })).execute().get();
+            try (ClickHouseResponse resp = request.write().table("my_temp_table")
+                    .data(new ByteArrayInputStream(new byte[] { 3 })).executeAndWait()) {
+                // ignore
+            }
+
             int count = 0;
             try (ClickHouseResponse resp = request.format(ClickHouseFormat.RowBinaryWithNamesAndTypes)
                     .query("select * from my_temp_table order by a").execute().get()) {
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnection.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnection.java
@@ -9,6 +9,7 @@
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Map.Entry;
@@ -158,39 +159,52 @@ static String buildUrl(String baseUrl, ClickHouseRequest<?> request) {
 
     protected static Map<String, String> createDefaultHeaders(ClickHouseConfig config, ClickHouseNode server) {
         Map<String, String> map = new LinkedHashMap<>();
+        boolean hasAuthorizationHeader = false;
         // add customer headers
-        map.putAll(ClickHouseOption.toKeyValuePairs(config.getStrOption(ClickHouseHttpOption.CUSTOM_HEADERS)));
-        map.put("Accept", "*/*");
+        for (Entry<String, String> header : ClickHouseOption
+                .toKeyValuePairs(config.getStrOption(ClickHouseHttpOption.CUSTOM_HEADERS)).entrySet()) {
+            String name = header.getKey().toLowerCase(Locale.ROOT);
+            String value = header.getValue();
+            if (value == null) {
+                continue;
+            }
+            if ("authorization".equals(name)) {
+                hasAuthorizationHeader = true;
+            }
+            map.put(name, value);
+        }
+
+        map.put("accept", "*/*");
         if (!config.getBoolOption(ClickHouseHttpOption.KEEP_ALIVE)) {
-            map.put("Connection", "Close");
+            map.put("connection", "Close");
         }
-        map.put("User-Agent", config.getClientName());
+        map.put("user-agent", config.getClientName());
 
         ClickHouseCredentials credentials = server.getCredentials(config);
         if (credentials.useAccessToken()) {
             // TODO check if auth-scheme is available and supported
-            map.put("Authorization", credentials.getAccessToken());
-        } else {
-            map.put("X-ClickHouse-User", credentials.getUserName());
+            map.put("authorization", credentials.getAccessToken());
+        } else if (!hasAuthorizationHeader) {
+            map.put("x-clickhouse-user", credentials.getUserName());
             if (config.isSsl() && !ClickHouseChecker.isNullOrEmpty(config.getSslCert())) {
-                map.put("X-ClickHouse-SSL-Certificate-Auth", "on");
+                map.put("x-clickhouse-ssl-certificate-auth", "on");
             } else if (!ClickHouseChecker.isNullOrEmpty(credentials.getPassword())) {
-                map.put("X-ClickHouse-Key", credentials.getPassword());
+                map.put("x-clickhouse-key", credentials.getPassword());
             }
         }
 
         String database = server.getDatabase(config);
         if (!ClickHouseChecker.isNullOrEmpty(database)) {
-            map.put("X-ClickHouse-Database", database);
+            map.put("x-clickhouse-database", database);
         }
         // Also, you can use the ‘default_format’ URL parameter
-        map.put("X-ClickHouse-Format", config.getFormat().name());
+        map.put("x-clickhouse-format", config.getFormat().name());
         if (config.isResponseCompressed()) {
-            map.put("Accept-Encoding", config.getResponseCompressAlgorithm().encoding());
+            map.put("accept-encoding", config.getResponseCompressAlgorithm().encoding());
         }
         if (config.isRequestCompressed()
                 && config.getRequestCompressAlgorithm() != ClickHouseCompression.LZ4) {
-            map.put("Content-Encoding", config.getRequestCompressAlgorithm().encoding());
+            map.put("content-encoding", config.getRequestCompressAlgorithm().encoding());
         }
         return map;
     }
@@ -251,10 +265,12 @@ protected Map<String, String> mergeHeaders(Map<String, String> requestHeaders) {
         Map<String, String> merged = new LinkedHashMap<>();
         merged.putAll(defaultHeaders);
         for (Entry<String, String> header : requestHeaders.entrySet()) {
-            if (header.getValue() == null) {
-                merged.remove(header.getKey());
+            String name = header.getKey().toLowerCase(Locale.ROOT);
+            String value = header.getValue();
+            if (value == null) {
+                merged.remove(name);
             } else {
-                merged.put(header.getKey(), header.getValue());
+                merged.put(name, value);
             }
         }
         return merged;
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
@@ -6,9 +6,12 @@
 import com.clickhouse.client.ClickHouseNode;
 import com.clickhouse.client.ClickHouseRequest;
 
-public abstract class ClickHouseHttpConnectionFactory {
+public final class ClickHouseHttpConnectionFactory {
     public static ClickHouseHttpConnection createConnection(ClickHouseNode server, ClickHouseRequest<?> request,
             ExecutorService executor) throws IOException {
         return new HttpUrlConnectionImpl(server, request, executor);
     }
+
+    private ClickHouseHttpConnectionFactory() {
+    }
 }
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/HttpUrlConnectionImpl.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/HttpUrlConnectionImpl.java
@@ -45,11 +45,11 @@
 public class HttpUrlConnectionImpl extends ClickHouseHttpConnection {
     private static final Logger log = LoggerFactory.getLogger(HttpUrlConnectionImpl.class);
 
-    private static final byte[] HEADER_CONTENT_DISPOSITION = "Content-Disposition: form-data; name=\""
+    private static final byte[] HEADER_CONTENT_DISPOSITION = "content-disposition: form-data; name=\""
             .getBytes(StandardCharsets.US_ASCII);
-    private static final byte[] HEADER_OCTET_STREAM = "Content-Type: application/octet-stream\r\n"
+    private static final byte[] HEADER_OCTET_STREAM = "content-type: application/octet-stream\r\n"
             .getBytes(StandardCharsets.US_ASCII);
-    private static final byte[] HEADER_BINARY_ENCODING = "Content-Transfer-Encoding: binary\r\n\r\n"
+    private static final byte[] HEADER_BINARY_ENCODING = "content-transfer-encoding: binary\r\n\r\n"
             .getBytes(StandardCharsets.US_ASCII);
 
     private static final byte[] DOUBLE_DASH = new byte[] { '-', '-' };
@@ -217,14 +217,14 @@ protected boolean isReusable() {
     protected ClickHouseHttpResponse post(String sql, ClickHouseInputStream data, List<ClickHouseExternalTable> tables,
             String url, Map<String, String> headers, ClickHouseConfig config, Runnable postCloseAction)
             throws IOException {
-        Charset charset = StandardCharsets.US_ASCII;
+        Charset ascii = StandardCharsets.US_ASCII;
         byte[] boundary = null;
         if (tables != null && !tables.isEmpty()) {
             String uuid = UUID.randomUUID().toString();
-            conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=".concat(uuid));
-            boundary = uuid.getBytes(charset);
+            conn.setRequestProperty("content-type", "multipart/form-data; boundary=".concat(uuid));
+            boundary = uuid.getBytes(ascii);
         } else {
-            conn.setRequestProperty("Content-Type", "text/plain; charset=UTF-8");
+            conn.setRequestProperty("content-type", "text/plain; charset=UTF-8");
         }
         setHeaders(conn, headers);
 
@@ -241,7 +241,8 @@ protected ClickHouseHttpResponse post(String sql, ClickHouseInputStream data, Li
                 : (hasInput
                         ? ClickHouseClient.getAsyncRequestOutputStream(config, conn.getOutputStream(), null) // latch::countDown)
                         : ClickHouseClient.getRequestOutputStream(c, conn.getOutputStream(), null))) {
-            byte[] sqlBytes = hasFile ? new byte[0] : sql.getBytes(StandardCharsets.UTF_8);
+            Charset utf8 = StandardCharsets.UTF_8;
+            byte[] sqlBytes = hasFile ? new byte[0] : sql.getBytes(utf8);
             if (boundary != null) {
                 out.writeBytes(LINE_PREFIX);
                 out.writeBytes(boundary);
@@ -250,7 +251,7 @@ protected ClickHouseHttpResponse post(String sql, ClickHouseInputStream data, Li
                 out.writeBytes(SUFFIX_QUERY);
                 out.writeBytes(sqlBytes);
                 for (ClickHouseExternalTable t : tables) {
-                    byte[] tableName = t.getName().getBytes(StandardCharsets.UTF_8);
+                    byte[] tableName = t.getName().getBytes(utf8);
                     for (int i = 0; i < 3; i++) {
                         out.writeBytes(LINE_PREFIX);
                         out.writeBytes(boundary);
@@ -259,10 +260,10 @@ protected ClickHouseHttpResponse post(String sql, ClickHouseInputStream data, Li
                         out.writeBytes(tableName);
                         if (i == 0) {
                             out.writeBytes(SUFFIX_FORMAT);
-                            out.writeBytes(t.getFormat().name().getBytes(charset));
+                            out.writeBytes(t.getFormat().name().getBytes(ascii));
                         } else if (i == 1) {
                             out.writeBytes(SUFFIX_STRUCTURE);
-                            out.writeBytes(t.getStructure().getBytes(StandardCharsets.UTF_8));
+                            out.writeBytes(t.getStructure().getBytes(utf8));
                         } else {
                             out.writeBytes(SUFFIX_FILENAME);
                             out.writeBytes(tableName);
diff --git a/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/ClickHouseHttpOption.java b/clickhouse-http-client/src/main/java/com/clickhouse/client/http/config/ClickHouseHttpOption.java
@@ -19,7 +19,9 @@ public enum ClickHouseHttpOption implements ClickHouseOption {
      */
     CUSTOM_HEADERS("custom_http_headers", "", "Custom HTTP headers."),
     /**
-     * Custom HTTP query parameters.
+     * Custom HTTP query parameters. Consider
+     * {@link com.clickhouse.client.config.ClickHouseClientOption#CUSTOM_SETTINGS}
+     * if you don't want your implementation ties to http protocol.
      */
     CUSTOM_PARAMS("custom_http_params", "", "Custom HTTP query parameters."),
     /**
diff --git a/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java b/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/ClickHouseHttpConnectionFactory.java
@@ -8,7 +8,7 @@
 import com.clickhouse.client.http.config.ClickHouseHttpOption;
 import com.clickhouse.client.http.config.HttpConnectionProvider;
 
-public abstract class ClickHouseHttpConnectionFactory {
+public final class ClickHouseHttpConnectionFactory {
     public static ClickHouseHttpConnection createConnection(ClickHouseNode server, ClickHouseRequest<?> request,
             ExecutorService executor) throws IOException {
         HttpConnectionProvider provider = request.getConfig().getOption(ClickHouseHttpOption.CONNECTION_PROVIDER,
@@ -24,4 +24,7 @@ public static ClickHouseHttpConnection createConnection(ClickHouseNode server, C
             return new HttpUrlConnectionImpl(server, request, executor);
         }
     }
+
+    private ClickHouseHttpConnectionFactory() {
+    }
 }
diff --git a/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/HttpClientConnectionImpl.java b/clickhouse-http-client/src/main/java11/com/clickhouse/client/http/HttpClientConnectionImpl.java
diff --git a/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ClickHouseHttpClientTest.java b/clickhouse-http-client/src/test/java/com/clickhouse/client/http/ClickHouseHttpClientTest.java

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,10 @@ protected ClickHouseNode getSecureServer(ClickHouseProtocol protocol) {`
`19`	`19`	`return ClickHouseServerForTest.getClickHouseNode(protocol, true, ClickHouseNode.builder().build());`
`20`	`20`	`}`
`21`	`21`
	`22`	`+ protected ClickHouseNode getSecureServer(ClickHouseProtocol protocol, ClickHouseNode base) {`
	`23`	`+ return ClickHouseServerForTest.getClickHouseNode(protocol, true, base);`
	`24`	`+ }`
	`25`	`+`
`22`	`26`	`protected ClickHouseNode getServer(ClickHouseProtocol protocol) {`
`23`	`27`	`return ClickHouseServerForTest.getClickHouseNode(protocol, false, ClickHouseNode.builder().build());`
`24`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,12 @@`
`6`	`6`	`import com.clickhouse.client.ClickHouseNode;`
`7`	`7`	`import com.clickhouse.client.ClickHouseRequest;`
`8`	`8`
`9`		`-public abstract class ClickHouseHttpConnectionFactory {`
	`9`	`+public final class ClickHouseHttpConnectionFactory {`
`10`	`10`	`public static ClickHouseHttpConnection createConnection(ClickHouseNode server, ClickHouseRequest<?> request,`
`11`	`11`	`ExecutorService executor) throws IOException {`
`12`	`12`	`return new HttpUrlConnectionImpl(server, request, executor);`
`13`	`13`	`}`
	`14`	`+`
	`15`	`+ private ClickHouseHttpConnectionFactory() {`
	`16`	`+ }`
`14`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`	`import com.clickhouse.client.http.config.ClickHouseHttpOption;`
`9`	`9`	`import com.clickhouse.client.http.config.HttpConnectionProvider;`
`10`	`10`
`11`		`-public abstract class ClickHouseHttpConnectionFactory {`
	`11`	`+public final class ClickHouseHttpConnectionFactory {`
`12`	`12`	`public static ClickHouseHttpConnection createConnection(ClickHouseNode server, ClickHouseRequest<?> request,`
`13`	`13`	`ExecutorService executor) throws IOException {`
`14`	`14`	`HttpConnectionProvider provider = request.getConfig().getOption(ClickHouseHttpOption.CONNECTION_PROVIDER,`
`@@ -24,4 +24,7 @@ public static ClickHouseHttpConnection createConnection(ClickHouseNode server, C`
`24`	`24`	`return new HttpUrlConnectionImpl(server, request, executor);`
`25`	`25`	`}`
`26`	`26`	`}`
	`27`	`+`
	`28`	`+ private ClickHouseHttpConnectionFactory() {`
	`29`	`+ }`
`27`	`30`	`}`