resolve merge conflicts

Author: Artem

redisinsight/api/src/__mocks__/database-import.ts

@@ -62,3 +62,7 @@ export const mockDatabaseImportAnalytics = jest.fn(() => ({
   sendImportResults: jest.fn(),
   sendImportFailed: jest.fn(),
 }));
+
+export const mockCertificateImportService = jest.fn(() => {
+
+});

redisinsight/api/src/modules/database-import/database-import.service.spec.ts

@@ -1,6 +1,7 @@
 import { pick } from 'lodash';
 import { DatabaseImportService } from 'src/modules/database-import/database-import.service';
 import {
+  mockCertificateImportService,
   mockDatabase,
   mockDatabaseImportAnalytics,
   mockDatabaseImportFile,
@@ -14,9 +15,11 @@ import { ConnectionType } from 'src/modules/database/entities/database.entity';
 import { BadRequestException, ForbiddenException } from '@nestjs/common';
 import { ValidationError } from 'class-validator';
 import {
-  NoDatabaseImportFileProvidedException, SizeLimitExceededDatabaseImportFileException,
+  NoDatabaseImportFileProvidedException,
+  SizeLimitExceededDatabaseImportFileException,
   UnableToParseDatabaseImportFileException,
 } from 'src/modules/database-import/exceptions';
+import { CertificateImportService } from 'src/modules/database-import/certificate-import.service';
 
 describe('DatabaseImportService', () => {
   let service: DatabaseImportService;
@@ -36,6 +39,10 @@ describe('DatabaseImportService', () => {
             create: jest.fn().mockResolvedValue(mockDatabase),
           })),
         },
+        {
+          provide: CertificateImportService,
+          useFactory: mockCertificateImportService,
+        },
         {
           provide: DatabaseImportAnalytics,
           useFactory: mockDatabaseImportAnalytics,
@@ -154,6 +161,7 @@ describe('DatabaseImportService', () => {
     it('should create cluster database', async () => {
       await service['createDatabase']({
         ...mockDatabase,
+        connectionType: undefined,
         cluster: true,
       }, 0);
 
@@ -163,4 +171,64 @@ describe('DatabaseImportService', () => {
       });
     });
   });
+
+  describe('determineConnectionType', () => {
+    const tcs = [
+      // common
+      { input: {}, output: ConnectionType.NOT_CONNECTED },
+      // isCluster
+      { input: { isCluster: true }, output: ConnectionType.CLUSTER },
+      { input: { isCluster: false }, output: ConnectionType.NOT_CONNECTED },
+      { input: { isCluster: undefined }, output: ConnectionType.NOT_CONNECTED },
+      // sentinelMasterName
+      { input: { sentinelMasterName: 'some name' }, output: ConnectionType.SENTINEL },
+      // connectionType
+      { input: { connectionType: ConnectionType.STANDALONE }, output: ConnectionType.STANDALONE },
+      { input: { connectionType: ConnectionType.CLUSTER }, output: ConnectionType.CLUSTER },
+      { input: { connectionType: ConnectionType.SENTINEL }, output: ConnectionType.SENTINEL },
+      { input: { connectionType: 'something not supported' }, output: ConnectionType.NOT_CONNECTED },
+      // type
+      { input: { type: 'standalone' }, output: ConnectionType.STANDALONE },
+      { input: { type: 'cluster' }, output: ConnectionType.CLUSTER },
+      { input: { type: 'sentinel' }, output: ConnectionType.SENTINEL },
+      { input: { type: 'something not supported' }, output: ConnectionType.NOT_CONNECTED },
+      // priority tests
+      {
+        input: {
+          connectionType: ConnectionType.SENTINEL,
+          type: 'standalone',
+          isCluster: true,
+          sentinelMasterName: 'some name',
+        },
+        output: ConnectionType.SENTINEL,
+      },
+      {
+        input: {
+          type: 'standalone',
+          isCluster: true,
+          sentinelMasterName: 'some name',
+        },
+        output: ConnectionType.STANDALONE,
+      },
+      {
+        input: {
+          isCluster: true,
+          sentinelMasterName: 'some name',
+        },
+        output: ConnectionType.CLUSTER,
+      },
+      {
+        input: {
+          sentinelMasterName: 'some name',
+        },
+        output: ConnectionType.SENTINEL,
+      },
+    ];
+
+    tcs.forEach((tc) => {
+      it(`should return ${tc.output} when called with ${JSON.stringify(tc.input)}`, () => {
+        expect(DatabaseImportService.determineConnectionType(tc.input)).toEqual(tc.output);
+      });
+    });
+  });
 });

