Use atomic agent and package policy API in cloud connector task

x-pack/platform/plugins/shared/content_connectors/server/services/index.test.ts

@@ -31,13 +31,6 @@ import {
 } from '@kbn/fleet-plugin/server';
 import { AgentPolicy, PackagePolicy, PackagePolicyInput } from '@kbn/fleet-plugin/common';
 import { createAgentPolicyMock, createPackagePolicyMock } from '@kbn/fleet-plugin/common/mocks';
-import { createAgentPolicyWithPackages } from '@kbn/fleet-plugin/server/services/agent_policy_create';
-
-jest.mock('@kbn/fleet-plugin/server/services/agent_policy_create', () => {
-  return {
-    createAgentPolicyWithPackages: jest.fn().mockReturnValue({ id: 'test-policy' }),
-  };
-});
 
 jest.mock('@kbn/fleet-plugin/server/services/epm/packages', () => {
   const mockedGetPackageInfo = ({ pkgName }: { pkgName: string }) => {
@@ -451,7 +444,7 @@ describe('AgentlessConnectorsInfraService', () => {
       }
     });
 
-    test('Does not swallow an error if agent policy creation failed', async () => {
+    test('Does not swallow an error if agent with package policies creation failed', async () => {
       const connector = {
         id: '000000001',
         name: 'something',
@@ -460,29 +453,7 @@ describe('AgentlessConnectorsInfraService', () => {
       };
       const errorMessage = 'Failed to create an agent policy hehe';
 
-      (createAgentPolicyWithPackages as jest.Mock).mockImplementationOnce(() => {
-        throw new Error(errorMessage);
-      });
-
-      try {
-        await service.deployConnector(connector);
-        expect(true).toBe(false);
-      } catch (e) {
-        expect(e.message).toEqual(errorMessage);
-      }
-    });
-
-    test('Does not swallow an error if package policy creation failed', async () => {
-      const connector = {
-        id: '000000001',
-        name: 'something',
-        service_type: 'github',
-        is_deleted: false,
-      };
-      const errorMessage = 'Failed to create a package policy hehe';
-
-      agentPolicyInterface.create.mockResolvedValue(agentPolicy);
-      packagePolicyService.create.mockImplementation(() => {
+      agentPolicyInterface.createWithPackagePolicies.mockImplementationOnce(() => {
         throw new Error(errorMessage);
       });
 
@@ -494,19 +465,18 @@ describe('AgentlessConnectorsInfraService', () => {
       }
     });
 
-    test('Returns a created package policy when all goes well', async () => {
+    test('Returns a created agent policy when all goes well', async () => {
       const connector = {
         id: '000000001',
         name: 'something',
         service_type: 'github',
         is_deleted: false,
       };
 
-      agentPolicyInterface.create.mockResolvedValue(agentPolicy);
-      packagePolicyService.create.mockResolvedValue(sharepointOnlinePackagePolicy);
+      agentPolicyInterface.createWithPackagePolicies.mockResolvedValue(agentPolicy);
 
       const result = await service.deployConnector(connector);
-      expect(result).toBe(sharepointOnlinePackagePolicy);
+      expect(result).toBe(agentPolicy);
     });
 
     test('passes supports_agentless flag and global tags correctly to agent policy creation and package policy creation', async () => {
@@ -518,27 +488,27 @@ describe('AgentlessConnectorsInfraService', () => {
       };
 
       const fakeAgentPolicy = { id: 'agent-policy-005' } as AgentPolicy;
-      const fakePackagePolicy = {
-        id: 'package-policy-005',
-        policy_ids: ['agent-policy-005'],
-      } as PackagePolicy;
-
-      agentPolicyInterface.create.mockResolvedValue(fakeAgentPolicy);
-      packagePolicyService.create.mockResolvedValue(fakePackagePolicy);
+      agentPolicyInterface.createWithPackagePolicies.mockResolvedValue(fakeAgentPolicy);
 
       const result = await service.deployConnector(testConnector);
 
-      expect(createAgentPolicyWithPackages).toHaveBeenCalled();
-
-      expect(packagePolicyService.create).toHaveBeenCalledWith(
-        soClient,
-        esClient,
+      expect(agentPolicyInterface.createWithPackagePolicies).toHaveBeenCalledWith(
         expect.objectContaining({
-          supports_agentless: true,
-        }),
-        { force: true }
+          soClient,
+          esClient,
+          agentPolicy: expect.objectContaining({
+            supports_agentless: true,
+          }),
+          packagePolicies: expect.arrayContaining([
+            expect.objectContaining({
+              supports_agentless: true,
+            }),
+          ]),
+          options: expect.objectContaining({ force: true }),
+        })
       );
-      expect(result).toBe(fakePackagePolicy);
+
+      expect(result).toBe(fakeAgentPolicy);
     });
   });
   describe('removeDeployment', () => {

x-pack/platform/plugins/shared/content_connectors/server/services/index.ts

@@ -6,7 +6,12 @@
  */
 
 import { ElasticsearchClient } from '@kbn/core-elasticsearch-server';
-import { Agent, PACKAGE_POLICY_SAVED_OBJECT_TYPE, PackagePolicy } from '@kbn/fleet-plugin/common';
+import {
+  Agent,
+  AgentPolicy,
+  NewAgentPolicy,
+  PACKAGE_POLICY_SAVED_OBJECT_TYPE,
+} from '@kbn/fleet-plugin/common';
 import {
   AgentPolicyServiceInterface,
   AgentService,
@@ -15,7 +20,6 @@ import {
 import type { Logger, SavedObjectsClientContract } from '@kbn/core/server';
 import { NATIVE_CONNECTOR_DEFINITIONS, fetchConnectors } from '@kbn/search-connectors';
 import { getPackageInfo } from '@kbn/fleet-plugin/server/services/epm/packages';
-import { createAgentPolicyWithPackages } from '@kbn/fleet-plugin/server/services/agent_policy_create';
 import { DEFAULT_SPACE_ID } from '@kbn/spaces-plugin/common';
 
 export interface ConnectorMetadata {
@@ -160,7 +164,7 @@ export class AgentlessConnectorsInfraService {
     return policiesMetadata;
   };
 
-  public deployConnector = async (connector: ConnectorMetadata): Promise<PackagePolicy> => {
+  public deployConnector = async (connector: ConnectorMetadata): Promise<AgentPolicy> => {
     this.logger.info(
       `Connector ${connector.id} has no integration policy associated with it, creating`
     );
@@ -186,77 +190,73 @@ export class AgentlessConnectorsInfraService {
     const pkgVersion = await this.getPackageVersion();
     this.logger.debug(`Latest package version for ${pkgName} is ${pkgVersion}`);
 
-    const createdPolicy = await createAgentPolicyWithPackages({
+    const agentPolicyToCreate: NewAgentPolicy = {
+      name: `Agentless policy for ${connector.service_type} connector: ${connector.id}`,
+      description: `Automatically generated on ${new Date(Date.now()).toISOString()}`,
+      global_data_tags: [
+        {
+          name: 'organization',
+          value: 'elastic',
+        },
+        {
+          name: 'division',
+          value: 'engineering',
+        },
+        {
+          name: 'team',
+          value: 'search-extract-and-transform',
+        },
+      ],
+      namespace: 'default',
+      monitoring_enabled: ['logs', 'metrics'],
+      inactivity_timeout: 3600,
+      is_protected: false,
+      supports_agentless: true,
+    };
+
+    const packagePolicyToCreate = {
+      package: {
+        title: pkgTitle,
+        name: pkgName,
+        version: pkgVersion,
+      },
+      name: `${connector.service_type} connector ${connector.id}`,
+      description: '',
+      namespace: '',
+      enabled: true,
+      inputs: [
+        {
+          type: connectorsInputName,
+          policy_template: connector.service_type,
+          enabled: true,
+          vars: {
+            connector_id: { type: 'string', value: connector.id },
+            connector_name: { type: 'string', value: connector.name },
+            service_type: { type: 'string', value: connector.service_type },
+          },
+          streams: [],
+        },
+      ],
+      supports_agentless: true,
+    };
+
+    const agentPolicy = await this.agentPolicyService.createWithPackagePolicies({
       soClient: this.soClient,
       esClient: this.esClient,
-      newPolicy: {
-        name: `Agentless policy for ${connector.service_type} connector: ${connector.id}`,
-        description: `Automatically generated on ${new Date(Date.now()).toISOString()}`,
-        global_data_tags: [
-          {
-            name: 'organization',
-            value: 'elastic',
-          },
-          {
-            name: 'division',
-            value: 'engineering',
-          },
-          {
-            name: 'team',
-            value: 'search-extract-and-transform',
-          },
-        ],
-        namespace: 'default',
-        monitoring_enabled: ['logs', 'metrics'],
-        inactivity_timeout: 3600,
-        is_protected: false,
-        supports_agentless: true,
+      agentPolicy: agentPolicyToCreate,
+      packagePolicies: [packagePolicyToCreate],
+      options: {
+        withSysMonitoring: true,
+        spaceId: this.soClient.getCurrentNamespace() ?? DEFAULT_SPACE_ID,
+        force: true,
       },
-      withSysMonitoring: true,
-      spaceId: this.soClient.getCurrentNamespace() ?? DEFAULT_SPACE_ID,
     });
 
     this.logger.info(
-      `Successfully created agent policy ${createdPolicy.id} for agentless connector ${connector.id}`
-    );
-    this.logger.debug(`Creating a package policy for agentless connector ${connector.id}`);
-    const packagePolicy = await this.packagePolicyService.create(
-      this.soClient,
-      this.esClient,
-      {
-        policy_ids: [createdPolicy.id],
-        package: {
-          title: pkgTitle,
-          name: pkgName,
-          version: pkgVersion,
-        },
-        name: `${connector.service_type} connector ${connector.id}`,
-        description: '',
-        namespace: '',
-        enabled: true,
-        inputs: [
-          {
-            type: connectorsInputName,
-            policy_template: connector.service_type,
-            enabled: true,
-            vars: {
-              connector_id: { type: 'string', value: connector.id },
-              connector_name: { type: 'string', value: connector.name },
-              service_type: { type: 'string', value: connector.service_type },
-            },
-            streams: [],
-          },
-        ],
-        supports_agentless: true,
-      },
-      { force: true }
-    );
-
-    this.logger.info(
-      `Successfully created package policy ${packagePolicy.id} for agentless connector ${connector.id}`
+      `Successfully created agent policy ${agentPolicy.id} for agentless connector ${connector.id}`
     );
 
-    return packagePolicy;
+    return agentPolicy;
   };
 
   public removeDeployment = async (packagePolicyId: string): Promise<void> => {

x-pack/platform/plugins/shared/content_connectors/server/task.test.ts

@@ -14,7 +14,7 @@ import {
   PackagePolicyMetadata,
 } from './services';
 import { licensingMock } from '@kbn/licensing-plugin/server/mocks';
-import { createPackagePolicyMock } from '@kbn/fleet-plugin/common/mocks';
+import { createAgentPolicyMock } from '@kbn/fleet-plugin/common/mocks';
 import { coreMock } from '@kbn/core/server/mocks';
 import { AgentlessConnectorsInfraServiceFactory } from './services/infra_service_factory';
 
@@ -218,7 +218,7 @@ describe('infraSyncTaskRunner', () => {
         throw new Error('Cannot deploy these connectors');
       }
 
-      return createPackagePolicyMock();
+      return createAgentPolicyMock();
     });
 
     await infraSyncTaskRunner(

x-pack/platform/plugins/shared/fleet/server/mocks/index.ts

@@ -274,6 +274,7 @@ export const createPackagePolicyServiceMock = (): jest.Mocked<PackagePolicyClien
 export const createMockAgentPolicyService = (): jest.Mocked<AgentPolicyServiceInterface> => {
   return {
     create: jest.fn().mockReturnValue(Promise.resolve()),
+    createWithPackagePolicies: jest.fn().mockReturnValue(Promise.resolve()),
     get: jest.fn().mockReturnValue(Promise.resolve()),
     list: jest.fn().mockReturnValue(Promise.resolve()),
     delete: jest.fn().mockReturnValue(Promise.resolve()),
@@ -282,6 +283,7 @@ export const createMockAgentPolicyService = (): jest.Mocked<AgentPolicyServiceIn
     turnOffAgentTamperProtections: jest.fn().mockReturnValue(Promise.resolve()),
     fetchAllAgentPolicies: jest.fn().mockReturnValue(Promise.resolve()),
     fetchAllAgentPolicyIds: jest.fn().mockReturnValue(Promise.resolve()),
+    deployPolicy: jest.fn().mockRejectedValue(Promise.resolve()),
   };
 };
 

x-pack/platform/plugins/shared/fleet/server/routes/agent_policy/handlers.ts

@@ -370,6 +370,7 @@ export const createAgentPolicyHandler: FleetRequestHandler<
     const agentPolicy = await createAgentPolicyWithPackages({
       soClient,
       esClient,
+      agentPolicyService,
       newPolicy,
       hasFleetServer,
       withSysMonitoring,