fix(endpoints): guard against remote call hanging #3341

Problem:
On startup, Toolkit tries to fetch https://idetoolkits.amazonwebservices.com/endpoints.json
in EndpointsProvider#load. If that URL is is blocked by firewall, the toolkit is
blocked and unusuable. #3338

Solution:
First load local endpoints.json then dynamically update with the result of
remote call once it receives a response.

Author: JadenSimon

.changes/next-release/Bug Fix-4006343b-d60d-470e-a29d-ff9291704646.json

@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "endpoints: local file never loads if remote call hangs"
+}

src/extension.ts

@@ -32,8 +32,7 @@ import {
 } from './shared/extensionUtilities'
 import { getLogger, Logger } from './shared/logger/logger'
 import { activate as activateLogger } from './shared/logger/activation'
-import { RegionProvider } from './shared/regions/regionProvider'
-import { EndpointsProvider } from './shared/regions/endpointsProvider'
+import { getEndpointsFromFetcher, RegionProvider } from './shared/regions/regionProvider'
 import { FileResourceFetcher } from './shared/resourcefetcher/fileResourceFetcher'
 import { HttpResourceFetcher } from './shared/resourcefetcher/httpResourceFetcher'
 import { activate as activateEcr } from './ecr/activation'
@@ -299,13 +298,14 @@ function initializeCredentialsProviderManager() {
     manager.addProviders(new Ec2CredentialsProvider(), new EcsCredentialsProvider(), new EnvVarsCredentialsProvider())
 }
 
