Merge pull request #1848 from RedisInsight/main

merge main

Author: egor-zalenski

redisinsight/api/src/modules/browser/services/redisearch/redisearch.service.spec.ts

@@ -303,5 +303,66 @@ describe('RedisearchService', () => {
         expect(e).toBeInstanceOf(ForbiddenException);
       }
     });
+    it('should call once "FT.CONFIG GET MAXSEARCHRESULTS" for all requests', async () => {
+      when(nodeClient.sendCommand)
+        .calledWith(jasmine.objectContaining({ name: 'FT.SEARCH' }))
+        .mockResolvedValue([100, keyName1, keyName2]);
+      when(nodeClient.sendCommand)
+        .calledWith(jasmine.objectContaining({ name: 'FT.CONFIG' }))
+        .mockResolvedValue([['MAXSEARCHRESULTS', '10000']]);
+
+      const res = await service.search(mockBrowserClientMetadata, mockSearchRedisearchDto);
+      await service.search(mockBrowserClientMetadata, mockSearchRedisearchDto);
+      await service.search(mockBrowserClientMetadata, mockSearchRedisearchDto);
+
+      expect(res).toEqual({
+        cursor: mockSearchRedisearchDto.limit + mockSearchRedisearchDto.offset,
+        scanned: 2,
+        total: 100,
+        maxResults: 10_000,
+        keys: [{
+          name: keyName1,
+        }, {
+          name: keyName2,
+        }],
+      });
+
+      expect(nodeClient.sendCommand).toHaveBeenCalledTimes(4);
+      expect(nodeClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining({
+        name: 'FT.SEARCH',
+        args: [
+          mockSearchRedisearchDto.index,
+          mockSearchRedisearchDto.query,
+          'NOCONTENT',
+          'LIMIT', `${mockSearchRedisearchDto.offset}`, `${mockSearchRedisearchDto.limit}`,
+        ],
+      }));
+      expect(nodeClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining({
+        name: 'FT.CONFIG',
+        args: [
+          'GET',
+          'MAXSEARCHRESULTS',
+        ],
+      }));
+      expect(nodeClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining({
+        name: 'FT.SEARCH',
+        args: [
+          mockSearchRedisearchDto.index,
+          mockSearchRedisearchDto.query,
+          'NOCONTENT',
+          'LIMIT', `${mockSearchRedisearchDto.offset}`, `${mockSearchRedisearchDto.limit}`,
+        ],
+      }));
+      expect(nodeClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining({
+        name: 'FT.SEARCH',
+        args: [
+          mockSearchRedisearchDto.index,
+          mockSearchRedisearchDto.query,
+          'NOCONTENT',
+          'LIMIT', `${mockSearchRedisearchDto.offset}`, `${mockSearchRedisearchDto.limit}`,
+        ],
+      }));
+      expect(browserHistory.create).toHaveBeenCalled();
+    });
   });
 });

redisinsight/api/src/modules/browser/services/redisearch/redisearch.service.ts

@@ -1,5 +1,5 @@
 import { Cluster, Command, Redis } from 'ioredis';
