Merge branch 'master' into line-length-100

* master:
  Docs: Add comma to reverse nested agg snippet
  Fix third-party audit task for Gradle 3.4 (elastic#23612)
  Adapter action future should restore interrupts
  Update scripting.asciidoc
  Unmark reindex as experimental

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/ThirdPartyAuditTask.groovy

@@ -209,9 +209,11 @@ public class ThirdPartyAuditTask extends AntTask {
         try {
             ant.thirdPartyAudit(failOnUnsupportedJava: false,
                             failOnMissingClasses: false,
-                            signaturesFile: new File(getClass().getResource('/forbidden/third-party-audit.txt').toURI()),
                             classpath: classpath.asPath) {
                 fileset(dir: tmpDir)
+                signatures {
+                    string(value: getClass().getResourceAsStream('/forbidden/third-party-audit.txt').getText('UTF-8'))
+                }
             }
         } catch (BuildException ignore) {}
 

core/src/main/java/org/elasticsearch/action/support/AdapterActionFuture.java

@@ -38,6 +38,7 @@ public T actionGet() {
         try {
             return get();
         } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
             throw new IllegalStateException("Future got interrupted", e);
         } catch (ExecutionException e) {
             throw rethrowExecutionException(e);
@@ -66,6 +67,7 @@ public T actionGet(long timeout, TimeUnit unit) {
         } catch (TimeoutException e) {
             throw new ElasticsearchTimeoutException(e);
         } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
             throw new IllegalStateException("Future got interrupted", e);
         } catch (ExecutionException e) {
             throw rethrowExecutionException(e);
@@ -100,4 +102,5 @@ public void onFailure(Exception e) {
     }
 
     protected abstract T convert(L listenerResponse);
+
 }

core/src/test/java/org/elasticsearch/action/support/AdapterActionFutureTests.java

@@ -0,0 +1,92 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.action.support;
+
+import org.elasticsearch.common.unit.TimeValue;
+import org.elasticsearch.test.ESTestCase;
+
+import java.util.Objects;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class AdapterActionFutureTests extends ESTestCase {
+
+    public void testInterruption() throws Exception {
+        final AdapterActionFuture<String, Integer> adapter =
+                new AdapterActionFuture<String, Integer>() {
+                    @Override
+                    protected String convert(final Integer listenerResponse) {
+                        return Objects.toString(listenerResponse);
+                    }
+                };
+
+        // test all possible methods that can be interrupted
+        final Runnable runnable = () -> {
+            final int method = randomIntBetween(0, 4);
+            switch (method) {
+                case 0:
+                    adapter.actionGet();
+                    break;
+                case 1:
+                    adapter.actionGet("30s");
+                    break;
+                case 2:
+                    adapter.actionGet(30000);
+                    break;
+                case 3:
+                    adapter.actionGet(TimeValue.timeValueSeconds(30));
+                    break;
+                case 4:
+                    adapter.actionGet(30, TimeUnit.SECONDS);
+                    break;
+                default:
+                    throw new AssertionError(method);
+            }
+        };
+
+        final CyclicBarrier barrier = new CyclicBarrier(2);
+        final Thread main = Thread.currentThread();
+        final Thread thread = new Thread(() -> {
+            try {
+                barrier.await();
+            } catch (final BrokenBarrierException | InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            main.interrupt();
+        });
+        thread.start();
+
+        barrier.await();
+
+        final AtomicBoolean interrupted = new AtomicBoolean();
+        try {
+            runnable.run();
+        } catch (final IllegalStateException e) {
+            interrupted.set(Thread.currentThread().isInterrupted());
+        }
+        // we check this here instead of in the catch block to ensure that the catch block executed
+        assertTrue(interrupted.get());
+
+        thread.join();
+    }
+
+}

docs/java-api/docs/update-by-query.asciidoc

@@ -1,8 +1,6 @@
 [[docs-update-by-query]]
 == Update By Query API
 
-experimental[The update-by-query API is new and should still be considered experimental.  The API may change in ways that are not backwards compatible]
-
 The simplest usage of `updateByQuery` updates each
 document in an index without changing the source. This usage enables
 <<picking-up-a-new-property,picking up a new property>> or another online

docs/reference/aggregations/bucket/reverse-nested-aggregation.asciidoc

@@ -22,9 +22,9 @@ the issue documents as nested documents. The mapping could look like:
 
     "issue" : {
         "properties" : {
-            "tags" : { "type" : "text" }
+            "tags" : { "type" : "text" },
             "comments" : { <1>
-                "type" : "nested"
+                "type" : "nested",
                 "properties" : {
                     "username" : { "type" : "keyword" },
                     "comment" : { "type" : "text" }

docs/reference/docs/delete-by-query.asciidoc

@@ -1,8 +1,6 @@
 [[docs-delete-by-query]]
 == Delete By Query API
 
-experimental[The delete-by-query API is new and should still be considered experimental.  The API may change in ways that are not backwards compatible]
-
 The simplest usage of `_delete_by_query` just performs a deletion on every
 document that match a query. Here is the API:
 

docs/reference/docs/reindex.asciidoc

@@ -1,8 +1,6 @@
 [[docs-reindex]]
 == Reindex API
 
-experimental[The reindex API is new and should still be considered experimental.  The API may change in ways that are not backwards compatible]
-
 IMPORTANT: Reindex does not attempt to set up the destination index.  It does
 not copy the settings of the source index.  You should set up the destination
 index prior to running a `_reindex` action, including setting up mappings, shard

docs/reference/migration/migrate_6_0/scripting.asciidoc

@@ -8,7 +8,7 @@ Use painless instead.
 
 ==== Date fields now return dates
 
-`doc.some_date_field.value` now returns `ReadableDateTime`s instead of
+`doc.some_date_field.value` now returns ++ReadableDateTime++s instead of
 milliseconds since epoch as a `long`. The same is true for
 `doc.some_date_field[some_number]`. Use `doc.some_date_field.value.millis` to
 fetch the milliseconds since epoch if you need it.