-function makeEndpointsProvider(): EndpointsProvider {
+function makeEndpointsProvider() {
     const localManifestFetcher = new FileResourceFetcher(globals.manifestPaths.endpoints)
     const remoteManifestFetcher = new HttpResourceFetcher(endpointsFileUrl, { showUrl: true })
 
-    const provider = new EndpointsProvider(localManifestFetcher, remoteManifestFetcher)
-
-    return provider
+    return {
+        local: () => getEndpointsFromFetcher(localManifestFetcher),
+        remote: () => getEndpointsFromFetcher(remoteManifestFetcher),
+    }
 }
 
 function recordToolkitInitialization(activationStartedOn: number, logger?: Logger) {

src/shared/regions/endpointsProvider.ts

@@ -10,12 +10,12 @@ const localize = nls.loadMessageBundle()
 
 import * as vscode from 'vscode'
 import { getLogger } from '../logger'
-import { Endpoints, Region } from './endpoints'
-import { EndpointsProvider } from './endpointsProvider'
+import { Endpoints, loadEndpoints, Region } from './endpoints'
 import { AWSTreeNodeBase } from '../treeview/nodes/awsTreeNodeBase'
 import { regionSettingKey } from '../constants'
 import { AwsContext } from '../awsContext'
 import { getIdeProperties, isCloud9 } from '../extensionUtilities'
+import { ResourceFetcher } from '../resourcefetcher/resourcefetcher'
 
 export const defaultRegion = 'us-east-1'
 export const defaultPartition = 'aws'
@@ -120,6 +120,7 @@ export class RegionProvider {
     }
 
     private loadFromEndpoints(endpoints: Endpoints) {
+        this.regionData.clear()
         endpoints.partitions.forEach(partition => {
             partition.regions.forEach(region =>
                 this.regionData.set(region.id, {
@@ -140,40 +141,71 @@ export class RegionProvider {
                 })
             })
         })
+        this.onDidChangeEmitter.fire()
     }
 
-    public static fromEndpointsProvider(endpointsProvider: EndpointsProvider): RegionProvider {
+    /**
+     * @param endpointsProvider.local Retrieves endpoints manifest from local sources available to the toolkit. Expected
+     *                                to resolve fast, and is both a placeholder until the remote resources are loaded, and
+     *                                is a fallback in case the toolkit is unable to load a remote resource
+     * @param endpointsProvider.remote Retrieves endpoints manifest from remote host
+     */
+    public static fromEndpointsProvider(endpointsProvider: {
+        local: () => Endpoints | Promise<Endpoints>
+        remote: () => Endpoints | Promise<Endpoints>
+    }): RegionProvider {
         const instance = new this()
 
-        endpointsProvider
-            .load()
-            .then(endpoints => {
-                instance.regionData.clear()
-                instance.loadFromEndpoints(endpoints)
-                instance.onDidChangeEmitter.fire()
-            })
-            .catch(err => {
-                getLogger().error('Failure while loading Endpoints Manifest: %s', err)
-
-                vscode.window.showErrorMessage(
-                    `${localize(
-                        'AWS.error.endpoint.load.failure',
-                        'The {0} Toolkit was unable to load endpoints data.',
-                        getIdeProperties().company
-                    )} ${
-                        isCloud9()
-                            ? localize(
-                                  'AWS.error.impactedFunctionalityReset.cloud9',
-                                  'Toolkit functionality may be impacted until the Cloud9 browser tab is refreshed.'
-                              )
-                            : localize(
-                                  'AWS.error.impactedFunctionalityReset.vscode',
-                                  'Toolkit functionality may be impacted until VS Code is restarted.'
-                              )
-                    }`
+        async function load() {
+            getLogger().info('endpoints: retrieving AWS endpoints data')
+            instance.loadFromEndpoints(await endpointsProvider.local())
+
+            try {
+                instance.loadFromEndpoints(await endpointsProvider.remote())
+            } catch (err) {
+                getLogger().warn(
+                    `endpoints: failed to load from remote source, region data may appear outdated: %s`,
+                    err
                 )
-            })
+            }
+        }
+
+        load().catch(err => {
+            getLogger().error('Failure while loading Endpoints Manifest: %s', err)
+
+            vscode.window.showErrorMessage(
+                `${localize(
+                    'AWS.error.endpoint.load.failure',
+                    'The {0} Toolkit was unable to load endpoints data.',
+                    getIdeProperties().company
+                )} ${
+                    isCloud9()
+                        ? localize(
+                              'AWS.error.impactedFunctionalityReset.cloud9',
+                              'Toolkit functionality may be impacted until the Cloud9 browser tab is refreshed.'
+                          )
+                        : localize(
+                              'AWS.error.impactedFunctionalityReset.vscode',
+                              'Toolkit functionality may be impacted until VS Code is restarted.'
+                          )
+                }`
+            )
+        })
 
         return instance
     }
 }
+
+export async function getEndpointsFromFetcher(fetcher: ResourceFetcher): Promise<Endpoints> {
+    const endpointsJson = await fetcher.get()
+    if (!endpointsJson) {
+        throw new Error('Failed to get resource')
+    }
+
+    const endpoints = loadEndpoints(endpointsJson)
+    if (!endpoints) {
+        throw new Error('Failed to load endpoints')
+    }
+
+    return endpoints
+}

src/shared/regions/regionProvider.ts

@@ -7,7 +7,6 @@ import * as assert from 'assert'
 import * as sinon from 'sinon'
 import { AwsExplorer } from '../../awsexplorer/awsExplorer'
 import { RegionNode } from '../../awsexplorer/regionNode'
-import { EndpointsProvider } from '../../shared/regions/endpointsProvider'
 import { RegionProvider } from '../../shared/regions/regionProvider'
 import { FakeExtensionContext, FakeMemento } from '../fakeExtensionContext'
 import {
@@ -16,7 +15,6 @@ import {
     DEFAULT_TEST_REGION_NAME,
 } from '../shared/regions/testUtil'
 import { makeFakeAwsContextWithPlaceholderIds } from '../utilities/fakeAwsContext'
-import { stub } from '../utilities/stubber'
 
 describe('AwsExplorer', function () {
     let sandbox: sinon.SinonSandbox
@@ -52,15 +50,14 @@ describe('AwsExplorer', function () {
 
     it('refreshes when the Region Provider is updated', async function () {
         const fakeContext = await FakeExtensionContext.create()
-        const endpointsProvider = stub(EndpointsProvider)
-        endpointsProvider.load.resolves({ partitions: [] })
-
-        const regionProvider = RegionProvider.fromEndpointsProvider(endpointsProvider)
+        const endpoints = Promise.resolve({ partitions: [] })
+        const regionProvider = RegionProvider.fromEndpointsProvider({
+            local: () => endpoints,
+            remote: () => endpoints,
+        })
         const awsExplorer = new AwsExplorer(fakeContext, regionProvider)
-
         const refreshStub = sandbox.stub(awsExplorer, 'refresh')
-        await endpointsProvider.load()
-
+        await endpoints
         assert.ok(refreshStub.calledOnce, 'expected AWS Explorer to refresh itself')
     })
 })

src/test/awsExplorer/awsExplorer.test.ts

@@ -53,6 +53,24 @@ const endpoints = {
 }
 
 describe('RegionProvider', async function () {
+    describe('fromEndpointsProvider', function () {
+        it('pulls from the local source first and remote source later', async function () {
+            const localEndpoints = Promise.resolve({ partitions: endpoints.partitions.slice(0, 1) })
+            const remoteEndpoints = Promise.resolve(endpoints)
+            const regionProvider = RegionProvider.fromEndpointsProvider({
+                local: () => localEndpoints,
+                remote: () => remoteEndpoints,
+            })
+
+            await localEndpoints
+            assert.ok(regionProvider.isServiceInRegion(serviceId, regionCode), 'Expected service to be in region')
+            assert.strictEqual(regionProvider.getPartitionId('awscnregion1'), undefined)
+            await remoteEndpoints
+            assert.ok(regionProvider.isServiceInRegion(serviceId, regionCode), 'Expected service to be in region')
+            assert.strictEqual(regionProvider.getPartitionId('awscnregion1'), 'aws-cn')
+        })
+    })
+
     describe('isServiceInRegion', async function () {
         it('indicates when a service is in a region', async function () {
             const regionProvider = new RegionProvider(endpoints)