cancellation of interpreter execution

src/legacy/core_plugins/interpreter/public/functions/esaggs.ts

@@ -110,6 +110,7 @@ export const esaggs = (): ExpressionFunction<typeof name, Context, Arguments, Re
       partialRows: args.partialRows,
       inspectorAdapters: handlers.inspectorAdapters,
       queryFilter,
+      abortSignal: handlers.abortSignal,
     });
 
     return {

src/legacy/core_plugins/kibana/public/dashboard/dashboard_app_controller.tsx

@@ -249,17 +249,15 @@ export class DashboardAppController {
       !dashboardConfig.getHideWriteControls();
 
     $scope.updateQueryAndFetch = function({ query, dateRange }) {
-      if (dateRange) {
-        timefilter.setTime(dateRange);
-      }
-
-      const oldQuery = $scope.model.query;
-      if (_.isEqual(oldQuery, query)) {
+      if (_.isEqual($scope.model.query, query) && _.isEqual($scope.model.timeRange, dateRange)) {
         // The user can still request a reload in the query bar, even if the
         // query is the same, and in that case, we have to explicitly ask for
         // a reload, since no state changes will cause it.
         dashboardStateManager.requestReload();
       } else {
+        if (dateRange) {
+          timefilter.setTime(dateRange);
+        }
         $scope.model.query = query;
         dashboardStateManager.applyFilters($scope.model.query, $scope.model.filters);
       }

src/legacy/ui/public/vis/editors/default/default.js

@@ -164,18 +164,15 @@ const defaultEditor = function ($rootScope, $compile) {
             }
             this._loader = loader;
             this._handler = this._loader.embedVisualizationWithSavedObject(visualizationEl, this.savedObj, {
-              uiState: uiState,
               listenOnChange: false,
-              timeRange: timeRange,
-              filters: filters,
-              appState: appState,
+              uiState,
+              timeRange,
+              filters,
+              appState,
             });
           });
         } else {
-          this._handler.update({
-            timeRange: timeRange,
-            filters: filters,
-          });
+          this._handler.update({ timeRange, filters });
         }
 
       });

src/legacy/ui/public/vis/request_handlers/courier.js

@@ -40,9 +40,9 @@ const CourierRequestHandlerProvider = function () {
       partialRows,
       metricsAtAllLevels,
       inspectorAdapters,
-      queryFilter
+      queryFilter,
+      abortSignal
     }) {
-
       // Create a new search source that inherits the original search source
       // but has the appropriate timeRange applied via a filter.
       // This is a temporary solution until we properly pass down all required
@@ -102,6 +102,11 @@ const CourierRequestHandlerProvider = function () {
         request.stats(getRequestInspectorStats(requestSearchSource));
 
         try {
+          if (abortSignal) {
+            abortSignal.addEventListener('abort', () => {
+              requestSearchSource.cancelQueued();
+            });
+          }
           const response = await requestSearchSource.fetch();
 
           searchSource.lastQuery = queryHash;

src/legacy/ui/public/vis/request_handlers/request_handlers.d.ts

@@ -40,6 +40,7 @@ export interface RequestHandlerParams {
   inspectorAdapters?: Adapters;
   metricsAtAllLevels?: boolean;
   visParams?: any;
+  abortSignal?: AbortSignal;
 }
 
 export type RequestHandler = <T>(params: RequestHandlerParams) => T;

src/legacy/ui/public/visualize/loader/embedded_visualize_handler.ts

@@ -93,6 +93,12 @@ export class EmbeddedVisualizeHandler {
 
     const forceFetch = this.shouldForceNextFetch;
     this.shouldForceNextFetch = false;
+
+    // Abort any in-progress requests
+    if (this.abortController) this.abortController.abort();
+    this.abortController = new AbortController();
+    this.dataLoaderParams.abortSignal = this.abortController.signal;
+
     this.fetch(forceFetch).then(this.render);
   }, 100);
 
@@ -104,6 +110,7 @@ export class EmbeddedVisualizeHandler {
   private actions: any = {};
   private events$: Rx.Observable<any>;
   private autoFetch: boolean;
+  private abortController?: AbortController;
 
   constructor(
     private readonly element: HTMLElement,
@@ -223,7 +230,7 @@ export class EmbeddedVisualizeHandler {
    */
   public update(params: VisualizeUpdateParams = {}) {
     // Apply data- attributes to the element if specified
-    const dataAttrs = params.dataAttrs;
+    const { dataAttrs, ...otherParams } = params;
     if (dataAttrs) {
       Object.keys(dataAttrs).forEach(key => {
         if (dataAttrs[key] === null) {
@@ -235,19 +242,8 @@ export class EmbeddedVisualizeHandler {
       });
     }
 
-    let fetchRequired = false;
-    if (params.hasOwnProperty('timeRange')) {
-      fetchRequired = true;
-      this.dataLoaderParams.timeRange = params.timeRange;
-    }
-    if (params.hasOwnProperty('filters')) {
-      fetchRequired = true;
-      this.dataLoaderParams.filters = params.filters;
-    }
-    if (params.hasOwnProperty('query')) {
-      fetchRequired = true;
-      this.dataLoaderParams.query = params.query;
-    }
+    const fetchRequired = ['timeRange', 'filters', 'query'].some(key => params.hasOwnProperty(key));
+    this.dataLoaderParams = { ...this.dataLoaderParams, ...otherParams };
 
     if (fetchRequired) {
       this.fetchAndRender();
@@ -260,6 +256,7 @@ export class EmbeddedVisualizeHandler {
    */
   public destroy(): void {
     this.destroyed = true;
+    if (this.abortController) this.abortController.abort();
     this.debouncedFetchAndRender.cancel();
     if (this.autoFetch) {
       timefilter.off('autoRefreshFetch', this.reload);

src/legacy/ui/public/visualize/loader/pipeline_data_loader.ts

@@ -39,6 +39,7 @@ export class PipelineDataLoader {
             : undefined,
         }),
         inspectorAdapters: params.inspectorAdapters,
+        abortSignal: params.abortSignal,
       }
     );
   }

src/legacy/ui/public/visualize/loader/pipeline_helpers/run_pipeline.ts

@@ -30,6 +30,7 @@ type getInitialContextFunction = () => KibanaContext;
 export interface RunPipelineHandlers {
   getInitialContext: getInitialContextFunction;
   inspectorAdapters?: Adapters;
+  abortSignal?: AbortSignal;
 }
 
 export const runPipeline = async (

src/legacy/ui/public/visualize/loader/types.ts

@@ -98,6 +98,11 @@ export interface VisualizeLoaderParams {
    * cycle happens. Default value: `true`
    */
   autoFetch?: boolean;
+
+  /**
+   * AbortSignal can be provided which allows canceling ongoing process
+   */
+  abortSignal?: AbortSignal;
 }
 
 /**

src/plugins/data/common/expressions/interpreter_provider.ts

@@ -71,6 +71,11 @@ export function interpreterProvider(config: any) {
       // if something failed, just return the failure
       if (getType(newContext) === 'error') return newContext;
 
+      // if execution was aborted return error
+      if (handlers.abortSignal && handlers.abortSignal.aborted) {
+        return new Error(`abort was requested`);
+      }
+
       // Continue re-invoking chain until it's empty
       return await invokeChain(chain, newContext);
     } catch (e) {