From 6da0f0dcc097d71552226cf858e2e459a8f7b33a Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Wed, 5 Oct 2016 08:10:27 -0700 Subject: [PATCH 1/7] Build: Fix plugin poms to have correct artifact id (#20764) We already override the name in plugin pom files to be that configured for the plugin but we also need to explicitly set the artifactId. --- .../org/elasticsearch/gradle/plugin/PluginBuildPlugin.groovy | 1 + 1 file changed, 1 insertion(+) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/plugin/PluginBuildPlugin.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/plugin/PluginBuildPlugin.groovy index 0bb97aa84db..d5295519ad2 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/plugin/PluginBuildPlugin.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/plugin/PluginBuildPlugin.groovy @@ -231,6 +231,7 @@ public class PluginBuildPlugin extends BuildPlugin { * ahold of the actual task. Furthermore, this entire hack only exists so we can make publishing to * maven local work, since we publish to maven central externally. */ zipReal(MavenPublication) { + artifactId = project.pluginProperties.extension.name pom.withXml { XmlProvider xml -> Node root = xml.asNode() root.appendNode('name', project.pluginProperties.extension.name) From f895abcf40e6c4623bc89502c1fe02f97f467471 Mon Sep 17 00:00:00 2001 From: Anatolii Stepaniuk Date: Wed, 5 Oct 2016 15:54:32 +0300 Subject: [PATCH 2/7] Fix grammar issues in some docs This commit fixes some grammar issues in various docs. Closes #20751 Closes #20752 Closes #20754 Closes #20755 --- docs/reference/mapping/types/geo-shape.asciidoc | 2 +- docs/reference/query-dsl/geo-bounding-box-query.asciidoc | 2 +- docs/reference/query-dsl/geo-distance-query.asciidoc | 2 +- docs/reference/query-dsl/joining-queries.asciidoc | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/reference/mapping/types/geo-shape.asciidoc b/docs/reference/mapping/types/geo-shape.asciidoc index 1f0c76e1b93..4fe185fe463 100644 --- a/docs/reference/mapping/types/geo-shape.asciidoc +++ b/docs/reference/mapping/types/geo-shape.asciidoc @@ -175,7 +175,7 @@ this into a tree_levels setting of 26. ===== Performance considerations Elasticsearch uses the paths in the prefix tree as terms in the index -and in queries. The higher the levels is (and thus the precision), the +and in queries. The higher the level is (and thus the precision), the more terms are generated. Of course, calculating the terms, keeping them in memory, and storing them on disk all have a price. Especially with higher tree levels, indices can become extremely large even with a modest diff --git a/docs/reference/query-dsl/geo-bounding-box-query.asciidoc b/docs/reference/query-dsl/geo-bounding-box-query.asciidoc index 40debb57105..1307d0184f1 100644 --- a/docs/reference/query-dsl/geo-bounding-box-query.asciidoc +++ b/docs/reference/query-dsl/geo-bounding-box-query.asciidoc @@ -92,7 +92,7 @@ Default is `memory`. ==== Accepted Formats In much the same way the geo_point type can accept different -representation of the geo point, the filter can accept it as well: +representations of the geo point, the filter can accept it as well: [float] ===== Lat Lon As Properties diff --git a/docs/reference/query-dsl/geo-distance-query.asciidoc b/docs/reference/query-dsl/geo-distance-query.asciidoc index c6496eac39d..4591ccf5c9e 100644 --- a/docs/reference/query-dsl/geo-distance-query.asciidoc +++ b/docs/reference/query-dsl/geo-distance-query.asciidoc @@ -69,7 +69,7 @@ GET /my_locations/location/_search ==== Accepted Formats In much the same way the `geo_point` type can accept different -representation of the geo point, the filter can accept it as well: +representations of the geo point, the filter can accept it as well: [float] ===== Lat Lon As Properties diff --git a/docs/reference/query-dsl/joining-queries.asciidoc b/docs/reference/query-dsl/joining-queries.asciidoc index cfbbf5360b6..6a467fe539a 100644 --- a/docs/reference/query-dsl/joining-queries.asciidoc +++ b/docs/reference/query-dsl/joining-queries.asciidoc @@ -7,7 +7,7 @@ which are designed to scale horizontally. <>:: -Documents may contains fields of type <>. These +Documents may contain fields of type <>. These fields are used to index arrays of objects, where each object can be queried (with the `nested` query) as an independent document. From 41d6529d062bcfd53a10d2c9f3c537d0c9fe1500 Mon Sep 17 00:00:00 2001 From: Nik Everett Date: Wed, 5 Oct 2016 11:16:40 -0400 Subject: [PATCH 3/7] CONSOLEify scroll docs This causes the snippets to be tested during the build and gives helpful links to the reader to open the docs in console or copy them as curl commands. Relates to #18160 --- docs/build.gradle | 1 - docs/reference/search/request/scroll.asciidoc | 55 ++++++++++--------- 2 files changed, 30 insertions(+), 26 deletions(-) diff --git a/docs/build.gradle b/docs/build.gradle index 2d550e1f191..44b467dee9e 100644 --- a/docs/build.gradle +++ b/docs/build.gradle @@ -171,7 +171,6 @@ buildRestTests.expectedUnconvertedCandidates = [ 'reference/search/request/highlighting.asciidoc', 'reference/search/request/inner-hits.asciidoc', 'reference/search/request/rescore.asciidoc', - 'reference/search/request/scroll.asciidoc', 'reference/search/search-template.asciidoc', 'reference/search/suggesters/completion-suggest.asciidoc', ] diff --git a/docs/reference/search/request/scroll.asciidoc b/docs/reference/search/request/scroll.asciidoc index d924a56b652..bee8e158175 100644 --- a/docs/reference/search/request/scroll.asciidoc +++ b/docs/reference/search/request/scroll.asciidoc @@ -38,7 +38,7 @@ should keep the ``search context'' alive (see <>), eg `?s [source,js] -------------------------------------------------- -curl -XGET 'localhost:9200/twitter/tweet/_search?scroll=1m' -d ' +POST /twitter/tweet/_search?scroll=1m { "query": { "match" : { @@ -46,8 +46,9 @@ curl -XGET 'localhost:9200/twitter/tweet/_search?scroll=1m' -d ' } } } -' -------------------------------------------------- +// CONSOLE +// TEST[setup:twitter] The result from the above request includes a `_scroll_id`, which should be passed to the `scroll` API in order to retrieve the next batch of @@ -55,13 +56,14 @@ results. [source,js] -------------------------------------------------- -curl -XGET <1> 'localhost:9200/_search/scroll' <2> -d' +POST <1> /_search/scroll <2> { "scroll" : "1m", <3> - "scroll_id" : "c2Nhbjs2OzM0NDg1ODpzRlBLc0FXNlNyNm5JWUc1" <4> + "scroll_id" : "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAAD4WYm9laVYtZndUQlNsdDcwakFMNjU1QQ==" <4> } -' -------------------------------------------------- +// CONSOLE +// TEST[continued s/DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAAD4WYm9laVYtZndUQlNsdDcwakFMNjU1QQ==/$body._scroll_id/] <1> `GET` or `POST` can be used. <2> The URL should not include the `index` or `type` name -- these @@ -73,14 +75,6 @@ curl -XGET <1> 'localhost:9200/_search/scroll' <2> -d' Each call to the `scroll` API returns the next batch of results until there are no more results left to return, ie the `hits` array is empty. -For backwards compatibility, `scroll_id` and `scroll` can be passed in the query string. -And the `scroll_id` can be passed in the request body - -[source,js] --------------------------------------------------- -curl -XGET 'localhost:9200/_search/scroll?scroll=1m' -d 'c2Nhbjs2OzM0NDg1ODpzRlBLc0FXNlNyNm5JWUc1' --------------------------------------------------- - IMPORTANT: The initial search request and each subsequent scroll request returns a new `_scroll_id` -- only the most recent `_scroll_id` should be used. @@ -94,14 +88,15 @@ order, this is the most efficient option: [source,js] -------------------------------------------------- -curl -XGET 'localhost:9200/_search?scroll=1m' -d ' +GET /_search?scroll=1m { "sort": [ "_doc" ] } -' -------------------------------------------------- +// CONSOLE +// TEST[setup:twitter] [[scroll-search-context]] ==== Keeping the search context alive @@ -130,8 +125,9 @@ You can check how many search contexts are open with the [source,js] --------------------------------------- -curl -XGET localhost:9200/_nodes/stats/indices/search?pretty +GET /_nodes/stats/indices/search --------------------------------------- +// CONSOLE ==== Clear scroll API @@ -143,37 +139,46 @@ cleared as soon as the scroll is not being used anymore using the [source,js] --------------------------------------- -curl -XDELETE localhost:9200/_search/scroll -d ' +DELETE /_search/scroll { - "scroll_id" : ["c2Nhbjs2OzM0NDg1ODpzRlBLc0FXNlNyNm5JWUc1"] -}' + "scroll_id" : ["DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAAD4WYm9laVYtZndUQlNsdDcwakFMNjU1QQ=="] +} --------------------------------------- +// CONSOLE +// TEST[catch:missing] Multiple scroll IDs can be passed as array: [source,js] --------------------------------------- -curl -XDELETE localhost:9200/_search/scroll -d ' +DELETE /_search/scroll { - "scroll_id" : ["c2Nhbjs2OzM0NDg1ODpzRlBLc0FXNlNyNm5JWUc1", "aGVuRmV0Y2g7NTsxOnkxaDZ"] -}' + "scroll_id" : [ + "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAAD4WYm9laVYtZndUQlNsdDcwakFMNjU1QQ==", + "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAABFmtSWWRRWUJrU2o2ZExpSGJCVmQxYUEAAAAAAAAAAxZrUllkUVlCa1NqNmRMaUhiQlZkMWFBAAAAAAAAAAIWa1JZZFFZQmtTajZkTGlIYkJWZDFhQQAAAAAAAAAFFmtSWWRRWUJrU2o2ZExpSGJCVmQxYUEAAAAAAAAABBZrUllkUVlCa1NqNmRMaUhiQlZkMWFB" + ] +} --------------------------------------- +// CONSOLE +// TEST[catch:missing] All search contexts can be cleared with the `_all` parameter: [source,js] --------------------------------------- -curl -XDELETE localhost:9200/_search/scroll/_all +DELETE /_search/scroll/_all --------------------------------------- +// CONSOLE The `scroll_id` can also be passed as a query string parameter or in the request body. Multiple scroll IDs can be passed as comma separated values: [source,js] --------------------------------------- -curl -XDELETE localhost:9200/_search/scroll \ - -d 'c2Nhbjs2OzM0NDg1ODpzRlBLc0FXNlNyNm5JWUc1,aGVuRmV0Y2g7NTsxOnkxaDZ' +DELETE /_search/scroll/DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAAD4WYm9laVYtZndUQlNsdDcwakFMNjU1QQ==,DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAABFmtSWWRRWUJrU2o2ZExpSGJCVmQxYUEAAAAAAAAAAxZrUllkUVlCa1NqNmRMaUhiQlZkMWFBAAAAAAAAAAIWa1JZZFFZQmtTajZkTGlIYkJWZDFhQQAAAAAAAAAFFmtSWWRRWUJrU2o2ZExpSGJCVmQxYUEAAAAAAAAABBZrUllkUVlCa1NqNmRMaUhiQlZkMWFB --------------------------------------- +// CONSOLE +// TEST[catch:missing] [[sliced-scroll]] ==== Sliced Scroll From 8c4108d8868e4ee05601b2af9cb70483e9a36b5f Mon Sep 17 00:00:00 2001 From: Jason Tedor Date: Wed, 5 Oct 2016 11:26:19 -0400 Subject: [PATCH 4/7] Add response params to REST params did you mean This commit adds the response params as candidates for the did you mean suggestions for strict REST params handling. Relates #20753 --- .../java/org/elasticsearch/rest/BaseRestHandler.java | 12 ++++++++---- .../org/elasticsearch/rest/BaseRestHandlerTests.java | 7 +++++++ 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/core/src/main/java/org/elasticsearch/rest/BaseRestHandler.java b/core/src/main/java/org/elasticsearch/rest/BaseRestHandler.java index 3bc91dc48e2..3bb6c6773b9 100644 --- a/core/src/main/java/org/elasticsearch/rest/BaseRestHandler.java +++ b/core/src/main/java/org/elasticsearch/rest/BaseRestHandler.java @@ -33,6 +33,7 @@ import org.elasticsearch.plugins.ActionPlugin; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; +import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Set; @@ -70,7 +71,7 @@ public abstract class BaseRestHandler extends AbstractComponent implements RestH request.unconsumedParams().stream().filter(p -> !responseParams().contains(p)).collect(Collectors.toCollection(TreeSet::new)); // validate the non-response params - if (!unconsumedParams.isEmpty()) { + if (unconsumedParams.isEmpty() == false) { String message = String.format( Locale.ROOT, "request [%s] contains unrecognized parameter%s: ", @@ -80,10 +81,13 @@ public abstract class BaseRestHandler extends AbstractComponent implements RestH for (final String unconsumedParam : unconsumedParams) { final LevensteinDistance ld = new LevensteinDistance(); final List> scoredParams = new ArrayList<>(); - for (String consumedParam : request.consumedParams()) { - final float distance = ld.getDistance(unconsumedParam, consumedParam); + final Set candidateParams = new HashSet<>(); + candidateParams.addAll(request.consumedParams()); + candidateParams.addAll(responseParams()); + for (final String candidateParam : candidateParams) { + final float distance = ld.getDistance(unconsumedParam, candidateParam); if (distance > 0.5f) { - scoredParams.add(new Tuple<>(distance, consumedParam)); + scoredParams.add(new Tuple<>(distance, candidateParam)); } } CollectionUtil.timSort(scoredParams, (a, b) -> { diff --git a/core/src/test/java/org/elasticsearch/rest/BaseRestHandlerTests.java b/core/src/test/java/org/elasticsearch/rest/BaseRestHandlerTests.java index 8f9dd445369..ef67006c204 100644 --- a/core/src/test/java/org/elasticsearch/rest/BaseRestHandlerTests.java +++ b/core/src/test/java/org/elasticsearch/rest/BaseRestHandlerTests.java @@ -94,11 +94,17 @@ public class BaseRestHandlerTests extends ESTestCase { request.param("very_close_to_parameter_2"); return channel -> executed.set(true); } + + @Override + protected Set responseParams() { + return Collections.singleton("response_param"); + } }; final HashMap params = new HashMap<>(); params.put("consumed", randomAsciiOfLength(8)); params.put("flied", randomAsciiOfLength(8)); + params.put("respones_param", randomAsciiOfLength(8)); params.put("tokenzier", randomAsciiOfLength(8)); params.put("very_close_to_parametre", randomAsciiOfLength(8)); params.put("very_far_from_every_consumed_parameter", randomAsciiOfLength(8)); @@ -111,6 +117,7 @@ public class BaseRestHandlerTests extends ESTestCase { hasToString(containsString( "request [/] contains unrecognized parameters: " + "[flied] -> did you mean [field]?, " + + "[respones_param] -> did you mean [response_param]?, " + "[tokenzier] -> did you mean [tokenizer]?, " + "[very_close_to_parametre] -> did you mean any of [very_close_to_parameter_1, very_close_to_parameter_2]?, " + "[very_far_from_every_consumed_parameter]"))); From 02dd1ba61a6bdc2163eaee327a6938f8517c7f41 Mon Sep 17 00:00:00 2001 From: Dimitrios Liappis Date: Wed, 5 Oct 2016 17:42:25 +0200 Subject: [PATCH 5/7] [vagrant] packaging tests: add parametrized retries for dnf install (#20749) * Add parametrized retries for dnf install Given that dnf doesn't do retries installation of openjdk can sometimes be affected by checksum or network issues with mirrors offered by metalink. Allow setting number of retries through the parameter `install_command_retries` * Insert delay between package install retries Fedora's metalink occasionally returns broken mirrors. Pausing for a few seconds between retries increases the chance of receiving a different list of mirrors from metalink and success with package installation. --- Vagrantfile | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/Vagrantfile b/Vagrantfile index 761ef20628d..8ade7c8dd30 100644 --- a/Vagrantfile +++ b/Vagrantfile @@ -156,6 +156,7 @@ def dnf_common(config) update_command: "dnf check-update", update_tracking_file: "/var/cache/dnf/last_update", install_command: "dnf install -y", + install_command_retries: 5, java_package: "java-1.8.0-openjdk-devel") if Vagrant.has_plugin?("vagrant-cachier") # Autodetect doesn't work.... @@ -205,6 +206,7 @@ def provision(config, update_command: 'required', update_tracking_file: 'required', install_command: 'required', + install_command_retries: 0, java_package: 'required', extra: '') # Vagrant run ruby 2.0.0 which doesn't have required named parameters.... @@ -215,9 +217,27 @@ def provision(config, config.vm.provision "bats dependencies", type: "shell", inline: <<-SHELL set -e set -o pipefail + + # Retry install command up to $2 times, if failed + retry_installcommand() { + n=0 + while true; do + #{install_command} $1 && break + let n=n+1 + if [ $n -ge $2 ]; then + echo "==> Exhausted retries to install $1" + return 1 + fi + echo "==> Retrying installing $1, attempt $((n+1))" + # Add a small delay to increase chance of metalink providing updated list of mirrors + sleep 5 + done + } + installed() { command -v $1 2>&1 >/dev/null } + install() { # Only apt-get update if we haven't in the last day if [ ! -f #{update_tracking_file} ] || [ "x$(find #{update_tracking_file} -mtime +0)" == "x#{update_tracking_file}" ]; then @@ -226,8 +246,14 @@ def provision(config, touch #{update_tracking_file} fi echo "==> Installing $1" - #{install_command} $1 + if [ #{install_command_retries} -eq 0 ] + then + #{install_command} $1 + else + retry_installcommand $1 #{install_command_retries} + fi } + ensure() { installed $1 || install $1 } From ba88d9af57c1d26f3abb30c106c406477ee87af8 Mon Sep 17 00:00:00 2001 From: Jack Conradson Date: Wed, 5 Oct 2016 09:47:20 -0700 Subject: [PATCH 6/7] Remove all date 'now' methods from the Painless whitelist to ensure Painless scripts are pure functions. --- .../painless/java.time.chrono.txt | 20 ------------------- .../org/elasticsearch/painless/java.time.txt | 20 ------------------- 2 files changed, 40 deletions(-) diff --git a/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.chrono.txt b/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.chrono.txt index 7374efea04b..286141e2921 100644 --- a/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.chrono.txt +++ b/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.chrono.txt @@ -82,8 +82,6 @@ class Chronology -> java.time.chrono.Chronology extends Comparable { ChronoLocalDate date(Era,int,int,int) ChronoLocalDate date(int,int,int) ChronoLocalDate dateEpochDay(long) - ChronoLocalDate dateNow() - ChronoLocalDate dateNow(ZoneId) ChronoLocalDate dateYearDay(Era,int,int) ChronoLocalDate dateYearDay(int,int) boolean equals(Object) @@ -171,8 +169,6 @@ class HijrahChronology -> java.time.chrono.HijrahChronology extends AbstractChro HijrahDate date(int,int,int) HijrahDate date(Era,int,int,int) HijrahDate dateEpochDay(long) - HijrahDate dateNow() - HijrahDate dateNow(ZoneId) HijrahDate dateYearDay(int,int) HijrahDate dateYearDay(Era,int,int) HijrahEra eraOf(int) @@ -185,8 +181,6 @@ class HijrahDate -> java.time.chrono.HijrahDate extends ChronoLocalDate,Temporal HijrahEra getEra() HijrahDate minus(TemporalAmount) HijrahDate minus(long,TemporalUnit) - HijrahDate now() - HijrahDate now(ZoneId) HijrahDate of(int,int,int) HijrahDate plus(TemporalAmount) HijrahDate plus(long,TemporalUnit) @@ -201,8 +195,6 @@ class IsoChronology -> java.time.chrono.IsoChronology extends AbstractChronology LocalDate date(int,int,int) LocalDate date(Era,int,int,int) LocalDate dateEpochDay(long) - LocalDate dateNow() - LocalDate dateNow(ZoneId) LocalDate dateYearDay(int,int) LocalDate dateYearDay(Era,int,int) IsoEra eraOf(int) @@ -219,8 +211,6 @@ class JapaneseChronology -> java.time.chrono.JapaneseChronology extends Abstract JapaneseDate date(int,int,int) JapaneseDate date(Era,int,int,int) JapaneseDate dateEpochDay(long) - JapaneseDate dateNow() - JapaneseDate dateNow(ZoneId) JapaneseDate dateYearDay(int,int) JapaneseDate dateYearDay(Era,int,int) JapaneseEra eraOf(int) @@ -228,8 +218,6 @@ class JapaneseChronology -> java.time.chrono.JapaneseChronology extends Abstract } class JapaneseDate -> java.time.chrono.JapaneseDate extends ChronoLocalDate,Temporal,TemporalAccessor,TemporalAdjuster,Comparable,Object { - JapaneseDate now() - JapaneseDate now(ZoneId) JapaneseDate of(int,int,int) JapaneseDate from(TemporalAccessor) JapaneseChronology getChronology() @@ -259,8 +247,6 @@ class MinguoChronology -> java.time.chrono.MinguoChronology extends AbstractChro MinguoDate date(int,int,int) MinguoDate date(Era,int,int,int) MinguoDate dateEpochDay(long) - MinguoDate dateNow() - MinguoDate dateNow(ZoneId) MinguoDate dateYearDay(int,int) MinguoDate dateYearDay(Era,int,int) MinguoEra eraOf(int) @@ -268,8 +254,6 @@ class MinguoChronology -> java.time.chrono.MinguoChronology extends AbstractChro } class MinguoDate -> java.time.chrono.MinguoDate extends ChronoLocalDate,Temporal,TemporalAccessor,TemporalAdjuster,Comparable,Object { - MinguoDate now() - MinguoDate now(ZoneId) MinguoDate of(int,int,int) MinguoDate from(TemporalAccessor) MinguoChronology getChronology() @@ -288,8 +272,6 @@ class ThaiBuddhistChronology -> java.time.chrono.ThaiBuddhistChronology extends ThaiBuddhistDate date(int,int,int) ThaiBuddhistDate date(Era,int,int,int) ThaiBuddhistDate dateEpochDay(long) - ThaiBuddhistDate dateNow() - ThaiBuddhistDate dateNow(ZoneId) ThaiBuddhistDate dateYearDay(int,int) ThaiBuddhistDate dateYearDay(Era,int,int) ThaiBuddhistEra eraOf(int) @@ -297,8 +279,6 @@ class ThaiBuddhistChronology -> java.time.chrono.ThaiBuddhistChronology extends } class ThaiBuddhistDate -> java.time.chrono.ThaiBuddhistDate extends ChronoLocalDate,Temporal,TemporalAccessor,TemporalAdjuster,Comparable,Object { - ThaiBuddhistDate now() - ThaiBuddhistDate now(ZoneId) ThaiBuddhistDate of(int,int,int) ThaiBuddhistDate from(TemporalAccessor) ThaiBuddhistChronology getChronology() diff --git a/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.txt b/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.txt index 4481004fdf6..4c99be712ad 100644 --- a/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.txt +++ b/modules/lang-painless/src/main/resources/org/elasticsearch/painless/java.time.txt @@ -103,8 +103,6 @@ class Instant -> java.time.Instant extends Comparable,Temporal,TemporalAccessor, Instant minusMillis(long) Instant minusNanos(long) Instant minusSeconds(long) - Instant now() - Instant now(Clock) Instant ofEpochSecond(long) Instant ofEpochSecond(long,long) Instant ofEpochMilli(long) @@ -143,8 +141,6 @@ class LocalDate -> java.time.LocalDate extends ChronoLocalDate,Temporal,Temporal LocalDate minusMonths(long) LocalDate minusWeeks(long) LocalDate minusDays(long) - LocalDate now() - LocalDate now(ZoneId) LocalDate of(int,int,int) LocalDate ofYearDay(int,int) LocalDate ofEpochDay(long) @@ -191,8 +187,6 @@ class LocalDateTime -> java.time.LocalDateTime extends ChronoLocalDateTime,Tempo LocalDateTime minusSeconds(long) LocalDateTime minusWeeks(long) LocalDateTime minusYears(long) - LocalDateTime now() - LocalDateTime now(ZoneId) LocalDateTime of(LocalDate,LocalTime) LocalDateTime of(int,int,int,int,int) LocalDateTime of(int,int,int,int,int,int) @@ -246,8 +240,6 @@ class LocalTime -> java.time.LocalTime extends Temporal,TemporalAccessor,Tempora LocalTime minusMinutes(long) LocalTime minusNanos(long) LocalTime minusSeconds(long) - LocalTime now() - LocalTime now(ZoneId) LocalTime of(int,int) LocalTime of(int,int,int) LocalTime of(int,int,int,int) @@ -283,8 +275,6 @@ class MonthDay -> java.time.MonthDay extends TemporalAccessor,TemporalAdjuster,C boolean isAfter(MonthDay) boolean isBefore(MonthDay) boolean isValidYear(int) - MonthDay now() - MonthDay now(ZoneId) MonthDay of(int,int) MonthDay parse(CharSequence) MonthDay parse(CharSequence,DateTimeFormatter) @@ -325,8 +315,6 @@ class OffsetDateTime -> java.time.OffsetDateTime extends Temporal,TemporalAccess OffsetDateTime minusMinutes(long) OffsetDateTime minusSeconds(long) OffsetDateTime minusNanos(long) - OffsetDateTime now() - OffsetDateTime now(ZoneId) OffsetDateTime of(LocalDate,LocalTime,ZoneOffset) OffsetDateTime of(LocalDateTime,ZoneOffset) OffsetDateTime of(int,int,int,int,int,int,int,ZoneOffset) @@ -380,8 +368,6 @@ class OffsetTime -> java.time.OffsetTime extends Temporal,TemporalAccessor,Tempo boolean isAfter(OffsetTime) boolean isBefore(OffsetTime) boolean isEqual(OffsetTime) - OffsetTime now() - OffsetTime now(ZoneId) OffsetTime of(LocalTime,ZoneOffset) OffsetTime of(int,int,int,int,ZoneOffset) OffsetTime ofInstant(Instant,ZoneId) @@ -460,8 +446,6 @@ class Year -> java.time.Year extends Temporal,TemporalAccessor,TemporalAdjuster, Year minus(TemporalAmount) Year minus(long,TemporalUnit) Year minusYears(long) - Year now() - Year now(ZoneId) Year of(int) Year parse(CharSequence) Year parse(CharSequence,DateTimeFormatter) @@ -491,8 +475,6 @@ class YearMonth -> java.time.YearMonth extends Temporal,TemporalAccessor,Tempora YearMonth minus(long,TemporalUnit) YearMonth minusYears(long) YearMonth minusMonths(long) - YearMonth now() - YearMonth now(ZoneId) YearMonth of(int,int) YearMonth parse(CharSequence) YearMonth parse(CharSequence,DateTimeFormatter) @@ -530,8 +512,6 @@ class ZonedDateTime -> java.time.ZonedDateTime extends ChronoZonedDateTime,Tempo ZonedDateTime minusMinutes(long) ZonedDateTime minusSeconds(long) ZonedDateTime minusNanos(long) - ZonedDateTime now() - ZonedDateTime now(ZoneId) ZonedDateTime of(LocalDate,LocalTime,ZoneId) ZonedDateTime of(LocalDateTime,ZoneId) ZonedDateTime of(int,int,int,int,int,int,int,ZoneId) From 15950b71b8ccec44e7d64b38a801573730d77b1b Mon Sep 17 00:00:00 2001 From: Ali Beyad Date: Wed, 5 Oct 2016 14:23:25 -0400 Subject: [PATCH 7/7] BalancedShardAllocator code improvements (#20746) This commit improves the logic flow of BalancedShardsAllocator in preparation for separating out components of this class to be used in the cluster allocation explain APIs. In particular, this commit: 1. Adds a minimum value for the index/shard balance factor settings (0.0) 2. Makes the Balancer data structures immutable and pre-calculated at construction time. 3. Removes difficult to follow labeled blocks / GOTOs 4. Better logic for skipping over the same replica set when one of the replicas received a NO decision 5. Separates the decision making logic for a single shard from the logic to iterate over all unassigned shards. --- .../allocator/BalancedShardsAllocator.java | 245 ++++++++++-------- 1 file changed, 134 insertions(+), 111 deletions(-) diff --git a/core/src/main/java/org/elasticsearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java b/core/src/main/java/org/elasticsearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java index 50c2d28cf01..e35df67ae62 100644 --- a/core/src/main/java/org/elasticsearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java +++ b/core/src/main/java/org/elasticsearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java @@ -73,9 +73,9 @@ import static org.elasticsearch.cluster.routing.ShardRoutingState.RELOCATING; public class BalancedShardsAllocator extends AbstractComponent implements ShardsAllocator { public static final Setting INDEX_BALANCE_FACTOR_SETTING = - Setting.floatSetting("cluster.routing.allocation.balance.index", 0.55f, Property.Dynamic, Property.NodeScope); + Setting.floatSetting("cluster.routing.allocation.balance.index", 0.55f, 0.0f, Property.Dynamic, Property.NodeScope); public static final Setting SHARD_BALANCE_FACTOR_SETTING = - Setting.floatSetting("cluster.routing.allocation.balance.shard", 0.45f, Property.Dynamic, Property.NodeScope); + Setting.floatSetting("cluster.routing.allocation.balance.shard", 0.45f, 0.0f, Property.Dynamic, Property.NodeScope); public static final Setting THRESHOLD_SETTING = Setting.floatSetting("cluster.routing.allocation.balance.threshold", 1.0f, 0.0f, Property.Dynamic, Property.NodeScope); @@ -210,7 +210,7 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards */ public static class Balancer { private final Logger logger; - private final Map nodes = new HashMap<>(); + private final Map nodes; private final RoutingAllocation allocation; private final RoutingNodes routingNodes; private final WeightFunction weight; @@ -218,6 +218,7 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards private final float threshold; private final MetaData metaData; private final float avgShardsPerNode; + private final NodeSorter sorter; public Balancer(Logger logger, RoutingAllocation allocation, WeightFunction weight, float threshold) { this.logger = logger; @@ -227,7 +228,8 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards this.routingNodes = allocation.routingNodes(); this.metaData = allocation.metaData(); avgShardsPerNode = ((float) metaData.getTotalNumberOfShards()) / routingNodes.size(); - buildModelFromAssigned(); + nodes = Collections.unmodifiableMap(buildModelFromAssigned()); + sorter = newNodeSorter(); } /** @@ -304,11 +306,10 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards } public Map weighShard(ShardRouting shard) { - final NodeSorter sorter = newNodeSorter(); final ModelNode[] modelNodes = sorter.modelNodes; final float[] weights = sorter.weights; - buildWeightOrderedIndices(sorter); + buildWeightOrderedIndices(); Map nodes = new HashMap<>(modelNodes.length); float currentNodeWeight = 0.0f; for (int i = 0; i < modelNodes.length; i++) { @@ -332,20 +333,19 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards * weight of the maximum node and the minimum node according to the * {@link WeightFunction}. This weight is calculated per index to * distribute shards evenly per index. The balancer tries to relocate - * shards only if the delta exceeds the threshold. If the default case + * shards only if the delta exceeds the threshold. In the default case * the threshold is set to 1.0 to enforce gaining relocation * only, or in other words relocations that move the weight delta closer * to 0.0 */ private void balanceByWeights() { - final NodeSorter sorter = newNodeSorter(); final AllocationDeciders deciders = allocation.deciders(); final ModelNode[] modelNodes = sorter.modelNodes; final float[] weights = sorter.weights; - for (String index : buildWeightOrderedIndices(sorter)) { + for (String index : buildWeightOrderedIndices()) { IndexMetaData indexMetaData = metaData.index(index); - // find nodes that have a shard of this index or where shards of this index are allowed to stay + // find nodes that have a shard of this index or where shards of this index are allowed to be allocated to, // move these nodes to the front of modelNodes so that we can only balance based on these nodes int relevantNodes = 0; for (int i = 0; i < modelNodes.length; i++) { @@ -440,14 +440,14 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards * allocations on added nodes from one index when the weight parameters * for global balance overrule the index balance at an intermediate * state. For example this can happen if we have 3 nodes and 3 indices - * with 3 shards and 1 shard. At the first stage all three nodes hold - * 2 shard for each index. now we add another node and the first index - * is balanced moving 3 two of the nodes over to the new node since it + * with 3 primary and 1 replica shards. At the first stage all three nodes hold + * 2 shard for each index. Now we add another node and the first index + * is balanced moving three shards from two of the nodes over to the new node since it * has no shards yet and global balance for the node is way below * average. To re-balance we need to move shards back eventually likely * to the nodes we relocated them from. */ - private String[] buildWeightOrderedIndices(NodeSorter sorter) { + private String[] buildWeightOrderedIndices() { final String[] indices = allocation.routingTable().indicesRouting().keys().toArray(String.class); final float[] deltas = new float[indices.length]; for (int i = 0; i < deltas.length; i++) { @@ -501,7 +501,6 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards // Iterate over the started shards interleaving between nodes, and check if they can remain. In the presence of throttling // shard movements, the goal of this iteration order is to achieve a fairer movement of shards from the nodes that are // offloading the shards. - final NodeSorter sorter = newNodeSorter(); for (Iterator it = allocation.routingNodes().nodeInterleavedShardIterator(); it.hasNext(); ) { ShardRouting shardRouting = it.next(); // we can only move started shards... @@ -511,7 +510,7 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards RoutingNode routingNode = sourceNode.getRoutingNode(); Decision decision = allocation.deciders().canRemain(shardRouting, routingNode, allocation); if (decision.type() == Decision.Type.NO) { - moveShard(sorter, shardRouting, sourceNode, routingNode); + moveShard(shardRouting, sourceNode, routingNode); } } } @@ -520,7 +519,7 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards /** * Move started shard to the minimal eligible node with respect to the weight function */ - private void moveShard(NodeSorter sorter, ShardRouting shardRouting, ModelNode sourceNode, RoutingNode routingNode) { + private void moveShard(ShardRouting shardRouting, ModelNode sourceNode, RoutingNode routingNode) { logger.debug("[{}][{}] allocated on [{}], but can no longer be allocated on it, moving...", shardRouting.index(), shardRouting.id(), routingNode.node()); sorter.reset(shardRouting.getIndexName()); /* @@ -557,7 +556,8 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards * on the target node which we respect during the allocation / balancing * process. In short, this method recreates the status-quo in the cluster. */ - private void buildModelFromAssigned() { + private Map buildModelFromAssigned() { + Map nodes = new HashMap<>(); for (RoutingNode rn : routingNodes) { ModelNode node = new ModelNode(rn); nodes.put(rn.nodeId(), node); @@ -572,6 +572,7 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards } } } + return nodes; } /** @@ -626,91 +627,37 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards do { for (int i = 0; i < primaryLength; i++) { ShardRouting shard = primary[i]; - if (!shard.primary()) { - final Decision decision = deciders.canAllocate(shard, allocation); - if (decision.type() == Type.NO) { - UnassignedInfo.AllocationStatus allocationStatus = UnassignedInfo.AllocationStatus.fromDecision(decision); - unassigned.ignoreShard(shard, allocationStatus, allocation.changes()); - while(i < primaryLength-1 && comparator.compare(primary[i], primary[i+1]) == 0) { - unassigned.ignoreShard(primary[++i], allocationStatus, allocation.changes()); - } - continue; - } else { + Tuple allocationDecision = allocateUnassignedShard(shard, throttledNodes); + final Decision decision = allocationDecision.v1(); + final ModelNode minNode = allocationDecision.v2(); + + if (decision.type() == Type.YES) { + if (logger.isTraceEnabled()) { + logger.trace("Assigned shard [{}] to [{}]", shard, minNode.getNodeId()); + } + + final long shardSize = DiskThresholdDecider.getExpectedShardSize(shard, allocation, + ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE); + shard = routingNodes.initializeShard(shard, minNode.getNodeId(), null, shardSize, allocation.changes()); + minNode.addShard(shard); + if (!shard.primary()) { + // copy over the same replica shards to the secondary array so they will get allocated + // in a subsequent iteration, allowing replicas of other shards to be allocated first while(i < primaryLength-1 && comparator.compare(primary[i], primary[i+1]) == 0) { secondary[secondaryLength++] = primary[++i]; } } - } - assert !shard.assignedToNode() : shard; - /* find an node with minimal weight we can allocate on*/ - float minWeight = Float.POSITIVE_INFINITY; - ModelNode minNode = null; - Decision decision = null; - if (throttledNodes.size() < nodes.size()) { - /* Don't iterate over an identity hashset here the - * iteration order is different for each run and makes testing hard */ - for (ModelNode node : nodes.values()) { - if (throttledNodes.contains(node)) { - continue; - } - if (!node.containsShard(shard)) { - // simulate weight if we would add shard to node - float currentWeight = weight.weightShardAdded(this, node, shard.getIndexName()); - /* - * Unless the operation is not providing any gains we - * don't check deciders - */ - if (currentWeight <= minWeight) { - Decision currentDecision = deciders.canAllocate(shard, node.getRoutingNode(), allocation); - NOUPDATE: - if (currentDecision.type() == Type.YES || currentDecision.type() == Type.THROTTLE) { - if (currentWeight == minWeight) { - /* we have an equal weight tie breaking: - * 1. if one decision is YES prefer it - * 2. prefer the node that holds the primary for this index with the next id in the ring ie. - * for the 3 shards 2 replica case we try to build up: - * 1 2 0 - * 2 0 1 - * 0 1 2 - * such that if we need to tie-break we try to prefer the node holding a shard with the minimal id greater - * than the id of the shard we need to assign. This works find when new indices are created since - * primaries are added first and we only add one shard set a time in this algorithm. - */ - if (currentDecision.type() == decision.type()) { - final int repId = shard.id(); - final int nodeHigh = node.highestPrimary(shard.index().getName()); - final int minNodeHigh = minNode.highestPrimary(shard.getIndexName()); - if ((((nodeHigh > repId && minNodeHigh > repId) || (nodeHigh < repId && minNodeHigh < repId)) && (nodeHigh < minNodeHigh)) - || (nodeHigh > minNodeHigh && nodeHigh > repId && minNodeHigh < repId)) { - // nothing to set here; the minNode, minWeight, and decision get set below - } else { - break NOUPDATE; - } - } else if (currentDecision.type() != Type.YES) { - break NOUPDATE; - } - } - minNode = node; - minWeight = currentWeight; - decision = currentDecision; - } - } - } + } else { + // did *not* receive a YES decision + if (logger.isTraceEnabled()) { + logger.trace("No eligible node found to assign shard [{}] decision [{}]", shard, decision.type()); } - } - assert (decision == null) == (minNode == null); - if (minNode != null) { - final long shardSize = DiskThresholdDecider.getExpectedShardSize(shard, allocation, - ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE); - if (decision.type() == Type.YES) { - if (logger.isTraceEnabled()) { - logger.trace("Assigned shard [{}] to [{}]", shard, minNode.getNodeId()); - } - shard = routingNodes.initializeShard(shard, minNode.getNodeId(), null, shardSize, allocation.changes()); - minNode.addShard(shard); - continue; // don't add to ignoreUnassigned - } else { + if (minNode != null) { + // throttle decision scenario + assert decision.type() == Type.THROTTLE; + final long shardSize = DiskThresholdDecider.getExpectedShardSize(shard, allocation, + ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE); minNode.addShard(shard.initialize(minNode.getNodeId(), null, shardSize)); final RoutingNode node = minNode.getRoutingNode(); final Decision.Type nodeLevelDecision = deciders.canAllocate(node, allocation).type(); @@ -721,21 +668,19 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards assert nodeLevelDecision == Type.NO; throttledNodes.add(minNode); } + } else { + assert decision.type() == Type.NO; + if (logger.isTraceEnabled()) { + logger.trace("No Node found to assign shard [{}]", shard); + } } - if (logger.isTraceEnabled()) { - logger.trace("No eligible node found to assign shard [{}] decision [{}]", shard, decision.type()); - } - } else if (logger.isTraceEnabled()) { - logger.trace("No Node found to assign shard [{}]", shard); - } - assert decision == null || decision.type() == Type.THROTTLE; - UnassignedInfo.AllocationStatus allocationStatus = - decision == null ? UnassignedInfo.AllocationStatus.DECIDERS_NO : - UnassignedInfo.AllocationStatus.fromDecision(decision); - unassigned.ignoreShard(shard, allocationStatus, allocation.changes()); - if (!shard.primary()) { // we could not allocate it and we are a replica - check if we can ignore the other replicas - while(secondaryLength > 0 && comparator.compare(shard, secondary[secondaryLength-1]) == 0) { - unassigned.ignoreShard(secondary[--secondaryLength], allocationStatus, allocation.changes()); + + UnassignedInfo.AllocationStatus allocationStatus = UnassignedInfo.AllocationStatus.fromDecision(decision); + unassigned.ignoreShard(shard, allocationStatus, allocation.changes()); + if (!shard.primary()) { // we could not allocate it and we are a replica - check if we can ignore the other replicas + while(i < primaryLength-1 && comparator.compare(primary[i], primary[i+1]) == 0) { + unassigned.ignoreShard(primary[++i], allocationStatus, allocation.changes()); + } } } } @@ -748,6 +693,84 @@ public class BalancedShardsAllocator extends AbstractComponent implements Shards // clear everything we have either added it or moved to ignoreUnassigned } + /** + * Make a decision for allocating an unassigned shard. This method returns a two values in a tuple: the + * first value is the {@link Decision} taken to allocate the unassigned shard, the second value is the + * {@link ModelNode} representing the node that the shard should be assigned to. If the decision returned + * is of type {@link Type#NO}, then the assigned node will be null. + */ + private Tuple allocateUnassignedShard(final ShardRouting shard, final Set throttledNodes) { + assert !shard.assignedToNode() : "not an unassigned shard: " + shard; + if (allocation.deciders().canAllocate(shard, allocation).type() == Type.NO) { + // NO decision for allocating the shard, irrespective of any particular node, so exit early + return Tuple.tuple(Decision.NO, null); + } + + /* find an node with minimal weight we can allocate on*/ + float minWeight = Float.POSITIVE_INFINITY; + ModelNode minNode = null; + Decision decision = null; + if (throttledNodes.size() < nodes.size()) { + /* Don't iterate over an identity hashset here the + * iteration order is different for each run and makes testing hard */ + for (ModelNode node : nodes.values()) { + if (throttledNodes.contains(node)) { + continue; + } + if (!node.containsShard(shard)) { + // simulate weight if we would add shard to node + float currentWeight = weight.weightShardAdded(this, node, shard.getIndexName()); + /* + * Unless the operation is not providing any gains we + * don't check deciders + */ + if (currentWeight <= minWeight) { + Decision currentDecision = allocation.deciders().canAllocate(shard, node.getRoutingNode(), allocation); + if (currentDecision.type() == Type.YES || currentDecision.type() == Type.THROTTLE) { + final boolean updateMinNode; + if (currentWeight == minWeight) { + /* we have an equal weight tie breaking: + * 1. if one decision is YES prefer it + * 2. prefer the node that holds the primary for this index with the next id in the ring ie. + * for the 3 shards 2 replica case we try to build up: + * 1 2 0 + * 2 0 1 + * 0 1 2 + * such that if we need to tie-break we try to prefer the node holding a shard with the minimal id greater + * than the id of the shard we need to assign. This works find when new indices are created since + * primaries are added first and we only add one shard set a time in this algorithm. + */ + if (currentDecision.type() == decision.type()) { + final int repId = shard.id(); + final int nodeHigh = node.highestPrimary(shard.index().getName()); + final int minNodeHigh = minNode.highestPrimary(shard.getIndexName()); + updateMinNode = ((((nodeHigh > repId && minNodeHigh > repId) + || (nodeHigh < repId && minNodeHigh < repId)) + && (nodeHigh < minNodeHigh)) + || (nodeHigh > minNodeHigh && nodeHigh > repId && minNodeHigh < repId)); + } else { + updateMinNode = currentDecision.type() == Type.YES; + } + } else { + updateMinNode = true; + } + if (updateMinNode) { + minNode = node; + minWeight = currentWeight; + decision = currentDecision; + } + } + } + } + } + } + if (decision == null) { + // decision was not set and a node was not assigned, so treat it as a NO decision + decision = Decision.NO; + } + return Tuple.tuple(decision, minNode); + } + /** * Tries to find a relocation from the max node to the minimal node for an arbitrary shard of the given index on the * balance model. Iff this method returns a true the relocation has already been executed on the