added timeouts for multi-call methods

Author: toptobes

src/api/data-api-http-client.ts

@@ -12,27 +12,43 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { BaseOptions } from '@/src/data-api/types';
 import { DEFAULT_NAMESPACE, DEFAULT_TIMEOUT, HTTP_METHODS, HttpClient, RawDataApiResponse } from '@/src/api';
 import { DataAPIResponseError, DataAPITimeout, mkRespErrorFromResponse, ObjectId, UUID } from '@/src/data-api';
 import { logger } from '@/src/logger';
+import {
+  MkTimeoutError,
+  MultiCallTimeoutManager,
+  SingleCallTimeoutManager,
+  TimeoutManager, TimeoutOptions,
+} from '@/src/api/timeout-managers';
 
 interface DataApiRequestInfo {
   url: string;
-  timeout?: number;
   collection?: string;
   namespace?: string;
   command: Record<string, any>;
+  timeoutManager: TimeoutManager;
+}
+
+type ExecuteCommandOptions = TimeoutOptions & {
+  collection?: string;
+  namespace?: string;
 }
 
 export class DataApiHttpClient extends HttpClient {
   public collection?: string;
   public namespace?: string;
 
-  public async executeCommand(command: Record<string, any>, options?: BaseOptions & { collection?: string, namespace?: string }) {
+  public multiCallTimeoutManager(timeoutMs: number | undefined) {
+    return mkTimeoutManager(MultiCallTimeoutManager, timeoutMs);
+  }
+
+  public async executeCommand(command: Record<string, any>, options: ExecuteCommandOptions | undefined) {
+    const timeoutManager = options?.timeoutManager ?? mkTimeoutManager(SingleCallTimeoutManager, options?.maxTimeMS);
+
     const response = await this._requestDataApi({
       url: this.baseUrl,
-      timeout: options?.maxTimeMS,
+      timeoutManager: timeoutManager,
       collection: options?.collection,
       namespace: options?.namespace,
       command: command,
@@ -54,16 +70,13 @@ export class DataApiHttpClient extends HttpClient {
       const response = await this._request({
         url: url,
         data: JSON.stringify(info.command, replacer),
-        timeout: info.timeout,
+        timeoutManager: info.timeoutManager,
         method: HTTP_METHODS.Post,
-        timeoutError() {
-          return new DataAPITimeout(info.command, info.timeout || DEFAULT_TIMEOUT);
-        },
         reviver: reviver,
       });
 
       if (response.status === 401 || (response.data?.errors?.length > 0 && response.data?.errors[0]?.message === 'UNAUTHENTICATED: Invalid token')) {
-        return this._mkError('Authentication failed; is your token valid?');
+        return mkFauxErroredResponse('Authentication failed; is your token valid?');
       }
 
       if (response.status === 200) {
@@ -75,7 +88,7 @@ export class DataApiHttpClient extends HttpClient {
       } else {
         logger.error(info.url + ": " + response.status);
         logger.error("Data: " + JSON.stringify(info.command));
-        return this._mkError(`Some non-200 status code was returned. Check the logs for more information. ${response.status}, ${JSON.stringify(response.data)}`);
+        return mkFauxErroredResponse(`Some non-200 status code was returned. Check the logs for more information. ${response.status}, ${JSON.stringify(response.data)}`);
       }
     } catch (e: any) {
       logger.error(info.url + ": " + e.message);
@@ -88,10 +101,19 @@ export class DataApiHttpClient extends HttpClient {
       throw e;
     }
   }
+}
 
-  private _mkError(message: string): RawDataApiResponse {
-    return { errors: [{ message }] };
-  }
+const mkTimeoutManager = (constructor: new (maxMs: number, mkTimeoutError: MkTimeoutError) => TimeoutManager, maxMs: number | undefined) => {
+  const timeout = maxMs ?? DEFAULT_TIMEOUT;
+  return new constructor(timeout, mkTimeoutErrorMaker(timeout));
+}
+
+const mkTimeoutErrorMaker = (timeout: number): MkTimeoutError => {
+  return (info) => new DataAPITimeout(info.data!, timeout)
+}
+
+const mkFauxErroredResponse = (message: string): RawDataApiResponse => {
+  return { errors: [{ message }] };
 }
 
 export function replacer(this: any, key: string, value: any): any {

src/api/devops-api-http-client.ts

@@ -19,32 +19,50 @@ import { HTTPClientOptions } from '@/src/api/types';
 import { HTTP1AuthHeaderFactories, HTTP1Strategy } from '@/src/api/http1';
 import { DevopsApiResponseError, DevopsApiTimeout, DevopsUnexpectedStateError } from '@/src/devops/errors';
 import { AdminBlockingOptions } from '@/src/devops/types';
+import {
+  MkTimeoutError,
+  MultiCallTimeoutManager,
+  SingleCallTimeoutManager,
+  TimeoutManager,
+  TimeoutOptions,
+} from '@/src/api/timeout-managers';
 
 interface DevopsApiRequestInfo {
   path: string,
-  timeout?: number,
   method: HTTP_METHODS,
   data?: Record<string, any>,
   params?: Record<string, any>,
 }
 
+interface LongRunningRequestInfo {
+  id: string | ((resp: AxiosResponse) => string),
+  target: string,
+  legalStates: string[],
+  defaultPollInterval: number,
+  options: AdminBlockingOptions | undefined,
+}
+
 export class DevopsApiHttpClient extends HttpClient {
   constructor(props: HTTPClientOptions) {
     super(props);
     this.requestStrategy = new HTTP1Strategy(HTTP1AuthHeaderFactories.DevopsApi);
   }
 
-  public async request(info: DevopsApiRequestInfo): Promise<AxiosResponse> {
+  public multiCallTimeoutManager(timeoutMs: number | undefined) {
+    return mkTimeoutManager(MultiCallTimeoutManager, timeoutMs);
+  }
+
+  public async request(info: DevopsApiRequestInfo, options: TimeoutOptions | undefined): Promise<AxiosResponse> {
     try {
+      const timeoutManager = options?.timeoutManager ?? mkTimeoutManager(SingleCallTimeoutManager, options?.maxTimeMS);
       const url = this.baseUrl + info.path;
 
       return await this._request({
         url: url,
         method: info.method,
-        timeout: info.timeout || DEFAULT_TIMEOUT,
-        timeoutError: () => new DevopsApiTimeout(url, info.timeout || DEFAULT_TIMEOUT),
         params: info.params,
         data: info.data,
+        timeoutManager,
       }) as any;
     } catch (e) {
       if (!(e instanceof AxiosError)) {
@@ -54,15 +72,29 @@ export class DevopsApiHttpClient extends HttpClient {
     }
   }
 
-  public async awaitStatus(idRef: { id: string }, target: string, legalStates: string[], options: AdminBlockingOptions | undefined, defaultPollInterval: number): Promise<void> {
+  public async requestLongRunning(req: DevopsApiRequestInfo, info: LongRunningRequestInfo): Promise<AxiosResponse> {
+    const timeoutManager = this.multiCallTimeoutManager(info.options?.maxTimeMS);
+    const resp = await this.request(req, { timeoutManager });
+
+    const id = (typeof info.id === 'function')
+      ? info.id(resp)
+      : info.id;
+
+    await this._awaitStatus(id, 'ACTIVE', ['MAINTENANCE'], info.options, info.defaultPollInterval, timeoutManager);
+    return resp;
+  }
+
+  private async _awaitStatus(id: string, target: string, legalStates: string[], options: AdminBlockingOptions | undefined, defaultPollInterval: number, timeoutManager: TimeoutManager): Promise<void> {
     if (options?.blocking === false) {
       return;
     }
 
     for (;;) {
       const resp = await this.request({
         method: HTTP_METHODS.Get,
-        path: `/databases/${idRef.id}`,
+        path: `/databases/${id}`,
+      }, {
+        timeoutManager: timeoutManager,
       });
 
       if (resp.data?.status === target) {
@@ -79,3 +111,12 @@ export class DevopsApiHttpClient extends HttpClient {
     }
   }
 }
+
+const mkTimeoutManager = (constructor: new (maxMs: number, mkTimeoutError: MkTimeoutError) => TimeoutManager, maxMs: number | undefined) => {
+  const timeout = maxMs ?? DEFAULT_TIMEOUT;
+  return new constructor(timeout, mkTimeoutErrorMaker(timeout));
+}
+
+const mkTimeoutErrorMaker = (timeout: number): MkTimeoutError => {
+  return (info) => new DevopsApiTimeout(info.url, timeout);
+}

src/api/http-client.ts

@@ -12,13 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { CLIENT_USER_AGENT, DEFAULT_TIMEOUT } from '@/src/api/constants';
-import {
-  GuaranteedAPIResponse,
-  HTTPClientOptions,
-  HTTPRequestInfo,
-  HTTPRequestStrategy
-} from '@/src/api/types';
+import { CLIENT_USER_AGENT } from '@/src/api/constants';
+import { GuaranteedAPIResponse, HTTPClientOptions, HTTPRequestInfo, HTTPRequestStrategy } from '@/src/api/types';
 import { HTTP1AuthHeaderFactories, HTTP1Strategy } from '@/src/api/http1';
 import { HTTP2Strategy } from '@/src/api/http2';
 import { Mutable } from '@/src/data-api/types/utils';
@@ -96,12 +91,11 @@ export class HttpClient {
     return await this.requestStrategy.request({
       url: info.url,
       data: info.data,
-      timeout: info.timeout || DEFAULT_TIMEOUT,
       method: info.method,
       params: info.params ?? {},
       token: this.#applicationToken,
       userAgent: this.userAgent,
-      timeoutError: info.timeoutError,
+      timeoutManager: info.timeoutManager,
       reviver: info.reviver,
     });
   }

src/api/http1.ts

@@ -68,7 +68,7 @@ export class HTTP1Strategy implements HTTPRequestStrategy {
         data: info.data,
         params: info.params,
         method: info.method,
-        timeout: info.timeout,
+        timeout: info.timeoutManager.msRemaining,
         headers: {
           ...this._authHeaderFactory(info.token),
           'User-Agent': info.userAgent,
@@ -80,7 +80,7 @@ export class HTTP1Strategy implements HTTPRequestStrategy {
       });
     } catch (e: any) {
       if (e.code === 'ECONNABORTED') {
-        throw info.timeoutError();
+        throw info.timeoutManager.mkTimeoutError(info);
       }
       throw e;
     }

src/api/http2.ts

@@ -38,7 +38,7 @@ export class HTTP2Strategy implements HTTPRequestStrategy {
         this.#session = this._reviveSession();
       }
 
-      const timer = setTimeout(() => reject(info.timeoutError()), info.timeout);
+      const timer = setTimeout(() => reject(info.timeoutManager.mkTimeoutError(info)), info.timeoutManager.msRemaining);
 
       const path = info.url.replace(this.origin, '');
       const params = info.params ? `?${new URLSearchParams(info.params).toString()}` : '';

src/api/timeout-managers.ts

@@ -0,0 +1,52 @@
+// Copyright DataStax, Inc.
+//
+// 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.
+
+import { InternalHTTPRequestInfo } from '@/src/api/types';
+
+export type TimeoutOptions = {
+  maxTimeMS?: number,
+  timeoutManager?: never,
+} | {
+  timeoutManager: TimeoutManager,
+  maxTimeMS?: never,
+}
+
+export type MkTimeoutError = (ctx: InternalHTTPRequestInfo) => Error;
+
+export interface TimeoutManager {
+  msRemaining: number,
+  mkTimeoutError: MkTimeoutError,
+}
+
+export class SingleCallTimeoutManager implements TimeoutManager {
+  constructor(readonly msRemaining: number, readonly mkTimeoutError: MkTimeoutError) {}
+}
+
+export class MultiCallTimeoutManager implements TimeoutManager {
+  private _deadline!: number;
+  private _started: boolean;
+
+  constructor(maxMs: number, readonly mkTimeoutError: MkTimeoutError) {
+    this._deadline = maxMs;
+    this._started = false;
+  }
+
+  get msRemaining() {
+    if (!this._started) {
+      this._started = true;
+      this._deadline = Date.now() + this._deadline;
+    }
+    return this._deadline - Date.now();
+  }
+}

src/api/types.ts

@@ -14,6 +14,7 @@
 
 import type { HTTP_METHODS } from '@/src/api/index';
 import { Caller } from '@/src/client';
+import { TimeoutManager } from '@/src/api/timeout-managers';
 
 /**
  * @internal
@@ -51,9 +52,8 @@ export interface HTTPRequestInfo {
   data?: unknown,
   params?: Record<string, string>,
   method: HTTP_METHODS,
-  timeout?: number,
-  timeoutError: () => Error,
   reviver?: (key: string, value: any) => any,
+  timeoutManager: TimeoutManager,
 }
 
 /**
@@ -62,7 +62,6 @@ export interface HTTPRequestInfo {
 export interface InternalHTTPRequestInfo extends HTTPRequestInfo {
   token: string,
   method: HTTP_METHODS,
-  timeout: number,
   userAgent: string,
 }
 

src/common/index.ts

@@ -0,0 +1,15 @@
+// Copyright DataStax, Inc.
+//
+// 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.
+
+export * from './types';

src/common/types.ts

@@ -0,0 +1,17 @@
+// Copyright DataStax, Inc.
+//
+// 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.
+
+export interface WithTimeout {
+  maxTimeMS?: number;
+}