Merge branch 'master' into scottybollinger/fix-pd-bug

src/plugins/console/server/config.ts

@@ -15,8 +15,6 @@ export const config = schema.object(
     enabled: schema.boolean({ defaultValue: true }),
     proxyFilter: schema.arrayOf(schema.string(), { defaultValue: ['.*'] }),
     ssl: schema.object({ verify: schema.boolean({ defaultValue: false }) }, {}),
-
-    // This does not actually work, track this issue: https://github.com/elastic/kibana/issues/55576
     proxyConfig: schema.arrayOf(
       schema.object({
         match: schema.object({

test/plugin_functional/test_suites/doc_views/index.ts

@@ -11,7 +11,8 @@ import { PluginFunctionalProviderContext } from '../../services';
 export default function ({ getService, loadTestFile }: PluginFunctionalProviderContext) {
   const esArchiver = getService('esArchiver');
 
-  describe('doc views', function () {
+  // SKIPPED: https://github.com/elastic/kibana/issues/100060
+  describe.skip('doc views', function () {
     before(async () => {
       await esArchiver.loadIfNeeded('../functional/fixtures/es_archiver/discover');
     });

x-pack/plugins/alerting/server/alerts_client/alerts_client.ts

@@ -981,6 +981,11 @@ export class AlertsClient {
         ...this.apiKeyAsAlertAttributes(createdAPIKey, username),
         updatedBy: username,
         updatedAt: new Date().toISOString(),
+        executionStatus: {
+          status: 'pending',
+          lastExecutionDate: new Date().toISOString(),
+          error: null,
+        },
       });
       try {
         await this.unsecuredSavedObjectsClient.update('alert', id, updateAttributes, { version });

x-pack/plugins/alerting/server/alerts_client/tests/enable.test.ts

@@ -248,6 +248,11 @@ describe('enable()', () => {
             },
           },
         ],
+        executionStatus: {
+          status: 'pending',
+          lastExecutionDate: '2019-02-12T21:01:22.479Z',
+          error: null,
+        },
       },
       {
         version: '123',
@@ -352,6 +357,11 @@ describe('enable()', () => {
             },
           },
         ],
+        executionStatus: {
+          status: 'pending',
+          lastExecutionDate: '2019-02-12T21:01:22.479Z',
+          error: null,
+        },
       },
       {
         version: '123',

x-pack/plugins/enterprise_search/public/applications/app_search/components/schema/components/schema_table.tsx

@@ -35,7 +35,9 @@ export const SchemaTable: React.FC = () => {
       <EuiTableHeader>
         <EuiTableHeaderCell>{FIELD_NAME}</EuiTableHeaderCell>
         <EuiTableHeaderCell aria-hidden />
-        <EuiTableHeaderCell align="right">{FIELD_TYPE}</EuiTableHeaderCell>
+        <EuiTableHeaderCell align="right" id="schemaFieldType">
+          {FIELD_TYPE}
+        </EuiTableHeaderCell>
       </EuiTableHeader>
       <EuiTableBody>
         <EuiTableRow style={{ height: 56 }}>
@@ -74,6 +76,7 @@ export const SchemaTable: React.FC = () => {
                   fieldName={fieldName}
                   fieldType={fieldType}
                   updateExistingFieldType={updateSchemaFieldType}
+                  aria-labelledby="schemaFieldType"
                 />
               </EuiTableRowCell>
             </EuiTableRow>

x-pack/plugins/enterprise_search/public/applications/shared/schema/field_type_select/index.test.tsx

@@ -39,4 +39,10 @@ describe('SchemaFieldTypeSelect', () => {
 
     expect(wrapper.find(EuiSelect).prop('disabled')).toEqual(true);
   });
+
+  it('passes arbitrary props', () => {
+    const wrapper = shallow(<SchemaFieldTypeSelect {...props} disabled aria-label="Test label" />);
+
+    expect(wrapper.find(EuiSelect).prop('aria-label')).toEqual('Test label');
+  });
 });

x-pack/plugins/enterprise_search/public/applications/shared/schema/field_type_select/index.tsx

@@ -23,10 +23,12 @@ export const SchemaFieldTypeSelect: React.FC<Props> = ({
   fieldType,
   updateExistingFieldType,
   disabled,
+  ...rest
 }) => {
   const fieldTypeOptions = Object.values(SchemaType).map((type) => ({ value: type, text: type }));
   return (
     <EuiSelect
+      {...rest}
       name={fieldName}
       required
       value={fieldType}

x-pack/plugins/enterprise_search/public/applications/workplace_search/views/content_sources/components/schema/schema_fields_table.tsx

@@ -38,7 +38,7 @@ export const SchemaFieldsTable: React.FC = () => {
     <EuiTable tableLayout="auto">
       <EuiTableHeader>
         <EuiTableHeaderCell>{SCHEMA_ERRORS_TABLE_FIELD_NAME_HEADER}</EuiTableHeaderCell>
-        <EuiTableHeaderCell align="right">
+        <EuiTableHeaderCell align="right" id="schemaDataType">
           {SCHEMA_ERRORS_TABLE_DATA_TYPE_HEADER}
         </EuiTableHeaderCell>
       </EuiTableHeader>
@@ -58,6 +58,7 @@ export const SchemaFieldsTable: React.FC = () => {
                 fieldName={fieldName}
                 fieldType={filteredSchemaFields[fieldName]}
                 updateExistingFieldType={updateExistingFieldType}
+                aria-labelledby="schemaDataType"
               />
             </EuiTableRowCell>
           </EuiTableRow>

x-pack/plugins/fleet/common/types/index.ts

@@ -15,22 +15,13 @@ export interface FleetConfigType {
   registryProxyUrl?: string;
   agents: {
     enabled: boolean;
-    tlsCheckDisabled: boolean;
-    pollingRequestTimeout: number;
-    maxConcurrentConnections: number;
-    kibana: {
-      host?: string[] | string;
-      ca_sha256?: string;
-    };
     elasticsearch: {
       host?: string;
       ca_sha256?: string;
     };
     fleet_server?: {
       hosts?: string[];
     };
-    agentPolicyRolloutRateLimitIntervalMs: number;
-    agentPolicyRolloutRateLimitRequestPerInterval: number;
   };
   agentPolicies?: PreconfiguredAgentPolicy[];
   packages?: PreconfiguredPackage[];

x-pack/plugins/fleet/public/applications/fleet/mock/plugin_configuration.ts

@@ -14,19 +14,10 @@ export const createConfigurationMock = (): FleetConfigType => {
     registryProxyUrl: '',
     agents: {
       enabled: true,
-      tlsCheckDisabled: true,
-      pollingRequestTimeout: 1000,
-      maxConcurrentConnections: 100,
-      kibana: {
-        host: '',
-        ca_sha256: '',
-      },
       elasticsearch: {
         host: '',
         ca_sha256: '',
       },
-      agentPolicyRolloutRateLimitIntervalMs: 100,
-      agentPolicyRolloutRateLimitRequestPerInterval: 1000,
     },
   };
 };

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

@@ -30,6 +30,10 @@ export const createAppContextStartContractMock = (): FleetAppContext => {
     security: securityMock.createStart(),
     logger: loggingSystemMock.create().get(),
     isProductionMode: true,
+    configInitialValue: {
+      agents: { enabled: true, elasticsearch: {} },
+      enabled: true,
+    },
     kibanaVersion: '8.0.0',
     kibanaBranch: 'master',
   };

x-pack/plugins/fleet/server/plugin.ts

@@ -6,7 +6,6 @@
  */
 
 import type { Observable } from 'rxjs';
-import { first } from 'rxjs/operators';
 import type {
   CoreSetup,
   CoreStart,
@@ -110,6 +109,7 @@ export interface FleetAppContext {
   encryptedSavedObjectsSetup?: EncryptedSavedObjectsPluginSetup;
   security?: SecurityPluginStart;
   config$?: Observable<FleetConfigType>;
+  configInitialValue: FleetConfigType;
   savedObjects: SavedObjectsServiceStart;
   isProductionMode: PluginInitializerContext['env']['mode']['prod'];
   kibanaVersion: PluginInitializerContext['env']['packageInfo']['version'];
@@ -189,6 +189,7 @@ export class FleetPlugin
   implements AsyncPlugin<FleetSetupContract, FleetStartContract, FleetSetupDeps, FleetStartDeps> {
   private licensing$!: Observable<ILicense>;
   private config$: Observable<FleetConfigType>;
+  private configInitialValue: FleetConfigType;
   private cloud: CloudSetup | undefined;
   private logger: Logger | undefined;
 
@@ -204,15 +205,15 @@ export class FleetPlugin
     this.kibanaVersion = this.initializerContext.env.packageInfo.version;
     this.kibanaBranch = this.initializerContext.env.packageInfo.branch;
     this.logger = this.initializerContext.logger.get();
+    this.configInitialValue = this.initializerContext.config.get();
   }
 
-  public async setup(core: CoreSetup, deps: FleetSetupDeps) {
+  public setup(core: CoreSetup, deps: FleetSetupDeps) {
     this.httpSetup = core.http;
     this.licensing$ = deps.licensing.license$;
     this.encryptedSavedObjectsSetup = deps.encryptedSavedObjects;
     this.cloud = deps.cloud;
-
-    const config = await this.config$.pipe(first()).toPromise();
+    const config = this.configInitialValue;
 
     registerSavedObjects(core.savedObjects, deps.encryptedSavedObjects);
     registerEncryptedSavedObjects(deps.encryptedSavedObjects);
@@ -279,13 +280,14 @@ export class FleetPlugin
     }
   }
 
-  public async start(core: CoreStart, plugins: FleetStartDeps): Promise<FleetStartContract> {
-    await appContextService.start({
+  public start(core: CoreStart, plugins: FleetStartDeps): FleetStartContract {
+    appContextService.start({
       elasticsearch: core.elasticsearch,
       data: plugins.data,
       encryptedSavedObjectsStart: plugins.encryptedSavedObjects,
       encryptedSavedObjectsSetup: this.encryptedSavedObjectsSetup,
       security: plugins.security,
+      configInitialValue: this.configInitialValue,
       config$: this.config$,
       savedObjects: core.savedObjects,
       isProductionMode: this.isProductionMode,

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

@@ -7,7 +7,6 @@
 
 import type { Observable } from 'rxjs';
 import { BehaviorSubject } from 'rxjs';
-import { first } from 'rxjs/operators';
 import { kibanaPackageJson } from '@kbn/utils';
 import type { KibanaRequest } from 'src/core/server';
 import type {
@@ -44,7 +43,7 @@ class AppContextService {
   private httpSetup?: HttpServiceSetup;
   private externalCallbacks: ExternalCallbacksStorage = new Map();
 
-  public async start(appContext: FleetAppContext) {
+  public start(appContext: FleetAppContext) {
     this.data = appContext.data;
     this.esClient = appContext.elasticsearch.client.asInternalUser;
     this.encryptedSavedObjects = appContext.encryptedSavedObjectsStart?.getClient();
@@ -60,7 +59,7 @@ class AppContextService {
 
     if (appContext.config$) {
       this.config$ = appContext.config$;
-      const initialValue = await this.config$.pipe(first()).toPromise();
+      const initialValue = appContext.configInitialValue;
       this.configSubject$ = new BehaviorSubject(initialValue);
       this.config$.subscribe(this.configSubject$);
     }

x-pack/plugins/triggers_actions_ui/public/application/sections/alert_details/components/alert_details.test.tsx

@@ -8,6 +8,8 @@
 import * as React from 'react';
 import uuid from 'uuid';
 import { shallow } from 'enzyme';
+import { mountWithIntl, nextTick } from '@kbn/test/jest';
+import { act } from '@testing-library/react';
 import { AlertDetails } from './alert_details';
 import { Alert, ActionType, AlertTypeModel, AlertType } from '../../../../types';
 import { EuiTitle, EuiBadge, EuiFlexItem, EuiSwitch, EuiButtonEmpty, EuiText } from '@elastic/eui';
@@ -463,6 +465,74 @@ describe('disable button', () => {
     handler!({} as React.FormEvent);
     expect(enableAlert).toHaveBeenCalledTimes(1);
   });
+
+  it('should reset error banner dismissal after re-enabling the alert', async () => {
+    const alert = mockAlert({
+      enabled: true,
+      executionStatus: {
+        status: 'error',
+        lastExecutionDate: new Date('2020-08-20T19:23:38Z'),
+        error: {
+          reason: AlertExecutionStatusErrorReasons.Execute,
+          message: 'Fail',
+        },
+      },
+    });
+
+    const alertType: AlertType = {
+      id: '.noop',
+      name: 'No Op',
+      actionGroups: [{ id: 'default', name: 'Default' }],
+      recoveryActionGroup,
+      actionVariables: { context: [], state: [], params: [] },
+      defaultActionGroupId: 'default',
+      producer: ALERTS_FEATURE_ID,
+      authorizedConsumers,
+      minimumLicenseRequired: 'basic',
+      enabledInLicense: true,
+    };
+
+    const disableAlert = jest.fn();
+    const enableAlert = jest.fn();
+    const wrapper = mountWithIntl(
+      <AlertDetails
+        alert={alert}
+        alertType={alertType}
+        actionTypes={[]}
+        {...mockAlertApis}
+        disableAlert={disableAlert}
+        enableAlert={enableAlert}
+      />
+    );
+
+    await act(async () => {
+      await nextTick();
+      wrapper.update();
+    });
+
+    // Dismiss the error banner
+    await act(async () => {
+      wrapper.find('[data-test-subj="dismiss-execution-error"]').first().simulate('click');
+      await nextTick();
+    });
+
+    // Disable the alert
+    await act(async () => {
+      wrapper.find('[data-test-subj="disableSwitch"] .euiSwitch__button').first().simulate('click');
+      await nextTick();
+    });
+    expect(disableAlert).toHaveBeenCalled();
+
+    // Enable the alert
+    await act(async () => {
+      wrapper.find('[data-test-subj="disableSwitch"] .euiSwitch__button').first().simulate('click');
+      await nextTick();
+    });
+    expect(enableAlert).toHaveBeenCalled();
+
+    // Ensure error banner is back
+    expect(wrapper.find('[data-test-subj="dismiss-execution-error"]').length).toBeGreaterThan(0);
+  });
 });
 
 describe('mute button', () => {

x-pack/plugins/triggers_actions_ui/public/application/sections/alert_details/components/alert_details.tsx

@@ -236,6 +236,8 @@ export const AlertDetails: React.FunctionComponent<AlertDetailsProps> = ({
                         if (isEnabled) {
                           setIsEnabled(false);
                           await disableAlert(alert);
+                          // Reset dismiss if previously clicked
+                          setDissmissAlertErrors(false);
                         } else {
                           setIsEnabled(true);
                           await enableAlert(alert);
@@ -277,7 +279,7 @@ export const AlertDetails: React.FunctionComponent<AlertDetailsProps> = ({
                 </EuiFlexGroup>
               </EuiFlexItem>
             </EuiFlexGroup>
-            {!dissmissAlertErrors && alert.executionStatus.status === 'error' ? (
+            {alert.enabled && !dissmissAlertErrors && alert.executionStatus.status === 'error' ? (
               <EuiFlexGroup>
                 <EuiFlexItem>
                   <EuiCallOut
@@ -293,7 +295,11 @@ export const AlertDetails: React.FunctionComponent<AlertDetailsProps> = ({
                     <EuiSpacer size="s" />
                     <EuiFlexGroup gutterSize="s" wrap={true}>
                       <EuiFlexItem grow={false}>
-                        <EuiButton color="danger" onClick={() => setDissmissAlertErrors(true)}>
+                        <EuiButton
+                          data-test-subj="dismiss-execution-error"
+                          color="danger"
+                          onClick={() => setDissmissAlertErrors(true)}
+                        >
                           <FormattedMessage
                             id="xpack.triggersActionsUI.sections.alertDetails.dismissButtonTitle"
                             defaultMessage="Dismiss"

x-pack/plugins/triggers_actions_ui/public/application/sections/alert_details/components/alert_instances.test.tsx

@@ -262,7 +262,7 @@ describe('alertInstanceToListItem', () => {
     };
     expect(alertInstanceToListItem(fakeNow.getTime(), alertType, 'id', instance)).toEqual({
       instance: 'id',
-      status: { label: 'OK', healthColor: 'subdued' },
+      status: { label: 'Recovered', healthColor: 'subdued' },
       start: undefined,
       duration: 0,
       sortPriority: 1,

x-pack/plugins/triggers_actions_ui/public/application/sections/alert_details/components/alert_instances.tsx

@@ -226,7 +226,7 @@ const ACTIVE_LABEL = i18n.translate(
 
 const INACTIVE_LABEL = i18n.translate(
   'xpack.triggersActionsUI.sections.alertDetails.alertInstancesList.status.inactive',
-  { defaultMessage: 'OK' }
+  { defaultMessage: 'Recovered' }
 );
 
 function getActionGroupName(alertType: AlertType, actionGroupId?: string): string | undefined {

x-pack/test/functional_with_es_ssl/apps/triggers_actions_ui/details.ts

@@ -655,7 +655,7 @@ export default ({ getPageObjects, getService }: FtrProviderContext) => {
         ).to.eql([
           {
             instance: 'eu/east',
-            status: 'OK',
+            status: 'Recovered',
             start: '',
             duration: '',
           },