[Security Solution][Platform] - Add connectors to import/export API

packages/kbn-securitysolution-io-ts-types/src/import_query_schema/index.test.ts

@@ -16,6 +16,7 @@ describe('importQuerySchema', () => {
  as_new_list: false,
  overwrite: true,
  overwrite_exceptions: true,
+ overwrite_action_connectors: true,
  };
  const decoded = importQuerySchema.decode(payload);
  const checked = exactCheck(payload, decoded);
@@ -30,6 +31,7 @@ describe('importQuerySchema', () => {
  as_new_list: false,
  overwrite: 'wrong',
  overwrite_exceptions: true,
+ overwrite_action_connectors: true,
  };
  const decoded = importQuerySchema.decode(payload);
  const checked = exactCheck(payload, decoded);
@@ -48,6 +50,7 @@ describe('importQuerySchema', () => {
  as_new_list: false,
  overwrite: true,
  overwrite_exceptions: 'wrong',
+ overwrite_action_connectors: true,
  };
  const decoded = importQuerySchema.decode(payload);
  const checked = exactCheck(payload, decoded);
@@ -58,6 +61,24 @@ describe('importQuerySchema', () => {
  ]);
  expect(message.schema).toEqual({});
  });
+ test('it should NOT validate a non boolean value for "overwrite_action_connectors"', () => {
+ const payload: Omit<ImportQuerySchema, 'overwrite_action_connectors'> & {
+ overwrite_action_connectors: string;
+ } = {
+ as_new_list: false,
+ overwrite: true,
+ overwrite_exceptions: true,
+ overwrite_action_connectors: 'wrong',
+ };
+ const decoded = importQuerySchema.decode(payload);
+ const checked = exactCheck(payload, decoded);
+ const message = foldLeftRight(checked);
+
+ expect(getPaths(left(message.errors))).toEqual([
+ 'Invalid value "wrong" supplied to "overwrite_action_connectors"',
+ ]);
+ expect(message.schema).toEqual({});
+ });
 
  test('it should NOT allow an extra key to be sent in', () => {
  const payload: ImportQuerySchema & {

packages/kbn-securitysolution-io-ts-types/src/import_query_schema/index.ts

@@ -14,16 +14,18 @@ export const importQuerySchema = t.exact(
  t.partial({
  overwrite: DefaultStringBooleanFalse,
  overwrite_exceptions: DefaultStringBooleanFalse,
+ overwrite_action_connectors: DefaultStringBooleanFalse,
  as_new_list: DefaultStringBooleanFalse,
  })
 );
 
 export type ImportQuerySchema = t.TypeOf<typeof importQuerySchema>;
 export type ImportQuerySchemaDecoded = Omit<
  ImportQuerySchema,
- 'overwrite' | 'overwrite_exceptions' | 'as_new_list'
+ 'overwrite' | 'overwrite_exceptions' | 'as_new_list' | 'overwrite_action_connectors'
 > & {
  overwrite: boolean;
  overwrite_exceptions: boolean;
+ overwrite_action_connectors: boolean;
  as_new_list: boolean;
 };

x-pack/plugins/alerting/server/rules_client/lib/validate_actions.ts

@@ -17,7 +17,10 @@ import { parseDuration } from '../../lib';
 export async function validateActions(
  context: RulesClientContext,
  alertType: UntypedNormalizedRuleType,
- data: Pick<RawRule, 'notifyWhen' | 'throttle' | 'schedule'> & { actions: NormalizedAlertAction[] }
+ data: Pick<RawRule, 'notifyWhen' | 'throttle' | 'schedule'> & {
+ actions: NormalizedAlertAction[];
+ },
+ skipMissingSecretsValidation?: boolean
 ): Promise<void> {
  const { actions, notifyWhen, throttle } = data;
  const hasRuleLevelNotifyWhen = typeof notifyWhen !== 'undefined';
@@ -28,27 +31,28 @@ export async function validateActions(
 
  const errors = [];
 
- // check for actions using connectors with missing secrets
- const actionsClient = await context.getActionsClient();
- const actionIds = [...new Set(actions.map((action) => action.id))];
- const actionResults = (await actionsClient.getBulk(actionIds)) || [];
- const actionsUsingConnectorsWithMissingSecrets = actionResults.filter(
- (result) => result.isMissingSecrets
- );
-
- if (actionsUsingConnectorsWithMissingSecrets.length) {
- errors.push(
- i18n.translate('xpack.alerting.rulesClient.validateActions.misconfiguredConnector', {
- defaultMessage: 'Invalid connectors: {groups}',
- values: {
- groups: actionsUsingConnectorsWithMissingSecrets
- .map((connector) => connector.name)
- .join(', '),
- },
- })
+ if (!skipMissingSecretsValidation) {
+ // check for actions using connectors with missing secrets
+ const actionsClient = await context.getActionsClient();
+ const actionIds = [...new Set(actions.map((action) => action.id))];
+ const actionResults = (await actionsClient.getBulk(actionIds)) || [];
+ const actionsUsingConnectorsWithMissingSecrets = actionResults.filter(
+ (result) => result.isMissingSecrets
  );
- }
 
+ if (actionsUsingConnectorsWithMissingSecrets.length) {
+ errors.push(
+ i18n.translate('xpack.alerting.rulesClient.validateActions.misconfiguredConnector', {
+ defaultMessage: 'Invalid connectors: {groups}',
+ values: {
+ groups: actionsUsingConnectorsWithMissingSecrets
+ .map((connector) => connector.name)
+ .join(', '),
+ },
+ })
+ );
+ }
+ }
  // check for actions with invalid action groups
  const { actionGroups: alertTypeActionGroups } = alertType;
  const usedAlertActionGroups = actions.map((action) => action.group);

x-pack/plugins/alerting/server/rules_client/methods/create.ts

@@ -46,11 +46,12 @@ export interface CreateOptions<Params extends RuleTypeParams> {
  | 'nextRun'
  > & { actions: NormalizedAlertAction[] };
  options?: SavedObjectOptions;
+ skipMissingSecretsValidation?: boolean;
 }
 
 export async function create<Params extends RuleTypeParams = never>(
  context: RulesClientContext,
- { data, options }: CreateOptions<Params>
+ { data, options, skipMissingSecretsValidation }: CreateOptions<Params>
 ): Promise<SanitizedRule<Params>> {
  const id = options?.id || SavedObjectsUtils.generateId();
 
@@ -104,10 +105,11 @@ export async function create<Params extends RuleTypeParams = never>(
  }
  }
 
- await validateActions(context, ruleType, data);
+ await validateActions(context, ruleType, data, skipMissingSecretsValidation);
  await withSpan({ name: 'validateActions', type: 'rules' }, () =>
- validateActions(context, ruleType, data)
+ validateActions(context, ruleType, data, skipMissingSecretsValidation)
  );
+
  // Throw error if schedule interval is less than the minimum and we are enforcing it
  const intervalInMs = parseDuration(data.schedule.interval);
  if (

x-pack/plugins/alerting/server/rules_client/methods/update.ts

@@ -38,22 +38,23 @@ export interface UpdateOptions<Params extends RuleTypeParams> {
  throttle?: string | null;
  notifyWhen?: RuleNotifyWhenType | null;
  };
+ skipMissingSecretsValidation?: boolean;
 }
 
 export async function update<Params extends RuleTypeParams = never>(
  context: RulesClientContext,
- { id, data }: UpdateOptions<Params>
+ { id, data, skipMissingSecretsValidation }: UpdateOptions<Params>
 ): Promise<PartialRule<Params>> {
  return await retryIfConflicts(
  context.logger,
  `rulesClient.update('${id}')`,
- async () => await updateWithOCC<Params>(context, { id, data })
+ async () => await updateWithOCC<Params>(context, { id, data, skipMissingSecretsValidation })
  );
 }
 
 async function updateWithOCC<Params extends RuleTypeParams>(
  context: RulesClientContext,
- { id, data }: UpdateOptions<Params>
+ { id, data, skipMissingSecretsValidation }: UpdateOptions<Params>
 ): Promise<PartialRule<Params>> {
  let alertSavedObject: SavedObject<RawRule>;
 
@@ -99,7 +100,11 @@ async function updateWithOCC<Params extends RuleTypeParams>(
 
  context.ruleTypeRegistry.ensureRuleTypeEnabled(alertSavedObject.attributes.alertTypeId);
 
- const updateResult = await updateAlert<Params>(context, { id, data }, alertSavedObject);
+ const updateResult = await updateAlert<Params>(
+ context,
+ { id, data, skipMissingSecretsValidation },
+ alertSavedObject
+ );
 
  await Promise.all([
  alertSavedObject.attributes.apiKey
@@ -138,7 +143,7 @@ async function updateWithOCC<Params extends RuleTypeParams>(
 
 async function updateAlert<Params extends RuleTypeParams>(
  context: RulesClientContext,
- { id, data }: UpdateOptions<Params>,
+ { id, data, skipMissingSecretsValidation }: UpdateOptions<Params>,
  { attributes, version }: SavedObject<RawRule>
 ): Promise<PartialRule<Params>> {
  const ruleType = context.ruleTypeRegistry.get(attributes.alertTypeId);
@@ -156,7 +161,7 @@ async function updateAlert<Params extends RuleTypeParams>(
 
  // Validate
  const validatedAlertTypeParams = validateRuleTypeParams(data.params, ruleType.validate?.params);
- await validateActions(context, ruleType, data);
+ await validateActions(context, ruleType, data, skipMissingSecretsValidation);
 
  // Throw error if schedule interval is less than the minimum and we are enforcing it
  const intervalInMs = parseDuration(data.schedule.interval);

x-pack/plugins/alerting/server/rules_client/tests/create.test.ts

@@ -3047,4 +3047,120 @@ describe('create()', () => {
  expect(unsecuredSavedObjectsClient.create).not.toHaveBeenCalled();
  expect(taskManager.schedule).not.toHaveBeenCalled();
  });
+ test('should create a rule even if action is missing secret when skipMissingSecretsValidation is true', async () => {
+ const data = getMockData({
+ actions: [
+ {
+ group: 'default',
+ id: '1',
+ params: {
+ foo: true,
+ },
+ },
+ {
+ group: 'default',
+ id: '1',
+ params: {
+ foo: true,
+ },
+ },
+ {
+ group: 'default',
+ id: '2',
+ params: {
+ foo: true,
+ },
+ },
+ ],
+ });
+ actionsClient.getBulk.mockReset();
+ actionsClient.getBulk.mockResolvedValue([
+ {
+ id: '1',
+ actionTypeId: '.slack',
+ config: {},
+ isMissingSecrets: true,
+ name: 'Slack connector',
+ isPreconfigured: false,
+ isDeprecated: false,
+ },
+ ]);
+ unsecuredSavedObjectsClient.create.mockResolvedValueOnce({
+ id: '1',
+ type: 'alert',
+ attributes: {
+ alertTypeId: '123',
+ schedule: { interval: '1m' },
+ params: {
+ bar: true,
+ },
+ createdAt: new Date().toISOString(),
+ updatedAt: new Date().toISOString(),
+ notifyWhen: null,
+ actions: [
+ {
+ group: 'default',
+ actionRef: 'action_0',
+ actionTypeId: '.slack',
+ params: {
+ foo: true,
+ },
+ },
+ ],
+ },
+ references: [
+ {
+ name: 'action_0',
+ type: 'action',
+ id: '1',
+ },
+ {
+ name: 'action_1',
+ type: 'action',
+ id: '1',
+ },
+ {
+ name: 'action_2',
+ type: 'action',
+ id: '2',
+ },
+ ],
+ });
+ unsecuredSavedObjectsClient.create.mockResolvedValueOnce({
+ id: '1',
+ type: 'alert',
+ attributes: {
+ actions: [],
+ scheduledTaskId: 'task-123',
+ },
+ references: [],
+ });
+ const result = await rulesClient.create({ data, skipMissingSecretsValidation: true });
+ expect(result).toMatchInlineSnapshot(`
+ Object {
+ "actions": Array [
+ Object {
+ "actionTypeId": ".slack",
+ "group": "default",
+ "id": "1",
+ "params": Object {
+ "foo": true,
+ },
+ },
+ ],
+ "alertTypeId": "123",
+ "createdAt": 2019-02-12T21:01:22.479Z,
+ "id": "1",
+ "notifyWhen": null,
+ "params": Object {
+ "bar": true,
+ },
+ "schedule": Object {
+ "interval": "1m",
+ },
+ "scheduledTaskId": "task-123",
+ "updatedAt": 2019-02-12T21:01:22.479Z,
+ }
+ `);
+ });
 });