redisinsight/api/src/modules/database-import/database-import.service.ts

@@ -37,13 +37,20 @@ export class DatabaseImportService {
     ['port', ['port']],
     ['db', ['db']],
     ['isCluster', ['cluster']],
+    ['type', ['type']],
+    ['connectionType', ['connectionType']],
     ['tls', ['tls', 'ssl']],
-    ['tlsServername', ['tlsServername', 'sni_name', 'sni_server_name']],
+    ['tlsServername', ['tlsServername']],
     ['tlsCaName', ['caCert.name']],
-    ['tlsCaCert', ['caCert.certificate', 'sslOptions.ca', 'ssl_ca_cert_path']],
+    ['tlsCaCert', ['caCert.certificate', 'caCert', 'sslOptions.ca', 'ssl_ca_cert_path']],
     ['tlsClientName', ['clientCert.name']],
-    ['tlsClientCert', ['clientCert.certificate', 'sslOptions.cert', 'ssl_local_cert_path']],
-    ['tlsClientKey', ['clientCert.key', 'sslOptions.key', 'ssl_private_key_path']],
+    ['tlsClientCert', ['clientCert.certificate', 'certificate', 'sslOptions.cert', 'ssl_local_cert_path']],
+    ['tlsClientKey', ['clientCert.key', 'keyFile', 'sslOptions.key', 'ssl_private_key_path']],
+    ['sentinelMasterName', ['sentinelMaster.name', 'sentinelOptions.masterName', 'sentinelOptions.name']],
+    ['sentinelMasterUsername', ['sentinelMaster.username']],
+    ['sentinelMasterPassword', [
+      'sentinelMaster.password', 'sentinelOptions.nodePassword', 'sentinelOptions.sentinelPassword',
+    ]],
   ];
 
   constructor(
@@ -83,6 +90,8 @@ export class DatabaseImportService {
         fail: [],
       };
 
+      console.log('___ items', items);
+
       // it is very important to insert databases on-by-one to avoid db constraint errors
       await items.reduce((prev, item, index) => prev.finally(() => this.createDatabase(item, index)
         .then((result) => {
@@ -144,11 +153,18 @@ export class DatabaseImportService {
         data.name = `${data.host}:${data.port}`;
       }
 
-      // determine database type
-      if (data.isCluster) {
-        data.connectionType = ConnectionType.CLUSTER;
-      } else {
-        data.connectionType = ConnectionType.STANDALONE;
+      data.connectionType = DatabaseImportService.determineConnectionType(data);
+
+      if (data?.sentinelMasterName) {
+        data.sentinelMaster = {
+          name: data.sentinelMasterName,
+          username: data.sentinelMasterUsername,
+          password: data.sentinelMasterPassword,
+        };
+        data.nodes = [{
+          host: data.host,
+          port: parseInt(data.port, 10),
+        }];
       }
 
       if (data?.tlsCaCert) {
@@ -237,6 +253,49 @@ export class DatabaseImportService {
     }
   }
 
+  /**
+   * Try to determine connection type based on input data
+   * Should return NOT_CONNECTED when it is not possible
+   * @param data
+   */
+  static determineConnectionType(data: any = {}): ConnectionType {
+    if (data?.connectionType) {
+      switch (data.connectionType) {
+        case ConnectionType.CLUSTER:
+          return ConnectionType.CLUSTER;
+        case ConnectionType.SENTINEL:
+          return ConnectionType.SENTINEL;
+        case ConnectionType.STANDALONE:
+          return ConnectionType.STANDALONE;
+        default:
+          return ConnectionType.NOT_CONNECTED;
+      }
+    }
+
+    if (data?.type) {
+      switch (data.type) {
+        case 'cluster':
+          return ConnectionType.CLUSTER;
+        case 'sentinel':
+          return ConnectionType.SENTINEL;
+        case 'standalone':
+          return ConnectionType.STANDALONE;
+        default:
+          return ConnectionType.NOT_CONNECTED;
+      }
+    }
+
+    if (data?.isCluster === true) {
+      return ConnectionType.CLUSTER;
+    }
+
+    if (data?.sentinelMasterName) {
+      return ConnectionType.SENTINEL;
+    }
+
+    return ConnectionType.NOT_CONNECTED;
+  }
+
   /**
    * Try to parse file based on mimetype and known\supported formats
    * @param file

redisinsight/api/src/modules/database-import/dto/import.database.dto.ts

@@ -13,7 +13,7 @@ import { UseClientCertificateDto } from 'src/modules/certificate/dto/use.client-
 
 export class ImportDatabaseDto extends PickType(Database, [
   'host', 'port', 'name', 'db', 'username', 'password',
-  'connectionType', 'tls', 'verifyServerCert',
+  'connectionType', 'tls', 'verifyServerCert', 'sentinelMaster', 'nodes',
 ] as const) {
   @Expose()
   @IsNotEmpty()
@@ -43,5 +43,4 @@ export class ImportDatabaseDto extends PickType(Database, [
   @Type(clientCertTransformer)
   @ValidateNested()
   clientCert?: CreateClientCertificateDto | UseClientCertificateDto;
-
 }

redisinsight/api/src/modules/database/database-connection.service.ts

@@ -9,6 +9,7 @@ import { ClientMetadata } from 'src/modules/redis/models/client-metadata';
 import { DatabaseService } from 'src/modules/database/database.service';
 import { DatabaseInfoProvider } from 'src/modules/database/providers/database-info.provider';
 import { Database } from 'src/modules/database/models/database';
+import { ConnectionType } from 'src/modules/database/entities/database.entity';
 
 @Injectable()
 export class DatabaseConnectionService {
@@ -111,11 +112,29 @@ export class DatabaseConnectionService {
     const connectionName = generateRedisConnectionName(clientMetadata.namespace, clientMetadata.databaseId);
 
     try {
-      return await this.redisService.connectToDatabaseInstance(
+      const client = await this.redisService.connectToDatabaseInstance(
         database,
         clientMetadata.namespace,
         connectionName,
       );
+
+      if (database.connectionType === ConnectionType.NOT_CONNECTED) {
+        let connectionType = ConnectionType.STANDALONE;
+
+        // cluster check
+        if (client.isCluster) {
+          connectionType = ConnectionType.CLUSTER;
+        }
+
+        // sentinel check
+        if (client?.options?.['sentinels']?.length) {
+          connectionType = ConnectionType.SENTINEL;
+        }
+
+        await this.repository.update(database.id, { connectionType });
+      }
+
+      return client;
     } catch (error) {
       this.logger.error('Failed to create database client', error);
       const exception = getRedisConnectionException(

redisinsight/api/src/modules/database/entities/database.entity.ts

@@ -21,6 +21,7 @@ export enum ConnectionType {
   STANDALONE = 'STANDALONE',
   CLUSTER = 'CLUSTER',
   SENTINEL = 'SENTINEL',
+  NOT_CONNECTED = 'NOT CONNECTED',
 }
 
 @Entity('database_instance')

redisinsight/api/src/modules/database/models/database.ts

@@ -142,6 +142,8 @@ export class Database {
     type: Endpoint,
     isArray: true,
   })
+  @IsOptional()
+  @Type(() => Endpoint)
   @Expose()
   nodes?: Endpoint[];
 

redisinsight/api/src/modules/redis/redis.service.ts

@@ -195,12 +195,34 @@ export class RedisService {
         client = await this.createSentinelClient(database, nodes, tool, true, connectionName);
         break;
       default:
-        client = await this.createStandaloneClient(database, tool, true, connectionName);
+        // AUTO
+        client = await this.createClientAutomatically(database, tool, connectionName);
     }
 
     return client;
   }
 
+  public async createClientAutomatically(database: Database, tool: AppTool, connectionName) {
+    // try sentinel connection
+    if (database?.sentinelMaster) {
+      try {
+        return await this.createSentinelClient(database, database.nodes, tool, true, connectionName);
+      } catch (e) {
+        // ignore error
+      }
+    }
+
+    // try cluster connection
+    try {
+      return await this.createClusterClient(database, database.nodes, true, connectionName);
+    } catch (e) {
+      // ignore error
+    }
+
+    // Standalone in any other case
+    return this.createStandaloneClient(database, tool, true, connectionName);
+  }
+
   public isClientConnected(client: Redis | Cluster): boolean {
     try {
       return client.status === 'ready';