[Search] Session SO polling

src/core/server/ui_settings/create_or_upgrade_saved_config/create_or_upgrade_saved_config.test.ts

@@ -19,10 +19,10 @@
 
 import Chance from 'chance';
 
+import { getUpgradeableConfigMock } from './get_upgradeable_config.test.mock';
 import { SavedObjectsErrorHelpers } from '../../saved_objects';
 import { savedObjectsClientMock } from '../../saved_objects/service/saved_objects_client.mock';
 import { loggingSystemMock } from '../../logging/logging_system.mock';
-import { getUpgradeableConfigMock } from './get_upgradeable_config.test.mock';
 
 import { createOrUpgradeSavedConfig } from './create_or_upgrade_saved_config';
 

src/plugins/data/server/search/search_service.ts

@@ -108,13 +108,15 @@ export class SearchService implements Plugin<ISearchSetup, ISearchStart> {
  private readonly searchSourceService = new SearchSourceService();
  private defaultSearchStrategyName: string = ES_SEARCH_STRATEGY;
  private searchStrategies: StrategyMap = {};
+ private sessionService: BackgroundSessionService;
  private coreStart?: CoreStart;
- private sessionService: BackgroundSessionService = new BackgroundSessionService();
 
  constructor(
  private initializerContext: PluginInitializerContext<ConfigSchema>,
  private readonly logger: Logger
- ) {}
+ ) {
+ this.sessionService = new BackgroundSessionService(logger);
+ }
 
  public setup(
  core: CoreSetup<{}, DataPluginStart>,
@@ -230,6 +232,7 @@ export class SearchService implements Plugin<ISearchSetup, ISearchStart> {
  ): ISearchStart {
  const { elasticsearch, savedObjects, uiSettings } = core;
  const asScoped = this.asScopedProvider(core);
+ this.sessionService.start(core);
  return {
  aggs: this.aggsService.start({
  fieldFormats,

src/plugins/data/server/search/session/session_service.test.ts

@@ -17,16 +17,82 @@
  * under the License.
  */
 
-import type { SavedObject, SavedObjectsClientContract } from 'kibana/server';
+import { coreMock } from 'src/core/server/mocks';
+import type { SavedObject, SavedObjectsClientContract } from 'src/core/server';
 import { savedObjectsClientMock } from '../../../../../core/server/mocks';
 import { BackgroundSessionStatus } from '../../../common';
 import { BACKGROUND_SESSION_TYPE } from '../../saved_objects';
-import { BackgroundSessionService } from './session_service';
+import {
+ BackgroundSessionService,
+ INMEM_TRACKING_INTERVAL,
+ MAX_UPDATE_RETRIES,
+ SessionInfo,
+} from './session_service';
 import { createRequestHash } from './utils';
+import moment from 'moment';
 
 describe('BackgroundSessionService', () => {
  let savedObjectsClient: jest.Mocked<SavedObjectsClientContract>;
  let service: BackgroundSessionService;
+ const mockCoreStart = coreMock.createStart();
+
+ const MOCK_SESSION_ID = 'session-id-mock';
+ const MOCK_ASYNC_ID = '123456';
+ const MOCK_KEY_HASH = '608de49a4600dbb5b173492759792e4a';
+
+ const createMockInternalSavedObjectClient = (
+ bulkGetSpy?: jest.SpyInstance<any>,
+ bulkUpdateSpy?: jest.SpyInstance<any>
+ ) => {
+ Object.defineProperty(service, 'internalSavedObjectsClient', {
+ get: () => {
+ const bulkGet =
+ bulkGetSpy ||
+ (() => {
+ return {
+ saved_objects: [
+ {
+ attributes: {
+ sessionId: MOCK_SESSION_ID,
+ idMapping: {
+ 'another-key': 'another-async-id',
+ },
+ },
+ id: MOCK_SESSION_ID,
+ version: '1',
+ },
+ ],
+ };
+ });
+
+ const bulkUpdate =
+ bulkUpdateSpy ||
+ (() => {
+ return {
+ saved_objects: [],
+ };
+ });
+ return {
+ bulkGet,
+ bulkUpdate,
+ };
+ },
+ });
+ };
+
+ const createMockIdMapping = (
+ mapValues: any[],
+ insertTime?: moment.Moment,
+ retryCount?: number
+ ): Map<string, SessionInfo> => {
+ const fakeMap = new Map();
+ fakeMap.set(MOCK_SESSION_ID, {
+ ids: new Map(mapValues),
+ insertTime: insertTime || moment(),
+ retryCount: retryCount || 0,
+ });
+ return fakeMap;
+ };
 
  const mockSavedObject: SavedObject = {
  id: 'd7170a35-7e2c-48d6-8dec-9a056721b489',
@@ -40,7 +106,12 @@ describe('BackgroundSessionService', () => {
 
  beforeEach(() => {
  savedObjectsClient = savedObjectsClientMock.create();
- service = new BackgroundSessionService();
+ const mockLogger: any = {
+ debug: jest.fn(),
+ warn: jest.fn(),
+ error: jest.fn(),
+ };
+ service = new BackgroundSessionService(mockLogger);
  });
 
  it('save throws if `name` is not provided', () => {
@@ -230,4 +301,173 @@ describe('BackgroundSessionService', () => {
  expect(id).toBe(searchId);
  });
  });
+
+ describe('Monitor', () => {
+ beforeEach(() => {
+ jest.useFakeTimers();
+ service.start(mockCoreStart);
+ });
+
+ afterEach(() => {
+ jest.useRealTimers();
+ service.stop();
+ });
+
+ it('should delete expired IDs', async () => {
+ const bulkGetSpy = jest.fn().mockResolvedValueOnce({ saved_objects: [] });
+ createMockInternalSavedObjectClient(bulkGetSpy);
+
+ const mockIdMapping = createMockIdMapping(
+ [[MOCK_KEY_HASH, MOCK_ASYNC_ID]],
+ moment().subtract(2, 'm')
+ );
+
+ const deleteSpy = jest.spyOn(mockIdMapping, 'delete');
+ Object.defineProperty(service, 'sessionSearchMap', {
+ get: () => mockIdMapping,
+ });
+
+ // Get setInterval to fire
+ jest.advanceTimersByTime(INMEM_TRACKING_INTERVAL);
+
+ expect(bulkGetSpy).not.toHaveBeenCalled();
+ expect(deleteSpy).toHaveBeenCalledTimes(1);
+ });
+
+ it('should delete IDs that passed max retries', async () => {
+ const bulkGetSpy = jest.fn().mockResolvedValueOnce({ saved_objects: [] });
+ createMockInternalSavedObjectClient(bulkGetSpy);
+
+ const mockIdMapping = createMockIdMapping(
+ [[MOCK_KEY_HASH, MOCK_ASYNC_ID]],
+ moment(),
+ MAX_UPDATE_RETRIES
+ );
+
+ const deleteSpy = jest.spyOn(mockIdMapping, 'delete');
+ Object.defineProperty(service, 'sessionSearchMap', {
+ get: () => mockIdMapping,
+ });
+
+ // Get setInterval to fire
+ jest.advanceTimersByTime(INMEM_TRACKING_INTERVAL);
+
+ expect(bulkGetSpy).not.toHaveBeenCalled();
+ expect(deleteSpy).toHaveBeenCalledTimes(1);
+ });
+
+ it('should bot fetch when no IDs are mapped', async () => {
+ const bulkGetSpy = jest.fn().mockResolvedValueOnce({ saved_objects: [] });
+ createMockInternalSavedObjectClient(bulkGetSpy);
+
+ jest.advanceTimersByTime(INMEM_TRACKING_INTERVAL);
+ expect(bulkGetSpy).not.toHaveBeenCalled();
+ });
+
+ it('should try to fetch saved objects if some ids are mapped', async () => {
+ const mockIdMapping = createMockIdMapping([[MOCK_KEY_HASH, MOCK_ASYNC_ID]]);
+ Object.defineProperty(service, 'sessionSearchMap', {
+ get: () => mockIdMapping,
+ });
+
+ const bulkGetSpy = jest.fn().mockResolvedValueOnce({ saved_objects: [] });
+ const bulkUpdateSpy = jest.fn().mockResolvedValueOnce({ saved_objects: [] });
+ createMockInternalSavedObjectClient(bulkGetSpy, bulkUpdateSpy);
+
+ jest.advanceTimersByTime(INMEM_TRACKING_INTERVAL);
+ expect(bulkGetSpy).toHaveBeenCalledTimes(1);
+ expect(bulkUpdateSpy).not.toHaveBeenCalled();
+ });
+
+ it('should update saved objects if they are found, and delete ids on success', async () => {
+ const mockIdMapping = createMockIdMapping([[MOCK_KEY_HASH, MOCK_ASYNC_ID]], undefined, 1);
+ const mockMapDeleteSpy = jest.fn();
+ mockIdMapping.get(MOCK_SESSION_ID)!.ids.delete = mockMapDeleteSpy;
+ Object.defineProperty(service, 'sessionSearchMap', {
+ get: () => mockIdMapping,
+ });
+
+ const bulkGetSpy = jest.fn().mockResolvedValueOnce({
+ saved_objects: [
+ {
+ id: MOCK_SESSION_ID,
+ attributes: {
+ idMapping: {
+ b: 'c',
+ },
+ },
+ },
+ ],
+ });
+ const bulkUpdateSpy = jest.fn().mockResolvedValueOnce({
+ saved_objects: [
+ {
+ id: MOCK_SESSION_ID,
+ attributes: {
+ idMapping: {
+ b: 'c',
+ [MOCK_KEY_HASH]: MOCK_ASYNC_ID,
+ },
+ },
+ },
+ ],
+ });
+ createMockInternalSavedObjectClient(bulkGetSpy, bulkUpdateSpy);
+
+ jest.advanceTimersByTime(INMEM_TRACKING_INTERVAL);
+
+ // Release timers to call check after test actions are done.
+ jest.useRealTimers();
+ await new Promise((r) => setTimeout(r, 15));
+
+ expect(bulkGetSpy).toHaveBeenCalledTimes(1);
+ expect(bulkUpdateSpy).toHaveBeenCalledTimes(1);
+ expect(mockMapDeleteSpy).toHaveBeenCalledTimes(2);
+ expect(mockMapDeleteSpy).toBeCalledWith('b');
+ expect(mockMapDeleteSpy).toBeCalledWith(MOCK_KEY_HASH);
+ expect(mockIdMapping.get(MOCK_SESSION_ID)?.retryCount).toBe(0);
+ });
+
+ it('should update saved objects if they are found, and increase retryCount on error', async () => {
+ const mockIdMapping = createMockIdMapping([[MOCK_KEY_HASH, MOCK_ASYNC_ID]]);
+ const mockMapDeleteSpy = jest.fn();
+ mockIdMapping.get(MOCK_SESSION_ID)!.ids.delete = mockMapDeleteSpy;
+ Object.defineProperty(service, 'sessionSearchMap', {
+ get: () => mockIdMapping,
+ });
+
+ const bulkGetSpy = jest.fn().mockResolvedValueOnce({
+ saved_objects: [
+ {
+ id: MOCK_SESSION_ID,
+ attributes: {
+ idMapping: {
+ b: 'c',
+ },
+ },
+ },
+ ],
+ });
+ const bulkUpdateSpy = jest.fn().mockResolvedValueOnce({
+ saved_objects: [
+ {
+ id: MOCK_SESSION_ID,
+ error: 'not ok',
+ },
+ ],
+ });
+ createMockInternalSavedObjectClient(bulkGetSpy, bulkUpdateSpy);
+
+ jest.advanceTimersByTime(INMEM_TRACKING_INTERVAL);
+
+ // Release timers to call check after test actions are done.
+ jest.useRealTimers();
+ await new Promise((r) => setTimeout(r, 15));
+
+ expect(bulkGetSpy).toHaveBeenCalledTimes(1);
+ expect(bulkUpdateSpy).toHaveBeenCalledTimes(1);
+ expect(mockMapDeleteSpy).not.toHaveBeenCalled();
+ expect(mockIdMapping.get(MOCK_SESSION_ID)?.retryCount).toBe(1);
+ });
+ });
 });