update

Author: linglingye001

src/AzureAppConfigurationImpl.ts

@@ -15,7 +15,6 @@ import { RefreshTimer } from "./refresh/RefreshTimer.js";
 import { getConfigurationSettingWithTrace, listConfigurationSettingsWithTrace, requestTracingEnabled } from "./requestTracing/utils.js";
 import { KeyFilter, LabelFilter, SettingSelector } from "./types.js";
 import { ConfigurationClientManager } from "./ConfigurationClientManager.js";
-import { updateClientBackoffStatus } from "./ConfigurationClientWrapper.js";
 
 type PagedSettingSelector = SettingSelector & {
     /**
@@ -185,7 +184,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         const clientWrappers = await this.#clientManager.getClients();
         if (clientWrappers.length === 0) {
             this.#clientManager.refreshClients();
-            throw new Error("No client is available to connect to the target app configuration store.");
+            console.warn("Refresh skipped because no endpoint is accessible.");
         }
 
         let successful: boolean;
@@ -195,11 +194,11 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
                 const result = await funcToExecute(clientWrapper.client);
                 this.#isFailoverRequest = false;
                 successful = true;
-                updateClientBackoffStatus(clientWrapper, successful);
+                clientWrapper.updateBackoffStatus(successful);
                 return result;
             } catch (error) {
                 if (isFailoverableError(error)) {
-                    updateClientBackoffStatus(clientWrapper, successful);
+                    clientWrapper.updateBackoffStatus(successful);
                     this.#isFailoverRequest = true;
                     continue;
                 }
@@ -209,7 +208,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         }
 
         this.#clientManager.refreshClients();
-        throw new Error("All app configuration clients failed to get settings.");
+        throw new Error("Failed to get configuration settings from endpoint.");
     }
 
     async #loadSelectedKeyValues(): Promise<ConfigurationSetting[]> {
@@ -646,7 +645,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
     }
 
     #createFeatureFlagReference(setting: ConfigurationSetting<string>): string {
-        let featureFlagReference = `${this.#clientManager.endpoint}/kv/${setting.key}`;
+        let featureFlagReference = `${this.#clientManager.endpoint.origin}/kv/${setting.key}`;
         if (setting.label && setting.label.trim().length !== 0) {
             featureFlagReference += `?label=${setting.label}`;
         }

src/ConfigurationClientManager.ts

@@ -20,9 +20,9 @@ const MINIMAL_CLIENT_REFRESH_INTERVAL = 30 * 1000; // 30 seconds in milliseconds
 const SRV_QUERY_TIMEOUT = 30 * 1000; // 30 seconds in milliseconds
 
 export class ConfigurationClientManager {
-    isFailoverable: boolean;
-    dns: any;
-    endpoint: string;
+    #isFailoverable: boolean;
+    #dns: any;
+    endpoint: URL;
     #secret : string;
     #id : string;
     #credential: TokenCredential;
@@ -40,81 +40,79 @@ export class ConfigurationClientManager {
         appConfigOptions?: AzureAppConfigurationOptions
     ) {
         let staticClient: AppConfigurationClient;
+        const credentialPassed = instanceOfTokenCredential(credentialOrOptions);
 
-        if (typeof connectionStringOrEndpoint === "string" && !instanceOfTokenCredential(credentialOrOptions)) {
+        if (typeof connectionStringOrEndpoint === "string" && !credentialPassed) {
             const connectionString = connectionStringOrEndpoint;
             this.#appConfigOptions = credentialOrOptions as AzureAppConfigurationOptions;
             this.#clientOptions = getClientOptions(this.#appConfigOptions);
-            staticClient = new AppConfigurationClient(connectionString, this.#clientOptions);
             const ConnectionStringRegex = /Endpoint=(.*);Id=(.*);Secret=(.*)/;
             const regexMatch = connectionString.match(ConnectionStringRegex);
             if (regexMatch) {
-                this.endpoint = regexMatch[1];
+                const endpointFromConnectionStr = regexMatch[1];
+                this.endpoint = getValidUrl(endpointFromConnectionStr);
                 this.#id = regexMatch[2];
                 this.#secret = regexMatch[3];
             } else {
                 throw new Error(`Invalid connection string. Valid connection strings should match the regex '${ConnectionStringRegex.source}'.`);
             }
-        } else if ((connectionStringOrEndpoint instanceof URL || typeof connectionStringOrEndpoint === "string") && instanceOfTokenCredential(credentialOrOptions)) {
+            staticClient = new AppConfigurationClient(connectionString, this.#clientOptions);
+        } else if ((connectionStringOrEndpoint instanceof URL || typeof connectionStringOrEndpoint === "string") && credentialPassed) {
             let endpoint = connectionStringOrEndpoint;
             // ensure string is a valid URL.
             if (typeof endpoint === "string") {
-                try {
-                    endpoint = new URL(endpoint);
-                } catch (error) {
-                    if (error.code === "ERR_INVALID_URL") {
-                        throw new Error("Invalid endpoint URL.", { cause: error });
-                    } else {
-                        throw error;
-                    }
-                }
+                endpoint = getValidUrl(endpoint);
             }
 
             const credential = credentialOrOptions as TokenCredential;
             this.#appConfigOptions = appConfigOptions as AzureAppConfigurationOptions;
             this.#clientOptions = getClientOptions(this.#appConfigOptions);
-            staticClient = new AppConfigurationClient(connectionStringOrEndpoint.toString(), credential, this.#clientOptions);
-            this.endpoint = endpoint.toString();
+            this.endpoint = endpoint;
             this.#credential = credential;
+            staticClient = new AppConfigurationClient(this.endpoint.origin, this.#credential, this.#clientOptions);
         } else {
             throw new Error("A connection string or an endpoint with credential must be specified to create a client.");
         }
 
-        this.#staticClients = [new ConfigurationClientWrapper(this.endpoint, staticClient)];
-        this.#validDomain = getValidDomain(this.endpoint);
+        this.#staticClients = [new ConfigurationClientWrapper(this.endpoint.origin, staticClient)];
+        this.#validDomain = getValidDomain(this.endpoint.hostname.toLowerCase());
     }
 
     async init() {
         if (this.#appConfigOptions?.replicaDiscoveryEnabled === false || isBrowser() || isWebWorker()) {
-            this.isFailoverable = false;
+            this.#isFailoverable = false;
             return;
         }
 
         try {
-            this.dns = await import("dns/promises");
+            this.#dns = await import("dns/promises");
         }catch (error) {
-            this.isFailoverable = false;
+            this.#isFailoverable = false;
             console.warn("Failed to load the dns module:", error.message);
             return;
         }
 
-        this.isFailoverable = true;
+        this.#isFailoverable = true;
     }
 
     async getClients() : Promise<ConfigurationClientWrapper[]> {
-        if (!this.isFailoverable) {
+        if (!this.#isFailoverable) {
             return this.#staticClients;
         }
 
         const currentTime = Date.now();
-        if (this.#isFallbackClientDiscoveryDue(currentTime)) {
+        // Filter static clients whose backoff time has ended
+        let availableClients = this.#staticClients.filter(client => client.backoffEndTime <= currentTime);
+        if (currentTime >= this.#lastFallbackClientRefreshAttempt + MINIMAL_CLIENT_REFRESH_INTERVAL &&
+            (!this.#dynamicClients ||
+            // All dynamic clients are in backoff means no client is available
+            this.#dynamicClients.every(client => currentTime < client.backoffEndTime) ||
+            currentTime >= this.#lastFallbackClientRefreshTime + FALLBACK_CLIENT_REFRESH_EXPIRE_INTERVAL)) {
             this.#lastFallbackClientRefreshAttempt = currentTime;
-            const host = new URL(this.endpoint).hostname;
-            await this.#discoverFallbackClients(host);
+            await this.#discoverFallbackClients(this.endpoint.hostname);
+            return availableClients.concat(this.#dynamicClients);
         }
 
-        // Filter static clients whose backoff time has ended
-        let availableClients = this.#staticClients.filter(client => client.backoffEndTime <= currentTime);
         // If there are dynamic clients, filter and concatenate them
         if (this.#dynamicClients && this.#dynamicClients.length > 0) {
             availableClients = availableClients.concat(
@@ -127,23 +125,22 @@ export class ConfigurationClientManager {
 
     async refreshClients() {
         const currentTime = Date.now();
-        if (this.isFailoverable &&
-            currentTime > new Date(this.#lastFallbackClientRefreshAttempt + MINIMAL_CLIENT_REFRESH_INTERVAL).getTime()) {
+        if (this.#isFailoverable &&
+            currentTime >= new Date(this.#lastFallbackClientRefreshAttempt + MINIMAL_CLIENT_REFRESH_INTERVAL).getTime()) {
             this.#lastFallbackClientRefreshAttempt = currentTime;
-            const host = new URL(this.endpoint).hostname;
-            await this.#discoverFallbackClients(host);
+            await this.#discoverFallbackClients(this.endpoint.hostname);
         }
     }
 
-    async #discoverFallbackClients(host) {
+    async #discoverFallbackClients(host: string) {
         let result;
         try {
             result = await Promise.race([
                 new Promise((_, reject) => setTimeout(() => reject(new Error("SRV record query timed out.")), SRV_QUERY_TIMEOUT)),
                 this.#querySrvTargetHost(host)
             ]);
         } catch (error) {
-            throw new Error(`Fail to build fallback clients, ${error.message}`);
+            throw new Error(`Failed to build fallback clients, ${error.message}`);
         }
 
         const srvTargetHosts = result as string[];
@@ -157,10 +154,12 @@ export class ConfigurationClientManager {
         for (const host of srvTargetHosts) {
             if (isValidEndpoint(host, this.#validDomain)) {
                 const targetEndpoint = `https://${host}`;
-                if (targetEndpoint.toLowerCase() === this.endpoint.toLowerCase()) {
+                if (host.toLowerCase() === this.endpoint.hostname.toLowerCase()) {
                     continue;
                 }
-                const client = this.#credential ? new AppConfigurationClient(targetEndpoint, this.#credential, this.#clientOptions) : new AppConfigurationClient(buildConnectionString(targetEndpoint, this.#secret, this.#id), this.#clientOptions);
+                const client = this.#credential ?
+                                new AppConfigurationClient(targetEndpoint, this.#credential, this.#clientOptions) :
+                                new AppConfigurationClient(buildConnectionString(targetEndpoint, this.#secret, this.#id), this.#clientOptions);
                 newDynamicClients.push(new ConfigurationClientWrapper(targetEndpoint, client));
             }
         }
@@ -169,13 +168,6 @@ export class ConfigurationClientManager {
         this.#lastFallbackClientRefreshTime = Date.now();
     }
 
-    #isFallbackClientDiscoveryDue(dateTime) {
-        return dateTime >= this.#lastFallbackClientRefreshAttempt + MINIMAL_CLIENT_REFRESH_INTERVAL
-            && (!this.#dynamicClients
-                || this.#dynamicClients.every(client => dateTime < client.backoffEndTime)
-                || dateTime >= this.#lastFallbackClientRefreshTime + FALLBACK_CLIENT_REFRESH_EXPIRE_INTERVAL);
-    }
-
     /**
      * Query SRV records and return target hosts.
      */
@@ -184,7 +176,7 @@ export class ConfigurationClientManager {
 
         try {
             // Look up SRV records for the origin host
-            const originRecords = await this.dns.resolveSrv(`${TCP_ORIGIN_KEY_NAME}.${host}`);
+            const originRecords = await this.#dns.resolveSrv(`${TCP_ORIGIN_KEY_NAME}.${host}`);
             if (originRecords.length === 0) {
                 return results;
             }
@@ -198,7 +190,7 @@ export class ConfigurationClientManager {
             // eslint-disable-next-line no-constant-condition
             while (true) {
                 const currentAlt = `${ALT_KEY_NAME}${index}`;
-                const altRecords = await this.dns.resolveSrv(`${currentAlt}.${TCP_KEY_NAME}.${originHost}`);
+                const altRecords = await this.#dns.resolveSrv(`${currentAlt}.${TCP_KEY_NAME}.${originHost}`);
                 if (altRecords.length === 0) {
                     break; // No more alternate records, exit loop
                 }
@@ -238,19 +230,12 @@ function buildConnectionString(endpoint, secret, id: string): string {
 /**
  * Extracts a valid domain from the given endpoint URL based on trusted domain labels.
  */
-export function getValidDomain(endpoint: string): string {
-    try {
-        const url = new URL(endpoint);
-        const host = url.hostname.toLowerCase();
-
-        for (const label of TRUSTED_DOMAIN_LABELS) {
-            const index = host.lastIndexOf(label);
-            if (index !== -1) {
-                return host.substring(index);
-            }
+export function getValidDomain(host: string): string {
+    for (const label of TRUSTED_DOMAIN_LABELS) {
+        const index = host.lastIndexOf(label);
+        if (index !== -1) {
+            return host.substring(index);
         }
-    } catch (error) {
-        console.error("Error parsing URL:", error.message);
     }
 
     return "";
@@ -267,7 +252,7 @@ export function isValidEndpoint(host: string, validDomain: string): boolean {
     return host.toLowerCase().endsWith(validDomain.toLowerCase());
 }
 
-export function getClientOptions(options?: AzureAppConfigurationOptions): AppConfigurationClientOptions | undefined {
+function getClientOptions(options?: AzureAppConfigurationOptions): AppConfigurationClientOptions | undefined {
     // user-agent
     let userAgentPrefix = RequestTracing.USER_AGENT_PREFIX; // Default UA for JavaScript Provider
     const userAgentOptions = options?.clientOptions?.userAgentOptions;
@@ -290,6 +275,18 @@ export function getClientOptions(options?: AzureAppConfigurationOptions): AppCon
     });
 }
 
+function getValidUrl(endpoint: string): URL {
+    try {
+        return new URL(endpoint);
+    } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+            throw new Error("Invalid endpoint URL.", { cause: error });
+        } else {
+            throw error;
+        }
+    }
+}
+
 export function instanceOfTokenCredential(obj: unknown) {
     return obj && typeof obj === "object" && "getToken" in obj && typeof obj.getToken === "function";
 }

src/ConfigurationClientWrapper.ts

@@ -12,21 +12,21 @@ export class ConfigurationClientWrapper {
     endpoint: string;
     client: AppConfigurationClient;
     backoffEndTime: number = 0; // Timestamp
-    failedAttempts: number = 0;
+    #failedAttempts: number = 0;
 
     constructor(endpoint: string, client: AppConfigurationClient) {
         this.endpoint = endpoint;
         this.client = client;
     }
-}
 
-export function updateClientBackoffStatus(clientWrapper: ConfigurationClientWrapper, successfull: boolean) {
-    if (successfull) {
-        clientWrapper.failedAttempts = 0;
-        clientWrapper.backoffEndTime = Date.now();
-    } else {
-        clientWrapper.failedAttempts += 1;
-        clientWrapper.backoffEndTime = Date.now() + calculateBackoffDuration(clientWrapper.failedAttempts);
+    updateBackoffStatus(successfull: boolean) {
+        if (successfull) {
+            this.#failedAttempts = 0;
+            this.backoffEndTime = Date.now();
+        } else {
+            this.#failedAttempts += 1;
+            this.backoffEndTime = Date.now() + calculateBackoffDuration(this.#failedAttempts);
+        }
     }
 }
 
@@ -35,7 +35,7 @@ export function calculateBackoffDuration(failedAttempts: number) {
         return MinBackoffDuration;
     }
 
-    // exponential: minBackoff * 2^(failedAttempts-1)
+    // exponential: minBackoff * 2 ^ (failedAttempts - 1)
     const exponential = Math.min(failedAttempts - 1, MAX_SAFE_EXPONENTIAL);
     let calculatedBackoffDuration = MinBackoffDuration * (1 << exponential);
     if (calculatedBackoffDuration > MaxBackoffDuration) {

test/clientOptions.test.ts

@@ -30,7 +30,6 @@ describe("custom client options", function () {
     this.timeout(15000);
 
     const fakeEndpoint = "https://azure.azconfig.io";
-    const replicaDiscoveryEnabled = false;
     beforeEach(() => {
         // Thus here mock it to reply 500, in which case the retry mechanism works.
         nock(fakeEndpoint).persist().get(() => true).reply(500);
@@ -44,7 +43,6 @@ describe("custom client options", function () {
         const countPolicy = new HttpRequestCountPolicy();
         const loadPromise = () => {
             return load(createMockedConnectionString(fakeEndpoint), {
-                replicaDiscoveryEnabled: replicaDiscoveryEnabled,
                 clientOptions: {
                     additionalPolicies: [{
                         policy: countPolicy,
@@ -67,7 +65,6 @@ describe("custom client options", function () {
         const countPolicy = new HttpRequestCountPolicy();
         const loadWithMaxRetries = (maxRetries: number) => {
             return load(createMockedConnectionString(fakeEndpoint), {
-                replicaDiscoveryEnabled: replicaDiscoveryEnabled,
                 clientOptions: {
                     additionalPolicies: [{
                         policy: countPolicy,
@@ -106,7 +103,6 @@ describe("custom client options", function () {
         const countPolicy = new HttpRequestCountPolicy();
         const loadPromise = () => {
             return load(createMockedConnectionString(fakeEndpoint), {
-                replicaDiscoveryEnabled: replicaDiscoveryEnabled,
                 clientOptions: {
                     additionalPolicies: [{
                         policy: countPolicy,