-import { toNumber, uniq } from 'lodash';
+import { isNull, toNumber, uniq } from 'lodash';
 import {
   BadRequestException,
   ConflictException,
@@ -26,6 +26,8 @@ import { CreateBrowserHistoryDto } from '../../dto/browser-history/create.browse
 
 @Injectable()
 export class RedisearchService {
+  private maxSearchResults: number | null = null;
+
   private logger = new Logger('RedisearchService');
 
   constructor(
@@ -145,30 +147,30 @@ export class RedisearchService {
     this.logger.log('Searching keys using redisearch.');
 
     try {
-      let maxResults;
       const {
         index, query, offset, limit,
       } = dto;
 
       const client = await this.browserTool.getRedisClient(clientMetadata);
 
-      try {
-        const [[, maxSearchResults]] = await client.sendCommand(
-          // response: [ [ 'MAXSEARCHRESULTS', '10000' ] ]
-          new Command('FT.CONFIG', ['GET', 'MAXSEARCHRESULTS'], {
-            replyEncoding: 'utf8',
-          }),
-        ) as [[string, string]];
-
-        maxResults = toNumber(maxSearchResults);
-      } catch (error) {
-        maxResults = null;
+      if (isNull(this.maxSearchResults)) {
+        try {
+          const [[, maxSearchResults]] = await client.sendCommand(
+            // response: [ [ 'MAXSEARCHRESULTS', '10000' ] ]
+            new Command('FT.CONFIG', ['GET', 'MAXSEARCHRESULTS'], {
+              replyEncoding: 'utf8',
+            }),
+          ) as [[string, string]];
+
+          this.maxSearchResults = toNumber(maxSearchResults);
+        } catch (error) {
+          this.maxSearchResults = null;
+        }
       }
-
       // Workaround: recalculate limit to not query more then MAXSEARCHRESULTS
       let safeLimit = limit;
-      if (maxResults && offset + limit > maxResults) {
-        safeLimit = offset <= maxResults ? maxResults - offset : limit;
+      if (this.maxSearchResults && offset + limit > this.maxSearchResults) {
+        safeLimit = offset <= this.maxSearchResults ? this.maxSearchResults - offset : limit;
       }
 
       const [total, ...keyNames] = await client.sendCommand(
@@ -191,7 +193,7 @@ export class RedisearchService {
         total,
         scanned: keyNames.length + offset,
         keys: keyNames.map((name) => ({ name })),
-        maxResults,
+        maxResults: this.maxSearchResults,
       });
     } catch (e) {
       this.logger.error('Failed to search keys using redisearch index', e);

redisinsight/api/src/modules/database/providers/database-overview.provider.spec.ts

@@ -57,7 +57,7 @@ const mockNodeInfo = {
   keyspace: mockKeyspace,
 };
 
-const mockGetTotalResponse_1 = 1;
+const mockGetTotalResponse1 = 1;
 
 export const mockDatabaseOverview: DatabaseOverview = {
   version: mockServerInfo.redis_version,
@@ -127,6 +127,42 @@ describe('OverviewService', () => {
           totalKeysPerDb: undefined,
         });
       });
+      it('should return total 3 and empty total per db object (even when role is not master)', async () => {
+        spyGetNodeInfo.mockResolvedValueOnce({
+          ...mockNodeInfo,
+          replication: {
+            role: 'slave',
+          },
+          keyspace: {
+            db0: 'keys=3,expires=0,avg_ttl=0',
+          },
+        });
+
+        expect(await service.getOverview(mockClientMetadata, mockClient)).toEqual({
+          ...mockDatabaseOverview,
+          totalKeys: 3,
+          totalKeysPerDb: undefined,
+        });
+      });
+      it('should not return particular fields when metrics are not available', async () => {
+        spyGetNodeInfo.mockResolvedValueOnce({
+          ...mockNodeInfo,
+          replication: {
+            role: 'slave',
+          },
+          keyspace: undefined,
+          memory: undefined,
+          clients: undefined,
+        });
+
+        expect(await service.getOverview(mockClientMetadata, mockClient)).toEqual({
+          ...mockDatabaseOverview,
+          totalKeys: undefined,
+          usedMemory: undefined,
+          totalKeysPerDb: undefined,
+          connectedClients: undefined,
+        });
+      });
       it('check for cpu on second attempt', async () => {
         spyGetNodeInfo.mockResolvedValueOnce(mockNodeInfo);
         spyGetNodeInfo.mockResolvedValueOnce({
@@ -197,7 +233,7 @@ describe('OverviewService', () => {
     });
     describe('Cluster', () => {
       it('Should calculate overview and ignore replica where needed', async () => {
-        const getTotal = jest.spyOn(Utils, 'getTotal').mockResolvedValue(mockGetTotalResponse_1);
+        const getTotal = jest.spyOn(Utils, 'getTotal').mockResolvedValue(mockGetTotalResponse1);
         mockCluster.nodes = jest.fn()
           .mockReturnValue(new Array(6).fill(Promise.resolve()));
 

redisinsight/api/src/modules/database/providers/database-overview.provider.ts

@@ -187,9 +187,7 @@ export class DatabaseOverviewProvider {
    */
   private calculateUsedMemory(nodes = []): number {
     try {
-      const masterNodes = filter(nodes, (node) => ['master', undefined].includes(
-        get(node, 'replication.role'),
-      ));
+      const masterNodes = DatabaseOverviewProvider.getMasterNodesToWorkWith(nodes);
 
       if (!this.isMetricsAvailable(masterNodes, 'memory.used_memory', [undefined])) {
         return undefined;
@@ -209,14 +207,12 @@ export class DatabaseOverviewProvider {
    * @private
    */
   private calculateTotalKeys(nodes = [], index: number): [number, Record<string, number>] {
-    if (!this.isMetricsAvailable(nodes, 'keyspace', [undefined])) {
-      return [undefined, undefined];
-    }
-
     try {
-      const masterNodes = filter(nodes, (node) => ['master', undefined].includes(
-        get(node, 'replication.role'),
-      ));
+      const masterNodes = DatabaseOverviewProvider.getMasterNodesToWorkWith(nodes);
+
+      if (!this.isMetricsAvailable(masterNodes, 'keyspace', [undefined])) {
+        return [undefined, undefined];
+      }
 
       const totalKeysPerDb = {};
 
@@ -334,4 +330,16 @@ export class DatabaseOverviewProvider {
 
     return true;
   }
+
+  static getMasterNodesToWorkWith(nodes = []): any[] {
+    let masterNodes = nodes;
+
+    if (nodes?.length > 1) {
+      masterNodes = filter(nodes, (node) => ['master', undefined].includes(
+        get(node, 'replication.role'),
+      ));
+    }
+
+    return masterNodes;
+  }
 }