enhance provider

Author: arthosofteq

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

@@ -167,7 +167,6 @@ describe('DatabaseService', () => {
         ...mockDatabase,
         port: 6380,
         password: 'password',
-        provider: 'LOCALHOST',
       });
 
       expect(await service.update(
@@ -240,7 +239,6 @@ describe('DatabaseService', () => {
         port: 6380,
         password: 'password',
         connectionType: 'STANDALONE',
-        provider: 'LOCALHOST',
         new: false,
         version: '7.0',
         ssh: true,

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

@@ -9,7 +9,7 @@ import ERROR_MESSAGES from 'src/constants/error-messages';
 import { DatabaseRepository } from 'src/modules/database/repositories/database.repository';
 import { DatabaseAnalytics } from 'src/modules/database/database.analytics';
 import {
-  catchRedisConnectionError, classToClass, getHostingProvider, getRedisConnectionException,
+  catchRedisConnectionError, classToClass, getRedisConnectionException,
 } from 'src/utils';
 import { CreateDatabaseDto } from 'src/modules/database/dto/create.database.dto';
 import { DatabaseInfoProvider } from 'src/modules/database/providers/database-info.provider';
@@ -55,6 +55,11 @@ export class DatabaseService {
     'clientCert',
   ];
 
+  static endpointFields: string[] = [
+    'host',
+    'port',
+  ];
+
   constructor(
     private repository: DatabaseRepository,
     private redisClientStorage: RedisClientStorage,
@@ -69,6 +74,10 @@ export class DatabaseService {
     return Object.keys(omitBy(dto, isUndefined)).some((field) => this.connectionFields.includes(field));
   }
 
+  static isEndpointAffected(dto: object) {
+    return Object.keys(omitBy(dto, isUndefined)).some((field) => this.endpointFields.includes(field));
+  }
+
   private async merge(database: Database, dto: UpdateDatabaseDto): Promise<Database> {
     const updatedDatabase = database;
     if (dto?.caCert) {
@@ -184,13 +193,12 @@ export class DatabaseService {
       database = await this.merge(oldDatabase, dto);
 
       if (DatabaseService.isConnectionAffected(dto)) {
-        database = await this.databaseFactory.createDatabaseModel(database);
-
-        // todo: investigate manual update flag
-        if (manualUpdate) {
-          database.provider = getHostingProvider(database.host);
+        if (DatabaseService.isEndpointAffected(dto)) {
+          database.provider = undefined;
         }
 
+        database = await this.databaseFactory.createDatabaseModel(database);
+
         await this.redisClientStorage.removeManyByMetadata({ databaseId: id });
       }
 

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

@@ -10,13 +10,22 @@ import { SshOptionsEntity } from 'src/modules/ssh/entities/ssh-options.entity';
 import { CloudDatabaseDetailsEntity } from 'src/modules/cloud/database/entities/cloud-database-details.entity';
 
 export enum HostingProvider {
-  UNKNOWN = 'UNKNOWN',
-  LOCALHOST = 'LOCALHOST',
   RE_CLUSTER = 'RE_CLUSTER',
   RE_CLOUD = 'RE_CLOUD',
+  REDIS_MANAGED = 'REDIS_MANAGED',
   AZURE = 'AZURE',
-  AWS = 'AWS',
-  GOOGLE = 'GOOGLE',
+  COMMUNITY_EDITION = 'COMMUNITY_EDITION',
+  AWS_ELASTICACHE = 'AWS_ELASTICACHE',
+  AWS_MEMORYDB = 'AWS_MEMORYDB',
+  VALKEY = 'VALKEY',
+  MEMORYSTORE = 'MEMORYSTORE',
+  DRAGONFLY = 'DRAGONFLY',
+  KEYDB = 'KEYDB',
+  GARNET = 'GARNET',
+  KVROCKS = 'KVROCKS',
+  REDICT = 'REDICT',
+  UPSTASH = 'UPSTASH',
+  UNKNOWN = 'UNKNOWN',
 }
 
 export enum ConnectionType {

redisinsight/api/src/modules/database/providers/database.factory.ts

@@ -1,5 +1,5 @@
 import { Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { ConnectionType } from 'src/modules/database/entities/database.entity';
+import { ConnectionType, HostingProvider } from 'src/modules/database/entities/database.entity';
 import { catchRedisConnectionError, getHostingProvider } from 'src/utils';
 import { Database } from 'src/modules/database/models/database';
 import { ClientContext, SessionMetadata } from 'src/common/models';
@@ -42,6 +42,10 @@ export class DatabaseFactory {
       { useRetry: true },
     );
 
+    if (!HostingProvider[model.provider]) {
+      model.provider = await getHostingProvider(client, model.host);
+    }
+
     if (await isSentinel(client)) {
       if (!database.sentinelMaster) {
         throw new Error(RedisErrorCodes.SentinelParamsRequired);
@@ -72,10 +76,6 @@ export class DatabaseFactory {
 
     model.connectionType = ConnectionType.STANDALONE;
 
-    if (!model.provider) {
-      model.provider = getHostingProvider(model.host);
-    }
-
     // fetch ca cert if needed to be able to connect
     if (model.caCert?.id) {
       model.caCert = await this.caCertificateService.get(model.caCert?.id);

redisinsight/api/src/utils/hosting-provider-helper.spec.ts

@@ -1,32 +1,123 @@
 import { HostingProvider } from 'src/modules/database/entities/database.entity';
+import { mockStandaloneRedisClient } from 'src/__mocks__';
 import { getHostingProvider } from './hosting-provider-helper';
 
 const getHostingProviderTests = [
-  { input: '127.0.0.1', output: HostingProvider.LOCALHOST },
-  { input: '0.0.0.0', output: HostingProvider.LOCALHOST },
-  { input: 'localhost', output: HostingProvider.LOCALHOST },
-  { input: '172.18.0.2', output: HostingProvider.LOCALHOST },
+  { input: '127.0.0.1', output: HostingProvider.COMMUNITY_EDITION },
+  { input: '0.0.0.0', output: HostingProvider.COMMUNITY_EDITION },
+  { input: 'localhost', output: HostingProvider.COMMUNITY_EDITION },
+  { input: '172.18.0.2', output: HostingProvider.COMMUNITY_EDITION },
   { input: '176.87.56.244', output: HostingProvider.UNKNOWN },
   { input: '192.12.56.244', output: HostingProvider.UNKNOWN },
   { input: '255.255.56.244', output: HostingProvider.UNKNOWN },
   { input: 'redis', output: HostingProvider.UNKNOWN },
   { input: 'demo-redislabs.rlrcp.com', output: HostingProvider.RE_CLOUD },
+  { input: 'memorydb.aws.com', output: HostingProvider.AWS_MEMORYDB },
   {
     input: 'redis-16781.c273.us-east-1-2.ec2.cloud.redislabs.com',
     output: HostingProvider.RE_CLOUD,
   },
   {
     input: 'askubuntu.mki5tz.0001.use1.cache.amazonaws.com',
-    output: HostingProvider.AWS,
+    output: HostingProvider.AWS_ELASTICACHE,
   },
   { input: 'contoso5.redis.cache.windows.net', output: HostingProvider.AZURE },
   { input: 'demo-redis-provider.unknown.com', output: HostingProvider.UNKNOWN },
+  {
+    input: 'localhost',
+    hello: [
+      'server', 'redis',
+      'modules', [
+        [
+          'name', 'search',
+          'path', '/enterprise-managed',
+        ],
+      ],
+    ],
+    info: '#Server\r\n'
+      + 'redis_version: 7.2.0',
+    output: HostingProvider.REDIS_MANAGED,
+  },
+  {
+    input: 'localhost',
+    hello: [
+      'server', 'redis',
+      'modules', [
+        [
+          'name', 'search',
+          'path', 'google',
+        ],
+      ],
+    ],
+    output: HostingProvider.MEMORYSTORE,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'server_name:valkey',
+    output: HostingProvider.VALKEY,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'dragonfly_version:df-7.0.0',
+    output: HostingProvider.DRAGONFLY,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'garnet_version:gr-7.0.0',
+    output: HostingProvider.GARNET,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'kvrocks_version:kv-7.0.0',
+    output: HostingProvider.KVROCKS,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'redict_version:rd-7.0.0',
+    output: HostingProvider.REDICT,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'upstash_version:up-7.0.0',
+    output: HostingProvider.UPSTASH,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'ElastiCache:sometinhg',
+    output: HostingProvider.AWS_ELASTICACHE,
+  },
+  {
+    input: 'localhost',
+    info: '#Server\r\n'
+      + 'MemoryDB:sometinhg',
+    output: HostingProvider.AWS_MEMORYDB,
+  },
+  {
+    input: 'localhost',
+    info: '#KeyDb\r\n'
+      + 'some:data',
+    output: HostingProvider.KEYDB,
+  },
 ];
 
 describe('getHostingProvider', () => {
+  beforeEach(() => {
+    mockStandaloneRedisClient.sendCommand.mockReset();
+  });
+
   getHostingProviderTests.forEach((test) => {
     it(`should be output: ${test.output} for input: ${test.input} `, async () => {
-      const result = getHostingProvider(test.input);
+      mockStandaloneRedisClient.sendCommand.mockResolvedValueOnce(test.hello);
+      mockStandaloneRedisClient.sendCommand.mockResolvedValueOnce(test.info);
+
+      const result = await getHostingProvider(mockStandaloneRedisClient, test.input);
 
       expect(result).toEqual(test.output);
     });

redisinsight/api/src/utils/hosting-provider-helper.ts

@@ -1,25 +1,101 @@
 import { IP_ADDRESS_REGEX, PRIVATE_IP_ADDRESS_REGEX } from 'src/constants';
 import { HostingProvider } from 'src/modules/database/entities/database.entity';
+import { RedisClient } from 'src/modules/redis/client';
 
 // Ignore LGTM [js/incomplete-url-substring-sanitization] alert.
 // Because we do not bind potentially dangerous logic to this.
 // We define a hosting provider for telemetry only.
-export const getHostingProvider = (host: string): HostingProvider => {
-  // Tries to detect the hosting provider from the hostname.
-  if (host === '0.0.0.0' || host === 'localhost') {
-    return HostingProvider.LOCALHOST;
-  }
-  if (IP_ADDRESS_REGEX.test(host) && PRIVATE_IP_ADDRESS_REGEX.test(host)) {
-    return HostingProvider.LOCALHOST;
-  }
-  if (host.endsWith('rlrcp.com') || host.endsWith('redislabs.com')) { // lgtm[js/incomplete-url-substring-sanitization]
-    return HostingProvider.RE_CLOUD;
-  }
-  if (host.endsWith('cache.amazonaws.com')) { // lgtm[js/incomplete-url-substring-sanitization]
-    return HostingProvider.AWS;
-  }
-  if (host.endsWith('cache.windows.net')) { // lgtm[js/incomplete-url-substring-sanitization]
-    return HostingProvider.AZURE;
+export const getHostingProvider = async (client: RedisClient, databaseHost: string): Promise<HostingProvider> => {
+  try {
+    const host = databaseHost.toLowerCase();
+
+    // Tries to detect the hosting provider from the hostname.
+    if (host.endsWith('rlrcp.com') || host.endsWith('redislabs.com')) { // lgtm[js/incomplete-url-substring-sanitization]
+      return HostingProvider.RE_CLOUD;
+    }
+    if (host.endsWith('cache.amazonaws.com')) { // lgtm[js/incomplete-url-substring-sanitization]
+      return HostingProvider.AWS_ELASTICACHE;
+    }
+    if (host.includes('memorydb')) {
+      return HostingProvider.AWS_MEMORYDB;
+    }
+    if (host.endsWith('cache.windows.net')) { // lgtm[js/incomplete-url-substring-sanitization]
+      return HostingProvider.AZURE;
+    }
+
+    try {
+      const hello = JSON.stringify(await client.sendCommand(
+        ['hello'],
+        { replyEncoding: 'utf8' },
+      ) as string[]).toLowerCase();
+
+      if (hello.includes('/enterprise-managed')) {
+        return HostingProvider.REDIS_MANAGED;
+      }
+
+      if (hello.includes('google')) {
+        return HostingProvider.MEMORYSTORE;
+      }
+    } catch (e) {
+      // ignore errors
+    }
+
+    try {
+      const info = (await client.sendCommand(
+        ['info'],
+        { replyEncoding: 'utf8' },
+      ) as string).toLowerCase();
+
+      if (info.includes('elasticache')) {
+        return HostingProvider.AWS_ELASTICACHE;
+      }
+
+      if (info.includes('memorydb')) {
+        return HostingProvider.AWS_MEMORYDB;
+      }
+
+      if (info.includes('keydb')) {
+        return HostingProvider.KEYDB;
+      }
+
+      if (info.includes('valkey')) {
+        return HostingProvider.VALKEY;
+      }
+
+      if (info.includes('dragonfly_version')) {
+        return HostingProvider.DRAGONFLY;
+      }
+
+      if (info.includes('garnet_version')) {
+        return HostingProvider.GARNET;
+      }
+
+      if (info.includes('kvrocks_version')) {
+        return HostingProvider.KVROCKS;
+      }
+
+      if (info.includes('redict_version')) {
+        return HostingProvider.REDICT;
+      }
+
+      if (info.includes('upstash_version')) {
+        return HostingProvider.UPSTASH;
+      }
+    } catch (e) {
+      // ignore error
+    }
+
+    if (host === '0.0.0.0' || host === 'localhost' || host === '127.0.0.1') {
+      return HostingProvider.COMMUNITY_EDITION;
+    }
+
+    // todo: investigate weather we need this
+    if (IP_ADDRESS_REGEX.test(host) && PRIVATE_IP_ADDRESS_REGEX.test(host)) {
+      return HostingProvider.COMMUNITY_EDITION;
+    }
+  } catch (e) {
+    // ignore any error
   }
+
   return HostingProvider.UNKNOWN;
 };