feat!: isAvailable now tries both DNS and IP, choosing whichever responds first (#239)

Benjamin E. Coe · web-flow · commit 25bc11657001 · 2019-09-16T17:32:26.000-07:00
diff --git a/package.json b/package.json
@@ -17,7 +17,7 @@
     "samples-test": "npm link && cd samples/ && npm link ../ && npm test && cd ../",
     "presystem-test": "npm run compile",
     "system-test": "mocha build/system-test --timeout 600000",
-    "test": "c8 mocha build/test",
+    "test": "c8 mocha --timeout=5000 build/test",
     "docs": "compodoc src/",
     "lint": "gts check && eslint '**/*.js'",
     "docs-test": "linkinator docs",
diff --git a/src/index.ts b/src/index.ts
@@ -5,13 +5,15 @@
  * See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
  */
 
-import {request} from 'gaxios';
+import {GaxiosOptions, GaxiosResponse, request} from 'gaxios';
 import {OutgoingHttpHeaders} from 'http';
 const jsonBigint = require('json-bigint');
 
 export const HOST_ADDRESS = 'http://169.254.169.254';
 export const BASE_PATH = '/computeMetadata/v1';
 export const BASE_URL = HOST_ADDRESS + BASE_PATH;
+export const SECONDARY_HOST_ADDRESS = 'http://metadata.google.internal.';
+export const SECONDARY_BASE_URL = SECONDARY_HOST_ADDRESS + BASE_PATH;
 export const HEADER_NAME = 'Metadata-Flavor';
 export const HEADER_VALUE = 'Google';
 export const HEADERS = Object.freeze({[HEADER_NAME]: HEADER_VALUE});
@@ -47,7 +49,8 @@ function validate(options: Options) {
 async function metadataAccessor<T>(
   type: string,
   options?: string | Options,
-  noResponseRetries = 3
+  noResponseRetries = 3,
+  fastFail = false
 ): Promise<T> {
   options = options || {};
   if (typeof options === 'string') {
@@ -59,7 +62,8 @@ async function metadataAccessor<T>(
   }
   validate(options);
   try {
-    const res = await request<T>({
+    const requestMethod = fastFail ? fastFailMetadataRequest : request;
+    const res = await requestMethod<T>({
       url: `${BASE_URL}/${type}${property}`,
       headers: Object.assign({}, HEADERS, options.headers),
       retryConfig: {noResponseRetries},
@@ -91,6 +95,16 @@ async function metadataAccessor<T>(
   }
 }
 
+async function fastFailMetadataRequest<T>(
+  options: GaxiosOptions
+): Promise<GaxiosResponse> {
+  const secondaryOptions = {
+    ...options,
+    url: options.url!.replace(BASE_URL, SECONDARY_BASE_URL),
+  };
+  return Promise.race([request<T>(options), request<T>(secondaryOptions)]);
+}
+
 // tslint:disable-next-line no-any
 export function instance<T = any>(options?: string | Options) {
   return metadataAccessor<T>('instance', options);
@@ -109,11 +123,18 @@ export async function isAvailable() {
     // Attempt to read instance metadata. As configured, this will
     // retry 3 times if there is a valid response, and fail fast
     // if there is an ETIMEDOUT or ENOTFOUND error.
-    await metadataAccessor('instance', undefined, 0);
+    await metadataAccessor('instance', undefined, 0, true);
     return true;
   } catch (err) {
-    // Failure to resolve the metadata service means that it is not available.
-    if (err.code && (err.code === 'ENOTFOUND' || err.code === 'ENOENT')) {
+    if (err.type === 'request-timeout') {
+      // If running in a GCP environment, metadata endpoint should return
+      // within ms.
+      return false;
+    } else if (
+      err.code &&
+      (err.code === 'ENOTFOUND' || err.code === 'ENOENT')
+    ) {
+      // Failure to resolve the metadata service means that it is not available.
       return false;
     }
     // Throw unexpected errors.
diff --git a/test/index.test.ts b/test/index.test.ts
@@ -11,7 +11,10 @@ import * as gcp from '../src';
 
 const assertRejects = require('assert-rejects');
 
+// the metadata IP entry:
 const HOST = gcp.HOST_ADDRESS;
+// the metadata DNS entry:
+const SECONDARY_HOST = gcp.SECONDARY_HOST_ADDRESS;
 const PATH = gcp.BASE_PATH;
 const TYPE = 'instance';
 const PROPERTY = 'property';
@@ -174,33 +177,106 @@ it('should retry on DNS errors', async () => {
   assert(data);
 });
 
-it('should report isGCE if the server returns a 500 first', async () => {
-  const scope = nock(HOST)
+async function secondaryHostRequest(
+  delay: number,
+  responseType = 'success'
+): Promise<void> {
+  let secondary: nock.Scope;
+  if (responseType === 'success') {
+    secondary = nock(SECONDARY_HOST)
+      .get(`${PATH}/${TYPE}`)
+      .delayConnection(delay)
+      .reply(200, {}, HEADERS);
+  } else {
+    secondary = nock(SECONDARY_HOST)
+      .get(`${PATH}/${TYPE}`)
+      .delayConnection(delay)
+      .replyWithError({code: responseType});
+  }
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      try {
+        secondary.done();
+        return resolve();
+      } catch (err) {
+        return reject(err);
+      }
+    }, delay + 50);
+  });
+}
+
+it('should report isGCE if primary server returns 500 followed by 200', async () => {
+  const secondary = secondaryHostRequest(500);
+  const primary = nock(HOST)
     .get(`${PATH}/${TYPE}`)
     .twice()
     .reply(500)
     .get(`${PATH}/${TYPE}`)
     .reply(200, {}, HEADERS);
   const isGCE = await gcp.isAvailable();
-  scope.done();
+  await secondary;
+  primary.done();
   assert.strictEqual(isGCE, true);
 });
 
 it('should fail fast on isAvailable if ENOTFOUND is returned', async () => {
-  const scope = nock(HOST)
+  const secondary = secondaryHostRequest(500);
+  const primary = nock(HOST)
     .get(`${PATH}/${TYPE}`)
     .replyWithError({code: 'ENOTFOUND'});
   const isGCE = await gcp.isAvailable();
-  scope.done();
+  await secondary;
+  primary.done();
   assert.strictEqual(false, isGCE);
 });
 
 it('should fail fast on isAvailable if ENOENT is returned', async () => {
-  const scope = nock(HOST)
+  const secondary = secondaryHostRequest(500);
+  const primary = nock(HOST)
     .get(`${PATH}/${TYPE}`)
     .replyWithError({code: 'ENOENT'});
   const isGCE = await gcp.isAvailable();
-  scope.done();
+  await secondary;
+  primary.done();
+  assert.strictEqual(false, isGCE);
+});
+
+it('should fail on isAvailable if request times out', async () => {
+  const secondary = secondaryHostRequest(5000);
+  const primary = nock(HOST)
+    .get(`${PATH}/${TYPE}`)
+    .delayConnection(3500)
+    // this should never get called, as the 3000 timeout will trigger.
+    .reply(200, {}, HEADERS);
+  const isGCE = await gcp.isAvailable();
+  // secondary is allowed to simply timeout in the aether, to avoid
+  // having a test that waits 5000 ms.
+  primary.done();
+  assert.strictEqual(false, isGCE);
+});
+
+it('should report isGCE if secondary responds before primary', async () => {
+  const secondary = secondaryHostRequest(10);
+  const primary = nock(HOST)
+    .get(`${PATH}/${TYPE}`)
+    .delayConnection(3500)
+    // this should never get called, as the 3000 timeout will trigger.
+    .reply(200, {}, HEADERS);
+  const isGCE = await gcp.isAvailable();
+  await secondary;
+  primary.done();
+  assert.strictEqual(isGCE, true);
+});
+
+it('should fail fast on isAvailable if ENOENT is returned by secondary', async () => {
+  const secondary = secondaryHostRequest(10, 'ENOENT');
+  const primary = nock(HOST)
+    .get(`${PATH}/${TYPE}`)
+    .delayConnection(250)
+    .replyWithError({code: 'ENOENT'});
+  const isGCE = await gcp.isAvailable();
+  await secondary;
+  primary.done();
   assert.strictEqual(false, isGCE);
 });
 
