[Ingest Manager] Do not await setupIngestManager in plugin start

x-pack/plugins/ingest_manager/public/plugin.ts

@@ -28,7 +28,7 @@ export type IngestManagerSetup = void;
  */
 export interface IngestManagerStart {
   registerDatasource: typeof registerDatasource;
-  success: boolean;
+  success?: boolean;
   error?: {
     message: string;
   };
@@ -81,8 +81,8 @@ export class IngestManagerPlugin
     try {
       const permissionsResponse = await core.http.get(appRoutesService.getCheckPermissionsPath());
       if (permissionsResponse.success) {
-        const { isInitialized: success } = await core.http.post(setupRouteService.getSetupPath());
-        return { success, registerDatasource };
+        core.http.post(setupRouteService.getSetupPath());
+        return { registerDatasource };
       } else {
         throw new Error(permissionsResponse.error);
       }

x-pack/plugins/ingest_manager/server/routes/epm/handlers.ts

@@ -28,6 +28,8 @@ import {
   removeInstallation,
 } from '../../services/epm/packages';
 
+import { appContextService } from '../../services';
+
 export const getCategoriesHandler: RequestHandler = async (context, request, response) => {
   try {
     const res = await getCategories();
@@ -125,6 +127,20 @@ export const installPackageHandler: RequestHandler<TypeOf<
     const { pkgkey } = request.params;
     const savedObjectsClient = context.core.savedObjects.client;
     const callCluster = context.core.elasticsearch.legacy.client.callAsCurrentUser;
+
+    if (appContextService.getIsInitialized()?.status === 'not_started') {
+      return response.customError({
+        statusCode: 503,
+        body: 'Ingest Manager is not initialized',
+      });
+    }
+
+    if (appContextService.getIsInitialized()?.status === 'error') {
+      return response.customError({
+        statusCode: 500,
+        body: 'There was an error setting up Ingest Manager',
+      });
+    }
     const res = await installPackage({
       savedObjectsClient,
       pkgkey,

x-pack/plugins/ingest_manager/server/routes/setup/handlers.ts

@@ -78,6 +78,7 @@ export const ingestManagerSetupHandler: RequestHandler = async (context, request
   const logger = appContextService.getLogger();
   try {
     await setupIngestManager(soClient, callCluster);
+
     return response.ok({
       body: { isInitialized: true },
     });

x-pack/plugins/ingest_manager/server/services/app_context.ts

@@ -12,6 +12,10 @@ import { IngestManagerConfigType } from '../../common';
 import { IngestManagerAppContext } from '../plugin';
 import { CloudSetup } from '../../../cloud/server';
 
+interface InitializationState {
+  status: 'not_started' | 'success' | 'error';
+  error?: Error;
+}
 class AppContextService {
   private encryptedSavedObjects: EncryptedSavedObjectsClient | undefined;
   private security: SecurityPluginSetup | undefined;
@@ -23,6 +27,7 @@ class AppContextService {
   private cloud?: CloudSetup;
   private logger: Logger | undefined;
   private httpSetup?: HttpServiceSetup;
+  private initializationState?: InitializationState;
 
   public async start(appContext: IngestManagerAppContext) {
     this.encryptedSavedObjects = appContext.encryptedSavedObjects?.getClient();
@@ -33,6 +38,7 @@ class AppContextService {
     this.logger = appContext.logger;
     this.kibanaVersion = appContext.kibanaVersion;
     this.httpSetup = appContext.httpSetup;
+    this.initializationState = { status: 'not_started' };
 
     if (appContext.config$) {
       this.config$ = appContext.config$;
@@ -84,6 +90,14 @@ class AppContextService {
     return this.savedObjects;
   }
 
+  public getIsInitialized() {
+    return this.initializationState;
+  }
+
+  public setIsInitialized(vals: InitializationState) {
+    this.initializationState = vals;
+  }
+
   public getIsProductionMode() {
     return this.isProductionMode;
   }

x-pack/plugins/ingest_manager/server/services/es_index_pattern.ts

@@ -6,10 +6,12 @@
 import { SavedObjectsClientContract } from 'kibana/server';
 import { getInstallation } from './epm/packages';
 import { ESIndexPatternService } from '../../server';
+import { CallESAsCurrentUser } from '../types';
 
 export class ESIndexPatternSavedObjectService implements ESIndexPatternService {
   public async getESIndexPattern(
     savedObjectsClient: SavedObjectsClientContract,
+    callCluster: CallESAsCurrentUser,
     pkgName: string,
     datasetPath: string
   ): Promise<string | undefined> {

x-pack/plugins/ingest_manager/server/services/index.ts

@@ -5,7 +5,7 @@
  */
 
 import { SavedObjectsClientContract } from 'kibana/server';
-import { AgentStatus } from '../types';
+import { AgentStatus, CallESAsCurrentUser } from '../types';
 import * as settingsService from './settings';
 export { ESIndexPatternSavedObjectService } from './es_index_pattern';
 
@@ -15,6 +15,7 @@ export { ESIndexPatternSavedObjectService } from './es_index_pattern';
 export interface ESIndexPatternService {
   getESIndexPattern(
     savedObjectsClient: SavedObjectsClientContract,
+    callCluster: CallESAsCurrentUser,
     pkgName: string,
     datasetPath: string
   ): Promise<string | undefined>;

x-pack/plugins/ingest_manager/server/services/setup.ts

@@ -34,67 +34,74 @@ export async function setupIngestManager(
   soClient: SavedObjectsClientContract,
   callCluster: CallESAsCurrentUser
 ) {
-  const [installedPackages, defaultOutput, config] = await Promise.all([
-    // packages installed by default
-    ensureInstalledDefaultPackages(soClient, callCluster),
-    outputService.ensureDefaultOutput(soClient),
-    agentConfigService.ensureDefaultAgentConfig(soClient),
-    ensureDefaultIndices(callCluster),
-    settingsService.getSettings(soClient).catch((e: any) => {
-      if (e.isBoom && e.output.statusCode === 404) {
-        const http = appContextService.getHttpSetup();
-        const serverInfo = http.getServerInfo();
-        const basePath = http.basePath;
-
-        const cloud = appContextService.getCloud();
-        const cloudId = cloud?.isCloudEnabled && cloud.cloudId;
-        const cloudUrl = cloudId && decodeCloudId(cloudId)?.kibanaUrl;
-        const flagsUrl = appContextService.getConfig()?.fleet?.kibana?.host;
-        const defaultUrl = url.format({
-          protocol: serverInfo.protocol,
-          hostname: serverInfo.host,
-          port: serverInfo.port,
-          pathname: basePath.serverBasePath,
-        });
-
-        return settingsService.saveSettings(soClient, {
-          agent_auto_upgrade: true,
-          package_auto_upgrade: true,
-          kibana_url: cloudUrl || flagsUrl || defaultUrl,
-        });
-      }
-
-      return Promise.reject(e);
-    }),
-  ]);
-
-  // ensure default packages are added to the default conifg
-  const configWithDatasource = await agentConfigService.get(soClient, config.id, true);
-  if (!configWithDatasource) {
-    throw new Error('Config not found');
-  }
-  if (
-    configWithDatasource.datasources.length &&
-    typeof configWithDatasource.datasources[0] === 'string'
-  ) {
-    throw new Error('Config not found');
-  }
-  for (const installedPackage of installedPackages) {
-    const packageShouldBeInstalled = DEFAULT_AGENT_CONFIGS_PACKAGES.some(
-      (packageName) => installedPackage.name === packageName
-    );
-    if (!packageShouldBeInstalled) {
-      continue;
+  try {
+    const [installedPackages, defaultOutput, config] = await Promise.all([
+      // packages installed by default
+      ensureInstalledDefaultPackages(soClient, callCluster),
+      outputService.ensureDefaultOutput(soClient),
+      agentConfigService.ensureDefaultAgentConfig(soClient),
+      ensureDefaultIndices(callCluster),
+      settingsService.getSettings(soClient).catch((e: any) => {
+        if (e.isBoom && e.output.statusCode === 404) {
+          const http = appContextService.getHttpSetup();
+          const serverInfo = http.getServerInfo();
+          const basePath = http.basePath;
+
+          const cloud = appContextService.getCloud();
+          const cloudId = cloud?.isCloudEnabled && cloud.cloudId;
+          const cloudUrl = cloudId && decodeCloudId(cloudId)?.kibanaUrl;
+          const flagsUrl = appContextService.getConfig()?.fleet?.kibana?.host;
+          const defaultUrl = url.format({
+            protocol: serverInfo.protocol,
+            hostname: serverInfo.host,
+            port: serverInfo.port,
+            pathname: basePath.serverBasePath,
+          });
+
+          return settingsService.saveSettings(soClient, {
+            agent_auto_upgrade: true,
+            package_auto_upgrade: true,
+            kibana_url: cloudUrl || flagsUrl || defaultUrl,
+          });
+        }
+
+        return Promise.reject(e);
+      }),
+    ]);
+
+    // ensure default packages are added to the default conifg
+    const configWithDatasource = await agentConfigService.get(soClient, config.id, true);
+    if (!configWithDatasource) {
+      throw new Error('Config not found');
     }
+    if (
+      configWithDatasource.datasources.length &&
+      typeof configWithDatasource.datasources[0] === 'string'
+    ) {
+      throw new Error('Config not found');
+    }
+    for (const installedPackage of installedPackages) {
+      const packageShouldBeInstalled = DEFAULT_AGENT_CONFIGS_PACKAGES.some(
+        (packageName) => installedPackage.name === packageName
+      );
+      if (!packageShouldBeInstalled) {
+        continue;
+      }
 
-    const isInstalled = configWithDatasource.datasources.some((d: Datasource | string) => {
-      return typeof d !== 'string' && d.package?.name === installedPackage.name;
-    });
+      const isInstalled = configWithDatasource.datasources.some((d: Datasource | string) => {
+        return typeof d !== 'string' && d.package?.name === installedPackage.name;
+      });
 
-    if (!isInstalled) {
-      await addPackageToConfig(soClient, installedPackage, configWithDatasource, defaultOutput);
+      if (!isInstalled) {
+        await addPackageToConfig(soClient, installedPackage, configWithDatasource, defaultOutput);
+      }
     }
+  } catch (e) {
+    appContextService.setIsInitialized({ status: 'error', error: e });
   }
+
+  appContextService.setIsInitialized({ status: 'success' });
+  return;
 }
 
 export async function setupFleet(

x-pack/plugins/security_solution/server/endpoint/alerts/index_pattern.ts

@@ -60,6 +60,7 @@ export class IngestIndexPatternRetriever implements IndexPatternRetriever {
     try {
       const pattern = await this.service.getESIndexPattern(
         ctx.core.savedObjects.client,
+        ctx.core.elasticsearch.legacy.client.callAsCurrentUser,
         IngestIndexPatternRetriever.endpointPackageName,
         datasetPath
       );