Entity store/maintainer framework poc

packages/kbn-check-saved-objects-cli/current_fields.json

@@ -408,6 +408,11 @@
     "timestampField",
     "type"
   ],
+  "entity-maintainers-tasks": [
+    "entity-maintainers-tasks",
+    "entity-maintainers-tasks.id",
+    "entity-maintainers-tasks.interval"
+  ],
   "epm-packages": [
     "additional_spaces_installed_kibana",
     "es_index_patterns",

packages/kbn-check-saved-objects-cli/current_mappings.json

@@ -1374,6 +1374,22 @@
       }
     }
   },
+  "entity-maintainers-tasks": {
+    "dynamic": false,
+    "properties": {
+      "entity-maintainers-tasks": {
+        "properties": {
+          "id": {
+            "type": "keyword"
+          },
+          "interval": {
+            "type": "keyword"
+          }
+        },
+        "type": "nested"
+      }
+    }
+  },
   "epm-packages": {
     "dynamic": false,
     "properties": {

x-pack/solutions/security/plugins/entity_store/server/domain/asset_manager.ts

@@ -15,10 +15,12 @@ import type {
   ManagedEntityDefinition,
 } from '../../common/domain/definitions/entity_schema';
 import { scheduleExtractEntityTask, stopExtractEntityTask } from '../tasks/extract_entity_task';
+import { scheduleEntityMaintainerTasks } from '../tasks/entity_maintainer';
 import { installElasticsearchAssets, uninstallElasticsearchAssets } from './assets/install_assets';
 import type {
   EngineDescriptor,
   EngineDescriptorClient,
+  EntityMaintainersTasksClient,
   LogExtractionState,
 } from './definitions/saved_objects';
 import type { LogExtractionBodyParams } from '../routes/constants';
@@ -48,6 +50,7 @@ interface AssetManagerDependencies {
   namespace: string;
   isServerless: boolean;
   logsExtractionClient: LogsExtractionClient;
+  entityMaintainersTasksClient: EntityMaintainersTasksClient;
 }
 
 export class AssetManager {
@@ -58,6 +61,7 @@ export class AssetManager {
   private readonly namespace: string;
   private readonly isServerless: boolean;
   private readonly logsExtractionClient: LogsExtractionClient;
+  private readonly entityMaintainersTasksClient: EntityMaintainersTasksClient;
 
   constructor(deps: AssetManagerDependencies) {
     this.logger = deps.logger;
@@ -67,15 +71,30 @@ export class AssetManager {
     this.namespace = deps.namespace;
     this.isServerless = deps.isServerless;
     this.logsExtractionClient = deps.logsExtractionClient;
+    this.entityMaintainersTasksClient = deps.entityMaintainersTasksClient;
   }
 
-  public async initEntity(
+  public async init(
     request: KibanaRequest,
-    type: EntityType,
+    entityTypes: EntityType[],
     logExtractionParams?: LogExtractionBodyParams
   ) {
-    await this.install(type, logExtractionParams); // TODO: async
-    await this.start(request, type);
+    try {
+      await Promise.all(
+        entityTypes.map((type) => this.initEntity(request, type, logExtractionParams))
+      );
+
+      await scheduleEntityMaintainerTasks({
+        logger: this.logger,
+        taskManager: this.taskManager,
+        namespace: this.namespace,
+        request,
+        entityMaintainersTasksClient: this.entityMaintainersTasksClient,
+      });
+    } catch (error) {
+      this.logger.error('Error during entity store init:', error);
+      throw error;
+    }
   }
 
   public async start(request: KibanaRequest, type: EntityType) {
@@ -113,37 +132,6 @@ export class AssetManager {
     }
   }
 
-  public async install(
-    type: EntityType,
-    logExtractionParams?: LogExtractionBodyParams
-  ): Promise<ManagedEntityDefinition> {
-    // TODO: return early if already installed
-    try {
-      this.logger.get(type).debug(`Installing assets for entity type: ${type}`);
-      const definition = getEntityDefinition(type, this.namespace);
-      const initialState: Partial<LogExtractionState> = logExtractionParams ?? {};
-
-      await Promise.all([
-        this.engineDescriptorClient.init(type, initialState),
-        installElasticsearchAssets({
-          esClient: this.esClient,
-          logger: this.logger,
-          definition,
-          namespace: this.namespace,
-        }),
-      ]);
-
-      await this.engineDescriptorClient.update(type, { status: ENGINE_STATUS.STARTED });
-
-      this.logger.debug(`Installed definition: ${type}`);
-
-      return definition;
-    } catch (error) {
-      this.logger.error(`Error installing assets for entity type ${type}`, { error });
-      throw error;
-    }
-  }
-
   public async uninstall(type: EntityType) {
     try {
       const definition = getEntityDefinition(type, this.namespace);
@@ -185,6 +173,46 @@ export class AssetManager {
     }
   }
 
+  private async initEntity(
+    request: KibanaRequest,
+    type: EntityType,
+    logExtractionParams?: LogExtractionBodyParams
+  ) {
+    await this.install(type, logExtractionParams);
+    await this.start(request, type);
+  }
+
+  private async install(
+    type: EntityType,
+    logExtractionParams?: LogExtractionBodyParams
+  ): Promise<ManagedEntityDefinition> {
+    // TODO: return early if already installed
+    try {
+      this.logger.get(type).debug(`Installing assets for entity type: ${type}`);
+      const definition = getEntityDefinition(type, this.namespace);
+      const initialState: Partial<LogExtractionState> = logExtractionParams ?? {};
+
+      await Promise.all([
+        this.engineDescriptorClient.init(type, initialState),
+        installElasticsearchAssets({
+          esClient: this.esClient,
+          logger: this.logger,
+          definition,
+          namespace: this.namespace,
+        }),
+      ]);
+
+      await this.engineDescriptorClient.update(type, { status: ENGINE_STATUS.STARTED });
+
+      this.logger.debug(`Installed definition: ${type}`);
+
+      return definition;
+    } catch (error) {
+      this.logger.error(`Error installing assets for entity type ${type}`, { error });
+      throw error;
+    }
+  }
+
   private async getEngineWithComponents(
     engine: EngineDescriptor
   ): Promise<EngineDescriptor & { components: EngineComponentStatus[] }> {

x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/constants.ts → x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/engine_descriptor/constants.ts

@@ -6,9 +6,9 @@
  */
 
 import { z } from '@kbn/zod';
-import { TasksConfig } from '../../../tasks/config';
-import { EntityStoreTaskType } from '../../../tasks/constants';
-import { EntityType } from '../../../../common/domain/definitions/entity_schema';
+import { TasksConfig } from '../../../../tasks/config';
+import { EntityStoreTaskType } from '../../../../tasks/constants';
+import { EntityType } from '../../../../../common/domain/definitions/entity_schema';
 
 export type EngineStatus = z.infer<typeof EngineStatus>;
 export const EngineStatus = z.enum(['installing', 'started', 'stopped', 'updating', 'error']);
@@ -34,7 +34,7 @@ export const LogExtractionState = z.object({
   frequency: z
     .string()
     .regex(/[smdh]$/)
-    .default(TasksConfig[EntityStoreTaskType.Values.extractEntity].interval),
+    .default(TasksConfig[EntityStoreTaskType.Values.extractEntity].interval || '30s'),
   paginationTimestamp: z.string().optional(),
   lastExecutionTimestamp: z.string().optional(),
 });

x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/engine_descriptor.ts → x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/engine_descriptor/index.ts

@@ -10,11 +10,11 @@ import type {
   SavedObjectsFindResponse,
 } from '@kbn/core-saved-objects-api-server';
 import { SavedObjectsErrorHelpers, type Logger } from '@kbn/core/server';
-import type { EntityType } from '../../../../common/domain/definitions/entity_schema';
+import type { EntityType } from '../../../../../common/domain/definitions/entity_schema';
 import type { EngineDescriptor } from './constants';
 import { LogExtractionState, VersionState } from './constants';
-import { EngineDescriptorTypeName } from './engine_descriptor_type';
-import { ENGINE_STATUS } from '../../constants';
+import { EngineDescriptorTypeName } from './types';
+import { ENGINE_STATUS } from '../../../constants';
 
 export class EngineDescriptorClient {
   constructor(

x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/entity_maintainers_client/constants.ts

@@ -0,0 +1,14 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { z } from '@kbn/zod';
+
+export type EntityMaintainerTaskEntry = z.infer<typeof EntityMaintainerTaskEntry>;
+export const EntityMaintainerTaskEntry = z.object({
+  id: z.string(),
+  interval: z.string().regex(/[smdh]$/),
+});

x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/entity_maintainers_client/index.ts

@@ -0,0 +1,66 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import type { ISavedObjectsRepository } from '@kbn/core/server';
+import { SavedObjectsErrorHelpers, type Logger } from '@kbn/core/server';
+import type { EntityMaintainerTaskEntry } from './constants';
+import { EntityMaintainerTaskEntry as EntityMaintainerTaskEntrySchema } from './constants';
+import { EntityMaintainersTasksTypeName, EntityMaintainersTasksId } from './types';
+
+const ENTITY_MAINTAINERS_TASKS_ATTR = 'entity-maintainers-tasks' as const;
+
+export class EntityMaintainersTasksClient {
+  constructor(
+    private readonly repository: ISavedObjectsRepository,
+    private readonly logger: Logger
+  ) {}
+
+  async getAll(): Promise<EntityMaintainerTaskEntry[]> {
+    try {
+      const doc = await this.repository.get<
+        Record<typeof ENTITY_MAINTAINERS_TASKS_ATTR, unknown[]>
+      >(EntityMaintainersTasksTypeName, EntityMaintainersTasksId);
+      const raw = doc.attributes[ENTITY_MAINTAINERS_TASKS_ATTR] ?? [];
+      return raw.map((entry) => EntityMaintainerTaskEntrySchema.parse(entry));
+    } catch (err) {
+      if (SavedObjectsErrorHelpers.isNotFoundError(err)) {
+        return [];
+      }
+      this.logger.error(`Failed to get entity maintainer tasks: ${err?.message}`);
+      throw err;
+    }
+  }
+
+  async addOrUpdate(entry: EntityMaintainerTaskEntry): Promise<void> {
+    const taskEntry = EntityMaintainerTaskEntrySchema.parse(entry);
+    try {
+      const existing = await this.repository.get<
+        Record<typeof ENTITY_MAINTAINERS_TASKS_ATTR, EntityMaintainerTaskEntry[]>
+      >(EntityMaintainersTasksTypeName, EntityMaintainersTasksId);
+      const tasks = existing.attributes[ENTITY_MAINTAINERS_TASKS_ATTR] ?? [];
+      this.logger.debug(`Tasks registered: ${JSON.stringify(tasks)}`);
+      const filtered = tasks.filter((t) => t.id !== taskEntry.id);
+      await this.repository.update(EntityMaintainersTasksTypeName, EntityMaintainersTasksId, {
+        [ENTITY_MAINTAINERS_TASKS_ATTR]: [...filtered, taskEntry],
+      });
+    } catch (err) {
+      if (SavedObjectsErrorHelpers.isNotFoundError(err)) {
+        this.logger.debug(`Creating entity maintainers tasks document with first entry`);
+        await this.repository.create(
+          EntityMaintainersTasksTypeName,
+          { [ENTITY_MAINTAINERS_TASKS_ATTR]: [taskEntry] },
+          { id: EntityMaintainersTasksId }
+        );
+        return;
+      }
+      this.logger.error(
+        `Failed to register entity maintainer task in saved object: ${err?.message}`
+      );
+      throw err;
+    }
+  }
+}

x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/entity_maintainers_client/types.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import type { SavedObjectsFullModelVersion } from '@kbn/core-saved-objects-server';
+import type { SavedObjectsType } from '@kbn/core/server';
+import { schema } from '@kbn/config-schema';
+
+export const EntityMaintainersTasksTypeName = 'entity-maintainers-tasks';
+export const EntityMaintainersTasksId = 'entity-maintainers-tasks';
+
+export const EntityMaintainersTasksTypeMappings: SavedObjectsType['mappings'] = {
+  dynamic: false,
+  properties: {
+    'entity-maintainers-tasks': {
+      type: 'nested',
+      properties: {
+        id: { type: 'keyword' },
+        interval: { type: 'keyword' },
+      },
+    },
+  },
+};
+
+const entityMaintainerTaskEntrySchema = schema.object({
+  id: schema.string(),
+  interval: schema.string(),
+});
+
+const entityMaintainersTasksAttributesSchema = {
+  'entity-maintainers-tasks': schema.arrayOf(entityMaintainerTaskEntrySchema),
+};
+
+const version1: SavedObjectsFullModelVersion = {
+  changes: [],
+  schemas: {
+    create: schema.object(entityMaintainersTasksAttributesSchema),
+    forwardCompatibility: schema.object(entityMaintainersTasksAttributesSchema, {
+      unknowns: 'ignore',
+    }),
+  },
+};
+
+export const EntityMaintainersTasksType: SavedObjectsType = {
+  name: EntityMaintainersTasksTypeName,
+  hidden: true,
+  namespaceType: 'single',
+  mappings: EntityMaintainersTasksTypeMappings,
+  modelVersions: { 1: version1 },
+  hiddenFromHttpApis: true,
+};

x-pack/solutions/security/plugins/entity_store/server/domain/definitions/saved_objects/index.ts

@@ -5,6 +5,9 @@
  * 2.0.
  */
 
-export * from './engine_descriptor_type';
+export * from './engine_descriptor/constants';
+export * from './engine_descriptor/types';
 export * from './engine_descriptor';
-export * from './constants';
+export * from './entity_maintainers_client/constants';
+export * from './entity_maintainers_client/types';
+export * from './entity_maintainers_client';