fix retries

Author: ArtemHoruzhenko

redisinsight/api/src/__mocks__/cloud-capi-key.ts

@@ -69,4 +69,6 @@ export const mockCloudCapiKeyService = jest.fn(() => ({
 export const mockCloudCapiKeyAnalytics = jest.fn(() => ({
   sendCloudAccountKeyGenerated: jest.fn(),
   sendCloudAccountKeyGenerationFailed: jest.fn(),
+  sendCloudAccountSecretGenerated: jest.fn(),
+  sendCloudAccountSecretGenerationFailed: jest.fn(),
 }));

redisinsight/api/src/__mocks__/cloud-common.ts

@@ -1,19 +1,46 @@
+import { HttpStatus } from '@nestjs/common';
+import ERROR_MESSAGES from 'src/constants/error-messages';
+import { CustomErrorCodes } from 'src/constants';
+
 export const mockCapiUnauthorizedError = {
   message: 'Request failed with status code 401',
   response: {
     status: 401,
   },
 };
 
-export const mockApiInternalServerError = {
+export const mockSmApiUnauthorizedError = mockCapiUnauthorizedError;
+
+export const mockSmApiInternalServerError = {
   message: 'Something wrong',
   response: {
     status: 500,
   },
 };
 
+export const mockSmApiBadRequestError = {
+  message: 'Bad Request',
+  response: {
+    status: 400,
+  },
+};
+
 export const mockUtm = {
   source: 'redisinsight',
   medium: 'sso',
   campaign: 'workbench',
 };
+
+export const mockCloudApiUnauthorizedExceptionResponse = {
+  error: 'CloudApiUnauthorized',
+  errorCode: CustomErrorCodes.CloudApiUnauthorized,
+  message: ERROR_MESSAGES.UNAUTHORIZED,
+  statusCode: HttpStatus.UNAUTHORIZED,
+};
+
+export const mockCloudApiBadRequestExceptionResponse = {
+  error: 'CloudApiBadRequest',
+  errorCode: CustomErrorCodes.CloudApiBadRequest,
+  message: ERROR_MESSAGES.BAD_REQUEST,
+  statusCode: HttpStatus.BAD_REQUEST,
+};

redisinsight/api/src/__mocks__/cloud-user.ts

@@ -136,6 +136,7 @@ export const mockCloudUserRepository = jest.fn(() => ({
 export const mockCloudUserApiService = jest.fn(() => ({
   getCapiKeys: jest.fn().mockResolvedValue(mockCloudCapiAuthDto),
   me: jest.fn().mockResolvedValue(mockCloudUser),
+  getCloudUser: jest.fn().mockResolvedValue(mockCloudUser),
   setCurrentAccount: jest.fn(),
   updateUser: jest.fn(),
 }));

redisinsight/api/src/constants/telemetry-events.ts

@@ -39,6 +39,8 @@ export enum TelemetryEvents {
   // Event for cloud CAPI keys
   CloudAccountKeyGenerated = 'CLOUD_ACCOUNT_KEY_GENERATED',
   CloudAccountKeyGenerationFailed = 'CLOUD_ACCOUNT_KEY_GENERATION_FAILED',
+  CloudAccountSecretGenerated = 'CLOUD_ACCOUNT_SECRET_GENERATED',
+  CloudAccountSecretGenerationFailed = 'CLOUD_ACCOUNT_SECRET_GENERATION_FAILED',
 
   // Events for cli tool
   CliClientCreated = 'CLI_CLIENT_CREATED',

redisinsight/api/src/modules/ai/query/exceptions/ai-query.bad-request.exception.ts

@@ -8,7 +8,7 @@ export class AiQueryBadRequestException extends HttpException {
       message,
       statusCode: HttpStatus.BAD_REQUEST,
       error: 'AiQueryBadRequest',
-      errorCode: CustomErrorCodes.QueryAiInternalServerError,
+      errorCode: CustomErrorCodes.QueryAiBadRequest,
     };
 
     super(response, response.statusCode, options);

redisinsight/api/src/modules/cloud/autodiscovery/me.cloud-autodiscovery.service.spec.ts

@@ -4,7 +4,7 @@ import {
   mockCloudAutodiscoveryService,
   mockCloudCapiAuthDto, mockCloudCapiKeyService,
   mockCloudDatabase,
-  mockCloudDatabaseFixed,
+  mockCloudDatabaseFixed, mockCloudSessionService,
   mockCloudSubscription,
   mockCloudSubscriptionFixed,
   mockImportCloudDatabaseDto, mockImportCloudDatabaseDtoFixed,
@@ -22,6 +22,8 @@ import {
 } from 'src/modules/cloud/common/exceptions';
 import { MeCloudAutodiscoveryService } from 'src/modules/cloud/autodiscovery/me.cloud-autodiscovery.service';
 import { CloudCapiKeyService } from 'src/modules/cloud/capi-key/cloud-capi-key.service';
+import { CloudCapiKeyApiProvider } from 'src/modules/cloud/capi-key/cloud-capi-key.api.provider';
+import { CloudSessionService } from 'src/modules/cloud/session/cloud-session.service';
 
 describe('MeCloudAutodiscoveryService', () => {
   let service: MeCloudAutodiscoveryService;
@@ -33,6 +35,7 @@ describe('MeCloudAutodiscoveryService', () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         MeCloudAutodiscoveryService,
+        CloudCapiKeyApiProvider,
         {
           provide: CloudAutodiscoveryService,
           useFactory: mockCloudAutodiscoveryService,
@@ -41,6 +44,10 @@ describe('MeCloudAutodiscoveryService', () => {
           provide: CloudCapiKeyService,
           useFactory: mockCloudCapiKeyService,
         },
+        {
+          provide: CloudSessionService,
+          useFactory: mockCloudSessionService,
+        },
       ],
     }).compile();
 
@@ -53,7 +60,8 @@ describe('MeCloudAutodiscoveryService', () => {
     it('successfully get cloud account info', async () => {
       expect(await service.getAccount(mockSessionMetadata)).toEqual(mockCloudAccountInfo);
     });
-    it('should throw CloudApiUnauthorizedException exception', async () => {
+    it('should throw CloudApiUnauthorizedException exception if failed twice', async () => {
+      cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       await expect(service.getAccount(mockSessionMetadata)).rejects.toThrow(
         CloudApiUnauthorizedException,
@@ -76,7 +84,8 @@ describe('MeCloudAutodiscoveryService', () => {
         CloudAutodiscoveryAuthType.Sso,
       );
     });
-    it('should throw CloudApiUnauthorizedException exception', async () => {
+    it('should throw CloudApiUnauthorizedException exception if failed twice', async () => {
+      cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       await expect(service.discoverSubscriptions(mockSessionMetadata)).rejects.toThrow(
         CloudApiUnauthorizedException,
@@ -128,7 +137,8 @@ describe('MeCloudAutodiscoveryService', () => {
         CloudAutodiscoveryAuthType.Sso,
       );
     });
-    it('should throw CloudApiUnauthorizedException exception', async () => {
+    it('should throw CloudApiUnauthorizedException exception if failed twice', async () => {
+      cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       await expect(service.discoverDatabases(
         mockSessionMetadata,
@@ -183,7 +193,8 @@ describe('MeCloudAutodiscoveryService', () => {
         ],
       );
     });
-    it('should throw CloudApiUnauthorizedException exception', async () => {
+    it('should throw CloudApiUnauthorizedException exception if failed twice', async () => {
+      cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       cloudCapiKeyService.getCapiCredentials.mockRejectedValueOnce(new CloudApiUnauthorizedException());
       await expect(service.addRedisCloudDatabases(
         mockSessionMetadata,

redisinsight/api/src/modules/cloud/autodiscovery/me.cloud-autodiscovery.service.ts

@@ -16,12 +16,14 @@ import { CloudDatabase } from 'src/modules/cloud/database/models';
 import { CloudAutodiscoveryService } from 'src/modules/cloud/autodiscovery/cloud-autodiscovery.service';
 import { CloudRequestUtm } from 'src/modules/cloud/common/models';
 import { CloudCapiKeyService } from 'src/modules/cloud/capi-key/cloud-capi-key.service';
+import { CloudCapiKeyApiProvider } from 'src/modules/cloud/capi-key/cloud-capi-key.api.provider';
 
 @Injectable()
 export class MeCloudAutodiscoveryService {
   constructor(
     private readonly cloudAutodiscoveryService: CloudAutodiscoveryService,
     private readonly cloudCapiKeyService: CloudCapiKeyService,
+    private readonly api: CloudCapiKeyApiProvider,
   ) {}
 
   private async getCapiCredentials(sessionMetadata: SessionMetadata, utm?: CloudRequestUtm): Promise<CloudCapiAuthDto> {
@@ -34,13 +36,15 @@ export class MeCloudAutodiscoveryService {
    * @param utm
    */
   async getAccount(sessionMetadata: SessionMetadata, utm?: CloudRequestUtm): Promise<CloudAccountInfo> {
-    try {
-      return await this.cloudAutodiscoveryService.getAccount(
-        await this.getCapiCredentials(sessionMetadata, utm),
-      );
-    } catch (e) {
-      throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
-    }
+    return this.api.callWithAuthRetry(sessionMetadata.sessionId, async () => {
+      try {
+        return await this.cloudAutodiscoveryService.getAccount(
+          await this.getCapiCredentials(sessionMetadata, utm),
+        );
+      } catch (e) {
+        throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
+      }
+    });
   }
 
   /**
@@ -49,14 +53,16 @@ export class MeCloudAutodiscoveryService {
    * @param utm
    */
   async discoverSubscriptions(sessionMetadata: SessionMetadata, utm?: CloudRequestUtm): Promise<CloudSubscription[]> {
-    try {
-      return await this.cloudAutodiscoveryService.discoverSubscriptions(
-        await this.getCapiCredentials(sessionMetadata, utm),
-        CloudAutodiscoveryAuthType.Sso,
-      );
-    } catch (e) {
-      throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
-    }
+    return this.api.callWithAuthRetry(sessionMetadata.sessionId, async () => {
+      try {
+        return await this.cloudAutodiscoveryService.discoverSubscriptions(
+          await this.getCapiCredentials(sessionMetadata, utm),
+          CloudAutodiscoveryAuthType.Sso,
+        );
+      } catch (e) {
+        throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
+      }
+    });
   }
 
   /**
@@ -70,15 +76,17 @@ export class MeCloudAutodiscoveryService {
     dto: DiscoverCloudDatabasesDto,
     utm?: CloudRequestUtm,
   ): Promise<CloudDatabase[]> {
-    try {
-      return await this.cloudAutodiscoveryService.discoverDatabases(
-        await this.getCapiCredentials(sessionMetadata, utm),
-        dto,
-        CloudAutodiscoveryAuthType.Sso,
-      );
-    } catch (e) {
-      throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
-    }
+    return this.api.callWithAuthRetry(sessionMetadata.sessionId, async () => {
+      try {
+        return await this.cloudAutodiscoveryService.discoverDatabases(
+          await this.getCapiCredentials(sessionMetadata, utm),
+          dto,
+          CloudAutodiscoveryAuthType.Sso,
+        );
+      } catch (e) {
+        throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
+      }
+    });
   }
 
   /**
@@ -92,13 +100,15 @@ export class MeCloudAutodiscoveryService {
     addDatabasesDto: ImportCloudDatabaseDto[],
     utm?: CloudRequestUtm,
   ): Promise<ImportCloudDatabaseResponse[]> {
-    try {
-      return await this.cloudAutodiscoveryService.addRedisCloudDatabases(
-        await this.getCapiCredentials(sessionMetadata, utm),
-        addDatabasesDto,
-      );
-    } catch (e) {
-      throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
-    }
+    return this.api.callWithAuthRetry(sessionMetadata.sessionId, async () => {
+      try {
+        return await this.cloudAutodiscoveryService.addRedisCloudDatabases(
+          await this.getCapiCredentials(sessionMetadata, utm),
+          addDatabasesDto,
+        );
+      } catch (e) {
+        throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
+      }
+    });
   }
 }

redisinsight/api/src/modules/cloud/capi-key/cloud-capi-key.analytics.ts

@@ -25,4 +25,21 @@ export class CloudCapiKeyAnalytics extends TelemetryBaseService {
       exception,
     );
   }
+
+  sendCloudAccountSecretGenerated() {
+    try {
+      this.sendEvent(
+        TelemetryEvents.CloudAccountSecretGenerated,
+      );
+    } catch (e) {
+      // continue regardless of error
+    }
+  }
+
+  sendCloudAccountSecretGenerationFailed(exception: HttpException) {
+    this.sendFailedEvent(
+      TelemetryEvents.CloudAccountSecretGenerationFailed,
+      exception,
+    );
+  }
 }

redisinsight/api/src/modules/cloud/capi-key/cloud-capi-key.module.ts

@@ -23,6 +23,9 @@ import { CloudCapiKeyAnalytics } from 'src/modules/cloud/capi-key/cloud-capi-key
       useClass: LocalCloudCapiKeyRepository,
     },
   ],
-  exports: [CloudCapiKeyService],
+  exports: [
+    CloudCapiKeyService,
+    CloudCapiKeyApiProvider,
+  ],
 })
 export class CloudCapiKeyModule {}

redisinsight/api/src/modules/cloud/capi-key/cloud-capi-key.service.spec.ts

@@ -116,7 +116,7 @@ describe('CloudCapiKeyService', () => {
     });
     it('Should generate new capi key but enable CAPI before', async () => {
       repository.getByUserAccount.mockResolvedValueOnce(null);
-      cloudUserApiService.me.mockResolvedValueOnce({
+      cloudUserApiService.getCloudUser.mockResolvedValueOnce({
         ...mockCloudUser,
         capiKey: undefined,
         accounts: [{
@@ -133,17 +133,6 @@ describe('CloudCapiKeyService', () => {
       expect(mockedAxios.post)
         .toHaveBeenNthCalledWith(2, '/accounts/cloud-api/cloudApiKeys', expect.anything(), expect.anything());
     });
-    it('Should generate new capi key from 2nd attempt', async () => {
-      repository.getByUserAccount.mockResolvedValueOnce(null);
-      when(mockedAxios.post).calledWith('/accounts/cloud-api/cloudApiKeys', expect.anything(), expect.anything())
-        .mockRejectedValueOnce(mockCapiUnauthorizedError);
-
-      expect(await service['ensureCapiKeys'](mockSessionMetadata, mockUtm))
-        .toEqual(mockCloudUser.capiKey);
-      expect(mockedAxios.post).toHaveBeenCalledTimes(1);
-      expect(mockedAxios.post)
-        .toHaveBeenNthCalledWith(1, '/accounts/cloud-api/cloudApiKeys', expect.anything(), expect.anything());
-    });
     it('Should throw CloudCapiKeyUnauthorizedException if capiKey is not valid', async () => {
       repository.getByUserAccount.mockResolvedValueOnce({ ...mockCloudCapiKey, valid: false });
 
@@ -152,7 +141,7 @@ describe('CloudCapiKeyService', () => {
       expect(mockedAxios.post).toHaveBeenCalledTimes(0);
     });
     it('Should throw CloudApiBadRequestException', async () => {
-      cloudUserApiService.me.mockResolvedValue(null);
+      cloudUserApiService.getCloudUser.mockResolvedValue(null);
       CloudUserApiService.getCurrentAccount(null);
       await expect(service['ensureCapiKeys'](mockSessionMetadata, mockUtm))
         .rejects.toThrowError(CloudApiBadRequestException);