This class provides utility methods for serializing to and deserializing from JSON, - * managing customized parameters, and handling HTTP headers and requests.
- */ -public abstract class AbstractModel { - - /** - * Stores HTTP headers for the request. - */ - public MapThis class provides utility methods for serializing to and deserializing from JSON, + * managing customized parameters, and handling HTTP headers and requests.
+ */ +public abstract class AbstractModel { + + /** + * Stores HTTP headers for the request. + */ + public MapWe mainly use two of them: - * - *
Permanent credential: SecretId & SecretKey, can only be obtained from Tencent Cloud Management - * Console, https://console.cloud.tencent.com/cam/capi. - * - *
Ephemeral credential, can be obtained from Security Token Service (STS), has three dimensions: - * SecretId, SecretKey and Token. It will expire after a short time, hence you need to invoke STS - * API to refresh it. - * - *
Thread-safety and atomicity. The triple (secretId, secretKey, token) is only guaranteed - * to be read atomically via {@link #getSnapshot()}. The individual {@code getSecretId()}, - * {@code getSecretKey()}, {@code getToken()} getters do NOT guarantee that two consecutive calls - * observe a consistent triple — a refresh triggered between them may yield an id/key/token - * mismatch. Any code path that consumes more than one of the three fields together (e.g. request - * signing) should use {@link #getSnapshot()}. - */ -public class Credential { - private String secretId; - private String secretKey; - private String token; - private Updater updater; - - public Credential() { - } - - public Credential(String secretId, String secretKey) { - this(secretId, secretKey, ""); - } - - public Credential(String secretId, String secretKey, String token) { - this.secretId = secretId; - this.secretKey = secretKey; - this.token = token; - } - - public Credential(String secretId, String secretKey, String token, Updater updater) { - this.secretId = secretId; - this.secretKey = secretKey; - this.token = token; - this.updater = updater; - } - - public Updater getUpdater() { - return updater; - } - - public void setUpdater(Updater updater) { - this.updater = updater; - } - - /** - * Returns the secret id, triggering a refresh via the attached {@link Updater} if one is set. - * - *
Backward-compatibility note. This getter calls {@link #tryUpdate()} outside of any - * synchronization block. Two consequences follow from this: - *
See {@link #getSecretId()} for the backward-compatibility caveats that apply to all three - * individual getters. Prefer {@link #getSnapshot()} when reading multiple fields together. - */ - public String getSecretKey() { - tryUpdate(); - return this.secretKey; - } - - public void setSecretKey(String secretKey) { - this.secretKey = secretKey; - } - - /** - * Returns the session token, triggering a refresh via the attached {@link Updater} if one is - * set. - * - *
See {@link #getSecretId()} for the backward-compatibility caveats that apply to all three - * individual getters. Prefer {@link #getSnapshot()} when reading multiple fields together. - */ - public String getToken() { - tryUpdate(); - return this.token; - } - - public void setToken(String token) { - this.token = token; - } - - /** - * Atomically replaces the entire (secretId, secretKey, token) triple under the same monitor - * used by {@link #getSnapshot()}. - * - *
Use this instead of three separate {@code setSecretId} / {@code setSecretKey} / - * {@code setToken} calls whenever you need to publish a freshly-refreshed triple: concurrent - * readers going through {@link #getSnapshot()} are guaranteed to observe either the old triple - * or the new triple in its entirety, never a mix of the two. The individual setters do not - * provide this guarantee and should only be used when no other thread is reading. - * - *
This method is the intended write-side companion to {@link #getSnapshot()}'s read-side - * atomicity. {@link Updater} implementations that refresh the triple in place (rather than - * constructing a new {@code Credential}) should call this method instead of the individual - * setters. - * - * @param secretId the new secret id. - * @param secretKey the new secret key. - * @param token the new token, may be empty or {@code null} for permanent credentials. - */ - public void setCredential(String secretId, String secretKey, String token) { - synchronized (this) { - this.secretId = secretId; - this.secretKey = secretKey; - this.token = token; - } - } - - /** - * Returns a point-in-time, self-consistent copy of the (secretId, secretKey, token) triple. - * - *
This is the only thread-safe, atomic way to read the credential triple. The refresh hook - * (if any) is invoked exactly once under a lock, and the three fields are then sampled together - * into a new {@code Credential} that does not carry an {@link Updater}. Use this in any code - * path that consumes more than one of the three fields together (e.g. request signing). - * - *
The returned object should be treated as read-only. It is a fresh instance and mutating it - * via the setters has no effect on the source credential, but doing so will break the - * consistency guarantee for the holder of the snapshot. - * - * @return a point-in-time copy of the credential triple, with no attached updater. - */ - public Credential getSnapshot() { - synchronized (this) { - tryUpdate(); - return new Credential(secretId, secretKey, token); - } - } - - private void tryUpdate() { - if (updater == null) { - return; - } - - try { - updater.update(this); - } catch (TencentCloudSDKException e) { - // wrap as RuntimeException to keep API consistent - throw new RuntimeException(e); - } - } - - public interface Updater { - void update(Credential credential) throws TencentCloudSDKException; - } -} +/* + * Copyright (c) 2018 THL A29 Limited, a Tencent company. All Rights Reserved. + * + * Licensed 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 com.tencentcloudapi.common; + +import com.tencentcloudapi.common.exception.TencentCloudSDKException; + +/** + * Credential has many types in Tencent Cloud Access Management service. + * + *
We mainly use two of them: + * + *
Permanent credential: SecretId & SecretKey, can only be obtained from Tencent Cloud Management + * Console, https://console.cloud.tencent.com/cam/capi. + * + *
Ephemeral credential, can be obtained from Security Token Service (STS), has three dimensions: + * SecretId, SecretKey and Token. It will expire after a short time, hence you need to invoke STS + * API to refresh it. + * + *
Thread-safety and atomicity. The triple (secretId, secretKey, token) is only guaranteed + * to be read atomically via {@link #getSnapshot()}. The individual {@code getSecretId()}, + * {@code getSecretKey()}, {@code getToken()} getters do NOT guarantee that two consecutive calls + * observe a consistent triple — a refresh triggered between them may yield an id/key/token + * mismatch. Any code path that consumes more than one of the three fields together (e.g. request + * signing) should use {@link #getSnapshot()}. + */ +public class Credential { + private String secretId; + private String secretKey; + private String token; + private Updater updater; + + public Credential() { + } + + public Credential(String secretId, String secretKey) { + this(secretId, secretKey, ""); + } + + public Credential(String secretId, String secretKey, String token) { + this.secretId = secretId; + this.secretKey = secretKey; + this.token = token; + } + + public Credential(String secretId, String secretKey, String token, Updater updater) { + this.secretId = secretId; + this.secretKey = secretKey; + this.token = token; + this.updater = updater; + } + + public Updater getUpdater() { + return updater; + } + + public void setUpdater(Updater updater) { + this.updater = updater; + } + + /** + * Returns the secret id, triggering a refresh via the attached {@link Updater} if one is set. + * + *
Backward-compatibility note. This getter calls {@link #tryUpdate()} outside of any + * synchronization block. Two consequences follow from this: + *
See {@link #getSecretId()} for the backward-compatibility caveats that apply to all three + * individual getters. Prefer {@link #getSnapshot()} when reading multiple fields together. + */ + public String getSecretKey() { + tryUpdate(); + return this.secretKey; + } + + public void setSecretKey(String secretKey) { + this.secretKey = secretKey; + } + + /** + * Returns the session token, triggering a refresh via the attached {@link Updater} if one is + * set. + * + *
See {@link #getSecretId()} for the backward-compatibility caveats that apply to all three + * individual getters. Prefer {@link #getSnapshot()} when reading multiple fields together. + */ + public String getToken() { + tryUpdate(); + return this.token; + } + + public void setToken(String token) { + this.token = token; + } + + /** + * Atomically replaces the entire (secretId, secretKey, token) triple under the same monitor + * used by {@link #getSnapshot()}. + * + *
Use this instead of three separate {@code setSecretId} / {@code setSecretKey} / + * {@code setToken} calls whenever you need to publish a freshly-refreshed triple: concurrent + * readers going through {@link #getSnapshot()} are guaranteed to observe either the old triple + * or the new triple in its entirety, never a mix of the two. The individual setters do not + * provide this guarantee and should only be used when no other thread is reading. + * + *
This method is the intended write-side companion to {@link #getSnapshot()}'s read-side + * atomicity. {@link Updater} implementations that refresh the triple in place (rather than + * constructing a new {@code Credential}) should call this method instead of the individual + * setters. + * + * @param secretId the new secret id. + * @param secretKey the new secret key. + * @param token the new token, may be empty or {@code null} for permanent credentials. + */ + public void setCredential(String secretId, String secretKey, String token) { + synchronized (this) { + this.secretId = secretId; + this.secretKey = secretKey; + this.token = token; + } + } + + /** + * Returns a point-in-time, self-consistent copy of the (secretId, secretKey, token) triple. + * + *
This is the only thread-safe, atomic way to read the credential triple. The refresh hook + * (if any) is invoked exactly once under a lock, and the three fields are then sampled together + * into a new {@code Credential} that does not carry an {@link Updater}. Use this in any code + * path that consumes more than one of the three fields together (e.g. request signing). + * + *
The returned object should be treated as read-only. It is a fresh instance and mutating it
+ * via the setters has no effect on the source credential, but doing so will break the
+ * consistency guarantee for the holder of the snapshot.
+ *
+ * @return a point-in-time copy of the credential triple, with no attached updater.
+ */
+ public Credential getSnapshot() {
+ synchronized (this) {
+ tryUpdate();
+ return new Credential(secretId, secretKey, token);
+ }
+ }
+
+ private void tryUpdate() {
+ if (updater == null) {
+ return;
+ }
+
+ try {
+ updater.update(this);
+ } catch (TencentCloudSDKException e) {
+ // wrap as RuntimeException to keep API consistent
+ throw new RuntimeException(e);
+ }
+ }
+
+ public interface Updater {
+ void update(Credential credential) throws TencentCloudSDKException;
+ }
+}
diff --git a/src/main/java/com/tencentcloudapi/common/EndpointFailoverInterceptor.java b/src/main/java/com/tencentcloudapi/common/EndpointFailoverInterceptor.java
new file mode 100644
index 000000000..eb04f1a8b
--- /dev/null
+++ b/src/main/java/com/tencentcloudapi/common/EndpointFailoverInterceptor.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2018 Tencent. All Rights Reserved.
+ *
+ * Licensed 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 com.tencentcloudapi.common;
+
+import com.tencentcloudapi.common.exception.TencentCloudSDKException;
+import okhttp3.*;
+
+import javax.net.ssl.SSLException;
+import java.io.IOException;
+import java.net.*;
+import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Selects a healthy API host via per-host circuit breakers.
+ * No same-request retry — API calls may be non-idempotent.
+ * All breakers open → fall through to origin host.
+ */
+class EndpointFailoverInterceptor implements Interceptor {
+
+ /** More-specific families first — matchFamily returns first hit. */
+ static final String[][] FAILOVER_DOMAIN_FAMILIES = {
+ {
+ "ai.tencentcloudapi.com",
+ "ai.tencentcloudapi.com.cn",
+ "ai.tencentcloudapi.cn",
+ },
+ {
+ "internal.tencentcloudapi.com",
+ "internal.tencentcloudapi.com.cn",
+ "internal.tencentcloudapi.cn",
+ },
+ {
+ "tencentcloudapi.com",
+ "tencentcloudapi.com.cn",
+ "tencentcloudapi.cn",
+ },
+ };
+
+ public static long BREAKER_TIMEOUT_MS = 60 * 1000;
+
+ private final AbstractClient client;
+ private final String backupEndpoint;
+ // Per AbstractClient instance.
+ private final ConcurrentHashMap Mirrors the Go SDK requestBuilder: {@code url} is the single source of truth for
+ * transport, {@code host} signs the canonical Host header. Failover swaps both
+ * {@code url.host} and {@code host}, then rebuilds. This field also controls the legacy single-fallback "backup endpoint"
+ * mode (see {@link #setBackupEndpoint}); both schemes are gated by the same
+ * switch.
+ */
+ private boolean enableDomainFailover = true;
+
+ /**
+ * Constructor to initialize ClientProfile with a specific signing method and HTTP profile.
+ * If the signing method is null or empty, it defaults to "TC3-HMAC-SHA256".
+ *
+ * @param signMethod The method used for signing the request (e.g., HmacSHA1, HmacSHA256, TC3-HMAC-SHA256).
+ * @param httpProfile The HTTP profile containing endpoint and connection settings.
+ */
+ public ClientProfile(String signMethod, HttpProfile httpProfile) {
+ if (signMethod == null || signMethod.isEmpty()) {
+ signMethod = SIGN_TC3_256;
+ }
+ this.signMethod = signMethod;
+ this.httpProfile = httpProfile;
+ this.unsignedPayload = false;
+ this.language = null;
+ this.setDebug(false);
+ }
+
+ /**
+ * Constructor to initialize ClientProfile with a specific signing method.
+ * Initializes the HTTP profile to a default new instance.
+ *
+ * @param signMethod The method used for signing the request (e.g., HmacSHA1, HmacSHA256, TC3-HMAC-SHA256).
+ */
+ public ClientProfile(String signMethod) {
+ this(signMethod, new HttpProfile());
+ }
+
+ /**
+ * Default constructor which initializes the ClientProfile with the default
+ * signing method "TC3-HMAC-SHA256" and a default HTTP profile.
+ */
+ public ClientProfile() {
+ this(ClientProfile.SIGN_TC3_256, new HttpProfile());
+ }
+
+ /**
+ * Getter for the signature method used in API requests.
+ *
+ * @return The signature method (e.g., HmacSHA1, HmacSHA256, TC3-HMAC-SHA256).
+ */
+ public String getSignMethod() {
+ return this.signMethod;
+ }
+
+ /**
+ * Setter for the signature method used in API requests.
+ *
+ * @param signMethod The signature method (e.g., HmacSHA1, HmacSHA256, TC3-HMAC-SHA256).
+ */
+ public void setSignMethod(String signMethod) {
+ this.signMethod = signMethod;
+ }
+
+ /**
+ * Getter for the HTTP profile associated with the client.
+ *
+ * @return The HTTP profile containing endpoint and connection settings.
+ */
+ public HttpProfile getHttpProfile() {
+ return this.httpProfile;
+ }
+
+ /**
+ * Setter for the HTTP profile associated with the client.
+ *
+ * @param httpProfile The new HTTP profile to be set.
+ */
+ public void setHttpProfile(HttpProfile httpProfile) {
+ this.httpProfile = httpProfile;
+ }
+
+ /**
+ * Getter for the flag indicating whether the payload is ignored during signing.
+ *
+ * @return true if the payload is ignored during signing, false otherwise.
+ */
+ public boolean isUnsignedPayload() {
+ return this.unsignedPayload;
+ }
+
+ /**
+ * Setter for the flag indicating whether the payload should be ignored during signing.
+ * This is only relevant for POST requests.
+ *
+ * @param flag Set to true if the payload should be ignored, false otherwise.
+ */
+ public void setUnsignedPayload(boolean flag) {
+ this.unsignedPayload = flag;
+ }
+
+ /**
+ * Getter for the language setting of the client.
+ *
+ * @return The current language setting (e.g., zh-CN, en-US).
+ */
+ public Language getLanguage() {
+ return this.language;
+ }
+
+ /**
+ * Setter for the language setting of the client.
+ *
+ * @param lang The language to set (e.g., zh-CN, en-US).
+ */
+ public void setLanguage(Language lang) {
+ this.language = lang;
+ }
+
+ /**
+ * Getter for the debug flag, which indicates whether debugging is enabled.
+ *
+ * @return true if debugging is enabled, false otherwise.
+ */
+ public boolean isDebug() {
+ return debug;
+ }
+
+ /**
+ * Setter for the debug flag, enabling or disabling debugging.
+ *
+ * @param debug Set to true to enable debugging, false to disable.
+ */
+ public void setDebug(boolean debug) {
+ this.debug = debug;
+ }
+
+ /**
+ * Getter for the backup endpoint, used when the primary endpoint is unavailable.
+ *
+ * @return The backup endpoint URL.
+ */
+ public String getBackupEndpoint() {
+ return backupEndpoint;
+ }
+
+ /**
+ * Setter for the backup endpoint.
+ *
+ * @param backupEndpoint The backup endpoint URL to be set.
+ */
+ public void setBackupEndpoint(String backupEndpoint) {
+ this.backupEndpoint = backupEndpoint;
+ }
+
+ /**
+ * @return true if region-level domain failover is enabled (default), false otherwise.
+ */
+ public boolean isEnableDomainFailover() {
+ return this.enableDomainFailover;
+ }
+
+ /**
+ * Enable or disable region-level domain failover. See {@link #enableDomainFailover}.
+ *
+ * @param enabled true to enable (default), false to disable.
+ */
+ public void setEnableDomainFailover(boolean enabled) {
+ this.enableDomainFailover = enabled;
+ }
+}
diff --git a/src/main/java/com/tencentcloudapi/common/profile/HttpProfile.java b/src/main/java/com/tencentcloudapi/common/profile/HttpProfile.java
index f480adc3c..d7d7afe1a 100644
--- a/src/main/java/com/tencentcloudapi/common/profile/HttpProfile.java
+++ b/src/main/java/com/tencentcloudapi/common/profile/HttpProfile.java
@@ -1,416 +1,416 @@
-/*
- * Copyright (c) 2018 Tencent. All Rights Reserved.
- *
- * Licensed 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 com.tencentcloudapi.common.profile;
-
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.SSLSocketFactory;
-import javax.net.ssl.X509TrustManager;
-
-/**
- * HttpProfile defines the configuration settings for HTTP requests made by the Tencent Cloud client.
- * It includes settings for the request method, endpoint, timeouts, proxy configurations, SSL settings, etc.
- */
-public class HttpProfile {
-
- // Constants for request protocols and methods
- public static final String REQ_HTTPS = "https://";
- public static final String REQ_HTTP = "http://";
- public static final String REQ_POST = "POST";
- public static final String REQ_GET = "GET";
-
- /**
- * Time unit constant: 1 minute equals 60 seconds.
- */
- public static final int TM_MINUTE = 60;
-
- // HTTP method for the request (GET/POST)
- private String reqMethod;
-
- /**
- * The endpoint for the API request (e.g., "cvm.tencentcloudapi.com").
- */
- private String endpoint;
-
- /**
- * The root domain of the API (e.g., "tencentcloudapi.com").
- */
- private String rootDomain;
-
- /**
- * The protocol used for the request. Currently, only HTTPS is valid.
- */
- private String protocol;
-
- /**
- * Read timeout in seconds. Specifies the time to wait for a server response.
- */
- private int readTimeout;
-
- /**
- * Write timeout in seconds. Specifies the time to wait for data to be sent to the server.
- */
- private int writeTimeout;
-
- /**
- * Connect timeout in seconds. Specifies the time to wait for a connection to be established.
- */
- private int connTimeout;
-
- /**
- * HTTP proxy host, if a proxy is being used.
- */
- private String proxyHost;
-
- /**
- * HTTP proxy port, if a proxy is being used.
- */
- private int proxyPort;
-
- /**
- * HTTP proxy username, if authentication is required for the proxy.
- */
- private String proxyUsername;
-
- /**
- * HTTP proxy password, if authentication is required for the proxy.
- */
- private String proxyPassword;
-
- // SSL-related fields for secure communication
- private SSLSocketFactory sslSocketFactory;
- private X509TrustManager trustManager;
- private HostnameVerifier hostnameVerifier;
-
- /**
- * The API Gateway endpoint, which can be different from the regular API endpoint.
- */
- private String apigwEndpoint;
-
- /**
- * For advanced users, an object for fine-grained control over the HTTP client.
- * If this is set, other configurations like timeouts and proxy settings will be ignored.
- */
- private Object httpClient;
-
- /**
- * Default constructor for HttpProfile.
- * Initializes default values for the HTTP profile configuration.
- */
- public HttpProfile() {
- this.reqMethod = HttpProfile.REQ_POST;
- this.endpoint = null;
- this.rootDomain = "tencentcloudapi.com";
- this.protocol = HttpProfile.REQ_HTTPS;
- this.readTimeout = 0;
- this.writeTimeout = 0;
- this.connTimeout = HttpProfile.TM_MINUTE;
- this.apigwEndpoint = null;
- }
-
- /**
- * Get the HTTP request method (e.g., POST or GET).
- *
- * @return The request method.
- */
- public String getReqMethod() {
- return this.reqMethod;
- }
-
- /**
- * Set the HTTP request method (e.g., POST or GET).
- *
- * @param reqMethod The HTTP method to set.
- */
- public void setReqMethod(String reqMethod) {
- this.reqMethod = reqMethod;
- }
-
- /**
- * Get the endpoint to which the request is sent.
- *
- * @return The endpoint (e.g., "cvm.tencentcloudapi.com").
- */
- public String getEndpoint() {
- return this.endpoint;
- }
-
- /**
- * Set the endpoint for the API request.
- *
- * Endpoint is the domain where the request is sent, e.g., [productName].tencentcloudapi.com.
- * If you need to request a specific region (e.g., Guangzhou), set it to [productName].ap-guangzhou
- * .tencentcloudapi.com.
- *
- * @param endpoint The endpoint URL.
- */
- public void setEndpoint(String endpoint) {
- this.endpoint = endpoint;
- }
-
- /**
- * Get the read timeout value in seconds.
- *
- * @return The read timeout in seconds.
- */
- public int getReadTimeout() {
- return this.readTimeout;
- }
-
- /**
- * Set the read timeout value in seconds. This specifies how long to wait for a response from the server.
- *
- * @param readTimeout The read timeout in seconds.
- */
- public void setReadTimeout(int readTimeout) {
- this.readTimeout = readTimeout;
- }
-
- /**
- * Get the write timeout value in seconds.
- *
- * @return The write timeout in seconds.
- */
- public int getWriteTimeout() {
- return this.writeTimeout;
- }
-
- /**
- * Set the write timeout value in seconds. This specifies how long to wait for the server to accept the data.
- *
- * @param writeTimeout The write timeout in seconds.
- */
- public void setWriteTimeout(int writeTimeout) {
- this.writeTimeout = writeTimeout;
- }
-
- /**
- * Get the connect timeout value in seconds.
- *
- * @return The connection timeout in seconds.
- */
- public int getConnTimeout() {
- return this.connTimeout;
- }
-
- /**
- * Set the connect timeout value in seconds. This specifies how long to wait for a connection to be established.
- *
- * @param connTimeout The connect timeout in seconds.
- */
- public void setConnTimeout(int connTimeout) {
- this.connTimeout = connTimeout;
- }
-
- /**
- * Get the protocol used for the request (HTTP or HTTPS).
- *
- * @return The protocol (e.g., "https://").
- */
- public String getProtocol() {
- return this.protocol;
- }
-
- /**
- * Set the protocol for the request. Currently, only HTTPS is supported.
- *
- * @param protocol The protocol to use (e.g., "https://").
- */
- public void setProtocol(String protocol) {
- this.protocol = protocol;
- }
-
- /**
- * Get the proxy host if a proxy is being used.
- *
- * @return The proxy host.
- */
- public String getProxyHost() {
- return proxyHost;
- }
-
- /**
- * Set the proxy host for HTTP requests.
- *
- * @param proxyHost The proxy host to set.
- */
- public void setProxyHost(String proxyHost) {
- this.proxyHost = proxyHost;
- }
-
- /**
- * Get the proxy port if a proxy is being used.
- *
- * @return The proxy port.
- */
- public int getProxyPort() {
- return proxyPort;
- }
-
- /**
- * Set the proxy port for HTTP requests.
- *
- * @param proxyPort The proxy port to set.
- */
- public void setProxyPort(int proxyPort) {
- this.proxyPort = proxyPort;
- }
-
- /**
- * Get the proxy username for authentication.
- *
- * @return The proxy username.
- */
- public String getProxyUsername() {
- return proxyUsername;
- }
-
- /**
- * Set the proxy username for authentication.
- *
- * @param proxyUsername The proxy username to set.
- */
- public void setProxyUsername(String proxyUsername) {
- this.proxyUsername = proxyUsername;
- }
-
- /**
- * Get the proxy password for authentication.
- *
- * @return The proxy password.
- */
- public String getProxyPassword() {
- return proxyPassword;
- }
-
- /**
- * Set the proxy password for authentication.
- *
- * @param proxyPassword The proxy password to set.
- */
- public void setProxyPassword(String proxyPassword) {
- this.proxyPassword = proxyPassword;
- }
-
- /**
- * Get the root domain (e.g., "tencentcloudapi.com").
- *
- * @return The root domain.
- */
- public String getRootDomain() {
- return rootDomain;
- }
-
- /**
- * Set the root domain of the API (e.g., "tencentcloudapi.com").
- *
- * @param rootDomain The root domain to set.
- */
- public void setRootDomain(String rootDomain) {
- this.rootDomain = rootDomain;
- }
-
- /**
- * Get the SSLSocketFactory for SSL connections.
- *
- * @return The SSL socket factory.
- */
- public SSLSocketFactory getSslSocketFactory() {
- return sslSocketFactory;
- }
-
- /**
- * Set the SSLSocketFactory for SSL connections.
- *
- * @param sslSocketFactory The SSL socket factory to set.
- */
- public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
- this.sslSocketFactory = sslSocketFactory;
- }
-
- /**
- * Get the trust manager for SSL connections.
- *
- * @return The X509 trust manager.
- */
- public X509TrustManager getX509TrustManager() {
- return trustManager;
- }
-
- /**
- * Set the trust manager for SSL connections.
- *
- * @param trustManager The X509 trust manager to set.
- */
- public void setX509TrustManager(X509TrustManager trustManager) {
- this.trustManager = trustManager;
- }
-
- /**
- * Get the API Gateway endpoint.
- *
- * @return The API Gateway endpoint.
- */
- public String getApigwEndpoint() {
- return apigwEndpoint;
- }
-
- /**
- * Set the API Gateway endpoint.
- *
- * @param apigwEndpoint The API Gateway endpoint to set.
- */
- public void setApigwEndpoint(String apigwEndpoint) {
- this.apigwEndpoint = apigwEndpoint;
- }
-
- /**
- * Get the HostnameVerifier used for hostname verification.
- *
- * @return The hostname verifier.
- */
- public HostnameVerifier getHostnameVerifier() {
- return hostnameVerifier;
- }
-
- /**
- * Set the HostnameVerifier used for hostname verification.
- *
- * @param hostnameVerifier The hostname verifier to set.
- */
- public void setHostnameVerifier(HostnameVerifier hostnameVerifier) {
- this.hostnameVerifier = hostnameVerifier;
- }
-
- /**
- * Get the custom HTTP client for advanced configuration.
- *
- * @return The custom HTTP client.
- */
- public Object getHttpClient() {
- return httpClient;
- }
-
- /**
- * Set a custom HTTP client for advanced configuration.
- *
- * @param client The custom HTTP client to set.
- */
- public void setHttpClient(Object client) {
- httpClient = client;
- }
-}
+/*
+ * Copyright (c) 2018 Tencent. All Rights Reserved.
+ *
+ * Licensed 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 com.tencentcloudapi.common.profile;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * HttpProfile defines the configuration settings for HTTP requests made by the Tencent Cloud client.
+ * It includes settings for the request method, endpoint, timeouts, proxy configurations, SSL settings, etc.
+ */
+public class HttpProfile {
+
+ // Constants for request protocols and methods
+ public static final String REQ_HTTPS = "https://";
+ public static final String REQ_HTTP = "http://";
+ public static final String REQ_POST = "POST";
+ public static final String REQ_GET = "GET";
+
+ /**
+ * Time unit constant: 1 minute equals 60 seconds.
+ */
+ public static final int TM_MINUTE = 60;
+
+ // HTTP method for the request (GET/POST)
+ private String reqMethod;
+
+ /**
+ * The endpoint for the API request (e.g., "cvm.tencentcloudapi.com").
+ */
+ private String endpoint;
+
+ /**
+ * The root domain of the API (e.g., "tencentcloudapi.com").
+ */
+ private String rootDomain;
+
+ /**
+ * The protocol used for the request. Currently, only HTTPS is valid.
+ */
+ private String protocol;
+
+ /**
+ * Read timeout in seconds. Specifies the time to wait for a server response.
+ */
+ private int readTimeout;
+
+ /**
+ * Write timeout in seconds. Specifies the time to wait for data to be sent to the server.
+ */
+ private int writeTimeout;
+
+ /**
+ * Connect timeout in seconds. Specifies the time to wait for a connection to be established.
+ */
+ private int connTimeout;
+
+ /**
+ * HTTP proxy host, if a proxy is being used.
+ */
+ private String proxyHost;
+
+ /**
+ * HTTP proxy port, if a proxy is being used.
+ */
+ private int proxyPort;
+
+ /**
+ * HTTP proxy username, if authentication is required for the proxy.
+ */
+ private String proxyUsername;
+
+ /**
+ * HTTP proxy password, if authentication is required for the proxy.
+ */
+ private String proxyPassword;
+
+ // SSL-related fields for secure communication
+ private SSLSocketFactory sslSocketFactory;
+ private X509TrustManager trustManager;
+ private HostnameVerifier hostnameVerifier;
+
+ /**
+ * The API Gateway endpoint, which can be different from the regular API endpoint.
+ */
+ private String apigwEndpoint;
+
+ /**
+ * For advanced users, an object for fine-grained control over the HTTP client.
+ * If this is set, other configurations like timeouts and proxy settings will be ignored.
+ */
+ private Object httpClient;
+
+ /**
+ * Default constructor for HttpProfile.
+ * Initializes default values for the HTTP profile configuration.
+ */
+ public HttpProfile() {
+ this.reqMethod = HttpProfile.REQ_POST;
+ this.endpoint = null;
+ this.rootDomain = "tencentcloudapi.com";
+ this.protocol = HttpProfile.REQ_HTTPS;
+ this.readTimeout = 0;
+ this.writeTimeout = 0;
+ this.connTimeout = HttpProfile.TM_MINUTE;
+ this.apigwEndpoint = null;
+ }
+
+ /**
+ * Get the HTTP request method (e.g., POST or GET).
+ *
+ * @return The request method.
+ */
+ public String getReqMethod() {
+ return this.reqMethod;
+ }
+
+ /**
+ * Set the HTTP request method (e.g., POST or GET).
+ *
+ * @param reqMethod The HTTP method to set.
+ */
+ public void setReqMethod(String reqMethod) {
+ this.reqMethod = reqMethod;
+ }
+
+ /**
+ * Get the endpoint to which the request is sent.
+ *
+ * @return The endpoint (e.g., "cvm.tencentcloudapi.com").
+ */
+ public String getEndpoint() {
+ return this.endpoint;
+ }
+
+ /**
+ * Set the endpoint for the API request.
+ *
+ * Endpoint is the domain where the request is sent, e.g., [productName].tencentcloudapi.com.
+ * If you need to request a specific region (e.g., Guangzhou), set it to [productName].ap-guangzhou
+ * .tencentcloudapi.com.
+ *
+ * @param endpoint The endpoint URL.
+ */
+ public void setEndpoint(String endpoint) {
+ this.endpoint = endpoint;
+ }
+
+ /**
+ * Get the read timeout value in seconds.
+ *
+ * @return The read timeout in seconds.
+ */
+ public int getReadTimeout() {
+ return this.readTimeout;
+ }
+
+ /**
+ * Set the read timeout value in seconds. This specifies how long to wait for a response from the server.
+ *
+ * @param readTimeout The read timeout in seconds.
+ */
+ public void setReadTimeout(int readTimeout) {
+ this.readTimeout = readTimeout;
+ }
+
+ /**
+ * Get the write timeout value in seconds.
+ *
+ * @return The write timeout in seconds.
+ */
+ public int getWriteTimeout() {
+ return this.writeTimeout;
+ }
+
+ /**
+ * Set the write timeout value in seconds. This specifies how long to wait for the server to accept the data.
+ *
+ * @param writeTimeout The write timeout in seconds.
+ */
+ public void setWriteTimeout(int writeTimeout) {
+ this.writeTimeout = writeTimeout;
+ }
+
+ /**
+ * Get the connect timeout value in seconds.
+ *
+ * @return The connection timeout in seconds.
+ */
+ public int getConnTimeout() {
+ return this.connTimeout;
+ }
+
+ /**
+ * Set the connect timeout value in seconds. This specifies how long to wait for a connection to be established.
+ *
+ * @param connTimeout The connect timeout in seconds.
+ */
+ public void setConnTimeout(int connTimeout) {
+ this.connTimeout = connTimeout;
+ }
+
+ /**
+ * Get the protocol used for the request (HTTP or HTTPS).
+ *
+ * @return The protocol (e.g., "https://").
+ */
+ public String getProtocol() {
+ return this.protocol;
+ }
+
+ /**
+ * Set the protocol for the request. Currently, only HTTPS is supported.
+ *
+ * @param protocol The protocol to use (e.g., "https://").
+ */
+ public void setProtocol(String protocol) {
+ this.protocol = protocol;
+ }
+
+ /**
+ * Get the proxy host if a proxy is being used.
+ *
+ * @return The proxy host.
+ */
+ public String getProxyHost() {
+ return proxyHost;
+ }
+
+ /**
+ * Set the proxy host for HTTP requests.
+ *
+ * @param proxyHost The proxy host to set.
+ */
+ public void setProxyHost(String proxyHost) {
+ this.proxyHost = proxyHost;
+ }
+
+ /**
+ * Get the proxy port if a proxy is being used.
+ *
+ * @return The proxy port.
+ */
+ public int getProxyPort() {
+ return proxyPort;
+ }
+
+ /**
+ * Set the proxy port for HTTP requests.
+ *
+ * @param proxyPort The proxy port to set.
+ */
+ public void setProxyPort(int proxyPort) {
+ this.proxyPort = proxyPort;
+ }
+
+ /**
+ * Get the proxy username for authentication.
+ *
+ * @return The proxy username.
+ */
+ public String getProxyUsername() {
+ return proxyUsername;
+ }
+
+ /**
+ * Set the proxy username for authentication.
+ *
+ * @param proxyUsername The proxy username to set.
+ */
+ public void setProxyUsername(String proxyUsername) {
+ this.proxyUsername = proxyUsername;
+ }
+
+ /**
+ * Get the proxy password for authentication.
+ *
+ * @return The proxy password.
+ */
+ public String getProxyPassword() {
+ return proxyPassword;
+ }
+
+ /**
+ * Set the proxy password for authentication.
+ *
+ * @param proxyPassword The proxy password to set.
+ */
+ public void setProxyPassword(String proxyPassword) {
+ this.proxyPassword = proxyPassword;
+ }
+
+ /**
+ * Get the root domain (e.g., "tencentcloudapi.com").
+ *
+ * @return The root domain.
+ */
+ public String getRootDomain() {
+ return rootDomain;
+ }
+
+ /**
+ * Set the root domain of the API (e.g., "tencentcloudapi.com").
+ *
+ * @param rootDomain The root domain to set.
+ */
+ public void setRootDomain(String rootDomain) {
+ this.rootDomain = rootDomain;
+ }
+
+ /**
+ * Get the SSLSocketFactory for SSL connections.
+ *
+ * @return The SSL socket factory.
+ */
+ public SSLSocketFactory getSslSocketFactory() {
+ return sslSocketFactory;
+ }
+
+ /**
+ * Set the SSLSocketFactory for SSL connections.
+ *
+ * @param sslSocketFactory The SSL socket factory to set.
+ */
+ public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
+ this.sslSocketFactory = sslSocketFactory;
+ }
+
+ /**
+ * Get the trust manager for SSL connections.
+ *
+ * @return The X509 trust manager.
+ */
+ public X509TrustManager getX509TrustManager() {
+ return trustManager;
+ }
+
+ /**
+ * Set the trust manager for SSL connections.
+ *
+ * @param trustManager The X509 trust manager to set.
+ */
+ public void setX509TrustManager(X509TrustManager trustManager) {
+ this.trustManager = trustManager;
+ }
+
+ /**
+ * Get the API Gateway endpoint.
+ *
+ * @return The API Gateway endpoint.
+ */
+ public String getApigwEndpoint() {
+ return apigwEndpoint;
+ }
+
+ /**
+ * Set the API Gateway endpoint.
+ *
+ * @param apigwEndpoint The API Gateway endpoint to set.
+ */
+ public void setApigwEndpoint(String apigwEndpoint) {
+ this.apigwEndpoint = apigwEndpoint;
+ }
+
+ /**
+ * Get the HostnameVerifier used for hostname verification.
+ *
+ * @return The hostname verifier.
+ */
+ public HostnameVerifier getHostnameVerifier() {
+ return hostnameVerifier;
+ }
+
+ /**
+ * Set the HostnameVerifier used for hostname verification.
+ *
+ * @param hostnameVerifier The hostname verifier to set.
+ */
+ public void setHostnameVerifier(HostnameVerifier hostnameVerifier) {
+ this.hostnameVerifier = hostnameVerifier;
+ }
+
+ /**
+ * Get the custom HTTP client for advanced configuration.
+ *
+ * @return The custom HTTP client.
+ */
+ public Object getHttpClient() {
+ return httpClient;
+ }
+
+ /**
+ * Set a custom HTTP client for advanced configuration.
+ *
+ * @param client The custom HTTP client to set.
+ */
+ public void setHttpClient(Object client) {
+ httpClient = client;
+ }
+}
diff --git a/src/main/java/com/tencentcloudapi/common/provider/DefaultCredentialsProvider.java b/src/main/java/com/tencentcloudapi/common/provider/DefaultCredentialsProvider.java
index 2d7c77d66..9d57a14b7 100644
--- a/src/main/java/com/tencentcloudapi/common/provider/DefaultCredentialsProvider.java
+++ b/src/main/java/com/tencentcloudapi/common/provider/DefaultCredentialsProvider.java
@@ -24,7 +24,13 @@ public Credential getCredentials() throws TencentCloudSDKException {
return cred;
}
- cred = new OIDCRoleArnProvider().getCredentials();
- return cred;
+ try {
+ cred = new OIDCRoleArnProvider().getCredentials();
+ return cred;
+ } catch (TencentCloudSDKException e) {
+ // OIDC not configured or unavailable; fall through
+ }
+
+ throw new TencentCloudSDKException("No valid credential");
}
}
diff --git a/src/main/java/com/tencentcloudapi/common/provider/ProfileCredentialsProvider.java b/src/main/java/com/tencentcloudapi/common/provider/ProfileCredentialsProvider.java
index a54c0cdea..ba272316e 100644
--- a/src/main/java/com/tencentcloudapi/common/provider/ProfileCredentialsProvider.java
+++ b/src/main/java/com/tencentcloudapi/common/provider/ProfileCredentialsProvider.java
@@ -2,17 +2,18 @@
import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
-import org.ini4j.Wini;
+import org.apache.commons.configuration2.INIConfiguration;
+import org.apache.commons.configuration2.ex.ConfigurationException;
-import java.io.File;
+import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
public class ProfileCredentialsProvider implements CredentialsProvider {
- private static Wini ini;
+ private static INIConfiguration ini;
- private static Wini getIni() throws TencentCloudSDKException {
+ private static INIConfiguration getIni() throws TencentCloudSDKException {
String fileName;
if (Files.exists(Paths.get(System.getProperty("user.home") + "\\.tencentcloud\\credentials"))) {
fileName = System.getProperty("user.home") + "\\.tencentcloud\\credentials";
@@ -23,19 +24,20 @@ private static Wini getIni() throws TencentCloudSDKException {
} else {
throw new TencentCloudSDKException("Not found file");
}
- try {
- ini = new Wini(new File(fileName));
- } catch (IOException e) {
- throw new TencentCloudSDKException("IOException");
+ try (FileReader reader = new FileReader(fileName)) {
+ ini = new INIConfiguration();
+ ini.read(reader);
+ } catch (IOException | ConfigurationException e) {
+ throw new TencentCloudSDKException("IOException or ConfigurationException");
}
return ini;
}
@Override
public Credential getCredentials() throws TencentCloudSDKException {
- Wini ini = getIni();
- String secretId = ini.get("default", "secret_id");
- String secretKey = ini.get("default", "secret_key");
+ INIConfiguration ini = getIni();
+ String secretId = ini.getString("default.secret_id");
+ String secretKey = ini.getString("default.secret_key");
if (secretId == null || secretKey == null) {
throw new TencentCloudSDKException("Not found secretId or secretKey");
}
diff --git a/src/test/java/com/tencentcloudapi/common/AbstractClientProxyAuthTest.java b/src/test/java/com/tencentcloudapi/common/AbstractClientProxyAuthTest.java
new file mode 100644
index 000000000..81b1a1791
--- /dev/null
+++ b/src/test/java/com/tencentcloudapi/common/AbstractClientProxyAuthTest.java
@@ -0,0 +1,120 @@
+package com.tencentcloudapi.common;
+
+import com.tencentcloudapi.common.http.HttpConnection;
+import com.tencentcloudapi.common.profile.ClientProfile;
+import com.tencentcloudapi.common.profile.HttpProfile;
+import okhttp3.Authenticator;
+import okhttp3.OkHttpClient;
+import okhttp3.Protocol;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+
+/**
+ * Unit tests for the proxy authentication setup in {@link AbstractClient}.
+ *
+ * Regression coverage for the okhttp 3.x -> 4.x upgrade: okhttp 4's
+ * {@code Credentials.basic(username, password)} rejects a null password with an NPE,
+ * so {@code AbstractClient.trySetProxy} now falls back to an empty password when the
+ * profile only configures a proxy username.
+ */
+public class AbstractClientProxyAuthTest {
+
+ /**
+ * Minimal concrete subclass: AbstractClient declares no abstract methods, so an empty
+ * subclass is enough to instantiate it. The constructor performs no network I/O.
+ */
+ private static final class TestClient extends AbstractClient {
+ TestClient(ClientProfile profile) {
+ super("cvm.tencentcloudapi.com", "2017-03-12",
+ new Credential("secret-id", "secret-key"), "ap-guangzhou", profile);
+ }
+ }
+
+ private static ClientProfile proxyProfile(String username, String password) {
+ HttpProfile httpProfile = new HttpProfile();
+ httpProfile.setProxyHost("127.0.0.1");
+ httpProfile.setProxyPort(8080);
+ if (username != null) {
+ httpProfile.setProxyUsername(username);
+ }
+ if (password != null) {
+ httpProfile.setProxyPassword(password);
+ }
+ ClientProfile profile = new ClientProfile();
+ profile.setHttpProfile(httpProfile);
+ return profile;
+ }
+
+ private static OkHttpClient extractOkHttpClient(AbstractClient client) throws Exception {
+ Field connField = AbstractClient.class.getDeclaredField("httpConnection");
+ connField.setAccessible(true);
+ HttpConnection conn = (HttpConnection) connField.get(client);
+ Field clientField = HttpConnection.class.getDeclaredField("client");
+ clientField.setAccessible(true);
+ return (OkHttpClient) clientField.get(conn);
+ }
+
+ private static Response fakeProxyChallenge() {
+ Request request = new Request.Builder()
+ .url("https://cvm.tencentcloudapi.com/")
+ .build();
+ return new Response.Builder()
+ .request(request)
+ .protocol(Protocol.HTTP_1_1)
+ .code(407)
+ .message("Proxy Authentication Required")
+ .build();
+ }
+
+ /**
+ * The core regression: with only a proxy username configured (password is null), the
+ * authenticator must not throw on okhttp 4, and must send an empty password.
+ * base64("user:") = "dXNlcjo=".
+ */
+ @Test
+ public void nullProxyPasswordFallsBackToEmpty() throws Exception {
+ OkHttpClient ok = extractOkHttpClient(new TestClient(proxyProfile("user", null)));
+ Authenticator authenticator = ok.proxyAuthenticator();
+ Request authenticated = authenticator.authenticate(null, fakeProxyChallenge());
+ assertEquals("Basic dXNlcjo=", authenticated.header("Proxy-Authorization"));
+ }
+
+ /**
+ * A configured password must be passed through unchanged.
+ * base64("user:pass") = "dXNlcjpwYXNz".
+ */
+ @Test
+ public void configuredProxyPasswordIsUsed() throws Exception {
+ OkHttpClient ok = extractOkHttpClient(new TestClient(proxyProfile("user", "pass")));
+ Authenticator authenticator = ok.proxyAuthenticator();
+ Request authenticated = authenticator.authenticate(null, fakeProxyChallenge());
+ assertEquals("Basic dXNlcjpwYXNz", authenticated.header("Proxy-Authorization"));
+ }
+
+ /**
+ * Proxy host configured but no username: no authenticator should be installed
+ * (okhttp default is Authenticator.NONE).
+ */
+ @Test
+ public void proxyWithoutUsernameKeepsDefaultAuthenticator() throws Exception {
+ OkHttpClient ok = extractOkHttpClient(new TestClient(proxyProfile(null, "pass")));
+ assertSame(Authenticator.NONE, ok.proxyAuthenticator());
+ }
+
+ /**
+ * No proxy configured at all: neither proxy nor authenticator should be installed.
+ */
+ @Test
+ public void noProxyKeepsDefaults() throws Exception {
+ OkHttpClient ok = extractOkHttpClient(new TestClient(new ClientProfile()));
+ assertSame(Authenticator.NONE, ok.proxyAuthenticator());
+ assertNull(ok.proxy());
+ }
+}
diff --git a/src/test/java/com/tencentcloudapi/common/CircuitBreakerUnitTest.java b/src/test/java/com/tencentcloudapi/common/CircuitBreakerUnitTest.java
new file mode 100644
index 000000000..e00003453
--- /dev/null
+++ b/src/test/java/com/tencentcloudapi/common/CircuitBreakerUnitTest.java
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) 2018 Tencent. All Rights Reserved.
+ *
+ * Licensed 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 com.tencentcloudapi.common;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Unit tests for {@link CircuitBreaker} state-machine branches not covered by
+ * the basic smoke tests in
+ * {@code integration/common/CircuitBreakerTest.java}.
+ *
+ * Covers: failure-percentage threshold, consecutive-failure threshold,
+ * HalfOpen success path, stale-generation report discarding, window-interval
+ * counter reset, custom {@link CircuitBreaker.Setting} combinations, and
+ * {@link EndpointFailoverInterceptor#breakerFor(String)} inheriting the region
+ * breaker's settings.
+ */
+public class CircuitBreakerUnitTest {
+
+ // =================================================================
+ // readyToOpen: maxFailPercentage threshold
+ // =================================================================
+
+ /**
+ * {@code readyToOpen()} fires when {@code failures >= maxFailNum && failPre
+ * >= maxFailPercentage}. To isolate the percentage branch from the
+ * consecutive-failure branch (consecutiveFailures > 5) and from the pure
+ * count branch, use maxFailNum=6 so the count alone wouldn't fire at 5
+ * failures but the conjunction does once both thresholds are met.
+ *
+ * Sequence with maxFailNum=6, maxFailPercentage=0.75 (default):
+ * 3 failures + 1 success + 3 failures = failures=6, all=7, failPre=6/7≈0.857
+ * ≥ 0.75 and failures=6 >= 6 → opens. The success keeps consecutiveFailures
+ * at 3 on the final failure, so the consecutive branch (consecutiveFailures > 5)
+ * does not fire first.
+ */
+ @Test
+ public void testOpensOnFailurePercentageThreshold() {
+ CircuitBreaker.Setting setting = new CircuitBreaker.Setting();
+ setting.maxFailNum = 6; // count branch alone needs >= 6
+ CircuitBreaker cb = new CircuitBreaker(setting);
+ CircuitBreaker.Token t;
+
+ // 3 failures (consecutiveFailures=3, failures=3, all=3).
+ for (int i = 0; i < 3; i++) {
+ t = cb.allow();
+ Assert.assertTrue("call " + (i + 1) + " should be allowed", t.allowed);
+ t.report(false);
+ }
+
+ // 1 success resets consecutiveFailures but keeps failures=3, all=4.
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(true);
+
+ // 2 more failures: failures=5, all=6, failPre=5/6≈0.83 ≥ 0.75 but
+ // failures=5 < 6 → not open yet (count branch not satisfied).
+ for (int i = 0; i < 2; i++) {
+ t = cb.allow();
+ Assert.assertTrue("failure " + (i + 1) + " should be allowed", t.allowed);
+ t.report(false);
+ }
+
+ // 3rd failure after success: failures=6 >= 6 and failPre=6/7≈0.857
+ // ≥ 0.75 → opens. consecutiveFailures=3 so the consecutive branch
+ // is not the trigger.
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(false);
+
+ t = cb.allow();
+ Assert.assertFalse(
+ "percentage branch should have opened the breaker", t.allowed);
+ }
+
+ // =================================================================
+ // readyToOpen: consecutiveFailures > 5 threshold
+ // =================================================================
+
+ /**
+ * {@code readyToOpen()}'s second condition: {@code consecutiveFailures > 5}
+ * opens the breaker regardless of failure count or percentage. With 5
+ * consecutive failures {@code consecutiveFailures == 5} (not > 5), so the
+ * breaker stays closed; the 6th consecutive failure trips it.
+ */
+ @Test
+ public void testOpensOnSixConsecutiveFailures() {
+ CircuitBreaker cb = new CircuitBreaker();
+ CircuitBreaker.Token t;
+
+ // 5 consecutive failures — fails the percentage branch check too
+ // (failures=5 >= 5, failPre=1.0 >= 0.75), so this actually opens at 5.
+ // To isolate the consecutiveFailures branch we must keep failPre low,
+ // but maxFailNum=5 dominates once reached. Use a custom setting where
+ // maxFailNum is high so only the consecutive branch can fire.
+ CircuitBreaker.Setting setting = new CircuitBreaker.Setting();
+ setting.maxFailNum = 100; // disable the count branch
+ setting.maxFailPercentage = 1.0f; // disable the percentage branch
+ cb = new CircuitBreaker(setting);
+
+ // 5 consecutive failures: consecutiveFailures=5, not > 5 → stays closed.
+ for (int i = 0; i < 5; i++) {
+ t = cb.allow();
+ Assert.assertTrue("call " + (i + 1) + " should be allowed", t.allowed);
+ t.report(false);
+ }
+
+ // Insert a success to prove consecutiveFailures is the trigger, not
+ // total failures: reset consecutiveFailures, then accumulate again.
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(true);
+
+ // 5 more consecutive failures — consecutiveFailures=5 again, still closed.
+ for (int i = 0; i < 5; i++) {
+ t = cb.allow();
+ Assert.assertTrue("call " + (i + 1) + " after reset should be allowed", t.allowed);
+ t.report(false);
+ }
+
+ // 6th consecutive failure (consecutiveFailures=6 > 5) → opens.
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(false);
+
+ t = cb.allow();
+ Assert.assertFalse("breaker should be open on 6th consecutive failure", t.allowed);
+ }
+
+ // =================================================================
+ // HalfOpen success → Closed
+ // =================================================================
+
+ /**
+ * {@code onSuccess(State.HalfOpen, ...)} transitions to Closed when
+ * {@code all - failures > maxRequests}. With default maxRequests=0, the
+ * first HalfOpen success (all=1, failures=0, 1-0>0) closes the breaker.
+ * This complements {@code integration} testFail5Recover2 which only
+ * covers the HalfOpen-failure → re-Open path.
+ */
+ @Test
+ public void testHalfOpenSuccessClosesBreaker() throws InterruptedException {
+ CircuitBreaker.Setting setting = new CircuitBreaker.Setting();
+ setting.timeoutMs = 100;
+ CircuitBreaker cb = new CircuitBreaker(setting);
+ CircuitBreaker.Token t;
+
+ // 5 failures → Open.
+ for (int i = 0; i < 5; i++) {
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(false);
+ }
+ t = cb.allow();
+ Assert.assertFalse(t.allowed);
+
+ // Wait past Open timeout → HalfOpen.
+ Thread.sleep(setting.timeoutMs + 20);
+
+ // First HalfOpen probe succeeds → Closed.
+ t = cb.allow();
+ Assert.assertTrue("HalfOpen probe should be allowed", t.allowed);
+ t.report(true);
+
+ // Now Closed: subsequent calls are allowed and a fresh failure does
+ // not immediately re-open (consecutiveFailures=1, not > 5; failures=1
+ // < 5).
+ t = cb.allow();
+ Assert.assertTrue("Closed after HalfOpen success", t.allowed);
+ t.report(false);
+ t = cb.allow();
+ Assert.assertTrue("single failure in fresh Closed window should not re-open", t.allowed);
+ }
+
+ // =================================================================
+ // Stale-generation report is discarded
+ // =================================================================
+
+ /**
+ * {@code report()} returns early when {@code result.generation !=
+ * beforeGeneration}. A token captured before a state-transition-induced
+ * generation bump must not affect the new generation's counters.
+ *
+ * Sequence: 5 failures → Open (gen=1). Capture a token (gen=1) but do
+ * not report. Sleep past Open timeout → HalfOpen (gen=2). Reporting the
+ * stale gen=1 token with failure must NOT trip HalfOpen back to Open —
+ * the next allow must still be permitted (HalfOpen).
+ */
+ @Test
+ public void testStaleGenerationReportIsDiscarded() throws InterruptedException {
+ CircuitBreaker.Setting setting = new CircuitBreaker.Setting();
+ setting.timeoutMs = 100;
+ CircuitBreaker cb = new CircuitBreaker(setting);
+ CircuitBreaker.Token t;
+
+ for (int i = 0; i < 5; i++) {
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(false);
+ }
+ // Open — capture a token but hold it without reporting.
+ CircuitBreaker.Token staleToken = cb.allow();
+ Assert.assertFalse(staleToken.allowed);
+
+ // Sleep into HalfOpen (new generation).
+ Thread.sleep(setting.timeoutMs + 20);
+ CircuitBreaker.Token halfOpenToken = cb.allow();
+ Assert.assertTrue("should be in HalfOpen", halfOpenToken.allowed);
+
+ // Report the stale token as a failure — must be discarded.
+ staleToken.report(false);
+
+ // The HalfOpen probe should still be viable: reporting it as success
+ // should close the breaker. If the stale report had been applied,
+ // HalfOpen would have flipped back to Open and the success report
+ // would land on a new generation and be discarded, leaving the next
+ // allow() rejected.
+ halfOpenToken.report(true);
+ CircuitBreaker.Token after = cb.allow();
+ Assert.assertTrue(
+ "stale failure report must not have flipped HalfOpen back to Open",
+ after.allowed);
+ }
+
+ // =================================================================
+ // windowIntervalMs resets Closed counters
+ // =================================================================
+
+ /**
+ * In Closed state, when {@code expiry < now} the breaker calls
+ * {@code toNewGeneration}, zeroing {@code failures} and {@code all} (but
+ * NOT {@code consecutiveFailures} — that field is only reset by a success
+ * or a state transition). Verify the window reset by showing that a fresh
+ * failure burst opens the breaker later than it would if the counters had
+ * carried over.
+ *
+ * With maxFailNum=5, maxFailPercentage=0.75: 3 failures + 1 success
+ * (resets consecutiveFailures) + window expiry + 5 failures. With reset,
+ * failures climbs 1..5 and opens on the 5th (failures=5 >= 5, failPre=1.0
+ * >= 0.75, consecutiveFailures=5, not > 5). Without reset, failures would
+ * be 3+2=5 on the 2nd post-window failure and open early.
+ */
+ @Test
+ public void testWindowIntervalResetsClosedCounters() throws InterruptedException {
+ CircuitBreaker.Setting setting = new CircuitBreaker.Setting();
+ setting.windowIntervalMs = 200;
+ setting.timeoutMs = 200;
+ CircuitBreaker cb = new CircuitBreaker(setting);
+ CircuitBreaker.Token t;
+
+ // 3 failures (failures=3, all=3, consecutiveFailures=3).
+ for (int i = 0; i < 3; i++) {
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(false);
+ }
+
+ // 1 success: consecutiveFailures=0, failures=3, all=4.
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(true);
+
+ // Wait past the Closed window so the next allow() starts a new
+ // generation with zeroed failures/all.
+ Thread.sleep(setting.windowIntervalMs + 100);
+
+ // 4 post-window failures: with reset, failures=4 < 5 → still closed.
+ // (consecutiveFailures=4, not > 5.) Without reset, failures would be
+ // 3+4=7 and the breaker would have opened at the 2nd failure here.
+ for (int i = 0; i < 4; i++) {
+ t = cb.allow();
+ Assert.assertTrue(
+ "failure " + (i + 1) + " after reset should be allowed", t.allowed);
+ t.report(false);
+ }
+
+ // 5th post-window failure: failures=5 >= 5, failPre=5/5=1.0 >= 0.75 → opens.
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(false);
+
+ t = cb.allow();
+ Assert.assertFalse(
+ "breaker should open once failures re-accumulates past threshold",
+ t.allowed);
+ }
+
+ // =================================================================
+ // Custom Setting combinations
+ // =================================================================
+
+ /**
+ * Exercises non-default {@link CircuitBreaker.Setting} values together:
+ * maxFailNum=3 lowers the count threshold; maxFailPercentage=0.5 lowers
+ * the percentage threshold; maxRequests=2 requires more than 2
+ * HalfOpen successes (with no failures) before closing.
+ */
+ @Test
+ public void testCustomSettingCombination() throws InterruptedException {
+ CircuitBreaker.Setting setting = new CircuitBreaker.Setting();
+ setting.maxFailNum = 3;
+ setting.maxFailPercentage = 0.5f;
+ setting.timeoutMs = 100;
+ setting.maxRequests = 2;
+ CircuitBreaker cb = new CircuitBreaker(setting);
+ CircuitBreaker.Token t;
+
+ // 3 failures, failPre=1.0 >= 0.5 and failures=3 >= 3 → opens on 3rd.
+ for (int i = 0; i < 3; i++) {
+ t = cb.allow();
+ Assert.assertTrue(t.allowed);
+ t.report(false);
+ }
+ t = cb.allow();
+ Assert.assertFalse("custom maxFailNum=3 should open after 3 failures", t.allowed);
+
+ // Sleep into HalfOpen.
+ Thread.sleep(setting.timeoutMs + 20);
+
+ // maxRequests=2: need all - failures > 2, i.e. at least 3 successes.
+ // 2 successes → all=2, failures=0, 2-0=2 not > 2 → stays HalfOpen.
+ for (int i = 0; i < 2; i++) {
+ t = cb.allow();
+ Assert.assertTrue("HalfOpen probe " + (i + 1) + " should be allowed", t.allowed);
+ t.report(true);
+ }
+ // 3rd success → all=3, 3-0=3 > 2 → Closed.
+ t = cb.allow();
+ Assert.assertTrue("HalfOpen probe 3 should be allowed", t.allowed);
+ t.report(true);
+
+ // Closed again — fresh allow must succeed and a single failure must
+ // not re-open (failures=1 < 3).
+ t = cb.allow();
+ Assert.assertTrue("should be Closed after 3 HalfOpen successes", t.allowed);
+ t.report(false);
+ t = cb.allow();
+ Assert.assertTrue("single failure should not re-open custom-threshold breaker", t.allowed);
+ }
+
+ // =================================================================
+ // EndpointFailoverInterceptor.newBreaker inherits regionBreaker setting
+ // =================================================================
+
+ /**
+ * {@link EndpointFailoverInterceptor#breakerFor(String)} calls
+ * {@code newBreaker()}, which — when a region breaker has been set —
+ * constructs the per-host breaker with {@code regionBreaker.getSetting()}
+ * instead of the default. Verify the inherited setting takes effect by
+ * checking the per-host breaker opens after the region breaker's custom
+ * maxFailNum, not the default 5.
+ */
+ @Test
+ public void testNewBreakerInheritsRegionBreakerSetting() throws Exception {
+ // Build an interceptor via reflection: the constructor needs an
+ // AbstractClient, but newBreaker()/breakerFor()/setRegionBreaker()
+ // only read client.getClientProfile().getBackupEndpoint() in the
+ // constructor. Use a real CvmClient with a default profile.
+ com.tencentcloudapi.common.profile.ClientProfile profile =
+ new com.tencentcloudapi.common.profile.ClientProfile();
+ com.tencentcloudapi.cvm.v20170312.CvmClient client =
+ new com.tencentcloudapi.cvm.v20170312.CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+
+ EndpointFailoverInterceptor interceptor =
+ new EndpointFailoverInterceptor(client);
+
+ CircuitBreaker.Setting regionSetting = new CircuitBreaker.Setting();
+ regionSetting.maxFailNum = 3;
+ regionSetting.maxFailPercentage = 1.0f; // isolate the count branch
+ CircuitBreaker regionBreaker = new CircuitBreaker(regionSetting);
+ interceptor.setRegionBreaker(regionBreaker);
+
+ // Trigger creation of a per-host breaker.
+ String host = "cvm.tencentcloudapi.com";
+ CircuitBreaker perHost = interceptor.breakerFor(host);
+
+ // The new breaker should share the region breaker's Setting instance
+ // (newBreaker returns new CircuitBreaker(regionBreaker.getSetting())).
+ Assert.assertSame(
+ "per-host breaker should inherit regionBreaker's Setting instance",
+ regionSetting, perHost.getSetting());
+
+ // Behavioural check: opens after 3 failures (region's maxFailNum),
+ // not 5 (default). With maxFailPercentage=1.0f the percentage branch
+ // never fires, so only the count branch (failures >= 3) can open it.
+ CircuitBreaker.Token t;
+ for (int i = 0; i < 3; i++) {
+ t = perHost.allow();
+ Assert.assertTrue("failure " + (i + 1) + " should be allowed", t.allowed);
+ t.report(false);
+ }
+ t = perHost.allow();
+ Assert.assertFalse(
+ "inherited maxFailNum=3 should open after 3 failures", t.allowed);
+ }
+}
diff --git a/src/test/java/com/tencentcloudapi/common/CommonRequestTest.java b/src/test/java/com/tencentcloudapi/common/CommonRequestTest.java
new file mode 100644
index 000000000..3743f8764
--- /dev/null
+++ b/src/test/java/com/tencentcloudapi/common/CommonRequestTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2018 Tencent. All Rights Reserved.
+ *
+ * Licensed 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 com.tencentcloudapi.common;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests for {@link CommonRequest}.
+ *
+ * {@link CommonRequest} wraps a JSON string into an {@link AbstractModel}
+ * by deserialising it into a {@code HashMap Each test scenario is run against every domain family (N1/N2/N3) via a
+ * {@code for (Family f : FAMILIES)} loop inside the test method. This gives
+ * M × N coverage while keeping the code DRY.
+ *
+ * Scenarios that do NOT depend on the domain family (e.g. pure helper
+ * methods like {@code isKnownTencentCloudHost}) use a single test method
+ * without the family loop.
+ *
+ * How tests are organized
+ *
+ * Adding a new test case
+ *
+ *
+ *
+ *
+ *
+ *
+ * Domain families (N)
+ *
+ *
+ *
+ * Test scenarios (M)
+ *
+ * Pure helpers
+ *
+ *
+ *
+ * Pass-through
+ *
+ *
+ *
+ * Failover triggers
+ *
+ *
+ *
+ * Response after failover
+ *
+ *
+ *
+ * Circuit breaker lifecycle
+ *
+ *
+ *
+ * Failure reporting & isolation
+ *
+ *
+ *
+ * Request re-signing
+ *
+ *
+ *
+ * Response type handling
+ *
+ *
+ *
+ * backupEndpoint mode
+ *
+ *
+ *
+ * TLD boundary & region-pinned
+ *
+ *
+ *
+ * Passthrough details
+ *
+ *
+ *
+ * Endpoint eligibility
+ *
+ *
+ *
+ * TLD family rotation
+ *
+ *
+ *
+ * Re-sign details
+ *
+ *
+ *
+ * backupEndpoint details
+ *
+ *
+ */
+public class EndpointFailoverInterceptorTest {
+
+ // =================================================================
+ // Domain families
+ // =================================================================
+
+ private static final Family N1 = new Family(
+ "Normal", "tencentcloudapi.com",
+ "cvm.tencentcloudapi.com",
+ "cvm.tencentcloudapi.com.cn",
+ "cvm.tencentcloudapi.cn");
+
+ private static final Family N2 = new Family(
+ "AI", "ai.tencentcloudapi.com",
+ "cvm.ai.tencentcloudapi.com",
+ "cvm.ai.tencentcloudapi.com.cn",
+ "cvm.ai.tencentcloudapi.cn");
+
+ private static final Family N3 = new Family(
+ "Internal", "internal.tencentcloudapi.com",
+ "cvm.internal.tencentcloudapi.com",
+ "cvm.internal.tencentcloudapi.com.cn",
+ "cvm.internal.tencentcloudapi.cn");
+
+ private static final Family[] FAMILIES = {N1, N2, N3};
+
+ private static class Family {
+ final String name;
+ final String rootDomain;
+ final String originHost;
+ final String firstFailover;
+ final String secondFailover;
+ final String[] allTldHosts;
+
+ Family(String name, String rootDomain, String host0, String host1, String host2) {
+ this.name = name;
+ this.rootDomain = rootDomain;
+ this.originHost = host0;
+ this.firstFailover = host1;
+ this.secondFailover = host2;
+ this.allTldHosts = new String[]{host0, host1, host2};
+ }
+ }
+
+ // =================================================================
+ // M1: isKnownTencentCloudHost — host classification
+ // =================================================================
+
+ @Test
+ public void testIsKnownTencentCloudHost() {
+ // Normal family (tencentcloudapi.com / .cn / .com.cn)
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.tencentcloudapi.com"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.tencentcloudapi.cn"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.tencentcloudapi.com.cn"));
+ // intl prefix maps to the normal family.
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.intl.tencentcloudapi.com"));
+ // Region-pinned.
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ap-shanghai.tencentcloudapi.com"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ap-shanghai.tencentcloudapi.cn"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ap-shanghai.tencentcloudapi.com.cn"));
+
+ // AI family (ai.tencentcloudapi.com / .cn / .com.cn)
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ai.tencentcloudapi.com"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ai.tencentcloudapi.cn"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ai.tencentcloudapi.com.cn"));
+ // Region-pinned.
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ap-guangzhou.ai.tencentcloudapi.com"));
+
+ // Internal family (internal.tencentcloudapi.com / .cn / .com.cn)
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.internal.tencentcloudapi.com"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.internal.tencentcloudapi.cn"));
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.internal.tencentcloudapi.com.cn"));
+ // Region-pinned.
+ assertTrue(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.ap-guangzhou.internal.tencentcloudapi.com"));
+
+ // Empty prefix (no service label)
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("tencentcloudapi.com"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("tencentcloudapi.cn"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("tencentcloudapi.com.cn"));
+
+ // Malformed prefix
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost(".tencentcloudapi.com"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost(".foo.tencentcloudapi.com"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("foo..tencentcloudapi.com"));
+
+ // Non-TencentCloud hosts
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("example.com"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("cvm.tencentcloudapi.woa.com"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("proxy.internal"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost("192.168.0.1"));
+ assertFalse(EndpointFailoverInterceptor.isKnownTencentCloudHost(null));
+ }
+
+ // =================================================================
+ // M2: hostWithTld / serviceOf — utility helpers
+ // =================================================================
+
+ @Test
+ public void testHostWithTldBuildsCorrectHosts() {
+ assertEquals("cvm.tencentcloudapi.com",
+ EndpointFailoverInterceptor.hostWithTld("cvm.tencentcloudapi.com", 0));
+ assertEquals("cvm.tencentcloudapi.com.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.tencentcloudapi.com", 1));
+ assertEquals("cvm.tencentcloudapi.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.tencentcloudapi.com", 2));
+
+ assertEquals("cvm.ai.tencentcloudapi.com",
+ EndpointFailoverInterceptor.hostWithTld("cvm.ai.tencentcloudapi.com", 0));
+ assertEquals("cvm.ai.tencentcloudapi.com.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.ai.tencentcloudapi.com", 1));
+
+ assertEquals("cvm.internal.tencentcloudapi.com",
+ EndpointFailoverInterceptor.hostWithTld("cvm.internal.tencentcloudapi.com", 0));
+ }
+
+ @Test
+ public void testMatchFamilyReturnsNullForUnknownHosts() {
+ assertNull(EndpointFailoverInterceptor.matchFamily("example.com"));
+ assertNull(EndpointFailoverInterceptor.matchFamily(null));
+ }
+
+ @Test
+ public void testMatchFamilyReturnsFirstMatchingFamily() {
+ EndpointFailoverInterceptor.Match m;
+
+ m = EndpointFailoverInterceptor.matchFamily("cvm.tencentcloudapi.com");
+ assertNotNull(m);
+ assertEquals("cvm", m.prefix);
+ assertEquals("tencentcloudapi.com", m.family[0]);
+
+ m = EndpointFailoverInterceptor.matchFamily("cvm.ai.tencentcloudapi.cn");
+ assertNotNull(m);
+ assertEquals("cvm", m.prefix);
+ assertEquals("ai.tencentcloudapi.com", m.family[0]);
+
+ m = EndpointFailoverInterceptor.matchFamily("cvm.internal.tencentcloudapi.com.cn");
+ assertNotNull(m);
+ assertEquals("cvm", m.prefix);
+ assertEquals("internal.tencentcloudapi.com", m.family[0]);
+ }
+
+ // intl prefix (cvm.intl.tencentcloudapi.com) maps to the normal family,
+ // with "intl" folded into the prefix rather than treated as a TLD.
+ @Test
+ public void testMatchFamilyHandlesIntlPrefix() {
+ EndpointFailoverInterceptor.Match m =
+ EndpointFailoverInterceptor.matchFamily("cvm.intl.tencentcloudapi.com");
+ assertNotNull(m);
+ assertEquals("cvm.intl", m.prefix);
+ assertEquals("tencentcloudapi.com", m.family[0]);
+ assertEquals(0, m.tldIdx);
+ }
+
+ @Test
+ public void testHostWithTldDropsIntlPrefix() {
+ assertEquals("cvm.tencentcloudapi.com.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.intl.tencentcloudapi.com", 1));
+ assertEquals("cvm.tencentcloudapi.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.intl.tencentcloudapi.com", 2));
+ }
+
+ // End-to-end: an intl-prefixed origin host rotates within the normal
+ // family (.com -> .com.cn -> .cn), same as a plain public host.
+ @Test
+ public void testIntlHostFailoverRotatesWithinNormalFamily() throws Exception {
+ Family f = new Family("Intl", "tencentcloudapi.com",
+ "cvm.intl.tencentcloudapi.com",
+ "cvm.tencentcloudapi.com.cn",
+ "cvm.tencentcloudapi.cn");
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(1, transport.received.size());
+ assertEquals(f.firstFailover, transport.received.get(0).url().host());
+ }
+
+ // =================================================================
+ // M2a: hostWithTld — boundary origins (.cn, .com.cn, region-pinned)
+ // =================================================================
+
+ @Test
+ public void testHostWithTldFromCnAndComCnOrigins() {
+ // From .cn origin (tldIdx=2): idx 0 -> .com, idx 2 -> .cn
+ assertEquals("cvm.tencentcloudapi.com",
+ EndpointFailoverInterceptor.hostWithTld("cvm.tencentcloudapi.cn", 0));
+ assertEquals("cvm.tencentcloudapi.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.tencentcloudapi.cn", 2));
+
+ // From .com.cn origin (tldIdx=1): idx 0 -> .com, idx 1 -> .com.cn
+ assertEquals("cvm.tencentcloudapi.com",
+ EndpointFailoverInterceptor.hostWithTld("cvm.tencentcloudapi.com.cn", 0));
+ assertEquals("cvm.tencentcloudapi.com.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.tencentcloudapi.com.cn", 1));
+ }
+
+ @Test
+ public void testHostWithTldDropsRegionInPrefix() {
+ assertEquals("cvm.tencentcloudapi.com.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.ap-guangzhou.tencentcloudapi.com", 1));
+ assertEquals("cvm.ai.tencentcloudapi.com.cn",
+ EndpointFailoverInterceptor.hostWithTld("cvm.ap-guangzhou.ai.tencentcloudapi.com", 1));
+ }
+
+ // =================================================================
+ // M3: Non-TencentCloud host — passthrough (family loop)
+ // =================================================================
+
+ @Test
+ public void testPassthroughNonTencentCloudHost() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ // Build a request to a non-TencentCloud host.
+ OkHttpClient http = grabOkHttpClient(client);
+ Request req = new Request.Builder()
+ .url("https://example.com/")
+ .header("Host", "example.com")
+ .header("Authorization", "SKIP")
+ .header("Content-Type", "application/json")
+ .post(RequestBody.create(MediaType.parse("application/json"), "{}".getBytes()))
+ .build();
+ transport.programOk();
+ Response resp = http.newCall(req).execute();
+ resp.close();
+ assertEquals(1, transport.received.size());
+ assertEquals("example.com", transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M3a: Non-TencentCloud host — DNS miss + backup details
+ // =================================================================
+
+ @Test
+ public void testNonTencentHostDnsMissPropagatesWithoutRetry() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("proxy dns miss"));
+
+ OkHttpClient http = grabOkHttpClient(client);
+ Request req = new Request.Builder()
+ .url("https://proxy.internal/")
+ .header("Host", "proxy.internal")
+ .header("Authorization", "SKIP")
+ .header("Content-Type", "application/json")
+ .post(RequestBody.create(MediaType.parse("application/json"), "{}".getBytes()))
+ .build();
+
+ try {
+ http.newCall(req).execute();
+ fail(f.name + ": expected IOException");
+ } catch (IOException e) {
+ assertTrue(f.name, e instanceof UnknownHostException);
+ }
+ assertEquals(f.name + ": no retry for non-TencentCloud host",
+ 1, transport.received.size());
+ }
+ }
+
+ @Test
+ public void testNonTencentHostWithBackupDoesNotRetrySameRequest() throws Exception {
+ for (Family f : FAMILIES) {
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ profile.setBackupEndpoint("backup.example.com");
+ CvmClient client = new CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("proxy dns miss"));
+
+ OkHttpClient http = grabOkHttpClient(client);
+ Request req = new Request.Builder()
+ .url("https://proxy.internal/")
+ .header("Host", "proxy.internal")
+ .header("Authorization", "SKIP")
+ .header("Content-Type", "application/json")
+ .post(RequestBody.create(MediaType.parse("application/json"), "{}".getBytes()))
+ .build();
+
+ try {
+ http.newCall(req).execute();
+ fail(f.name + ": expected IOException");
+ } catch (IOException ignored) { }
+ assertEquals(f.name + ": only one attempt, no retry to backup",
+ 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M4: Unknown TLD — passthrough (family loop)
+ // =================================================================
+
+ @Test
+ public void testPassthroughUnknownTld() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M5: Non-POST request — passthrough (family loop)
+ // =================================================================
+
+ @Test
+ public void testPassthroughNonPostRequest() throws Exception {
+ for (Family f : FAMILIES) {
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setReqMethod(HttpProfile.REQ_GET);
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ CvmClient client = new CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M6: Non-failover IOException — propagate without retry (family loop)
+ // =================================================================
+
+ @Test
+ public void testGenericIOExceptionPropagatesWithoutFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new IOException("unrelated I/O error"));
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException e) {
+ assertTrue(f.name + ": expected IOException cause",
+ e.getCause() instanceof IOException);
+ assertEquals(f.name + ": should not retry", 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+ }
+
+ // =================================================================
+ // M6a-M6d: Endpoint eligibility (family loop)
+ // =================================================================
+
+ @Test
+ public void testCnOriginIsEligibleForFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("cn dns miss"));
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ @Test
+ public void testRegionPinnedHostIsEligibleForFailover() throws Exception {
+ // Use region-pinned hosts: cvm.ap-guangzhou.tencentcloudapi.com etc.
+ Family[] regionFamilies = {
+ new Family("Normal-R", "tencentcloudapi.com",
+ "cvm.ap-guangzhou.tencentcloudapi.com",
+ "cvm.tencentcloudapi.com.cn",
+ "cvm.tencentcloudapi.cn"),
+ new Family("AI-R", "ai.tencentcloudapi.com",
+ "cvm.ap-guangzhou.ai.tencentcloudapi.com",
+ "cvm.ai.tencentcloudapi.com.cn",
+ "cvm.ai.tencentcloudapi.cn"),
+ new Family("Internal-R", "internal.tencentcloudapi.com",
+ "cvm.ap-guangzhou.internal.tencentcloudapi.com",
+ "cvm.internal.tencentcloudapi.com.cn",
+ "cvm.internal.tencentcloudapi.cn"),
+ };
+ for (Family f : regionFamilies) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("region dns miss"));
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ @Test
+ public void testFailoverEnabledAtRuntimeHasNoEffect() throws Exception {
+ // setEnableDomainFailover(false) after constructor: interceptor is already installed.
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ client.getClientProfile().setEnableDomainFailover(false);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("dns miss"));
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name + ": interceptor is already installed, flag has no effect",
+ 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M7-M13: Failover IOException types (family loop)
+ // =================================================================
+
+ @Test public void testFailoverOnUnknownHostException() throws Exception {
+ for (Family f : FAMILIES) runFailoverFor(f, new UnknownHostException("dns miss"));
+ }
+
+ @Test public void testFailoverOnSslPeerUnverifiedException() throws Exception {
+ for (Family f : FAMILIES) runFailoverFor(f, new SSLPeerUnverifiedException("cert mismatch"));
+ }
+
+ @Test public void testFailoverOnSslHandshakeException() throws Exception {
+ for (Family f : FAMILIES) runFailoverFor(f, new SSLHandshakeException("tls fail"));
+ }
+
+ @Test public void testFailoverOnConnectException() throws Exception {
+ for (Family f : FAMILIES) runFailoverFor(f, new ConnectException("connection refused"));
+ }
+
+ @Test public void testFailoverOnNoRouteToHostException() throws Exception {
+ for (Family f : FAMILIES) runFailoverFor(f, new NoRouteToHostException("no route"));
+ }
+
+ @Test public void testFailoverOnPortUnreachableException() throws Exception {
+ for (Family f : FAMILIES) runFailoverFor(f, new java.net.PortUnreachableException("port unreachable"));
+ }
+
+ @Test public void testFailoverOnSocketTimeoutException() throws Exception {
+ for (Family f : FAMILIES) runFailoverFor(f, new SocketTimeoutException("read timed out"));
+ }
+
+ private void runFailoverFor(Family f, IOException failure) throws Exception {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(failure);
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name + ": one transport attempt per request",
+ 1, transport.received.size());
+ assertEquals(f.name + ": first attempt hits origin",
+ f.originHost, transport.received.get(0).url().host());
+ }
+
+ // =================================================================
+ // M14: Protocol-level failover (family loop)
+ // =================================================================
+
+ @Test
+ public void testNon200ResponseRecordsFailureWithoutRetry() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programResponse(503, "{\"Response\":{\"Error\":{}}}");
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M16a-M16b: TLD family rotation (AI/Internal don't cross families)
+ // =================================================================
+
+ @Test
+ public void testAiFamilyRotationStaysWithinFamily() throws Exception {
+ Family f = N2;
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(1, transport.received.size());
+ assertEquals(f.firstFailover, transport.received.get(0).url().host());
+ // Must be within ai.tencentcloudapi family, NOT plain cvm.tencentcloudapi.cn
+ assertTrue(transport.received.get(0).url().host().contains("ai.tencentcloudapi"));
+ }
+
+ @Test
+ public void testInternalFamilyRotationStaysWithinFamily() throws Exception {
+ Family f = N3;
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(1, transport.received.size());
+ assertEquals(f.firstFailover, transport.received.get(0).url().host());
+ assertTrue(transport.received.get(0).url().host().contains("internal.tencentcloudapi"));
+ }
+
+ @Test
+ public void testRegionPinnedHostFailoverDropsPrefix() throws Exception {
+ Family f = new Family("R", "tencentcloudapi.com",
+ "cvm.ap-guangzhou.tencentcloudapi.com",
+ "cvm.tencentcloudapi.com.cn",
+ "cvm.tencentcloudapi.cn");
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(1, transport.received.size());
+ assertEquals(f.firstFailover, transport.received.get(0).url().host());
+ assertFalse(transport.received.get(0).url().host().contains("ap-guangzhou"));
+ }
+
+ // =================================================================
+ // M17: API response delivered after failover (family loop)
+ // =================================================================
+
+ @Test
+ public void testApiResponseDeliveredAfterFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programJsonOk("{\"Response\":{\"TotalCount\":42,\"InstanceSet\":[],\"RequestId\":\"req-xyz\"}}");
+
+ DescribeInstancesResponse resp = client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, Long.valueOf(42), resp.getTotalCount());
+ assertEquals(f.name, "req-xyz", resp.getRequestId());
+ assertEquals(f.name, f.firstFailover, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M18: Sustained failure opens breaker (family loop)
+ // =================================================================
+
+ @Test
+ public void testBreakerOpensAfterSustainedFailure() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+
+ for (int i = 0; i < 5; i++) {
+ transport.programFailure(new UnknownHostException("fail " + i));
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ }
+ assertEquals(f.name, 5, transport.received.size());
+
+ assertFalse(f.name + ": origin breaker should be Open",
+ failoverInterceptorOf(client).breakerFor(f.originHost).allow().allowed);
+
+ // Next request short-circuits origin, goes to first failover.
+ transport.received.clear();
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.firstFailover, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M19: Open breaker short-circuits host (family loop)
+ // =================================================================
+
+ @Test
+ public void testOpenBreakerShortCircuitsHost() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name + ": should skip origin and hit first failover",
+ f.firstFailover, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M20: Open → HalfOpen after cooldown (family loop)
+ // =================================================================
+
+ @Test
+ public void testBreakerTransitionsOpenToHalfOpenAfterCooldown() throws Exception {
+ long shortTimeoutMs = 100;
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ CircuitBreaker breaker = tripBreakerFor(client, f.originHost, shortTimeoutMs);
+ assertFalse(f.name, breaker.allow().allowed);
+
+ Thread.sleep(shortTimeoutMs + 50);
+ CircuitBreaker.Token probe = breaker.allow();
+ assertTrue(f.name + ": should permit HalfOpen probe", probe.allowed);
+ }
+ }
+
+ // =================================================================
+ // M21: HalfOpen probe success → Closed (family loop)
+ // =================================================================
+
+ @Test
+ public void testBreakerReClosesAfterHalfOpenSuccess() throws Exception {
+ long shortTimeoutMs = 100;
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ CircuitBreaker breaker = tripBreakerFor(client, f.originHost, shortTimeoutMs);
+ TransportStub transport = installStub(client);
+
+ Thread.sleep(shortTimeoutMs + 50);
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+
+ for (int i = 0; i < 10; i++) {
+ assertTrue(f.name + ": should be Closed after HalfOpen success",
+ breaker.allow().allowed);
+ }
+ }
+ }
+
+ // =================================================================
+ // M22: HalfOpen probe failure → re-Open (family loop)
+ // =================================================================
+
+ @Test
+ public void testBreakerReOpensWhenHalfOpenProbeFails() throws Exception {
+ long shortTimeoutMs = 100;
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ CircuitBreaker breaker = tripBreakerFor(client, f.originHost, shortTimeoutMs);
+ TransportStub transport = installStub(client);
+
+ Thread.sleep(shortTimeoutMs + 50);
+ transport.programFailure(new UnknownHostException("still down"));
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+
+ assertFalse(f.name + ": should re-Open after HalfOpen failure",
+ breaker.allow().allowed);
+
+ // Next request short-circuits origin again.
+ transport.received.clear();
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.firstFailover, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M23: All breakers open → fallback to origin host (family loop)
+ // =================================================================
+
+ @Test
+ public void testAllBreakersOpenFallsBackToOriginHost() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripAllBreakersFor(client, f, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M23a: Candidate rotation follows family TLD order, not just the
+ // first candidate. Trip origin AND firstFailover's breakers, leaving
+ // only secondFailover closed — the request must land on secondFailover,
+ // proving buildCandidateHosts walks the family array in order
+ // ((tldIdx+1)%len, (tldIdx+2)%len, ...) rather than stopping/looping
+ // incorrectly after the first entry.
+ // =================================================================
+
+ @Test
+ public void testFailoverAdvancesToSecondCandidateWhenFirstIsAlsoOpen() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ tripBreakerFor(client, f.firstFailover, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name + ": origin and first candidate open, must advance to second",
+ f.secondFailover, transport.received.get(0).url().host());
+ }
+ }
+
+ // Same idea, but verified directly against selectHost's returned
+ // Candidate rather than through a full DescribeInstances round-trip —
+ // pins down the exact rotation order independent of request signing.
+ @Test
+ public void testSelectHostWalksCandidatesInFamilyOrder() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ EndpointFailoverInterceptor interceptor = failoverInterceptorOf(client);
+ Request req = new Request.Builder()
+ .url("https://" + f.originHost + "/")
+ .header("Host", f.originHost)
+ .build();
+
+ // All breakers closed: origin wins.
+ assertEquals(f.name, f.originHost, interceptor.selectHost(req).host);
+
+ // Origin open: first candidate (tldIdx+1) wins.
+ tripBreakerFor(client, f.originHost, 60_000);
+ assertEquals(f.name, f.firstFailover, interceptor.selectHost(req).host);
+
+ // Origin + first open: second candidate (tldIdx+2) wins.
+ tripBreakerFor(client, f.firstFailover, 60_000);
+ assertEquals(f.name, f.secondFailover, interceptor.selectHost(req).host);
+
+ // All three open: falls back to origin.
+ tripBreakerFor(client, f.secondFailover, 60_000);
+ assertEquals(f.name, f.originHost, interceptor.selectHost(req).host);
+ }
+ }
+
+ // =================================================================
+ // M24: One transport attempt per request (family loop)
+ // =================================================================
+
+ @Test
+ public void testEndpointFailureSurfacesAttemptFailure() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("dns miss " + f.name));
+
+ TencentCloudSDKException sdkEx = null;
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException e) {
+ sdkEx = e;
+ }
+ IOException primary = unwrapToIOException(sdkEx);
+ assertTrue(f.name, primary.getMessage().contains("dns miss"));
+ assertEquals(f.name, 0, primary.getSuppressed().length);
+ assertEquals(f.name, 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M25: Failure preserves original exception type and message (family loop)
+ // =================================================================
+
+ @Test
+ public void testFailurePreservesAttemptCauseType() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new ConnectException("connect fail " + f.name));
+
+ TencentCloudSDKException sdkEx = null;
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException e) {
+ sdkEx = e;
+ }
+ IOException primary = unwrapToIOException(sdkEx);
+ assertTrue(f.name, primary instanceof ConnectException);
+ assertEquals(f.name, 0, primary.getSuppressed().length);
+ assertEquals(f.name, 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M26: Breaker skip mixed with real failure (family loop)
+ // =================================================================
+
+ @Test
+ public void testFailureMixesPriorBreakerSkipsWithRealFailure() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new SSLHandshakeException("tls fail"));
+
+ TencentCloudSDKException sdkEx = null;
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException e) {
+ sdkEx = e;
+ }
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name + ": origin skipped, hits first failover",
+ f.firstFailover, transport.received.get(0).url().host());
+
+ IOException primary = unwrapToIOException(sdkEx);
+ assertTrue(f.name, primary instanceof SSLHandshakeException);
+ assertEquals(f.name, 0, primary.getSuppressed().length);
+ }
+ }
+
+ // =================================================================
+ // M27: Failure does not pollute next request (family loop)
+ // =================================================================
+
+ @Test
+ public void testFailoverDoesNotPolluteNextRequest() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+
+ transport.programFailure(new UnknownHostException("run1 " + f.name));
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ transport.received.clear();
+
+ transport.programFailure(new UnknownHostException("run2 " + f.name));
+ TencentCloudSDKException sdkEx = null;
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException e) {
+ sdkEx = e;
+ }
+ IOException primary = unwrapToIOException(sdkEx);
+ assertEquals(f.name, 0, primary.getSuppressed().length);
+ assertTrue(f.name, primary.getMessage().contains("run2"));
+ assertFalse(f.name, primary.getMessage().contains("run1"));
+ }
+ }
+
+ // =================================================================
+ // M28: Breaker state isolated across origin hosts (family loop)
+ // =================================================================
+
+ @Test
+ public void testBreakerStateIsolatedAcrossOriginHosts() throws Exception {
+ // Trip breaker for one family, verify it doesn't affect another family.
+ // We test isolation between N1 and N2, and between N1 and N3.
+ Family[][] pairs = {{N1, N2}, {N1, N3}};
+ for (Family[] pair : pairs) {
+ Family a = pair[0];
+ Family b = pair[1];
+
+ CvmClient clientA = newClient(a);
+ tripBreakerFor(clientA, a.originHost, 60_000);
+
+ CvmClient clientB = newClient(b);
+ TransportStub transportB = installStub(clientB);
+ transportB.programOk();
+ clientB.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(b.name + " should be unaffected by " + a.name,
+ 1, transportB.received.size());
+ assertEquals(b.name, b.originHost, transportB.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M29: TC3 V3 re-sign (POST) (family loop)
+ // =================================================================
+
+ @Test
+ public void testTc3ResignOnFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ Request resigned = transport.received.get(0);
+ assertEquals(f.name, f.firstFailover, resigned.url().host());
+ assertTrue(f.name, resigned.header("Authorization").contains("TC3-HMAC-SHA256"));
+ }
+ }
+
+ // =================================================================
+ // M29a: TC3 resign preserves body and content-type
+ // =================================================================
+
+ @Test
+ public void testTc3ResignPreservesBodyAndContentType() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ Request resigned = transport.received.get(0);
+ assertEquals(f.name, f.firstFailover, resigned.url().host());
+ assertEquals(f.name, "application/json", resigned.header("Content-Type"));
+ byte[] body = bodyBytes(resigned);
+ assertTrue(f.name, body.length > 0);
+ }
+ }
+
+ // =================================================================
+ // M30: TC3 V3 GET re-sign (family loop)
+ // =================================================================
+
+ @Test
+ public void testTc3GetResignOnFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setReqMethod(HttpProfile.REQ_GET);
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ CvmClient client = new CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ Request resigned = transport.received.get(0);
+ assertEquals(f.name, f.firstFailover, resigned.url().host());
+ assertEquals(f.name, "GET", resigned.method());
+ assertTrue(f.name, resigned.header("Authorization").contains("TC3-HMAC-SHA256"));
+ }
+ }
+
+ // =================================================================
+ // M31: Hmac V1 re-sign (family loop)
+ // =================================================================
+
+ @Test
+ public void testHmacV1ResignOnFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ ClientProfile profile = new ClientProfile();
+ profile.setSignMethod(ClientProfile.SIGN_SHA1);
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ CvmClient client = new CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ Request resigned = transport.received.get(0);
+ assertEquals(f.name, f.firstFailover, resigned.url().host());
+ // Hmac V1 embeds Signature in body, not Authorization header.
+ byte[] body = bodyBytes(resigned);
+ assertTrue(f.name, new String(body).contains("Signature="));
+ }
+ }
+
+ // =================================================================
+ // M32: SKIP V3 — rewrite Host only (family loop)
+ // =================================================================
+
+ @Test
+ public void testSkipSignV3OnFailoverRewritesHostWithoutResigning() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ OkHttpClient http = grabOkHttpClient(client);
+ Request raw = new Request.Builder()
+ .url("https://" + f.originHost + "/")
+ .header("Host", f.originHost)
+ .header("Authorization", "SKIP")
+ .header("X-TC-Action", "DescribeInstances")
+ .header("X-TC-Version", "2017-03-12")
+ .header("Content-Type", "application/json")
+ .post(RequestBody.create(MediaType.parse("application/json"), "{}".getBytes()))
+ .build();
+
+ Response resp = http.newCall(raw).execute();
+ resp.close();
+ assertEquals(f.name, 1, transport.received.size());
+ Request resigned = transport.received.get(0);
+ assertEquals(f.name, f.firstFailover, resigned.url().host());
+ assertEquals(f.name, f.firstFailover, resigned.header("Host"));
+ assertEquals(f.name, "SKIP", resigned.header("Authorization"));
+ }
+ }
+
+ // =================================================================
+ // M33: Re-sign uses current credential (family loop)
+ // =================================================================
+
+ @Test
+ public void testResignUsesCurrentCredential() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ client.setCredential(new Credential("AKIDNEW", "SKNEW"));
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertTrue(f.name, transport.received.get(0).header("Authorization")
+ .contains("Credential=AKIDNEW/"));
+ }
+ }
+
+ // =================================================================
+ // M34: X-TC-Token rotation (family loop)
+ // =================================================================
+
+ @Test
+ public void testXtcTokenRotationOnFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ Credential cred = new Credential("AKIDTEST", "SKTEST", "token-abc");
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ CvmClient client = new CvmClient(cred, "ap-guangzhou", profile);
+ tripBreakerFor(client, f.originHost, 60_000);
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, "token-abc", transport.received.get(0).header("X-TC-Token"));
+ }
+ }
+
+ // =================================================================
+ // M34a: X-TC-Token dropped when cleared
+ // =================================================================
+
+ @Test
+ public void testResignDropsTokenWhenCleared() throws Exception {
+ for (Family f : FAMILIES) {
+ Credential cred = new Credential("AKIDTEST", "SKTEST", "token-abc");
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ CvmClient client = new CvmClient(cred, "ap-guangzhou", profile);
+ tripBreakerFor(client, f.originHost, 60_000);
+ // Clear the token before the failover request.
+ client.setCredential(new Credential("AKIDTEST", "SKTEST"));
+ TransportStub transport = installStub(client);
+ transport.programOk();
+
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name, 1, transport.received.size());
+ assertNull(f.name, transport.received.get(0).header("X-TC-Token"));
+ }
+ }
+
+ // =================================================================
+ // M35: SSE — no failover (family loop)
+ // =================================================================
+
+ @Test
+ public void testSseStreamResponseIsNotJsonValidated() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programResponseWithCt(200, "data: hello\n\n", "text/event-stream");
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ } catch (Exception ignored) { }
+ assertEquals(f.name, 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M36: No Content-Type — no failover (family loop)
+ // =================================================================
+
+ @Test
+ public void testResponseWithoutContentTypeIsNotJsonValidated() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programResponseWithCt(200, "oops", null);
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ } catch (Exception ignored) { }
+ assertEquals(f.name, 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M37: 200 + JSON business error — no failover (family loop)
+ // =================================================================
+
+ @Test
+ public void testBusinessSdkErrorDoesNotTriggerFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programJsonOk(
+ "{\"Response\":{\"RequestId\":\"req-bad\",\"Error\":{"
+ + "\"Code\":\"AuthFailure.SignatureFailure\","
+ + "\"Message\":\"signature wrong\"}}}");
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected business SDK exception");
+ } catch (TencentCloudSDKException e) {
+ assertEquals(f.name, "AuthFailure.SignatureFailure", e.getErrorCode());
+ assertEquals(f.name, "req-bad", e.getRequestId());
+ }
+ assertEquals(f.name, 1, transport.received.size());
+ }
+ }
+
+ // =================================================================
+ // M38: backupEndpoint failover behavior (family loop)
+ // =================================================================
+
+ @Test
+ public void testBackupEndpointFailover() throws Exception {
+ for (Family f : FAMILIES) {
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ profile.setBackupEndpoint("backup.example.com");
+ CvmClient client = new CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ TransportStub transport = installStub(client);
+
+ // Origin succeeds.
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name + " origin", 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+
+ // Trip origin breaker, backup should be used.
+ tripBreakerFor(client, f.originHost, 60_000);
+ transport.received.clear();
+ transport.programOk();
+ client.DescribeInstances(new DescribeInstancesRequest());
+ assertEquals(f.name + " backup", 1, transport.received.size());
+ String servicePrefix = f.originHost.substring(0, f.originHost.indexOf('.'));
+ String backupHost = servicePrefix + ".backup.example.com";
+ assertEquals(f.name, backupHost, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // M38a-M38d: backupEndpoint detail scenarios (family loop)
+ // =================================================================
+
+ @Test
+ public void testBackupEndpointOriginDnsMissDoesNotRetrySameRequest() throws Exception {
+ for (Family f : FAMILIES) {
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ profile.setBackupEndpoint("backup.example.com");
+ CvmClient client = new CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("origin dns miss"));
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name + ": no same-request retry to backup",
+ 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ @Test
+ public void testBackupEndpointNonFailoverErrorPropagates() throws Exception {
+ for (Family f : FAMILIES) {
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setEndpoint(f.originHost);
+ profile.setBackupEndpoint("backup.example.com");
+ CvmClient client = new CvmClient(
+ new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new IOException("generic I/O error"));
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException e) {
+ assertTrue(f.name, e.getCause() instanceof IOException);
+ }
+ assertEquals(f.name, 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ @Test
+ public void testNoBackupEndpointDnsMissDoesNotRetrySameRequest() throws Exception {
+ for (Family f : FAMILIES) {
+ CvmClient client = newClient(f);
+ TransportStub transport = installStub(client);
+ transport.programFailure(new UnknownHostException("dns miss"));
+
+ try {
+ client.DescribeInstances(new DescribeInstancesRequest());
+ fail(f.name + ": expected SDK exception");
+ } catch (TencentCloudSDKException ignored) { }
+ assertEquals(f.name + ": no same-request retry", 1, transport.received.size());
+ assertEquals(f.name, f.originHost, transport.received.get(0).url().host());
+ }
+ }
+
+ // =================================================================
+ // Helpers
+ // =================================================================
+
+ private static CvmClient newClient(Family family) {
+ ClientProfile profile = new ClientProfile();
+ profile.getHttpProfile().setEndpoint(family.originHost);
+ return new CvmClient(new Credential("AKIDTEST", "SKTEST"), "ap-guangzhou", profile);
+ }
+
+ private static TransportStub installStub(AbstractClient client) {
+ TransportStub stub = new TransportStub();
+ OkHttpClient orig = grabOkHttpClient(client);
+ setOkHttpClient(client, orig.newBuilder().addInterceptor(stub).build());
+ return stub;
+ }
+
+ private static OkHttpClient grabOkHttpClient(AbstractClient client) {
+ try {
+ Field f = AbstractClient.class.getDeclaredField("httpConnection");
+ f.setAccessible(true);
+ HttpConnection conn = (HttpConnection) f.get(client);
+ return (OkHttpClient) conn.getHttpClient();
+ } catch (ReflectiveOperationException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static void setOkHttpClient(AbstractClient client, OkHttpClient http) {
+ try {
+ Field f = AbstractClient.class.getDeclaredField("httpConnection");
+ f.setAccessible(true);
+ HttpConnection conn = (HttpConnection) f.get(client);
+ conn.setHttpClient(http);
+ } catch (ReflectiveOperationException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static EndpointFailoverInterceptor failoverInterceptorOf(AbstractClient client) {
+ for (Interceptor it : grabOkHttpClient(client).interceptors()) {
+ if (it instanceof EndpointFailoverInterceptor) {
+ return (EndpointFailoverInterceptor) it;
+ }
+ }
+ throw new IllegalStateException("EndpointFailoverInterceptor not installed on client");
+ }
+
+ private static CircuitBreaker tripBreakerFor(AbstractClient client, String host, long timeoutMs) {
+ CircuitBreaker breaker = newBreaker(timeoutMs);
+ failoverInterceptorOf(client).putBreakerForTesting(host, breaker);
+ tripBreaker(breaker);
+ return breaker;
+ }
+
+ private static void tripAllBreakersFor(AbstractClient client, Family f, long timeoutMs) {
+ for (String host : f.allTldHosts) {
+ tripBreakerFor(client, host, timeoutMs);
+ }
+ }
+
+ private static CircuitBreaker newBreaker(long timeoutMs) {
+ CircuitBreaker.Setting setting = new CircuitBreaker.Setting();
+ setting.timeoutMs = timeoutMs;
+ return new CircuitBreaker(setting);
+ }
+
+ private static void tripBreaker(CircuitBreaker breaker) {
+ for (int i = 0; i < 6; i++) {
+ CircuitBreaker.Token t = breaker.allow();
+ if (t.allowed) {
+ t.report(false);
+ }
+ }
+ }
+
+ private static IOException unwrapToIOException(TencentCloudSDKException e) {
+ Throwable cause = e.getCause();
+ assertNotNull("SDK exception must wrap an IOException, got null cause", cause);
+ assertTrue("expected IOException cause, got " + cause.getClass().getName(),
+ cause instanceof IOException);
+ return (IOException) cause;
+ }
+
+ private static byte[] bodyBytes(Request req) throws IOException {
+ if (req.body() == null) {
+ return new byte[0];
+ }
+ Buffer buf = new Buffer();
+ req.body().writeTo(buf);
+ return buf.readByteArray();
+ }
+
+ // =================================================================
+ // TransportStub
+ // =================================================================
+
+ private static final class TransportStub implements Interceptor {
+ final List