From b71e72f24639497668edf2403be5c8fc9bbef1e7 Mon Sep 17 00:00:00 2001 From: Isabel Drost-Fromm Date: Mon, 28 Sep 2015 16:27:12 +0200 Subject: [PATCH 01/22] Adds exception objects to log messages. Also forwards exception objects through failure listeners eliminates another 17 calls to getMessage(). Relates to #10021 --- .../elasticsearch/ElasticsearchException.java | 4 ++++ .../elasticsearch/bootstrap/JNANatives.java | 2 +- .../metadata/MetaDataIndexUpgradeService.java | 2 +- .../java/org/elasticsearch/common/Base64.java | 7 ++++--- .../inject/multibindings/Multibinder.java | 2 +- .../common/inject/spi/Message.java | 4 ++++ .../discovery/zen/ZenDiscovery.java | 10 +++++----- .../zen/fd/MasterFaultDetection.java | 20 +++++++++---------- .../publish/PublishClusterStateAction.java | 19 ++++++++++++++++-- .../index/analysis/Analysis.java | 4 ++-- .../shard/TranslogRecoveryPerformer.java | 2 +- .../IndexShardSnapshotException.java | 5 +++++ .../IndexShardSnapshotFailedException.java | 4 ++++ .../BlobStoreIndexShardRepository.java | 4 ++-- .../indices/recovery/RecoveryStatus.java | 3 ++- .../indices/recovery/RecoveryTarget.java | 13 ++++++++++-- .../SharedFSRecoverySourceHandler.java | 2 +- .../transport/TransportService.java | 2 +- .../discovery/ZenFaultDetectionTests.java | 4 ++-- 19 files changed, 78 insertions(+), 35 deletions(-) diff --git a/core/src/main/java/org/elasticsearch/ElasticsearchException.java b/core/src/main/java/org/elasticsearch/ElasticsearchException.java index 65da4ed93e1..7ae10e0a5a6 100644 --- a/core/src/main/java/org/elasticsearch/ElasticsearchException.java +++ b/core/src/main/java/org/elasticsearch/ElasticsearchException.java @@ -51,9 +51,13 @@ public class ElasticsearchException extends RuntimeException implements ToXConte private static final Map, ElasticsearchExceptionHandle> CLASS_TO_ELASTICSEARCH_EXCEPTION_HANDLE; private final Map> headers = new HashMap<>(); + /** + * Construct a ElasticsearchException with the specified cause exception. + */ public ElasticsearchException(Throwable cause) { super(cause); } + /** * Construct a ElasticsearchException with the specified detail message. * diff --git a/core/src/main/java/org/elasticsearch/bootstrap/JNANatives.java b/core/src/main/java/org/elasticsearch/bootstrap/JNANatives.java index 5db88ec254d..5356d33bb8e 100644 --- a/core/src/main/java/org/elasticsearch/bootstrap/JNANatives.java +++ b/core/src/main/java/org/elasticsearch/bootstrap/JNANatives.java @@ -191,7 +191,7 @@ class JNANatives { if (logger.isDebugEnabled()) { logger.debug("unable to install syscall filter", t); } - logger.warn("unable to install syscall filter: " + t.getMessage()); + logger.warn("unable to install syscall filter: ", t); } } } diff --git a/core/src/main/java/org/elasticsearch/cluster/metadata/MetaDataIndexUpgradeService.java b/core/src/main/java/org/elasticsearch/cluster/metadata/MetaDataIndexUpgradeService.java index 175a6ef5c5d..9394136746a 100644 --- a/core/src/main/java/org/elasticsearch/cluster/metadata/MetaDataIndexUpgradeService.java +++ b/core/src/main/java/org/elasticsearch/cluster/metadata/MetaDataIndexUpgradeService.java @@ -227,7 +227,7 @@ public class MetaDataIndexUpgradeService extends AbstractComponent { } } catch (Exception ex) { // Wrap the inner exception so we have the index name in the exception message - throw new IllegalStateException("unable to upgrade the mappings for the index [" + indexMetaData.getIndex() + "], reason: [" + ex.getMessage() + "]", ex); + throw new IllegalStateException("unable to upgrade the mappings for the index [" + indexMetaData.getIndex() + "]", ex); } } diff --git a/core/src/main/java/org/elasticsearch/common/Base64.java b/core/src/main/java/org/elasticsearch/common/Base64.java index 390b3708ffc..1bc6fd0ae3f 100644 --- a/core/src/main/java/org/elasticsearch/common/Base64.java +++ b/core/src/main/java/org/elasticsearch/common/Base64.java @@ -643,7 +643,8 @@ public class Base64 { try { encoded = encodeBytes(source, 0, source.length, NO_OPTIONS); } catch (java.io.IOException ex) { - assert false : ex.getMessage(); + // not sure why this was an assertion before, running with assertions disabled would mean swallowing this exception + throw new IllegalStateException(ex); } // end catch assert encoded != null; return encoded; @@ -705,7 +706,7 @@ public class Base64 { try { encoded = encodeBytes(source, off, len, NO_OPTIONS); } catch (java.io.IOException ex) { - assert false : ex.getMessage(); + throw new IllegalStateException(ex); } // end catch assert encoded != null; return encoded; @@ -766,7 +767,7 @@ public class Base64 { try { encoded = encodeBytesToBytes(source, 0, source.length, Base64.NO_OPTIONS); } catch (java.io.IOException ex) { - assert false : "IOExceptions only come from GZipping, which is turned off: " + ex.getMessage(); + throw new IllegalStateException("IOExceptions only come from GZipping, which is turned off: ", ex); } return encoded; } diff --git a/core/src/main/java/org/elasticsearch/common/inject/multibindings/Multibinder.java b/core/src/main/java/org/elasticsearch/common/inject/multibindings/Multibinder.java index 56f0ec0f055..5bc1595be5f 100644 --- a/core/src/main/java/org/elasticsearch/common/inject/multibindings/Multibinder.java +++ b/core/src/main/java/org/elasticsearch/common/inject/multibindings/Multibinder.java @@ -331,6 +331,6 @@ public abstract class Multibinder { NullPointerException npe = new NullPointerException(name); throw new ConfigurationException(singleton( - new Message(emptyList(), npe.toString(), npe))); + new Message(emptyList(), npe))); } } diff --git a/core/src/main/java/org/elasticsearch/common/inject/spi/Message.java b/core/src/main/java/org/elasticsearch/common/inject/spi/Message.java index e5488d07417..5a39b9edf13 100644 --- a/core/src/main/java/org/elasticsearch/common/inject/spi/Message.java +++ b/core/src/main/java/org/elasticsearch/common/inject/spi/Message.java @@ -58,6 +58,10 @@ public final class Message implements Serializable, Element { this(Collections.singletonList(source), message, null); } + public Message(Object source, Throwable cause) { + this(Collections.singletonList(source), null, cause); + } + public Message(String message) { this(Collections.emptyList(), message, null); } diff --git a/core/src/main/java/org/elasticsearch/discovery/zen/ZenDiscovery.java b/core/src/main/java/org/elasticsearch/discovery/zen/ZenDiscovery.java index c2b16046b0c..e5ec230fd66 100644 --- a/core/src/main/java/org/elasticsearch/discovery/zen/ZenDiscovery.java +++ b/core/src/main/java/org/elasticsearch/discovery/zen/ZenDiscovery.java @@ -525,7 +525,7 @@ public class ZenDiscovery extends AbstractLifecycleComponent implemen } }); } else if (node.equals(nodes().masterNode())) { - handleMasterGone(node, "shut_down"); + handleMasterGone(node, null, "shut_down"); } } @@ -615,7 +615,7 @@ public class ZenDiscovery extends AbstractLifecycleComponent implemen }); } - private void handleMasterGone(final DiscoveryNode masterNode, final String reason) { + private void handleMasterGone(final DiscoveryNode masterNode, final Throwable cause, final String reason) { if (lifecycleState() != Lifecycle.State.STARTED) { // not started, ignore a master failure return; @@ -625,7 +625,7 @@ public class ZenDiscovery extends AbstractLifecycleComponent implemen return; } - logger.info("master_left [{}], reason [{}]", masterNode, reason); + logger.info("master_left [{}], reason [{}]", cause, masterNode, reason); clusterService.submitStateUpdateTask("zen-disco-master_failed (" + masterNode + ")", Priority.IMMEDIATE, new ClusterStateUpdateTask() { @@ -1078,8 +1078,8 @@ public class ZenDiscovery extends AbstractLifecycleComponent implemen private class MasterNodeFailureListener implements MasterFaultDetection.Listener { @Override - public void onMasterFailure(DiscoveryNode masterNode, String reason) { - handleMasterGone(masterNode, reason); + public void onMasterFailure(DiscoveryNode masterNode, Throwable cause, String reason) { + handleMasterGone(masterNode, cause, reason); } } diff --git a/core/src/main/java/org/elasticsearch/discovery/zen/fd/MasterFaultDetection.java b/core/src/main/java/org/elasticsearch/discovery/zen/fd/MasterFaultDetection.java index 8333b967c2f..8842bafb116 100644 --- a/core/src/main/java/org/elasticsearch/discovery/zen/fd/MasterFaultDetection.java +++ b/core/src/main/java/org/elasticsearch/discovery/zen/fd/MasterFaultDetection.java @@ -49,7 +49,7 @@ public class MasterFaultDetection extends FaultDetection { public static interface Listener { /** called when pinging the master failed, like a timeout, transport disconnects etc */ - void onMasterFailure(DiscoveryNode masterNode, String reason); + void onMasterFailure(DiscoveryNode masterNode, Throwable cause, String reason); } @@ -117,7 +117,7 @@ public class MasterFaultDetection extends FaultDetection { transportService.connectToNode(masterNode); } catch (final Exception e) { // notify master failure (which stops also) and bail.. - notifyMasterFailure(masterNode, "failed to perform initial connect [" + e.getMessage() + "]"); + notifyMasterFailure(masterNode, e, "failed to perform initial connect "); return; } if (masterPinger != null) { @@ -176,22 +176,22 @@ public class MasterFaultDetection extends FaultDetection { threadPool.schedule(TimeValue.timeValueMillis(0), ThreadPool.Names.SAME, masterPinger); } catch (Exception e) { logger.trace("[master] [{}] transport disconnected (with verified connect)", masterNode); - notifyMasterFailure(masterNode, "transport disconnected (with verified connect)"); + notifyMasterFailure(masterNode, null, "transport disconnected (with verified connect)"); } } else { logger.trace("[master] [{}] transport disconnected", node); - notifyMasterFailure(node, "transport disconnected"); + notifyMasterFailure(node, null, "transport disconnected"); } } } - private void notifyMasterFailure(final DiscoveryNode masterNode, final String reason) { + private void notifyMasterFailure(final DiscoveryNode masterNode, final Throwable cause, final String reason) { if (notifiedMasterFailure.compareAndSet(false, true)) { threadPool.generic().execute(new Runnable() { @Override public void run() { for (Listener listener : listeners) { - listener.onMasterFailure(masterNode, reason); + listener.onMasterFailure(masterNode, cause, reason); } } }); @@ -255,15 +255,15 @@ public class MasterFaultDetection extends FaultDetection { return; } else if (exp.getCause() instanceof NotMasterException) { logger.debug("[master] pinging a master {} that is no longer a master", masterNode); - notifyMasterFailure(masterToPing, "no longer master"); + notifyMasterFailure(masterToPing, exp, "no longer master"); return; } else if (exp.getCause() instanceof ThisIsNotTheMasterYouAreLookingForException) { logger.debug("[master] pinging a master {} that is not the master", masterNode); - notifyMasterFailure(masterToPing, "not master"); + notifyMasterFailure(masterToPing, exp,"not master"); return; } else if (exp.getCause() instanceof NodeDoesNotExistOnMasterException) { logger.debug("[master] pinging a master {} but we do not exists on it, act as if its master failure", masterNode); - notifyMasterFailure(masterToPing, "do not exists on master, act as master failure"); + notifyMasterFailure(masterToPing, exp,"do not exists on master, act as master failure"); return; } @@ -272,7 +272,7 @@ public class MasterFaultDetection extends FaultDetection { if (retryCount >= pingRetryCount) { logger.debug("[master] failed to ping [{}], tried [{}] times, each with maximum [{}] timeout", masterNode, pingRetryCount, pingRetryTimeout); // not good, failure - notifyMasterFailure(masterToPing, "failed to ping, tried [" + pingRetryCount + "] times, each with maximum [" + pingRetryTimeout + "] timeout"); + notifyMasterFailure(masterToPing, null, "failed to ping, tried [" + pingRetryCount + "] times, each with maximum [" + pingRetryTimeout + "] timeout"); } else { // resend the request, not reschedule, rely on send timeout transportService.sendRequest(masterToPing, MASTER_PING_ACTION_NAME, request, options, this); diff --git a/core/src/main/java/org/elasticsearch/discovery/zen/publish/PublishClusterStateAction.java b/core/src/main/java/org/elasticsearch/discovery/zen/publish/PublishClusterStateAction.java index 93d457d7382..91fd622023f 100644 --- a/core/src/main/java/org/elasticsearch/discovery/zen/publish/PublishClusterStateAction.java +++ b/core/src/main/java/org/elasticsearch/discovery/zen/publish/PublishClusterStateAction.java @@ -140,9 +140,9 @@ public class PublishClusterStateAction extends AbstractComponent { throw t; } catch (Throwable t) { // try to fail committing, in cause it's still on going - if (sendingController.markAsFailed("unexpected error [" + t.getMessage() + "]")) { + if (sendingController.markAsFailed("unexpected error", t)) { // signal the change should be rejected - throw new Discovery.FailedToCommitClusterStateException("unexpected error [{}]", t, t.getMessage()); + throw new Discovery.FailedToCommitClusterStateException("unexpected error", t); } else { throw t; } @@ -583,6 +583,21 @@ public class PublishClusterStateAction extends AbstractComponent { return true; } + /** + * tries marking the publishing as failed, if a decision wasn't made yet + * + * @return true if the publishing was failed and the cluster state is *not* committed + **/ + synchronized private boolean markAsFailed(String details, Throwable reason) { + if (committedOrFailed()) { + return committed == false; + } + logger.trace("failed to commit version [{}]. {}", reason, clusterState.version(), details); + committed = false; + committedOrFailedLatch.countDown(); + return true; + } + /** * tries marking the publishing as failed, if a decision wasn't made yet * diff --git a/core/src/main/java/org/elasticsearch/index/analysis/Analysis.java b/core/src/main/java/org/elasticsearch/index/analysis/Analysis.java index 27cd9fd8c4c..a2c65c6441d 100644 --- a/core/src/main/java/org/elasticsearch/index/analysis/Analysis.java +++ b/core/src/main/java/org/elasticsearch/index/analysis/Analysis.java @@ -235,7 +235,7 @@ public class Analysis { try (BufferedReader reader = FileSystemUtils.newBufferedReader(wordListFile.toUri().toURL(), StandardCharsets.UTF_8)) { return loadWordList(reader, "#"); } catch (IOException ioe) { - String message = String.format(Locale.ROOT, "IOException while reading %s_path: %s", settingPrefix, ioe.getMessage()); + String message = String.format(Locale.ROOT, "IOException while reading %s_path: %s", settingPrefix); throw new IllegalArgumentException(message, ioe); } } @@ -282,7 +282,7 @@ public class Analysis { try { return FileSystemUtils.newBufferedReader(path.toUri().toURL(), StandardCharsets.UTF_8); } catch (IOException ioe) { - String message = String.format(Locale.ROOT, "IOException while reading %s_path: %s", settingPrefix, ioe.getMessage()); + String message = String.format(Locale.ROOT, "IOException while reading %s_path: %s", settingPrefix); throw new IllegalArgumentException(message, ioe); } } diff --git a/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java b/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java index 68c552d4419..ac46f6725de 100644 --- a/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java +++ b/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java @@ -67,7 +67,7 @@ public class TranslogRecoveryPerformer { numOps++; } } catch (Throwable t) { - throw new BatchOperationException(shardId, "failed to apply batch translog operation [" + t.getMessage() + "]", numOps, t); + throw new BatchOperationException(shardId, "failed to apply batch translog operation", numOps, t); } return numOps; } diff --git a/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotException.java b/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotException.java index 741350966a5..7ace0303f67 100644 --- a/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotException.java +++ b/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotException.java @@ -33,6 +33,11 @@ public class IndexShardSnapshotException extends ElasticsearchException { this(shardId, msg, null); } + public IndexShardSnapshotException(ShardId shardId, Throwable cause) { + super(cause); + setShard(shardId); + } + public IndexShardSnapshotException(ShardId shardId, String msg, Throwable cause) { super(msg, cause); setShard(shardId); diff --git a/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotFailedException.java b/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotFailedException.java index bfb755c9e14..7b7fc68d4d4 100644 --- a/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotFailedException.java +++ b/core/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotFailedException.java @@ -32,6 +32,10 @@ public class IndexShardSnapshotFailedException extends IndexShardSnapshotExcepti super(shardId, msg); } + public IndexShardSnapshotFailedException(ShardId shardId, Throwable cause) { + super(shardId, cause); + } + public IndexShardSnapshotFailedException(ShardId shardId, String msg, Throwable cause) { super(shardId, msg, cause); } diff --git a/core/src/main/java/org/elasticsearch/index/snapshots/blobstore/BlobStoreIndexShardRepository.java b/core/src/main/java/org/elasticsearch/index/snapshots/blobstore/BlobStoreIndexShardRepository.java index d90a869f5b3..674d1085660 100644 --- a/core/src/main/java/org/elasticsearch/index/snapshots/blobstore/BlobStoreIndexShardRepository.java +++ b/core/src/main/java/org/elasticsearch/index/snapshots/blobstore/BlobStoreIndexShardRepository.java @@ -191,7 +191,7 @@ public class BlobStoreIndexShardRepository extends AbstractComponent implements if (e instanceof IndexShardSnapshotFailedException) { throw (IndexShardSnapshotFailedException) e; } else { - throw new IndexShardSnapshotFailedException(shardId, e.getMessage(), e); + throw new IndexShardSnapshotFailedException(shardId, e); } } } @@ -373,7 +373,7 @@ public class BlobStoreIndexShardRepository extends AbstractComponent implements } catch (IOException e) { // We cannot delete index file - this is fatal, we cannot continue, otherwise we might end up // with references to non-existing files - throw new IndexShardSnapshotFailedException(shardId, "error deleting index files during cleanup, reason: " + e.getMessage(), e); + throw new IndexShardSnapshotFailedException(shardId, "error deleting index files during cleanup", e); } blobsToDelete = new ArrayList<>(); diff --git a/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryStatus.java b/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryStatus.java index 80f458b8f5c..0064021dd33 100644 --- a/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryStatus.java +++ b/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryStatus.java @@ -22,6 +22,7 @@ package org.elasticsearch.indices.recovery; import org.apache.lucene.store.IOContext; import org.apache.lucene.store.IndexOutput; import org.elasticsearch.ElasticsearchException; +import org.elasticsearch.ExceptionsHelper; import org.elasticsearch.cluster.node.DiscoveryNode; import org.elasticsearch.common.logging.ESLogger; import org.elasticsearch.common.logging.Loggers; @@ -175,7 +176,7 @@ public class RecoveryStatus extends AbstractRefCounted { listener.onRecoveryFailure(state(), e, sendShardFailure); } finally { try { - cancellableThreads.cancel("failed recovery [" + e.getMessage() + "]"); + cancellableThreads.cancel("failed recovery [" + ExceptionsHelper.stackTrace(e) + "]"); } finally { // release the initial reference. recovery files will be cleaned as soon as ref count goes to zero, potentially now decRef(); diff --git a/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryTarget.java b/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryTarget.java index 72872a585f1..2ccfbcb5420 100644 --- a/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryTarget.java +++ b/core/src/main/java/org/elasticsearch/indices/recovery/RecoveryTarget.java @@ -130,8 +130,17 @@ public class RecoveryTarget extends AbstractComponent implements IndexEventListe } + protected void retryRecovery(final RecoveryStatus recoveryStatus, final Throwable reason, TimeValue retryAfter, final StartRecoveryRequest currentRequest) { + logger.trace("will retry recovery with id [{}] in [{}]", reason, recoveryStatus.recoveryId(), retryAfter); + retryRecovery(recoveryStatus, retryAfter, currentRequest); + } + protected void retryRecovery(final RecoveryStatus recoveryStatus, final String reason, TimeValue retryAfter, final StartRecoveryRequest currentRequest) { - logger.trace("will retrying recovery with id [{}] in [{}] (reason [{}])", recoveryStatus.recoveryId(), retryAfter, reason); + logger.trace("will retry recovery with id [{}] in [{}] (reason [{}])", recoveryStatus.recoveryId(), retryAfter, reason); + retryRecovery(recoveryStatus, retryAfter, currentRequest); + } + + private void retryRecovery(final RecoveryStatus recoveryStatus, TimeValue retryAfter, final StartRecoveryRequest currentRequest) { try { recoveryStatus.resetRecovery(); } catch (Throwable e) { @@ -224,7 +233,7 @@ public class RecoveryTarget extends AbstractComponent implements IndexEventListe } if (cause instanceof DelayRecoveryException) { - retryRecovery(recoveryStatus, cause.getMessage(), recoverySettings.retryDelayStateSync(), request); + retryRecovery(recoveryStatus, cause, recoverySettings.retryDelayStateSync(), request); return; } diff --git a/core/src/main/java/org/elasticsearch/indices/recovery/SharedFSRecoverySourceHandler.java b/core/src/main/java/org/elasticsearch/indices/recovery/SharedFSRecoverySourceHandler.java index 123480e81de..e849580b2c4 100644 --- a/core/src/main/java/org/elasticsearch/indices/recovery/SharedFSRecoverySourceHandler.java +++ b/core/src/main/java/org/elasticsearch/indices/recovery/SharedFSRecoverySourceHandler.java @@ -69,7 +69,7 @@ public class SharedFSRecoverySourceHandler extends RecoverySourceHandler { // create a new IndexWriter logger.info("recovery failed for primary shadow shard, failing shard"); // pass the failure as null, as we want to ensure the store is not marked as corrupted - shard.failShard("primary relocation failed on shared filesystem caused by: [" + t.getMessage() + "]", null); + shard.failShard("primary relocation failed on shared filesystem", t); } else { logger.info("recovery failed on shared filesystem", t); } diff --git a/core/src/main/java/org/elasticsearch/transport/TransportService.java b/core/src/main/java/org/elasticsearch/transport/TransportService.java index 964cfacc8c1..14fc9029b00 100644 --- a/core/src/main/java/org/elasticsearch/transport/TransportService.java +++ b/core/src/main/java/org/elasticsearch/transport/TransportService.java @@ -484,7 +484,7 @@ public class TransportService extends AbstractLifecycleComponent Date: Thu, 19 Nov 2015 16:41:29 -0800 Subject: [PATCH 02/22] Update similarity.asciidoc --- docs/reference/index-modules/similarity.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/reference/index-modules/similarity.asciidoc b/docs/reference/index-modules/similarity.asciidoc index 82399a8cc79..0ade819dc0c 100644 --- a/docs/reference/index-modules/similarity.asciidoc +++ b/docs/reference/index-modules/similarity.asciidoc @@ -157,7 +157,7 @@ implementation used for these two methods, while not changing the `default`, it is possible to configure a similarity with the name `base`. This similarity will then be used for the two methods. -You can change the default similarity for all fields like this: +You can change the default similarity for all fields by putting the following setting into `elasticsearch.yml`: [source,js] -------------------------------------------------- From 5ca9f3ff8f6c5a424902d031587943482ede34e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christoph=20B=C3=BCscher?= Date: Tue, 17 Nov 2015 18:56:54 +0100 Subject: [PATCH 03/22] Geo: Make ShapeBuilders implement Writable We recently refactored the queries to make them parsable on the coordinating note and adding serialization and equals/hashCode capability to them. So far ShapeBuilders nested inside queries were still transported as a byte array that needs to be parsed later on the shard receiving the query. To be able to also serialize geo shapes this way, we also need to make all the implementations of ShapeBuilder implement Writable. This PR adds this to PointBuilder and also adds tests for serialization, equality and hashCode. --- .../common/geo/builders/CircleBuilder.java | 6 +- .../common/geo/builders/EnvelopeBuilder.java | 4 +- .../builders/GeometryCollectionBuilder.java | 2 +- .../geo/builders/LineStringBuilder.java | 2 +- .../geo/builders/MultiLineStringBuilder.java | 2 +- .../geo/builders/MultiPointBuilder.java | 2 +- .../geo/builders/MultiPolygonBuilder.java | 2 +- .../common/geo/builders/PointBuilder.java | 37 ++++- .../common/geo/builders/PolygonBuilder.java | 2 +- .../common/geo/builders/ShapeBuilder.java | 26 +++- .../AbstractShapeBuilderTestCase.java | 134 ++++++++++++++++++ .../geo/builders/PointBuilderTests.java | 38 +++++ 12 files changed, 242 insertions(+), 15 deletions(-) create mode 100644 core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java create mode 100644 core/src/test/java/org/elasticsearch/common/geo/builders/PointBuilderTests.java diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java index f1054e18663..ce1a51e657b 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java @@ -35,10 +35,10 @@ public class CircleBuilder extends ShapeBuilder { private DistanceUnit unit; private double radius; private Coordinate center; - + /** * Set the center of the circle - * + * * @param center coordinate of the circles center * @return this */ @@ -100,7 +100,7 @@ public class CircleBuilder extends ShapeBuilder { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.field(FIELD_RADIUS, unit.toString(radius)); builder.field(FIELD_COORDINATES); toXContent(builder, center); diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java index a296b3406ef..9acfdd2580e 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java @@ -27,7 +27,7 @@ import java.io.IOException; public class EnvelopeBuilder extends ShapeBuilder { - public static final GeoShapeType TYPE = GeoShapeType.ENVELOPE; + public static final GeoShapeType TYPE = GeoShapeType.ENVELOPE; protected Coordinate topLeft; protected Coordinate bottomRight; @@ -61,7 +61,7 @@ public class EnvelopeBuilder extends ShapeBuilder { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.startArray(FIELD_COORDINATES); toXContent(builder, topLeft); toXContent(builder, bottomRight); diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/GeometryCollectionBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/GeometryCollectionBuilder.java index 57f3fc67b64..45397ed962f 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/GeometryCollectionBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/GeometryCollectionBuilder.java @@ -102,7 +102,7 @@ public class GeometryCollectionBuilder extends ShapeBuilder { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.startArray(FIELD_GEOMETRIES); for (ShapeBuilder shape : shapes) { shape.toXContent(builder, params); diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/LineStringBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/LineStringBuilder.java index 265efe11621..4bf84ea8f50 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/LineStringBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/LineStringBuilder.java @@ -39,7 +39,7 @@ public class LineStringBuilder extends PointCollection { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.field(FIELD_COORDINATES); coordinatesToXcontent(builder, false); builder.endObject(); diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/MultiLineStringBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/MultiLineStringBuilder.java index 10ad25c89e1..a004b90a2dc 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/MultiLineStringBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/MultiLineStringBuilder.java @@ -57,7 +57,7 @@ public class MultiLineStringBuilder extends ShapeBuilder { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.field(FIELD_COORDINATES); builder.startArray(); for(LineStringBuilder line : lines) { diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPointBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPointBuilder.java index d12baad70d9..8d5cfabdabb 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPointBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPointBuilder.java @@ -37,7 +37,7 @@ public class MultiPointBuilder extends PointCollection { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.field(FIELD_COORDINATES); super.coordinatesToXcontent(builder, false); builder.endObject(); diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPolygonBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPolygonBuilder.java index 0998cd2944b..7911ddff835 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPolygonBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/MultiPolygonBuilder.java @@ -51,7 +51,7 @@ public class MultiPolygonBuilder extends ShapeBuilder { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.startArray(FIELD_COORDINATES); for(PolygonBuilder polygon : polygons) { builder.startArray(); diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java index 53c67387e91..39044728efd 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java @@ -20,7 +20,10 @@ package org.elasticsearch.common.geo.builders; import java.io.IOException; +import java.util.Objects; +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentBuilder; import com.spatial4j.core.shape.Point; @@ -30,6 +33,8 @@ public class PointBuilder extends ShapeBuilder { public static final GeoShapeType TYPE = GeoShapeType.POINT; + public static final PointBuilder PROTOTYPE = new PointBuilder(); + private Coordinate coordinate; public PointBuilder coordinate(Coordinate coordinate) { @@ -48,10 +53,10 @@ public class PointBuilder extends ShapeBuilder { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.field(FIELD_COORDINATES); toXContent(builder, coordinate); - return builder.endObject(); + return builder.endObject(); } @Override @@ -63,4 +68,32 @@ public class PointBuilder extends ShapeBuilder { public GeoShapeType type() { return TYPE; } + + @Override + public int hashCode() { + return Objects.hash(coordinate); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null || getClass() != obj.getClass()) { + return false; + } + PointBuilder other = (PointBuilder) obj; + return Objects.equals(coordinate, other.coordinate); + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + out.writeDouble(coordinate.x); + out.writeDouble(coordinate.y); + } + + @Override + public ShapeBuilder readFrom(StreamInput in) throws IOException { + return new PointBuilder().coordinate(new Coordinate(in.readDouble(), in.readDouble())); + } } diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/PolygonBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/PolygonBuilder.java index 4a406eb22b8..94d8fc049d8 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/PolygonBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/PolygonBuilder.java @@ -172,7 +172,7 @@ public class PolygonBuilder extends ShapeBuilder { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); - builder.field(FIELD_TYPE, TYPE.shapename); + builder.field(FIELD_TYPE, TYPE.shapeName()); builder.startArray(FIELD_COORDINATES); coordinatesArray(builder, params); builder.endArray(); diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java index 13237727173..e944af9166f 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java @@ -26,8 +26,12 @@ import com.spatial4j.core.shape.jts.JtsGeometry; import com.vividsolutions.jts.geom.Coordinate; import com.vividsolutions.jts.geom.Geometry; import com.vividsolutions.jts.geom.GeometryFactory; + import org.elasticsearch.ElasticsearchParseException; import org.elasticsearch.action.support.ToXContentToBytes; +import org.elasticsearch.common.io.stream.NamedWriteable; +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.logging.ESLogger; import org.elasticsearch.common.logging.ESLoggerFactory; import org.elasticsearch.common.unit.DistanceUnit.Distance; @@ -43,7 +47,7 @@ import java.util.*; /** * Basic class for building GeoJSON shapes like Polygons, Linestrings, etc */ -public abstract class ShapeBuilder extends ToXContentToBytes { +public abstract class ShapeBuilder extends ToXContentToBytes implements NamedWriteable { protected static final ESLogger LOGGER = ESLoggerFactory.getLogger(ShapeBuilder.class.getName()); @@ -565,12 +569,16 @@ public abstract class ShapeBuilder extends ToXContentToBytes { ENVELOPE("envelope"), CIRCLE("circle"); - protected final String shapename; + private final String shapename; private GeoShapeType(String shapename) { this.shapename = shapename; } + protected String shapeName() { + return shapename; + } + public static GeoShapeType forName(String geoshapename) { String typename = geoshapename.toLowerCase(Locale.ROOT); for (GeoShapeType type : values()) { @@ -823,4 +831,18 @@ public abstract class ShapeBuilder extends ToXContentToBytes { return geometryCollection; } } + + @Override + public String getWriteableName() { + return type().shapename; + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + } + + @Override + public ShapeBuilder readFrom(StreamInput in) throws IOException { + return null; + } } diff --git a/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java b/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java new file mode 100644 index 00000000000..0a60a3ccb31 --- /dev/null +++ b/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java @@ -0,0 +1,134 @@ +/* + * 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.common.geo.builders; + +import org.elasticsearch.common.io.stream.BytesStreamOutput; +import org.elasticsearch.common.io.stream.NamedWriteableAwareStreamInput; +import org.elasticsearch.common.io.stream.NamedWriteableRegistry; +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.xcontent.*; +import org.elasticsearch.test.ESTestCase; +import org.junit.BeforeClass; + +import java.io.IOException; + +import static org.hamcrest.Matchers.*; + +public abstract class AbstractShapeBuilderTestCase extends ESTestCase { + + private static final int NUMBER_OF_TESTBUILDERS = 1; + private static final NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(); + + /** + * Setup for the whole base test class. + */ + @BeforeClass + public static void init() { + namedWriteableRegistry.registerPrototype(ShapeBuilder.class, PointBuilder.PROTOTYPE); + } + + /** + * Create the shape that under test + */ + protected abstract SB createTestShapeBuilder(); + + /** + * mutate the given query so the returned query is different + */ + protected abstract SB mutate(SB original); + + /** + * Generic test that creates new shape from a random test shape and checks both for equality + */ + public void testFromXContent() throws IOException { + for (int runs = 0; runs < NUMBER_OF_TESTBUILDERS; runs++) { + SB testShape = createTestShapeBuilder(); + XContentBuilder builder = toXContent(testShape, randomFrom(XContentType.values())); + + XContentParser shapeParser = XContentHelper.createParser(builder.bytes()); + shapeParser.nextToken(); + ShapeBuilder parsedShape = ShapeBuilder.parse(shapeParser); + assertNotSame(testShape, parsedShape); + assertEquals(testShape, parsedShape); + assertEquals(testShape.hashCode(), parsedShape.hashCode()); + } + } + + protected static XContentBuilder toXContent(ShapeBuilder shape, XContentType contentType) throws IOException { + XContentBuilder builder = XContentFactory.contentBuilder(contentType); + if (randomBoolean()) { + builder.prettyPrint(); + } + return shape.toXContent(builder, ToXContent.EMPTY_PARAMS); + } + + /** + * Test serialization and deserialization of the test shape. + */ + public void testSerialization() throws IOException { + for (int runs = 0; runs < NUMBER_OF_TESTBUILDERS; runs++) { + SB testShape = createTestShapeBuilder(); + SB deserializedShape = copyShape(testShape); + assertEquals(deserializedShape, testShape); + assertEquals(deserializedShape.hashCode(), testShape.hashCode()); + assertNotSame(deserializedShape, testShape); + } + } + + public void testEqualsAndHashcode() throws IOException { + for (int runs = 0; runs < NUMBER_OF_TESTBUILDERS; runs++) { + SB firstShape = createTestShapeBuilder(); + assertFalse("shape is equal to null", firstShape.equals(null)); + assertFalse("shape is equal to incompatible type", firstShape.equals("")); + assertTrue("shape is not equal to self", firstShape.equals(firstShape)); + assertThat("same shape's hashcode returns different values if called multiple times", firstShape.hashCode(), + equalTo(firstShape.hashCode())); + assertThat("different shapes should not be equal", mutate(firstShape), not(equalTo(firstShape))); + assertThat("different shapes should have different hashcode", mutate(firstShape).hashCode(), not(equalTo(firstShape.hashCode()))); + + SB secondShape = copyShape(firstShape); + assertTrue("shape is not equal to self", secondShape.equals(secondShape)); + assertTrue("shape is not equal to its copy", firstShape.equals(secondShape)); + assertTrue("equals is not symmetric", secondShape.equals(firstShape)); + assertThat("shape copy's hashcode is different from original hashcode", secondShape.hashCode(), equalTo(firstShape.hashCode())); + + SB thirdShape = copyShape(secondShape); + assertTrue("shape is not equal to self", thirdShape.equals(thirdShape)); + assertTrue("shape is not equal to its copy", secondShape.equals(thirdShape)); + assertThat("shape copy's hashcode is different from original hashcode", secondShape.hashCode(), equalTo(thirdShape.hashCode())); + assertTrue("equals is not transitive", firstShape.equals(thirdShape)); + assertThat("shape copy's hashcode is different from original hashcode", firstShape.hashCode(), equalTo(thirdShape.hashCode())); + assertTrue("equals is not symmetric", thirdShape.equals(secondShape)); + assertTrue("equals is not symmetric", thirdShape.equals(firstShape)); + } + } + + private SB copyShape(SB original) throws IOException { + try (BytesStreamOutput output = new BytesStreamOutput()) { + original.writeTo(output); + try (StreamInput in = new NamedWriteableAwareStreamInput(StreamInput.wrap(output.bytes()), namedWriteableRegistry)) { + ShapeBuilder prototype = (ShapeBuilder) namedWriteableRegistry.getPrototype(ShapeBuilder.class, original.getWriteableName()); + @SuppressWarnings("unchecked") + SB copy = (SB) prototype.readFrom(in); + return copy; + } + } + } +} diff --git a/core/src/test/java/org/elasticsearch/common/geo/builders/PointBuilderTests.java b/core/src/test/java/org/elasticsearch/common/geo/builders/PointBuilderTests.java new file mode 100644 index 00000000000..1e94a1bab3a --- /dev/null +++ b/core/src/test/java/org/elasticsearch/common/geo/builders/PointBuilderTests.java @@ -0,0 +1,38 @@ +/* + * 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.common.geo.builders; + +import com.vividsolutions.jts.geom.Coordinate; + +import org.elasticsearch.test.geo.RandomShapeGenerator; +import org.elasticsearch.test.geo.RandomShapeGenerator.ShapeType; + +public class PointBuilderTests extends AbstractShapeBuilderTestCase { + + @Override + protected PointBuilder createTestShapeBuilder() { + return (PointBuilder) RandomShapeGenerator.createShape(getRandom(), ShapeType.POINT); + } + + @Override + protected PointBuilder mutate(PointBuilder original) { + return new PointBuilder().coordinate(new Coordinate(original.longitude()/2, original.latitude()/2)); + } +} From e25f7042b91a22d75560f999fc60c0be710a9f5c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christoph=20B=C3=BCscher?= Date: Tue, 17 Nov 2015 20:23:03 +0100 Subject: [PATCH 04/22] Making CircleBuilder writable and adding equals/hashcode --- .../common/geo/builders/CircleBuilder.java | 58 +++++++++++++++++++ .../common/geo/builders/PointBuilder.java | 5 +- .../common/geo/builders/ShapeBuilder.java | 9 +++ .../AbstractShapeBuilderTestCase.java | 9 ++- .../geo/builders/CirlceBuilderTests.java | 58 +++++++++++++++++++ .../common/unit/DistanceUnitTests.java | 16 +++++ 6 files changed, 149 insertions(+), 6 deletions(-) create mode 100644 core/src/test/java/org/elasticsearch/common/geo/builders/CirlceBuilderTests.java diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java index ce1a51e657b..c65b278c3c1 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java @@ -21,17 +21,23 @@ package org.elasticsearch.common.geo.builders; import com.spatial4j.core.shape.Circle; import com.vividsolutions.jts.geom.Coordinate; + +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.unit.DistanceUnit; import org.elasticsearch.common.unit.DistanceUnit.Distance; import org.elasticsearch.common.xcontent.XContentBuilder; import java.io.IOException; +import java.util.Objects; public class CircleBuilder extends ShapeBuilder { public static final String FIELD_RADIUS = "radius"; public static final GeoShapeType TYPE = GeoShapeType.CIRCLE; + public static final CircleBuilder PROTOTYPE = new CircleBuilder(); + private DistanceUnit unit; private double radius; private Coordinate center; @@ -57,6 +63,13 @@ public class CircleBuilder extends ShapeBuilder { return center(new Coordinate(lon, lat)); } + /** + * Get the center of the circle + */ + public Coordinate center() { + return center; + } + /** * Set the radius of the circle. The String value will be parsed by {@link DistanceUnit} * @param radius Value and unit of the circle combined in a string @@ -97,6 +110,20 @@ public class CircleBuilder extends ShapeBuilder { return this; } + /** + * Get the radius of the circle without unit + */ + public double radius() { + return this.radius; + } + + /** + * Get the radius unit of the circle + */ + public DistanceUnit unit() { + return this.unit; + } + @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); @@ -116,4 +143,35 @@ public class CircleBuilder extends ShapeBuilder { public GeoShapeType type() { return TYPE; } + + @Override + public int hashCode() { + return Objects.hash(center, radius, unit.ordinal()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null || getClass() != obj.getClass()) { + return false; + } + CircleBuilder other = (CircleBuilder) obj; + return Objects.equals(center, other.center) && + Objects.equals(radius, other.radius) && + Objects.equals(unit.ordinal(), other.unit.ordinal()); + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + writeCoordinateTo(center, out); + out.writeDouble(radius); + DistanceUnit.writeDistanceUnit(out, unit); + } + + @Override + public ShapeBuilder readFrom(StreamInput in) throws IOException { + return new CircleBuilder().center(readCoordinateFrom(in)).radius(in.readDouble(), DistanceUnit.readDistanceUnit(in)); + } } diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java index 39044728efd..127124e599c 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java @@ -88,12 +88,11 @@ public class PointBuilder extends ShapeBuilder { @Override public void writeTo(StreamOutput out) throws IOException { - out.writeDouble(coordinate.x); - out.writeDouble(coordinate.y); + writeCoordinateTo(coordinate, out); } @Override public ShapeBuilder readFrom(StreamInput in) throws IOException { - return new PointBuilder().coordinate(new Coordinate(in.readDouble(), in.readDouble())); + return new PointBuilder().coordinate(readCoordinateFrom(in)); } } diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java index e944af9166f..2c9f5b4f9bc 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java @@ -177,6 +177,15 @@ public abstract class ShapeBuilder extends ToXContentToBytes implements NamedWri return builder.startArray().value(coordinate.x).value(coordinate.y).endArray(); } + protected static void writeCoordinateTo(Coordinate coordinate, StreamOutput out) throws IOException { + out.writeDouble(coordinate.x); + out.writeDouble(coordinate.y); + } + + protected Coordinate readCoordinateFrom(StreamInput in) throws IOException { + return new Coordinate(in.readDouble(), in.readDouble()); + } + public static Orientation orientationFromString(String orientation) { orientation = orientation.toLowerCase(Locale.ROOT); switch (orientation) { diff --git a/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java b/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java index 0a60a3ccb31..f585215f9bd 100644 --- a/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java +++ b/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java @@ -33,7 +33,7 @@ import static org.hamcrest.Matchers.*; public abstract class AbstractShapeBuilderTestCase extends ESTestCase { - private static final int NUMBER_OF_TESTBUILDERS = 1; + private static final int NUMBER_OF_TESTBUILDERS = 20; private static final NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(); /** @@ -42,6 +42,7 @@ public abstract class AbstractShapeBuilderTestCase exte @BeforeClass public static void init() { namedWriteableRegistry.registerPrototype(ShapeBuilder.class, PointBuilder.PROTOTYPE); + namedWriteableRegistry.registerPrototype(ShapeBuilder.class, CircleBuilder.PROTOTYPE); } /** @@ -52,7 +53,7 @@ public abstract class AbstractShapeBuilderTestCase exte /** * mutate the given query so the returned query is different */ - protected abstract SB mutate(SB original); + protected abstract SB mutate(SB original) throws IOException; /** * Generic test that creates new shape from a random test shape and checks both for equality @@ -61,8 +62,10 @@ public abstract class AbstractShapeBuilderTestCase exte for (int runs = 0; runs < NUMBER_OF_TESTBUILDERS; runs++) { SB testShape = createTestShapeBuilder(); XContentBuilder builder = toXContent(testShape, randomFrom(XContentType.values())); + builder = toXContent(testShape, randomFrom(XContentType.values())); XContentParser shapeParser = XContentHelper.createParser(builder.bytes()); + XContentHelper.createParser(builder.bytes()); shapeParser.nextToken(); ShapeBuilder parsedShape = ShapeBuilder.parse(shapeParser); assertNotSame(testShape, parsedShape); @@ -120,7 +123,7 @@ public abstract class AbstractShapeBuilderTestCase exte } } - private SB copyShape(SB original) throws IOException { + protected SB copyShape(SB original) throws IOException { try (BytesStreamOutput output = new BytesStreamOutput()) { original.writeTo(output); try (StreamInput in = new NamedWriteableAwareStreamInput(StreamInput.wrap(output.bytes()), namedWriteableRegistry)) { diff --git a/core/src/test/java/org/elasticsearch/common/geo/builders/CirlceBuilderTests.java b/core/src/test/java/org/elasticsearch/common/geo/builders/CirlceBuilderTests.java new file mode 100644 index 00000000000..6b102b87b2c --- /dev/null +++ b/core/src/test/java/org/elasticsearch/common/geo/builders/CirlceBuilderTests.java @@ -0,0 +1,58 @@ +/* + * 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.common.geo.builders; + +import com.vividsolutions.jts.geom.Coordinate; + +import org.elasticsearch.common.unit.DistanceUnit; + +import java.io.IOException; + +public class CirlceBuilderTests extends AbstractShapeBuilderTestCase { + + @Override + protected CircleBuilder createTestShapeBuilder() { + double centerX = randomDoubleBetween(-180, 180, false); + double centerY = randomDoubleBetween(-90, 90, false); + return new CircleBuilder() + .center(new Coordinate(centerX, centerY)) + .radius(randomDoubleBetween(0.1, 10.0, false), randomFrom(DistanceUnit.values())); + } + + @Override + protected CircleBuilder mutate(CircleBuilder original) throws IOException { + CircleBuilder mutation = copyShape(original); + double radius = original.radius(); + DistanceUnit unit = original.unit(); + + if (randomBoolean()) { + mutation.center(new Coordinate(original.center().x/2, original.center().y/2)); + } else if (randomBoolean()) { + radius = radius/2; + } else { + DistanceUnit newRandom = unit; + while (newRandom == unit) { + newRandom = randomFrom(DistanceUnit.values()); + }; + unit = newRandom; + } + return mutation.radius(radius, unit); + } +} diff --git a/core/src/test/java/org/elasticsearch/common/unit/DistanceUnitTests.java b/core/src/test/java/org/elasticsearch/common/unit/DistanceUnitTests.java index 1010d2a5e8c..25c3a136271 100644 --- a/core/src/test/java/org/elasticsearch/common/unit/DistanceUnitTests.java +++ b/core/src/test/java/org/elasticsearch/common/unit/DistanceUnitTests.java @@ -57,4 +57,20 @@ public class DistanceUnitTests extends ESTestCase { assertThat("Value can be parsed from '" + testValue + unit.toString() + "'", DistanceUnit.Distance.parseDistance(unit.toString(testValue)).value, equalTo(testValue)); } } + + /** + * This test ensures that we are aware of accidental reordering in the distance unit ordinals, + * since equality in e.g. CircleShapeBuilder, hashCode and serialization rely on them + */ + public void testDistanceUnitNames() { + assertEquals(0, DistanceUnit.INCH.ordinal()); + assertEquals(1, DistanceUnit.YARD.ordinal()); + assertEquals(2, DistanceUnit.FEET.ordinal()); + assertEquals(3, DistanceUnit.KILOMETERS.ordinal()); + assertEquals(4, DistanceUnit.NAUTICALMILES.ordinal()); + assertEquals(5, DistanceUnit.MILLIMETERS.ordinal()); + assertEquals(6, DistanceUnit.CENTIMETERS.ordinal()); + assertEquals(7, DistanceUnit.MILES.ordinal()); + assertEquals(8, DistanceUnit.METERS.ordinal()); + } } From 31b7e91e5afa345f8f0a3c9c1782b2f12ebfa190 Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Mon, 23 Nov 2015 23:23:08 -0800 Subject: [PATCH 05/22] Build: Allow customizing wait condition and cluster settings The current wait condition for an integ test cluster being up is a simple http get on the root path for elasticsearch. However, it is useful to allow having arbitrary wait conditions. This change reworks the wait task to first check that each node process started successfully and has a socket up, followed by an arbitrary wait condition which defaults to the current http get. Also, cluster settings are allowed to be added, and overriden. Finally, custom setup commands are made relative to the elasticsearch home dir for each node. --- .../gradle/test/ClusterConfiguration.groovy | 36 +++- .../gradle/test/ClusterFormationTasks.groovy | 157 ++++++------------ .../elasticsearch/gradle/test/NodeInfo.groovy | 131 +++++++++++++++ .../gradle/test/RestIntegTestTask.groovy | 2 +- .../elasticsearch/gradle/test/RunTask.groovy | 2 +- 5 files changed, 213 insertions(+), 115 deletions(-) create mode 100644 buildSrc/src/main/groovy/org/elasticsearch/gradle/test/NodeInfo.groovy diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy index c8a37a8ec57..a6b59e58bf9 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy @@ -31,10 +31,10 @@ class ClusterConfiguration { int numNodes = 1 @Input - int httpPort = 9400 + int baseHttpPort = 9400 @Input - int transportPort = 9500 + int baseTransportPort = 9500 @Input boolean daemonize = true @@ -45,22 +45,44 @@ class ClusterConfiguration { @Input String jvmArgs = System.getProperty('tests.jvm.argline', '') + /** + * A closure to call before the cluster is considered ready. The closure is passed the node info, + * as well as a groovy AntBuilder, to enable running ant condition checks. The default wait + * condition is for http on the http port. + */ + @Input + Closure waitCondition = { NodeInfo node, AntBuilder ant -> + File tmpFile = new File(node.cwd, 'wait.success') + ant.get(src: "http://localhost:${node.httpPort()}", + dest: tmpFile.toString(), + ignoreerrors: true, // do not fail on error, so logging buffers can be flushed by the wait task + retries: 10) + return tmpFile.exists() + } + Map systemProperties = new HashMap<>() + Map settings = new HashMap<>() + LinkedHashMap plugins = new LinkedHashMap<>() LinkedHashMap setupCommands = new LinkedHashMap<>() - @Input - void plugin(String name, FileCollection file) { - plugins.put(name, file) - } - @Input void systemProperty(String property, String value) { systemProperties.put(property, value) } + @Input + void setting(String name, String value) { + settings.put(name, value) + } + + @Input + void plugin(String name, FileCollection file) { + plugins.put(name, file) + } + @Input void setupCommand(String name, Object... args) { setupCommands.put(name, args) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy index 0cc468c65fc..4123f32ad76 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy @@ -23,6 +23,7 @@ import org.apache.tools.ant.taskdefs.condition.Os import org.elasticsearch.gradle.VersionProperties import org.gradle.api.* import org.gradle.api.file.FileCollection +import org.gradle.api.logging.Logger import org.gradle.api.tasks.Copy import org.gradle.api.tasks.Delete import org.gradle.api.tasks.Exec @@ -34,87 +35,6 @@ import java.nio.file.Paths */ class ClusterFormationTasks { - static class NodeInfo { - /** common configuration for all nodes, including this one */ - ClusterConfiguration config - /** node number within the cluster, for creating unique names and paths */ - int nodeNum - /** name of the cluster this node is part of */ - String clusterName - /** root directory all node files and operations happen under */ - File baseDir - /** the pid file the node will use */ - File pidFile - /** elasticsearch home dir */ - File homeDir - /** working directory for the node process */ - File cwd - /** file that if it exists, indicates the node failed to start */ - File failedMarker - /** stdout/stderr log of the elasticsearch process for this node */ - File startLog - /** directory to install plugins from */ - File pluginsTmpDir - /** environment variables to start the node with */ - Map env - /** arguments to start the node with */ - List args - /** Path to the elasticsearch start script */ - String esScript - /** buffer for ant output when starting this node */ - ByteArrayOutputStream buffer = new ByteArrayOutputStream() - - /** Creates a node to run as part of a cluster for the given task */ - NodeInfo(ClusterConfiguration config, int nodeNum, Project project, Task task) { - this.config = config - this.nodeNum = nodeNum - clusterName = "${task.path.replace(':', '_').substring(1)}" - baseDir = new File(project.buildDir, "cluster/${task.name} node${nodeNum}") - pidFile = new File(baseDir, 'es.pid') - homeDir = homeDir(baseDir, config.distribution) - cwd = new File(baseDir, "cwd") - failedMarker = new File(cwd, 'run.failed') - startLog = new File(cwd, 'run.log') - pluginsTmpDir = new File(baseDir, "plugins tmp") - - env = [ - 'JAVA_HOME' : project.javaHome, - 'ES_GC_OPTS': config.jvmArgs // we pass these with the undocumented gc opts so the argline can set gc, etc - ] - args = config.systemProperties.collect { key, value -> "-D${key}=${value}" } - for (Map.Entry property : System.properties.entrySet()) { - if (property.getKey().startsWith('es.')) { - args.add("-D${property.getKey()}=${property.getValue()}") - } - } - // running with cmd on windows will look for this with the .bat extension - esScript = new File(homeDir, 'bin/elasticsearch').toString() - } - - /** Returns debug string for the command that started this node. */ - String getCommandString() { - String esCommandString = "Elasticsearch node ${nodeNum} command: ${esScript} " - esCommandString += args.join(' ') - esCommandString += '\nenvironment:' - env.each { k, v -> esCommandString += "\n ${k}: ${v}" } - return esCommandString - } - - /** Returns the directory elasticsearch home is contained in for the given distribution */ - static File homeDir(File baseDir, String distro) { - String path - switch (distro) { - case 'zip': - case 'tar': - path = "elasticsearch-${VersionProperties.elasticsearch}" - break; - default: - throw new InvalidUserDataException("Unknown distribution: ${distro}") - } - return new File(baseDir, path) - } - } - /** * Adds dependent tasks to the given task to start and stop a cluster with the given configuration. */ @@ -194,7 +114,10 @@ class ClusterFormationTasks { // extra setup commands for (Map.Entry command : node.config.setupCommands.entrySet()) { - setup = configureExecTask(taskName(task, node, command.getKey()), project, setup, node, command.getValue()) + // the first argument is the actual script name, relative to home + Object[] args = command.getValue().clone() + args[0] = new File(node.homeDir, args[0].toString()) + setup = configureExecTask(taskName(task, node, command.getKey()), project, setup, node, args) } Task start = configureStartTask(taskName(task, node, 'start'), project, setup, node) @@ -236,10 +159,10 @@ class ClusterFormationTasks { static Task configureWriteConfigTask(String name, Project project, Task setup, NodeInfo node) { Map esConfig = [ 'cluster.name' : node.clusterName, - 'http.port' : node.config.httpPort + node.nodeNum, - 'transport.tcp.port' : node.config.transportPort + node.nodeNum, + 'http.port' : node.httpPort(), + 'transport.tcp.port' : node.transportPort(), 'pidfile' : node.pidFile, - 'discovery.zen.ping.unicast.hosts': (0.. // we must add debug options inside the closure so the config is read at execution time, as // gradle task options are not processed until the end of the configuration phase if (node.config.debug) { @@ -334,7 +257,7 @@ class ClusterFormationTasks { script = wrapperScript.toString() } - exec(executable: executable, spawn: node.config.daemonize, dir: node.cwd, taskname: 'elasticsearch') { + ant.exec(executable: executable, spawn: node.config.daemonize, dir: node.cwd, taskname: 'elasticsearch') { node.env.each { key, value -> env(key: key, value: value) } arg(value: script) node.args.each { arg(value: it) } @@ -347,7 +270,6 @@ class ClusterFormationTasks { node.getCommandString().eachLine { line -> logger.info(line) } if (logger.isInfoEnabled() || node.config.daemonize == false) { - // run with piping streams directly out (even stderr to stdout since gradle would capture it) runAntCommand(project, antRunner, System.out, System.err) } else { // buffer the output, we may not need to print it @@ -364,7 +286,7 @@ class ClusterFormationTasks { static Task configureWaitTask(String name, Project project, List nodes, List startTasks) { Task wait = project.tasks.create(name: name, dependsOn: startTasks) wait.doLast { - ant.waitfor(maxwait: '30', maxwaitunit: 'second', checkevery: '500', checkeveryunit: 'millisecond', timeoutproperty: "failed${name}") { + ant.waitfor(maxwait: '15', maxwaitunit: 'second', checkevery: '500', checkeveryunit: 'millisecond', timeoutproperty: "failed${name}") { or { for (NodeInfo node : nodes) { resourceexists { @@ -376,7 +298,7 @@ class ClusterFormationTasks { resourceexists { file(file: node.pidFile.toString()) } - http(url: "http://localhost:${node.config.httpPort + node.nodeNum}") + socket(server: '127.0.0.1', port: node.httpPort()) } } } @@ -386,26 +308,48 @@ class ClusterFormationTasks { anyNodeFailed |= node.failedMarker.exists() } if (ant.properties.containsKey("failed${name}".toString()) || anyNodeFailed) { - for (NodeInfo node : nodes) { - if (logger.isInfoEnabled() == false) { - // We already log the command at info level. No need to do it twice. - node.getCommandString().eachLine { line -> logger.error(line) } - } - // the waitfor failed, so dump any output we got (may be empty if info logging, but that is ok) - logger.error("Node ${node.nodeNum} ant output:") - node.buffer.toString('UTF-8').eachLine { line -> logger.error(line) } - // also dump the log file for the startup script (which will include ES logging output to stdout) - if (node.startLog.exists()) { - logger.error("Node ${node.nodeNum} log:") - node.startLog.eachLine { line -> logger.error(line) } - } + waitFailed(nodes, logger, 'Failed to start elasticsearch') + } + + // go through each node checking the wait condition + for (NodeInfo node : nodes) { + // first bind node info to the closure, then pass to the ant runner so we can get good logging + Closure antRunner = node.config.waitCondition.curry(node) + + boolean success + if (logger.isInfoEnabled()) { + success = runAntCommand(project, antRunner, System.out, System.err) + } else { + PrintStream captureStream = new PrintStream(node.buffer, true, "UTF-8") + success = runAntCommand(project, antRunner, captureStream, captureStream) + } + + if (success == false) { + waitFailed(nodes, logger, 'Elasticsearch cluster failed to pass wait condition') } - throw new GradleException('Failed to start elasticsearch') } } return wait } + static void waitFailed(List nodes, Logger logger, String msg) { + for (NodeInfo node : nodes) { + if (logger.isInfoEnabled() == false) { + // We already log the command at info level. No need to do it twice. + node.getCommandString().eachLine { line -> logger.error(line) } + } + // the waitfor failed, so dump any output we got (may be empty if info logging, but that is ok) + logger.error("Node ${node.nodeNum} ant output:") + node.buffer.toString('UTF-8').eachLine { line -> logger.error(line) } + // also dump the log file for the startup script (which will include ES logging output to stdout) + if (node.startLog.exists()) { + logger.error("Node ${node.nodeNum} log:") + node.startLog.eachLine { line -> logger.error(line) } + } + } + throw new GradleException(msg) + } + /** Adds a task to check if the process with the given pidfile is actually elasticsearch */ static Task configureCheckPreviousTask(String name, Project project, Object depends, NodeInfo node) { return project.tasks.create(name: name, type: Exec, dependsOn: depends) { @@ -475,14 +419,15 @@ class ClusterFormationTasks { } /** Runs an ant command, sending output to the given out and error streams */ - static void runAntCommand(Project project, Closure command, PrintStream outputStream, PrintStream errorStream) { + static Object runAntCommand(Project project, Closure command, PrintStream outputStream, PrintStream errorStream) { DefaultLogger listener = new DefaultLogger( errorPrintStream: errorStream, outputPrintStream: outputStream, messageOutputLevel: org.apache.tools.ant.Project.MSG_INFO) project.ant.project.addBuildListener(listener) - project.configure(project.ant, command) + Object retVal = command(project.ant) project.ant.project.removeBuildListener(listener) + return retVal } } diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/NodeInfo.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/NodeInfo.groovy new file mode 100644 index 00000000000..3955b9e0269 --- /dev/null +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/NodeInfo.groovy @@ -0,0 +1,131 @@ +/* + * 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.gradle.test + +import org.elasticsearch.gradle.VersionProperties +import org.gradle.api.InvalidUserDataException +import org.gradle.api.Project +import org.gradle.api.Task + +/** + * A container for the files and configuration associated with a single node in a test cluster. + */ +class NodeInfo { + /** common configuration for all nodes, including this one */ + ClusterConfiguration config + + /** node number within the cluster, for creating unique names and paths */ + int nodeNum + + /** name of the cluster this node is part of */ + String clusterName + + /** root directory all node files and operations happen under */ + File baseDir + + /** the pid file the node will use */ + File pidFile + + /** elasticsearch home dir */ + File homeDir + + /** working directory for the node process */ + File cwd + + /** file that if it exists, indicates the node failed to start */ + File failedMarker + + /** stdout/stderr log of the elasticsearch process for this node */ + File startLog + + /** directory to install plugins from */ + File pluginsTmpDir + + /** environment variables to start the node with */ + Map env + + /** arguments to start the node with */ + List args + + /** Path to the elasticsearch start script */ + String esScript + + /** buffer for ant output when starting this node */ + ByteArrayOutputStream buffer = new ByteArrayOutputStream() + + /** Creates a node to run as part of a cluster for the given task */ + NodeInfo(ClusterConfiguration config, int nodeNum, Project project, Task task) { + this.config = config + this.nodeNum = nodeNum + clusterName = "${task.path.replace(':', '_').substring(1)}" + baseDir = new File(project.buildDir, "cluster/${task.name} node${nodeNum}") + pidFile = new File(baseDir, 'es.pid') + homeDir = homeDir(baseDir, config.distribution) + cwd = new File(baseDir, "cwd") + failedMarker = new File(cwd, 'run.failed') + startLog = new File(cwd, 'run.log') + pluginsTmpDir = new File(baseDir, "plugins tmp") + + env = [ + 'JAVA_HOME' : project.javaHome, + 'ES_GC_OPTS': config.jvmArgs // we pass these with the undocumented gc opts so the argline can set gc, etc + ] + args = config.systemProperties.collect { key, value -> "-D${key}=${value}" } + for (Map.Entry property : System.properties.entrySet()) { + if (property.getKey().startsWith('es.')) { + args.add("-D${property.getKey()}=${property.getValue()}") + } + } + // running with cmd on windows will look for this with the .bat extension + esScript = new File(homeDir, 'bin/elasticsearch').toString() + } + + /** Returns debug string for the command that started this node. */ + String getCommandString() { + String esCommandString = "Elasticsearch node ${nodeNum} command: ${esScript} " + esCommandString += args.join(' ') + esCommandString += '\nenvironment:' + env.each { k, v -> esCommandString += "\n ${k}: ${v}" } + return esCommandString + } + + /** Returns the http port for this node */ + int httpPort() { + return config.baseHttpPort + nodeNum + } + + /** Returns the transport port for this node */ + int transportPort() { + return config.baseTransportPort + nodeNum + } + + /** Returns the directory elasticsearch home is contained in for the given distribution */ + static File homeDir(File baseDir, String distro) { + String path + switch (distro) { + case 'zip': + case 'tar': + path = "elasticsearch-${VersionProperties.elasticsearch}" + break; + default: + throw new InvalidUserDataException("Unknown distribution: ${distro}") + } + return new File(baseDir, path) + } +} diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy index c68a6744237..7a3d067baab 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy @@ -75,7 +75,7 @@ class RestIntegTestTask extends RandomizedTestingTask { ClusterFormationTasks.setup(project, this, clusterConfig) configure { parallelism '1' - systemProperty 'tests.cluster', "localhost:${clusterConfig.transportPort}" + systemProperty 'tests.cluster', "localhost:${clusterConfig.baseTransportPort}" } } } diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RunTask.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RunTask.groovy index 6116ecf4ce2..37f65c88703 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RunTask.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RunTask.groovy @@ -6,7 +6,7 @@ import org.gradle.api.internal.tasks.options.Option class RunTask extends DefaultTask { - ClusterConfiguration clusterConfig = new ClusterConfiguration(httpPort: 9200, transportPort: 9300, daemonize: false) + ClusterConfiguration clusterConfig = new ClusterConfiguration(baseHttpPort: 9200, baseTransportPort: 9300, daemonize: false) RunTask() { project.afterEvaluate { From 556d80501c9efd565dd489fbba6b9566447bdaae Mon Sep 17 00:00:00 2001 From: Britta Weber Date: Mon, 23 Nov 2015 18:28:55 +0100 Subject: [PATCH 06/22] aggs: fix significant terms reduce for long terms Significant terms were not reduced correctly if they were long terms. Also, clean up the bwc test a little. Upgrades are not needed. related to #13522 --- .../significant/InternalSignificantTerms.java | 2 +- ...gnificantTermsBackwardCompatibilityIT.java | 16 +--- .../SignificanceHeuristicTests.java | 76 +++++++++++++++---- 3 files changed, 68 insertions(+), 26 deletions(-) diff --git a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/InternalSignificantTerms.java b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/InternalSignificantTerms.java index 27d9f58a7ff..21b92e83fff 100644 --- a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/InternalSignificantTerms.java +++ b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/InternalSignificantTerms.java @@ -173,7 +173,7 @@ public abstract class InternalSignificantTerms terms = (InternalSignificantTerms) aggregation; for (Bucket bucket : terms.buckets) { - List existingBuckets = buckets.get(bucket.getKey()); + List existingBuckets = buckets.get(bucket.getKeyAsString()); if (existingBuckets == null) { existingBuckets = new ArrayList<>(aggregations.size()); buckets.put(bucket.getKeyAsString(), existingBuckets); diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/bucket/SignificantTermsBackwardCompatibilityIT.java b/core/src/test/java/org/elasticsearch/search/aggregations/bucket/SignificantTermsBackwardCompatibilityIT.java index 5b7976043f8..d6afb35547f 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/bucket/SignificantTermsBackwardCompatibilityIT.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/bucket/SignificantTermsBackwardCompatibilityIT.java @@ -48,24 +48,16 @@ public class SignificantTermsBackwardCompatibilityIT extends ESBackcompatTestCas static final String CLASS_FIELD = "class"; /** - * Simple upgrade test for streaming significant terms buckets + * Test for streaming significant terms buckets to old es versions. */ public void testBucketStreaming() throws IOException, ExecutionException, InterruptedException { logger.debug("testBucketStreaming: indexing documents"); String type = randomBoolean() ? "string" : "long"; String settings = "{\"index.number_of_shards\": 5, \"index.number_of_replicas\": 0}"; index01Docs(type, settings); - + ensureGreen(); logClusterState(); - boolean upgraded; - int upgradedNodesCounter = 1; - do { - logger.debug("testBucketStreaming: upgrading {}st node", upgradedNodesCounter++); - upgraded = backwardsCluster().upgradeOneNode(); - ensureGreen(); - logClusterState(); - checkSignificantTermsAggregationCorrect(); - } while (upgraded); + checkSignificantTermsAggregationCorrect(); logger.debug("testBucketStreaming: done testing significant terms while upgrading"); } @@ -101,7 +93,7 @@ public class SignificantTermsBackwardCompatibilityIT extends ESBackcompatTestCas .execute() .actionGet(); assertSearchResponse(response); - StringTerms classes = (StringTerms) response.getAggregations().get("class"); + StringTerms classes = response.getAggregations().get("class"); assertThat(classes.getBuckets().size(), equalTo(2)); for (Terms.Bucket classBucket : classes.getBuckets()) { Map aggs = classBucket.getAggregations().asMap(); diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/bucket/significant/SignificanceHeuristicTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/bucket/significant/SignificanceHeuristicTests.java index c911da06ae9..b10dfd31b35 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/bucket/significant/SignificanceHeuristicTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/bucket/significant/SignificanceHeuristicTests.java @@ -28,6 +28,7 @@ import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.json.JsonXContent; import org.elasticsearch.search.SearchShardTarget; +import org.elasticsearch.search.aggregations.InternalAggregation; import org.elasticsearch.search.aggregations.InternalAggregations; import org.elasticsearch.search.aggregations.bucket.significant.heuristics.ChiSquare; import org.elasticsearch.search.aggregations.bucket.significant.heuristics.GND; @@ -38,6 +39,8 @@ import org.elasticsearch.search.aggregations.bucket.significant.heuristics.Signi import org.elasticsearch.search.aggregations.bucket.significant.heuristics.SignificanceHeuristicBuilder; import org.elasticsearch.search.aggregations.bucket.significant.heuristics.SignificanceHeuristicParser; import org.elasticsearch.search.aggregations.bucket.significant.heuristics.SignificanceHeuristicParserMapper; +import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; +import org.elasticsearch.search.aggregations.support.format.ValueFormatter; import org.elasticsearch.search.internal.SearchContext; import org.elasticsearch.test.ESTestCase; import org.elasticsearch.test.TestSearchContext; @@ -45,18 +48,11 @@ import org.elasticsearch.test.TestSearchContext; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; +import java.nio.charset.StandardCharsets; +import java.util.*; import static org.elasticsearch.test.VersionUtils.randomVersion; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.lessThanOrEqualTo; +import static org.hamcrest.Matchers.*; /** * @@ -83,24 +79,28 @@ public class SignificanceHeuristicTests extends ESTestCase { ByteArrayOutputStream outBuffer = new ByteArrayOutputStream(); OutputStreamStreamOutput out = new OutputStreamStreamOutput(outBuffer); out.setVersion(version); - sigTerms[0].writeTo(out); // read ByteArrayInputStream inBuffer = new ByteArrayInputStream(outBuffer.toByteArray()); InputStreamStreamInput in = new InputStreamStreamInput(inBuffer); in.setVersion(version); - sigTerms[1].readFrom(in); assertTrue(sigTerms[1].significanceHeuristic.equals(sigTerms[0].significanceHeuristic)); + InternalSignificantTerms.Bucket originalBucket = (InternalSignificantTerms.Bucket) sigTerms[0].buckets.get(0); + InternalSignificantTerms.Bucket streamedBucket = (InternalSignificantTerms.Bucket) sigTerms[1].buckets.get(0); + assertThat(originalBucket.getKeyAsString(), equalTo(streamedBucket.getKeyAsString())); + assertThat(originalBucket.getSupersetDf(), equalTo(streamedBucket.getSupersetDf())); + assertThat(originalBucket.getSubsetDf(), equalTo(streamedBucket.getSubsetDf())); + assertThat(streamedBucket.getSubsetSize(), equalTo(10l)); + assertThat(streamedBucket.getSupersetSize(), equalTo(20l)); } InternalSignificantTerms[] getRandomSignificantTerms(SignificanceHeuristic heuristic) { InternalSignificantTerms[] sTerms = new InternalSignificantTerms[2]; ArrayList buckets = new ArrayList<>(); if (randomBoolean()) { - BytesRef term = new BytesRef("123.0"); buckets.add(new SignificantLongTerms.Bucket(1, 2, 3, 4, 123, InternalAggregations.EMPTY, null)); sTerms[0] = new SignificantLongTerms(10, 20, "some_name", null, 1, 1, heuristic, buckets, Collections.EMPTY_LIST, null); @@ -125,6 +125,56 @@ public class SignificanceHeuristicTests extends ESTestCase { return heuristics.get(randomInt(3)); } + public void testReduce() { + List aggs = createInternalAggregations(); + SignificantTerms reducedAgg = (SignificantTerms) aggs.get(0).doReduce(aggs, null); + assertThat(reducedAgg.getBuckets().size(), equalTo(2)); + assertThat(reducedAgg.getBuckets().get(0).getSubsetDf(), equalTo(8l)); + assertThat(reducedAgg.getBuckets().get(0).getSubsetSize(), equalTo(16l)); + assertThat(reducedAgg.getBuckets().get(0).getSupersetDf(), equalTo(10l)); + assertThat(reducedAgg.getBuckets().get(0).getSupersetSize(), equalTo(30l)); + assertThat(reducedAgg.getBuckets().get(1).getSubsetDf(), equalTo(8l)); + assertThat(reducedAgg.getBuckets().get(1).getSubsetSize(), equalTo(16l)); + assertThat(reducedAgg.getBuckets().get(1).getSupersetDf(), equalTo(10l)); + assertThat(reducedAgg.getBuckets().get(1).getSupersetSize(), equalTo(30l)); + } + + // Create aggregations as they might come from three different shards and return as list. + private List createInternalAggregations() { + + String type = randomBoolean() ? "long" : "string"; + SignificanceHeuristic significanceHeuristic = getRandomSignificanceheuristic(); + + List aggs = new ArrayList<>(); + List terms0Buckets = new ArrayList<>(); + terms0Buckets.add(createBucket(type, 4, 4, 5, 10, 0)); + aggs.add(createAggregation(type, significanceHeuristic, terms0Buckets, 4, 10)); + List terms1Buckets = new ArrayList<>(); + terms0Buckets.add(createBucket(type, 4, 4, 5, 10, 1)); + aggs.add(createAggregation(type, significanceHeuristic, terms1Buckets, 4, 10)); + List terms01Buckets = new ArrayList<>(); + terms0Buckets.add(createBucket(type, 4, 8, 5, 10, 0)); + terms0Buckets.add(createBucket(type, 4, 8, 5, 10, 1)); + aggs.add(createAggregation(type, significanceHeuristic, terms01Buckets, 8, 10)); + return aggs; + } + + private InternalSignificantTerms createAggregation(String type, SignificanceHeuristic significanceHeuristic, List buckets, long subsetSize, long supersetSize) { + if (type.equals("string")) { + return new SignificantStringTerms(subsetSize, supersetSize, "sig_terms", 2, -1, significanceHeuristic, buckets, new ArrayList(), new HashMap()); + } else { + return new SignificantLongTerms(subsetSize, supersetSize, "sig_terms", ValueFormatter.RAW, 2, -1, significanceHeuristic, buckets, new ArrayList(), new HashMap()); + } + } + + private InternalSignificantTerms.Bucket createBucket(String type, long subsetDF, long subsetSize, long supersetDF, long supersetSize, long label) { + if (type.equals("string")) { + return new SignificantStringTerms.Bucket(new BytesRef(Long.toString(label).getBytes(StandardCharsets.UTF_8)), subsetDF, subsetSize, supersetDF, supersetSize, InternalAggregations.EMPTY); + } else { + return new SignificantLongTerms.Bucket(subsetDF, subsetSize, supersetDF, supersetSize, label, InternalAggregations.EMPTY, ValueFormatter.RAW); + } + } + // test that // 1. The output of the builders can actually be parsed // 2. The parser does not swallow parameters after a significance heuristic was defined From ff9c33b6c8eb95df29f51f631a635db21c3f3da8 Mon Sep 17 00:00:00 2001 From: Yannick Welsch Date: Tue, 24 Nov 2015 12:08:29 +0100 Subject: [PATCH 07/22] Use ObjectParser to parse AllocationID --- .../cluster/routing/AllocationId.java | 60 +++++++++---------- 1 file changed, 29 insertions(+), 31 deletions(-) diff --git a/core/src/main/java/org/elasticsearch/cluster/routing/AllocationId.java b/core/src/main/java/org/elasticsearch/cluster/routing/AllocationId.java index 20da5ce8cd3..528ed8b1c3f 100644 --- a/core/src/main/java/org/elasticsearch/cluster/routing/AllocationId.java +++ b/core/src/main/java/org/elasticsearch/cluster/routing/AllocationId.java @@ -20,15 +20,17 @@ package org.elasticsearch.cluster.routing; import org.elasticsearch.common.Nullable; +import org.elasticsearch.common.ParseField; import org.elasticsearch.common.Strings; import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; +import org.elasticsearch.common.xcontent.ObjectParser; import org.elasticsearch.common.xcontent.ToXContent; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.gateway.CorruptStateException; import java.io.IOException; +import java.util.Objects; /** * Uniquely identifies an allocation. An allocation is a shard moving from unassigned to initializing, @@ -43,6 +45,30 @@ public class AllocationId implements ToXContent { private static final String ID_KEY = "id"; private static final String RELOCATION_ID_KEY = "relocation_id"; + private static final ObjectParser ALLOCATION_ID_PARSER = new ObjectParser<>("allocationId"); + + static { + ALLOCATION_ID_PARSER.declareString(AllocationId.Builder::setId, new ParseField(ID_KEY)); + ALLOCATION_ID_PARSER.declareString(AllocationId.Builder::setRelocationId, new ParseField(RELOCATION_ID_KEY)); + } + + private static class Builder { + private String id; + private String relocationId; + + public void setId(String id) { + this.id = id; + } + + public void setRelocationId(String relocationId) { + this.relocationId = relocationId; + } + + public AllocationId build() { + return new AllocationId(id, relocationId); + } + } + private final String id; @Nullable private final String relocationId; @@ -58,6 +84,7 @@ public class AllocationId implements ToXContent { } private AllocationId(String id, String relocationId) { + Objects.requireNonNull(id, "Argument [id] must be non-null"); this.id = id; this.relocationId = relocationId; } @@ -164,35 +191,6 @@ public class AllocationId implements ToXContent { } public static AllocationId fromXContent(XContentParser parser) throws IOException { - XContentParser.Token token = parser.currentToken(); - if (token == null) { // fresh parser? move to the first real token under object - token = parser.nextToken(); - } - assert token == XContentParser.Token.START_OBJECT; - - String id = null; - String relocationId = null; - - String currentFieldName = null; - - while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { - if (token == XContentParser.Token.FIELD_NAME) { - currentFieldName = parser.currentName(); - } else if (token.isValue()) { - if (ID_KEY.equals(currentFieldName)) { - id = parser.text(); - } else if (RELOCATION_ID_KEY.equals(currentFieldName)) { - relocationId = parser.text(); - } else { - throw new CorruptStateException("unexpected field in allocation id [" + currentFieldName + "]"); - } - } else { - throw new CorruptStateException("unexpected token in allocation id [" + token.name() + "]"); - } - } - if (id == null) { - throw new CorruptStateException("missing value for [id] in allocation id"); - } - return new AllocationId(id, relocationId); + return ALLOCATION_ID_PARSER.parse(parser, new AllocationId.Builder()).build(); } } From 74d9c8f5cf6a4de1950cb54b851760c6919e1ab5 Mon Sep 17 00:00:00 2001 From: Clinton Gormley Date: Tue, 24 Nov 2015 12:31:31 +0100 Subject: [PATCH 08/22] Docs: Fix :issue: and :pull: asciidoc replacements Closes #14922 --- docs/reference/index.asciidoc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/reference/index.asciidoc b/docs/reference/index.asciidoc index 5783376a54f..34d1cba92c0 100644 --- a/docs/reference/index.asciidoc +++ b/docs/reference/index.asciidoc @@ -7,8 +7,8 @@ :jdk: 1.8.0_25 :defguide: https://www.elastic.co/guide/en/elasticsearch/guide/current :plugins: https://www.elastic.co/guide/en/elasticsearch/plugins/master -:issue: https://github.com/elastic/elasticsearch/issues -:pull: https://github.com/elastic/elasticsearch/pull +:issue: https://github.com/elastic/elasticsearch/issues/ +:pull: https://github.com/elastic/elasticsearch/pull/ include::getting-started.asciidoc[] From a25b407aeb8a55fa8a44f6987ca6333470c7ff05 Mon Sep 17 00:00:00 2001 From: Lee Hinman Date: Tue, 24 Nov 2015 08:22:20 -0700 Subject: [PATCH 09/22] Add support for headers in REST tests This adds support for arbitrary headers sent with each REST request, it will allow us to test things like different xcontent-encoding (see 50_with_headers.yaml for what this looks like). Headers are specified at the same level as `catch`, so a request would look like: ```yaml - do: headers: Content-Type: application/yaml get: index: test_1 type: _all id: 1 ``` --- .../test/get/50_with_headers.yaml | 30 ++++++++++++++++ .../test/rest/RestTestExecutionContext.java | 9 ++--- .../test/rest/client/RestClient.java | 5 ++- .../test/rest/parser/DoSectionParser.java | 34 ++++++++++++++----- .../test/rest/section/ApiCallSection.java | 13 +++++++ .../test/rest/section/DoSection.java | 6 +++- .../test/rest/support/Features.java | 2 +- .../test/rest/test/DoSectionParserTests.java | 23 +++++++++++++ 8 files changed, 106 insertions(+), 16 deletions(-) create mode 100644 rest-api-spec/src/main/resources/rest-api-spec/test/get/50_with_headers.yaml diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/get/50_with_headers.yaml b/rest-api-spec/src/main/resources/rest-api-spec/test/get/50_with_headers.yaml new file mode 100644 index 00000000000..71229686eed --- /dev/null +++ b/rest-api-spec/src/main/resources/rest-api-spec/test/get/50_with_headers.yaml @@ -0,0 +1,30 @@ +--- +"REST test with headers": + - skip: + features: headers + + - do: + index: + index: test_1 + type: test + id: 1 + body: { "body": "foo" } + + - do: + headers: + Content-Type: application/yaml + get: + index: test_1 + type: _all + id: 1 + + - match: + $body: | + /^---\n + _index:\s+\"test_1"\n + _type:\s+"test"\n + _id:\s+"1"\n + _version:\s+1\n + found:\s+true\n + _source:\n + \s+body:\s+"foo"\n$/ diff --git a/test-framework/src/main/java/org/elasticsearch/test/rest/RestTestExecutionContext.java b/test-framework/src/main/java/org/elasticsearch/test/rest/RestTestExecutionContext.java index b7dad93d593..4054b8efce1 100644 --- a/test-framework/src/main/java/org/elasticsearch/test/rest/RestTestExecutionContext.java +++ b/test-framework/src/main/java/org/elasticsearch/test/rest/RestTestExecutionContext.java @@ -62,7 +62,8 @@ public class RestTestExecutionContext implements Closeable { * Saves the obtained response in the execution context. * @throws RestException if the returned status code is non ok */ - public RestResponse callApi(String apiName, Map params, List> bodies) throws IOException, RestException { + public RestResponse callApi(String apiName, Map params, List> bodies, + Map headers) throws IOException, RestException { //makes a copy of the parameters before modifying them for this specific request HashMap requestParams = new HashMap<>(params); for (Map.Entry entry : requestParams.entrySet()) { @@ -74,7 +75,7 @@ public class RestTestExecutionContext implements Closeable { String body = actualBody(bodies); try { - response = callApiInternal(apiName, requestParams, body); + response = callApiInternal(apiName, requestParams, body, headers); //we always stash the last response body stash.stashValue("body", response.getBody()); return response; @@ -104,8 +105,8 @@ public class RestTestExecutionContext implements Closeable { return XContentFactory.jsonBuilder().map(body).string(); } - private RestResponse callApiInternal(String apiName, Map params, String body) throws IOException, RestException { - return restClient.callApi(apiName, params, body); + private RestResponse callApiInternal(String apiName, Map params, String body, Map headers) throws IOException, RestException { + return restClient.callApi(apiName, params, body, headers); } /** diff --git a/test-framework/src/main/java/org/elasticsearch/test/rest/client/RestClient.java b/test-framework/src/main/java/org/elasticsearch/test/rest/client/RestClient.java index 4b46a0e6498..63a8b397c45 100644 --- a/test-framework/src/main/java/org/elasticsearch/test/rest/client/RestClient.java +++ b/test-framework/src/main/java/org/elasticsearch/test/rest/client/RestClient.java @@ -132,7 +132,7 @@ public class RestClient implements Closeable { * @throws RestException if the obtained status code is non ok, unless the specific error code needs to be ignored * according to the ignore parameter received as input (which won't get sent to elasticsearch) */ - public RestResponse callApi(String apiName, Map params, String body) throws IOException, RestException { + public RestResponse callApi(String apiName, Map params, String body, Map headers) throws IOException, RestException { List ignores = new ArrayList<>(); Map requestParams = null; @@ -151,6 +151,9 @@ public class RestClient implements Closeable { } HttpRequestBuilder httpRequestBuilder = callApiBuilder(apiName, requestParams, body); + for (Map.Entry header : headers.entrySet()) { + httpRequestBuilder.addHeader(header.getKey(), header.getValue()); + } logger.debug("calling api [{}]", apiName); HttpResponse httpResponse = httpRequestBuilder.execute(); diff --git a/test-framework/src/main/java/org/elasticsearch/test/rest/parser/DoSectionParser.java b/test-framework/src/main/java/org/elasticsearch/test/rest/parser/DoSectionParser.java index ec5aef54459..2a20e0f3146 100644 --- a/test-framework/src/main/java/org/elasticsearch/test/rest/parser/DoSectionParser.java +++ b/test-framework/src/main/java/org/elasticsearch/test/rest/parser/DoSectionParser.java @@ -25,6 +25,8 @@ import org.elasticsearch.test.rest.section.ApiCallSection; import org.elasticsearch.test.rest.section.DoSection; import java.io.IOException; +import java.util.HashMap; +import java.util.Map; /** * Parser for do sections @@ -40,6 +42,8 @@ public class DoSectionParser implements RestTestFragmentParser { XContentParser.Token token; DoSection doSection = new DoSection(); + ApiCallSection apiCallSection = null; + Map headers = new HashMap<>(); while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { if (token == XContentParser.Token.FIELD_NAME) { @@ -49,8 +53,17 @@ public class DoSectionParser implements RestTestFragmentParser { doSection.setCatch(parser.text()); } } else if (token == XContentParser.Token.START_OBJECT) { - if (currentFieldName != null) { - ApiCallSection apiCallSection = new ApiCallSection(currentFieldName); + if ("headers".equals(currentFieldName)) { + String headerName = null; + while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { + if (token == XContentParser.Token.FIELD_NAME) { + headerName = parser.currentName(); + } else if (token.isValue()) { + headers.put(headerName, parser.text()); + } + } + } else if (currentFieldName != null) { // must be part of API call then + apiCallSection = new ApiCallSection(currentFieldName); String paramName = null; while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { if (token == XContentParser.Token.FIELD_NAME) { @@ -73,17 +86,20 @@ public class DoSectionParser implements RestTestFragmentParser { } } } - doSection.setApiCallSection(apiCallSection); } } } - - parser.nextToken(); - - if (doSection.getApiCallSection() == null) { - throw new RestTestParseException("client call section is mandatory within a do section"); + try { + if (apiCallSection == null) { + throw new RestTestParseException("client call section is mandatory within a do section"); + } + if (headers.isEmpty() == false) { + apiCallSection.addHeaders(headers); + } + doSection.setApiCallSection(apiCallSection); + } finally { + parser.nextToken(); } - return doSection; } } diff --git a/test-framework/src/main/java/org/elasticsearch/test/rest/section/ApiCallSection.java b/test-framework/src/main/java/org/elasticsearch/test/rest/section/ApiCallSection.java index da6c0b3be2c..030469148ed 100644 --- a/test-framework/src/main/java/org/elasticsearch/test/rest/section/ApiCallSection.java +++ b/test-framework/src/main/java/org/elasticsearch/test/rest/section/ApiCallSection.java @@ -33,6 +33,7 @@ public class ApiCallSection { private final String api; private final Map params = new HashMap<>(); + private final Map headers = new HashMap<>(); private final List> bodies = new ArrayList<>(); public ApiCallSection(String api) { @@ -56,6 +57,18 @@ public class ApiCallSection { this.params.put(key, value); } + public void addHeaders(Map otherHeaders) { + this.headers.putAll(otherHeaders); + } + + public void addHeader(String key, String value) { + this.headers.put(key, value); + } + + public Map getHeaders() { + return unmodifiableMap(headers); + } + public List> getBodies() { return Collections.unmodifiableList(bodies); } diff --git a/test-framework/src/main/java/org/elasticsearch/test/rest/section/DoSection.java b/test-framework/src/main/java/org/elasticsearch/test/rest/section/DoSection.java index 9a1bf1c9267..38504c4af5f 100644 --- a/test-framework/src/main/java/org/elasticsearch/test/rest/section/DoSection.java +++ b/test-framework/src/main/java/org/elasticsearch/test/rest/section/DoSection.java @@ -45,6 +45,9 @@ import static org.junit.Assert.fail; * * - do: * catch: missing + * headers: + * Authorization: Basic user:pass + * Content-Type: application/json * update: * index: test_1 * type: test @@ -86,7 +89,8 @@ public class DoSection implements ExecutableSection { } try { - RestResponse restResponse = executionContext.callApi(apiCallSection.getApi(), apiCallSection.getParams(), apiCallSection.getBodies()); + RestResponse restResponse = executionContext.callApi(apiCallSection.getApi(), apiCallSection.getParams(), + apiCallSection.getBodies(), apiCallSection.getHeaders()); if (Strings.hasLength(catchParam)) { String catchStatusCode; if (catches.containsKey(catchParam)) { diff --git a/test-framework/src/main/java/org/elasticsearch/test/rest/support/Features.java b/test-framework/src/main/java/org/elasticsearch/test/rest/support/Features.java index 018d2413737..0f51f72e8e5 100644 --- a/test-framework/src/main/java/org/elasticsearch/test/rest/support/Features.java +++ b/test-framework/src/main/java/org/elasticsearch/test/rest/support/Features.java @@ -34,7 +34,7 @@ import java.util.List; */ public final class Features { - private static final List SUPPORTED = Arrays.asList("stash_in_path", "groovy_scripting"); + private static final List SUPPORTED = Arrays.asList("stash_in_path", "groovy_scripting", "headers"); private Features() { diff --git a/test-framework/src/test/java/org/elasticsearch/test/rest/test/DoSectionParserTests.java b/test-framework/src/test/java/org/elasticsearch/test/rest/test/DoSectionParserTests.java index 5f0f2bd8b35..3c65fda94ca 100644 --- a/test-framework/src/test/java/org/elasticsearch/test/rest/test/DoSectionParserTests.java +++ b/test-framework/src/test/java/org/elasticsearch/test/rest/test/DoSectionParserTests.java @@ -341,6 +341,29 @@ public class DoSectionParserTests extends AbstractParserTestCase { assertThat(doSection.getApiCallSection().hasBody(), equalTo(false)); } + public void testParseDoSectionWithHeaders() throws Exception { + parser = YamlXContent.yamlXContent.createParser( + "headers:\n" + + " Authorization: \"thing one\"\n" + + " Content-Type: \"application/json\"\n" + + "indices.get_warmer:\n" + + " index: test_index\n" + + " name: test_warmer" + ); + + DoSectionParser doSectionParser = new DoSectionParser(); + DoSection doSection = doSectionParser.parse(new RestTestSuiteParseContext("api", "suite", parser)); + + assertThat(doSection.getApiCallSection(), notNullValue()); + assertThat(doSection.getApiCallSection().getApi(), equalTo("indices.get_warmer")); + assertThat(doSection.getApiCallSection().getParams().size(), equalTo(2)); + assertThat(doSection.getApiCallSection().hasBody(), equalTo(false)); + assertThat(doSection.getApiCallSection().getHeaders(), notNullValue()); + assertThat(doSection.getApiCallSection().getHeaders().size(), equalTo(2)); + assertThat(doSection.getApiCallSection().getHeaders().get("Authorization"), equalTo("thing one")); + assertThat(doSection.getApiCallSection().getHeaders().get("Content-Type"), equalTo("application/json")); + } + public void testParseDoSectionWithoutClientCallSection() throws Exception { parser = YamlXContent.yamlXContent.createParser( "catch: missing\n" From 647f324c46136fbe329e36cb9fa0397a5e36164c Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Tue, 24 Nov 2015 08:23:16 -0800 Subject: [PATCH 10/22] Change waitfor max time back to 30 seconds, in case jenkins is slow --- .../org/elasticsearch/gradle/test/ClusterFormationTasks.groovy | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy index 4123f32ad76..43b9f8af3a7 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy @@ -286,7 +286,7 @@ class ClusterFormationTasks { static Task configureWaitTask(String name, Project project, List nodes, List startTasks) { Task wait = project.tasks.create(name: name, dependsOn: startTasks) wait.doLast { - ant.waitfor(maxwait: '15', maxwaitunit: 'second', checkevery: '500', checkeveryunit: 'millisecond', timeoutproperty: "failed${name}") { + ant.waitfor(maxwait: '30', maxwaitunit: 'second', checkevery: '500', checkeveryunit: 'millisecond', timeoutproperty: "failed${name}") { or { for (NodeInfo node : nodes) { resourceexists { From aad84395c94c1cb60e888a52aa60caa2c5453156 Mon Sep 17 00:00:00 2001 From: Adrien Grand Date: Tue, 24 Nov 2015 19:13:49 +0100 Subject: [PATCH 11/22] Add a test that upgrades succeed even if a mapping contains fields that come from a plugin. --- dev-tools/create_bwc_index.py | 10 ++ .../create_bwc_index_with_plugin_mappings.py | 124 ++++++++++++++++++ .../Murmur3FieldMapperUpgradeTests.java | 77 +++++++++++ .../bwc/index-mapper-murmur3-2.0.0.zip | Bin 0 -> 8226 bytes .../size/SizeFieldMapperUpgradeTests.java | 88 +++++++++++++ .../indices/bwc/index-mapper-size-2.0.0.zip | Bin 0 -> 7973 bytes 6 files changed, 299 insertions(+) create mode 100644 dev-tools/create_bwc_index_with_plugin_mappings.py create mode 100644 plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java create mode 100644 plugins/mapper-murmur3/src/test/resources/indices/bwc/index-mapper-murmur3-2.0.0.zip create mode 100644 plugins/mapper-size/src/test/java/org/elasticsearch/index/mapper/size/SizeFieldMapperUpgradeTests.java create mode 100644 plugins/mapper-size/src/test/resources/indices/bwc/index-mapper-size-2.0.0.zip diff --git a/dev-tools/create_bwc_index.py b/dev-tools/create_bwc_index.py index 5d663ca69f3..83a35941577 100644 --- a/dev-tools/create_bwc_index.py +++ b/dev-tools/create_bwc_index.py @@ -149,6 +149,16 @@ def start_node(version, release_dir, data_dir, repo_dir, tcp_port=DEFAULT_TRANSP cmd.append('-f') # version before 1.0 start in background automatically return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) +def install_plugin(version, release_dir, plugin_name): + run_plugin(version, release_dir, 'install', [plugin_name]) + +def remove_plugin(version, release_dir, plugin_name): + run_plugin(version, release_dir, 'remove', [plugin_name]) + +def run_plugin(version, release_dir, plugin_cmd, args): + cmd = [os.path.join(release_dir, 'bin/plugin'), plugin_cmd] + args + subprocess.check_call(cmd) + def create_client(http_port=DEFAULT_HTTP_TCP_PORT, timeout=30): logging.info('Waiting for node to startup') for _ in range(0, timeout): diff --git a/dev-tools/create_bwc_index_with_plugin_mappings.py b/dev-tools/create_bwc_index_with_plugin_mappings.py new file mode 100644 index 00000000000..c30de412d1d --- /dev/null +++ b/dev-tools/create_bwc_index_with_plugin_mappings.py @@ -0,0 +1,124 @@ +import create_bwc_index +import logging +import os +import random +import shutil +import subprocess +import sys +import tempfile + +def fetch_version(version): + logging.info('fetching ES version %s' % version) + if subprocess.call([sys.executable, os.path.join(os.path.split(sys.argv[0])[0], 'get-bwc-version.py'), version]) != 0: + raise RuntimeError('failed to download ES version %s' % version) + +def create_index(plugin, mapping, docs): + ''' + Creates a static back compat index (.zip) with mappings using fields defined in plugins. + ''' + + logging.basicConfig(format='[%(levelname)s] [%(asctime)s] %(message)s', level=logging.INFO, + datefmt='%Y-%m-%d %I:%M:%S %p') + logging.getLogger('elasticsearch').setLevel(logging.ERROR) + logging.getLogger('urllib3').setLevel(logging.WARN) + + tmp_dir = tempfile.mkdtemp() + plugin_installed = False + node = None + try: + data_dir = os.path.join(tmp_dir, 'data') + repo_dir = os.path.join(tmp_dir, 'repo') + logging.info('Temp data dir: %s' % data_dir) + logging.info('Temp repo dir: %s' % repo_dir) + + version = '2.0.0' + classifier = '%s-%s' %(plugin, version) + index_name = 'index-%s' % classifier + + # Download old ES releases if necessary: + release_dir = os.path.join('backwards', 'elasticsearch-%s' % version) + if not os.path.exists(release_dir): + fetch_version(version) + + create_bwc_index.install_plugin(version, release_dir, plugin) + plugin_installed = True + node = create_bwc_index.start_node(version, release_dir, data_dir, repo_dir, cluster_name=index_name) + client = create_bwc_index.create_client() + put_plugin_mappings(client, index_name, mapping, docs) + create_bwc_index.shutdown_node(node) + + print('%s server output:\n%s' % (version, node.stdout.read().decode('utf-8'))) + node = None + create_bwc_index.compress_index(classifier, tmp_dir, 'plugins/%s/src/test/resources/indices/bwc' %plugin) + finally: + if node is not None: + create_bwc_index.shutdown_node(node) + if plugin_installed: + create_bwc_index.remove_plugin(version, release_dir, plugin) + shutil.rmtree(tmp_dir) + +def put_plugin_mappings(client, index_name, mapping, docs): + client.indices.delete(index=index_name, ignore=404) + logging.info('Create single shard test index') + + client.indices.create(index=index_name, body={ + 'settings': { + 'number_of_shards': 1, + 'number_of_replicas': 0 + }, + 'mappings': { + 'type': mapping + } + }) + health = client.cluster.health(wait_for_status='green', wait_for_relocating_shards=0) + assert health['timed_out'] == False, 'cluster health timed out %s' % health + + logging.info('Indexing documents') + for i in range(len(docs)): + client.index(index=index_name, doc_type="type", id=str(i), body=docs[i]) + logging.info('Flushing index') + client.indices.flush(index=index_name) + + logging.info('Running basic checks') + count = client.count(index=index_name)['count'] + assert count == len(docs), "expected %d docs, got %d" %(len(docs), count) + +def main(): + docs = [ + { + "foo": "abc" + }, + { + "foo": "abcdef" + }, + { + "foo": "a" + } + ] + + murmur3_mapping = { + 'properties': { + 'foo': { + 'type': 'string', + 'fields': { + 'hash': { + 'type': 'murmur3' + } + } + } + } + } + + create_index("mapper-murmur3", murmur3_mapping, docs) + + size_mapping = { + '_size': { + 'enabled': True + } + } + + create_index("mapper-size", size_mapping, docs) + +if __name__ == '__main__': + main() + diff --git a/plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java b/plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java new file mode 100644 index 00000000000..8ede994e2f4 --- /dev/null +++ b/plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java @@ -0,0 +1,77 @@ +/* + * 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.index.mapper.murmur3; + +import org.apache.lucene.util.LuceneTestCase; +import org.apache.lucene.util.TestUtil; +import org.elasticsearch.action.search.SearchResponse; +import org.elasticsearch.env.NodeEnvironment; +import org.elasticsearch.plugin.mapper.MapperMurmur3Plugin; +import org.elasticsearch.plugins.Plugin; +import org.elasticsearch.search.aggregations.AggregationBuilders; +import org.elasticsearch.search.aggregations.metrics.cardinality.Cardinality; +import org.elasticsearch.test.ESIntegTestCase; +import org.elasticsearch.test.hamcrest.ElasticsearchAssertions; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Collection; +import java.util.Collections; + +@ESIntegTestCase.ClusterScope(scope = ESIntegTestCase.Scope.TEST, numDataNodes = 0) +@LuceneTestCase.SuppressFileSystems("ExtrasFS") +public class Murmur3FieldMapperUpgradeTests extends ESIntegTestCase { + + @Override + protected Collection> nodePlugins() { + return Collections.singleton(MapperMurmur3Plugin.class); + } + + public void testUpgradeOldMapping() throws IOException { + final String indexName = "index-mapper-murmur3-2.0.0"; + Path unzipDir = createTempDir(); + Path unzipDataDir = unzipDir.resolve("data"); + Path backwardsIndex = getBwcIndicesPath().resolve(indexName + ".zip"); + try (InputStream stream = Files.newInputStream(backwardsIndex)) { + TestUtil.unzip(stream, unzipDir); + } + assertTrue(Files.exists(unzipDataDir)); + + final String node = internalCluster().startNode(); + Path[] nodePaths = internalCluster().getInstance(NodeEnvironment.class, node).nodeDataPaths(); + assertEquals(1, nodePaths.length); + Path dataPath = nodePaths[0].resolve(NodeEnvironment.INDICES_FOLDER); + assertFalse(Files.exists(dataPath)); + Path src = unzipDataDir.resolve(indexName + "/nodes/0/indices"); + Files.move(src, dataPath); + + ensureYellow(); + final SearchResponse countResponse = client().prepareSearch(indexName).setSize(0).get(); + ElasticsearchAssertions.assertHitCount(countResponse, 3L); + + final SearchResponse cardinalityResponse = client().prepareSearch(indexName).addAggregation( + AggregationBuilders.cardinality("card").field("foo.hash")).get(); + Cardinality cardinality = cardinalityResponse.getAggregations().get("card"); + assertEquals(3L, cardinality.getValue()); + } + +} diff --git a/plugins/mapper-murmur3/src/test/resources/indices/bwc/index-mapper-murmur3-2.0.0.zip b/plugins/mapper-murmur3/src/test/resources/indices/bwc/index-mapper-murmur3-2.0.0.zip new file mode 100644 index 0000000000000000000000000000000000000000..0b69aac180bc6a62f65f735812ba05ed5b59cf01 GIT binary patch literal 8226 zcmcIp2|UzkAODXrZW80_m5|z@9W!H^n8;P$TvK7(SB`O|QI3%9phK=+$jqepu!RW`-aMj z**f`R>H!9*0{%XcJ}5_`H~_UePjuQ2uBaGE03zHE1%Szi9rJ!&efsOcWPef&a<|W( zJ*05t?x=9^jz#L}qIJ=novr!ZdF>*0CWrZxA{MznX3oJ8i{5|g1ltxm!CVVyJ}iLr z1^Z2(g>8ww=Jmo{OEzC&X(5O4eO&vc1>qeL=@UufIF|<&I2gxb0Gp6rL@3!D0ssfV z(eR2?JQPJW~)SZS3^QVt7dms zi>A8X6I=`SA$GLQDcg;hPbrMP04x6mU#pJ${+0owSPP4~HQKIqW!tS6)Yb;MbJS7z zIk{Dv<>e*)B(ah<@>t2!1F{OSv}!B5#hbC0%XAYtj!h%RqhM|;|;r`6DD^v#9VheloM`gqTzvXR4gUnrrUU+TGp5}FkcdUJ}n z(^4NjGTet85gHcAsXOde$g>@?<1^*$`SEq28`z5^Fg(-1z@8cj;^S3-Oxi=0#HK$F zf)WCk;?@9Xf`6=y8PS`x)iGc@(jaV`&2Bq(rp;8)cQT<2_EiG=KfVG#iLT$SJ-m+L zw-bQw77^ab%l{5bjdHRpF6ev?W$a)q|5NYpM3Amq;PMmgs-f6X)2H`B1v$c5dLaOHxLXtj@idqH0WQ zq{q@rL?+Gy#m`Mv0ROq8Zyr0_@a6V6FJr#kaRBB=M z8P~NiKOAm<*w9e_w4PPp(pvX4or3H!Md6WI3YH3i<_65vw|l~JUMSH@u9He$7Q=7$ zDfO+*?(ch9S{#nA7D;Rn6}^7rhU&vJ9}^%FBWj+@#pgJuQ0RhL6&SX=KnOvB6jAx_ zq@p_8pes&$n<}6!Kb7SR&!JI1?AKB~a8UY5Ot3UY@S>4Hbhm`tDI4c>P~K$R=-GXX z;RcT{PdJtksuqZ6Sbv9?-Ec(n?;SgUyTeO5;=I$^Bx15OTO?1GahMB z;T%LG?3e}frnU9YU405!j%_$b)Xh!9(rE;szGmXxhrd1vKN)Qs+?#b3VWRlBUMW%j zsMP6(qdjHErFD+wsWz7zjaBE#x?d@b&k)sdQISp=N=mpp6&BPK*b7zLZ$&g&z!fSgiR^{vouw4CwYPnNUcC+V3L$}|;3LNaZ&6#_~0394XK9G0b7*hUksy*h@@E$Z4S zb4&(O1jCD>9e*Z- zhWaIXsAZurmio>c=~rLvZHm4*(DRpP1gk1OPe#QpVat1>TuT3eWU^GlYOO4kIK)>2 z(*3R8@s%x`Mql`xJkrs*LhHC($NRe;LXnWF5NSz<E-!^Za24~597@aekLVh z-{YQC} z&}}RAjpD_4(fFD=SR(ZIsL{h882-`0zqlVL=x8&9wOOa7Va`(G#ZCa##vebq3)@_d z2{wzpnRlydL(OB7)1Ri%$o^tlFC_7q&sEX75LtAY_7C*4d11DF#577)ULP==e(&wY z>({zuD^Qo#wX^m$o+31h^x9SK+pvGl;A>`TrAkIHDZK>qi@7u;1AR4yFk;t~{74b^ z4Q17D#U3Oby|CgMFtoqo0a=&T;E*$dfpQZOZDO@Aua#TB*IP zk2RaS8}T&e8gR0m9A7WLd8yc_ODni-oMbk3>Ns7b+UuZp{K_@-Y8c+sA?48cr|}Q$ zabbs_ik?vI0Oum)%W4;fkF&AGr5S&*^(*%JmnH)dQiFck7z|Jb>15wzfpIhT^OVpA z;|OhhY^Bb%mC5v0JT)B93ZH=2a#^7)!pgJ&x3I0blRSdU*4UzLu}5~$8asV>@Hf{Q zn#-Cyc*Qg63LgA%PKHK-ADI&7__u1qWtI6AR(SyY8XD}m09k{BA-^>60Q9-&@FI#c z8?fEOE!RzF3IJ5aKM@G7*=hzagq&QS8$bju<}M2_DRW;J(?l*vIM@P&EZK8t0HVyK#ro<~R zW-^ysCYlXZ8JvNZu%e(*(+EGm;D|=NaB}i@uDcz$lI6#x#yMFQ7x49rEW#}s%_h)B ze2EF<0Gll#f!xg-jx!Lsm7CcRgF%9q)W;l%Q##J#&~Zx_v(br22@2h$kg+&;+>*d- zcm!#|!2<;XUhux$*E~Px1-sP9Ef)y9*`p5#k^T0nL7K0)T> nodePlugins() { + return Collections.singleton(MapperSizePlugin.class); + } + + public void testUpgradeOldMapping() throws IOException { + final String indexName = "index-mapper-size-2.0.0"; + Path unzipDir = createTempDir(); + Path unzipDataDir = unzipDir.resolve("data"); + Path backwardsIndex = getBwcIndicesPath().resolve(indexName + ".zip"); + try (InputStream stream = Files.newInputStream(backwardsIndex)) { + TestUtil.unzip(stream, unzipDir); + } + assertTrue(Files.exists(unzipDataDir)); + + final String node = internalCluster().startNode(); + Path[] nodePaths = internalCluster().getInstance(NodeEnvironment.class, node).nodeDataPaths(); + assertEquals(1, nodePaths.length); + Path dataPath = nodePaths[0].resolve(NodeEnvironment.INDICES_FOLDER); + assertFalse(Files.exists(dataPath)); + Path src = unzipDataDir.resolve(indexName + "/nodes/0/indices"); + Files.move(src, dataPath); + + ensureYellow(); + final SearchResponse countResponse = client().prepareSearch(indexName).setSize(0).get(); + ElasticsearchAssertions.assertHitCount(countResponse, 3L); + + final SearchResponse sizeResponse = client().prepareSearch(indexName) + .addField("_source") + .addField("_size") + .get(); + ElasticsearchAssertions.assertHitCount(sizeResponse, 3L); + for (SearchHit hit : sizeResponse.getHits().getHits()) { + String source = hit.getSourceAsString(); + assertNotNull(source); + Map fields = hit.getFields(); + assertTrue(fields.containsKey("_size")); + Number size = fields.get("_size").getValue(); + assertNotNull(size); + assertEquals(source.length(), size.longValue()); + } + } + +} diff --git a/plugins/mapper-size/src/test/resources/indices/bwc/index-mapper-size-2.0.0.zip b/plugins/mapper-size/src/test/resources/indices/bwc/index-mapper-size-2.0.0.zip new file mode 100644 index 0000000000000000000000000000000000000000..0a74f835c3eb43ff8a9f65f724dcd917b908a853 GIT binary patch literal 7973 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 U{9t1M07>xu9hiC#z?}i$UwIFvIsgCw literal 0 HcmV?d00001 From c512cc5248d488a886d03ab52cf4a31cf11d2126 Mon Sep 17 00:00:00 2001 From: Clinton Gormley Date: Tue, 24 Nov 2015 19:20:52 +0100 Subject: [PATCH 12/22] Added bwc indices for 2.0.1 and 2.1.0 and versions 2.0.2-SNAPSHOT and 2.1.1-SNAPSHOT --- .../main/java/org/elasticsearch/Version.java | 12 ++++++++++-- .../test/resources/indices/bwc/index-2.0.1.zip | Bin 0 -> 83074 bytes .../test/resources/indices/bwc/index-2.1.0.zip | Bin 0 -> 83669 bytes .../test/resources/indices/bwc/repo-2.0.1.zip | Bin 0 -> 81144 bytes .../test/resources/indices/bwc/repo-2.1.0.zip | Bin 0 -> 81795 bytes 5 files changed, 10 insertions(+), 2 deletions(-) create mode 100644 core/src/test/resources/indices/bwc/index-2.0.1.zip create mode 100644 core/src/test/resources/indices/bwc/index-2.1.0.zip create mode 100644 core/src/test/resources/indices/bwc/repo-2.0.1.zip create mode 100644 core/src/test/resources/indices/bwc/repo-2.1.0.zip diff --git a/core/src/main/java/org/elasticsearch/Version.java b/core/src/main/java/org/elasticsearch/Version.java index 1b4bd35faa3..ca235d53fba 100644 --- a/core/src/main/java/org/elasticsearch/Version.java +++ b/core/src/main/java/org/elasticsearch/Version.java @@ -266,9 +266,13 @@ public class Version { public static final int V_2_0_0_ID = 2000099; public static final Version V_2_0_0 = new Version(V_2_0_0_ID, false, org.apache.lucene.util.Version.LUCENE_5_2_1); public static final int V_2_0_1_ID = 2000199; - public static final Version V_2_0_1 = new Version(V_2_0_1_ID, true, org.apache.lucene.util.Version.LUCENE_5_2_1); + public static final Version V_2_0_1 = new Version(V_2_0_1_ID, false, org.apache.lucene.util.Version.LUCENE_5_2_1); + public static final int V_2_0_2_ID = 2000299; + public static final Version V_2_0_2 = new Version(V_2_0_2_ID, true, org.apache.lucene.util.Version.LUCENE_5_2_1); public static final int V_2_1_0_ID = 2010099; - public static final Version V_2_1_0 = new Version(V_2_1_0_ID, true, org.apache.lucene.util.Version.LUCENE_5_3_0); + public static final Version V_2_1_0 = new Version(V_2_1_0_ID, false, org.apache.lucene.util.Version.LUCENE_5_3_0); + public static final int V_2_1_1_ID = 2010199; + public static final Version V_2_1_1 = new Version(V_2_1_1_ID, true, org.apache.lucene.util.Version.LUCENE_5_3_0); public static final int V_2_2_0_ID = 2020099; public static final Version V_2_2_0 = new Version(V_2_2_0_ID, true, org.apache.lucene.util.Version.LUCENE_5_3_0); public static final int V_3_0_0_ID = 3000099; @@ -289,8 +293,12 @@ public class Version { return V_3_0_0; case V_2_2_0_ID: return V_2_2_0; + case V_2_1_1_ID: + return V_2_1_1; case V_2_1_0_ID: return V_2_1_0; + case V_2_0_2_ID: + return V_2_0_2; case V_2_0_1_ID: return V_2_0_1; case V_2_0_0_ID: diff --git a/core/src/test/resources/indices/bwc/index-2.0.1.zip b/core/src/test/resources/indices/bwc/index-2.0.1.zip new file mode 100644 index 0000000000000000000000000000000000000000..dccb7774fa63c9ff4620e305848b17ed6b72a138 GIT binary patch literal 83074 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%0Ai)=8cQCH6#LT z%AI_5ut|1WZf7L4?vHCLSSf-fSyp^7HMo1eWpR6cR6FiW20d8`NYT7=1IvU@ImRJ+ z_th-JNuzS-3&$v_goTXSq*JfyopY(lSM5cu0OtBh@Su6?;KmA%UMT5 zY0Xj8n8H76JKr#O@E*qZOTWNNCuq5c_$V$x_w4T|H(}(oRVyHoB9AqpH~VN?Q|<)9 zZSf`MyNv-RSq#0?vcSnLtRF(dY^F>to)WHVE~$470*cokHTvAgti8yMwCuI_$*_v_ z1G8T}UBnMk-r5S>m(%D_KDk2{Zmb*{o)vk8N(D*|og4(X7>%2EnNl6qs(j)ns?Avg zHr9Ba9TAN7W&oiub|>UDH5L(DIFoZuH9khprP0WjMI{?zJrcftv%JK-J)}oVT1UZ)9-f^Cu4KallR%>abJe!8IN0L z@A!Aklau%31k^kp$sC6bG{P5pXZCtCagHsAUVjCZ%}N+MbY{!05Pl+1Yt5^WYRCC= zajeDF%tMpnVPSY~L8<=r9_wyR<@+OkIqnL~O6sbLz<%EU}@e(m)=aeKyZBY78mL z&At%8#Yqjh6Mp7sO~uGPKW?9Ud|w zHBi2~ZE1?!t>9zLT9LMWJ4d!+;3l|(s3IL$H^S0Zk2x2?nk;)>*G1aXidS&?4^{vp z-ha+2WbuyU^O-l=)Y5VhI*)m{_j;fBJNt8P*~s}>$^NpM(Q}p^Q37ehXna@gYb~^? z>Rz$@mlC!=G-XfJS^=BkqHek9`7{Ohb&*BZgpG6c>nUGj42orzl*+T}#9_v5zjm`O z^=fIsw`U{eb0*5+yj{xhqC%M-iIkM9H0@WlVbs;Az<4UkG+O-9g9SPkp|+v>-*T#a z0du71PYk0ld?beuMk6cOO7hvK<0^9G8_Y0I-aZ}Xd?MYFlW*@!7!z%=Ki$a$Lif_TIh!<;>p zeMe@|S!3lRdkY3Pqc_?2;AhK!*h^JXy0>yyVOQtdb>Z4yAE{^;1VxL-R&x#2SGl?Q zbXT$@$R`7QndJ7L7O->GrerTdHhLnGmkgleEynaPM6`pF)hz$i3z#Bv8QSz1-YMhq zw{!idx5FJ@VP@K0`IE-!S4x6%7^_)uTQqj64F@K}4W8ah_HoZ?q6Z|&(QTV^Dz?i6 zOp%f`^P*gHPY9$A0DDQT}=P zoPNU2rmgVxx2!LgEUFDeL&Dw7Ab~uY&xT4|-#E1rehK_Wf9Buk`fVJAfj&GqVce%Y zscGt562-PE7e)ZZ>WIK#Oc5w?SzaB0NP|bW%|e=H=$I+QXkfT(Fc!H)siFKMwh2O0 zJlJdt=0=q{?=&beup8_zwTL0Usmm1nPUQjS{8U!!NZoJFR_Bd}Wr(3V?dA1Y+4W0f z2f0f{S@4?4!1t`L|HQ%PB0gN){p@|Zxv{U=-!L{A7;X3B5^xo1@b6nuV}o0BGXlI2 zbI0Q>aTmh|uJ^{t#go6S&AaJUJ#pWyflmSCQKRelz3t*wN9^CV)(TY~*UM0Nm&(iA zO4r>@*RX$(&tiZ-$Mw^N{|@*f&Tkh8xbVHPY3O$M`~Ft4qaE)7X^l~ zu@`nWaWwqS$S|;zjiZ%~f$Gb)8Aqtlc`T*jq(Z;pPbVW5U~l(mU6DfH7Y_`b0X5UF z_wy>vm-TdH-u!&)!2&_oK5Io9nd-CN2IHymZb{qPaV|@X9ht0@j;$r)n5u< z`P&&E`SxM7)pdhaXHN-@A6w45q7Qd_lbKs>l`$G|-SGbe>avI`E`m3E*5np zePQ!<5-ICuy&q;ii2%>gN~@p8UX4jHY8i|^q;Nr#`U~)ZtSgeK#+2aK2A7x|w?1Qu|7N-(rkuh>4W1vnAmE+%<$DeKhfvD?> zoEsD{z*|cfq-g1ZF{+=g!aq#tlk0;{#_en37kDC7>HQ$4MjcLY+`#6jRJAQ`?(&%C zw~WeZjdKwcV5e_kKTnH?+!D?x+Y^aB3KrXxKn4UXA1z8&vlZ4BVfMhaAz&cFJ0 z36_X~It_c`kZu|h{f>z&tKzd=`E%gOkQt2T5`PB<80jgtDqV@JeIIBrH$G7fYWvF) zg9ujj-6F}C465UTdnG&jeKD_Jt`NC$Keyw&jpk=@abVAk9P}`Bm7BB!wSJ;%?H+L6 z-{R{csXK!M&QlhXLutyYosW5xfQ2^H>XIV&``H6yaeEusr|P8oErg<>6CmJL^4e=^ zN$xQ$@PoNKwJqaTpW1gK8NeJ6Ri38nIA}q*G?-b$`}=EVrTo*mWU-~y)8HcZSRu#S zx+>fRNJ`X$e|88Q#GpJmx%3SKTTjV`+ie2lXNs5?JrjKaU?$?HT>K72i&dhp^Fge5 zZo}$^7jg|I>!%>dUJo*ORr5K}-~fq#El+ z_h~Wt6Cpes>bxm~qOeAbCS8NX(j)J0?OkS=Id9&YT#ldLz8Onqq~l?g;2RdAa0K|Q zsD)C+wQ%<7S7rf!2h@((uRfs2RJmfXA#|W?v5`WyqQnz5piFb2Gnm8qj%oO8i=@9&4ed4^vye|SpHksSh$ie1mHA>^7 zjxcGW-oPeu(D>}46xD7JbE50I%X_&aWwA;d8UIVdt#fMy?Z!uR=dK?MKe&JB4>08d zP*qnq-?*Tox+D%!x**(iyNao{^RWrIRNNQX$l%f94*vT{kT<%SnVEvP5YEprF(a`P zGUKQQG(=V}yK0;2uDXjV&Qz;185GO-X}NKAjAh4!gj&iIZ?&vte{{T6#51yzsMp`l z8#n!Zaz(Qg>a%CDw_VjLt~Sq5%{U!i)G!&SmP1N#37TxbYIbwU%_s2f&kT*=xMmJ@ z-r;)Ru&1@25*L_L#`PG?cvGvxV#Nr!O^&Jno)_OJ%cV~|*?u|3gQhlxuC2@#jx&Ux6Mya& zjS;&WA>M}=P7~U3p81~ycEnzP=GrjpfHZsjW$`&O@tdQZzLsvOxcy6_-l^qcj|&fm zN;+F|!l)^HI4DX30_dzNwC0hXoC=N_=EA#el_LlHaRBaeu0EoqrVm6K8BC<3w6wB$ zGB<#P>lw9uLX{uw1ds-TD#?O>DU^7U2WS)Noh_=OC{iAURm}ZXBc`3^TQ{iZsx0Vb zD>3z7;))=%$Ie#GgdPl?qXj2|Zi#GMlFaxh9^<+o0_&J)@hpnn#o&rd=3is3Oi}|y zM0#Gc55Me45V9p&sF#w5%als-Iva-tnh>FywIcdftKfJ%NjQ_V-9!!o)ey>u?mUC* z7VDIp($25WseCd(uRoMlnD2h^ls1hwYLR&Ru~bY_7(6px2HYHVjRc$pK>g3%B>ASY zNRtmzfAkLli~rl*r2kc?z%995y3Y{jC%T-D4oVS*Dh5WPvRI*h`GU^u^XngWE2>Bi zd2zUvwUGhg!i&vqvX%x#-_Y|m?x!#M!{72Zn=>=teO~}?!=(aj8i!3|-`Ox^b(`1= z);MaS%!jzyc*8C^nvrK5|9QH+qup<0bqR6^+}}$%>Lv){^!<2B%x*aFb7ye0@Lv zhK{u=P(sf8&e-N76uo+g+d@7~5%a2liy)ytyB^b_li~yj7@nPiv)KBq8w7TQeKPt~ z-OJH}6zm9X-^V@(PEjZ^x5BVe=b*B-Is0 zcJHhw-sC1Of3(FFL3ZDbClS*oY)1t46`Fo8*b}#A6BBp&z%N?OJ5|3(pL;|!0PY(0d2@cJe6z%iIZvwQq-;J|(M^0V(a3O5H>uZ3c#k*s*`AV_9B|?(cgsTOlNry)n4P z6i3RotZ;6S-zk@=JJCpY_Vl)9@89t3@-72bbqQd}_Zxf7g0lwQzS*a8u2%gOoa3nH zAa_NCZzE@Fu`_VgjAE#hrmMwpSdCQG<(Z?U%~QH3w8W=yQ2$CN)p^-C`otx?i1#hL z*C;HonvQ)+lVCy9(!Gj)pS5ts@J4-Z6DTtWlbsdtQ_74B^qpXz79NjLJj<&|`S0#vpU}&1SM(uPw+!R+IBz`( z53-W!MmAYfjA8qP7?ZaY(RuT2ut>r@hE?*L-mhX6o;cfCJ8@j>w6Xmw9w1!i48FYL z58bRxcJU~IpQ*RDRtRD?&Vgvo(X zj#Uj;c45tHkfmzIpMjbcMo>(7H9IK z$;}!Epu+?L3+dSiAzw#53;nro0%>T+%*DfeKsPX9?)Fn4F(fKuc$~gc$&DDEO<>tZ zX2|b1$}{v&2*DoG?z(1hGdTAk=NctP=}PgQ>LxQ;*VXFa#a>tbI!4x_uaD?dY3+l7 zl^hCdt_#HmJ`APfsMmOBeB;#3Nt6^N&Zj#A_TG_PG5Wb^rF&^oGUhNK zk%*ZVg=)tLNA1e?H*#4S*Hu=tzXD&}guY0vZI$Q&=8kshaF^(4wQ%IRTJT?o+33Ww zm|ef*6&^w5s5cs^>lOg|(I;l0qra~jY4X_Zvp_Pf{}5{KPo4S(W~78QwzQ5*hOrv6 z6r%m&Qhv7s#Q*y-F7DG?b(bkQ#n(~MzuU8=g%D~KT`IZPak=%=a9vsju|xyIM96p< zBn2P%MP_iIjwgG4X16Z^wh(2x`HhJp9yzH9X}QQB^VD)B<3}n{l>}rBX=ByfYIXzD z(piS1ctT2JG*4;A{#Z~aLrHqS2~wG8zZ407gs*BfB&YIRQe}uE8Uj~)`j6Xm?ol*G ztNN7S&)kXuEae=PW@CRu$V43!jU*rZa#cMNCQjMiamwMxCFPV9WBSAvlq*;?sR$q~ zGxdNLR~_NX|M$G_{PTJT8*~Kxd;QlV^glb(4p}sK{Y0HL6ggi()qLUwQmuJ*P+)iqeVrBZoqu^4cQG?a^CQ0~zv@DI ze_6Q*`1kbC_58;4_xUM&e?tJ7#NmLrwKFtnEuY#539%6O;)EQCc`-r`#JvO|*kWEJ5NvTT7D&37SDBR7y0#QqP|L$d+|B~2%_vzn29kcFj0 z%c5~4V*$vmDalwTg(jo^bJ72EnOLRfWQ9$WN&)%9#Ak)0Oiy{Pu53` zLTWY3Zkf4~@|23@n;i*jL}zKlb!Ae#ig_R#_zgB*e* zixr904-&UV$zSGWqv&z=~jf-tp zrjY{}&>>V~y z`BPF5sqPHR5OZ3+3`!npGaZ~P`rUOFJ9IwT7lhSteJo+-nFPIGixiw2D||Ej+n0wR zA1ohAm3K1=((`?%I*kT2oYj~C+P11>&+1tkg5z@mXFIl?$2r*e^DjSM%~KynkN-Xu z9Oz{(CKX*4sGGRZ8#rSIPqO)A%CMxs~TZjvylI5WP2kP(UY-phTXDR&`rbtvE zXS5uFhybX`mA>!gCx|f=ijzcY4@ZcgH6~z&l3SBd!As4F=wl?6h6YjdcXd(!=SpFq zMY6i45iQr_)oww{%rJoeNRmbg-% zlTtc#*9{)LxHPuXtMDJn?jl1vtk&Ap@D?idC{|juQ_3E^UzFP9Q$4`z2zE^S)$B6908-IS!#q6TUTB^g{L>HIWMeu@~wo)}G}_Gq*+TB9n;e{HCx zrRJ2SQqUqd645%z%oqX~7wJ-@zTwMAZKONz?X@z^(JCt|WCzH>>x#SEk=Im^?8TX- zcadE9L{cixJftpWd-#gt7X0qGPd{6~nE%)5fw%awnYFls3_j6#R?3^8BTnypw9a!n zqc!L-5O^Xt=vvNsmCB;M=+v8kZmFEMap=;o7##xOO=E|KaY!TD4CL(LbzM1mRiz7B zYnO~F2wL7QmmEFKgAg}7DK<8X?xX%)Yi#%?KV3gNykD+qjNdT@{Cn=QWBmKlx7fwf z_0qn-;rD*m+=boscE93~x#9a9ZV)i5tAD?Syuh{b_U19UfxGd3nU!gI_4j?pU=1jA zR#>U=b|qKe@Xt6c^z^Q7)C~<|VN1rgauk@Ry6~Ta zuACEtxJH1VbItKN&3ibuAcgy^)YRmhL z*3@nHC_b9=Voe87k11fpIT@3ZPVNm3ld?iq9azbtWdoWhOqQ}pW~9`U)24Q1JF=hY zD=d*>N?xb*lYRPg%XZ}OmS4m!WtA|4U&J6SnPN`ur>LFlDrDt5bCVL(z-IWGH@(ZGD9FRe7g)RR6Yvr2J<<~-6YrlZX8TU|QIB(k#|1 z+(&taS)HNF(Mk!$%wy)fyc;v3H4-<%P_Nv535+uD!>|WtaJ!C@39E!d9__ZhqluL`4!?^C*u7^ zg(4o&L|7hj=YUl%FT?Ap-NX@-WU3^L&=ShYLR?LRdK~-d$^5Q?Ptm`zf_G(%Lc|rK z^|3k`o-}V8HSOzqjf=!X=afGf-L0cJux9Ctb;fEltXROtO#=iK*PDu|B=9Z_`&y?B znl^P4#+?ISqGPdu^qk-{#UtWpQA&uqUo`8=<77C>&A>zda0wQu}tU(wPWgW z99Vjc^9RVIN7ReDg^_xu;Z^91wNGo8%mWsq2ms%=1yzdVFPl}I#|sNMB4lyPur{A(1N_8!Yz+e(2`xVn7EX>L1Xz$uz92`}0Q>w$qtQ@8ftpJ=RfdPW`Hx)xfW4fBX`MW7L9 zpWRy&DkquUK4h#}%aEj z)joy+IO}bfmmBJ>9A#<_CNtnAG>?VX)}+Z%hZ0txDl{xFJfE? zXu>%}!O2NwClASN;<2fp@<%24hfELBvaRnoFB@kC?s3xDsxPZ9Re~Pl<~eO_7nUpQ zwH)eu%nQaTf#aMywtp=u#yNp!oCmfOE4sCIbohK>bS`lp3)Y% zG|1Rwo;FJAGYzLfQXwqnk@d*fVxHaVVg(xk`ryM)khlo!c{4p)HXWz8l2R15vitnP zb~)p=F9E1fmZY6p#~Ff@#^`nyTMBm_PlI@w@IqD}tit1*pfY08E+w zb{zx$nJ&y2tQXc2qlR9+ODi8slQXj*}D~;spO)537~lU27XO zX9fT}r(-hG>Cx))4paOETc>j{+UO0o%Q^xMSx3x3V2t!Qcon_kR#^|g)^+z*ULToN zCXxa{wsgI!=l)c0QIQN?`U0b!?s8j$ixtyOdn#Nwo~!!d;mk-;y$p7GHRGCYTl=l! z(b0@dw(8;8%urE{j8J+NBeou6D}f8oxwFVR>EZ(8if&W;sUzeF1U7316Qy@DKGPy1 ztzq1^XL_`5IuGoDz)WFIoNSY}PqhP*=|M56p*-Uv51=PbP@ zg+tWwAJrrsqrrVPwu(3>Eb_%?EIlUqL*(%zM4bXpp0{^PrBjmyT|=MZe-j1sfAJZ+ z;@)-Y-pL)pdz?FCnKb!3^f^A1D4HM3$M$N8cHo-!JCY4%lMnrs=5gJaN$U`Nd@7L- z|GoF=jV6^>;=s+)kNW$i-8x7?uSx2VHK5qHrdC~lzpl@uWQZ|-ji}03`Wl77e&majSmRqHz*0r%~|4ci}nnj_06W#yz&zK1V>%$M62}^nqv7W$GY-{aX$h zsD#`}aL9M!IrE-p$7S^(WD+(fS}>g!70H2FbPF_znNuOS=v)1~df9s90zPP(B$SHk z)ywe_d@!qkk^P#1!%So7+?^6w233y{28)1uP$O2^oJqYXi^&`Xedm!dq zm7fQJj8J;eZLqG$hp1C*xfPSj+;365X-@?e5b+9w-;+eOP)G&&`{ugTzUb z94bKtzwF0`ua>w|w4SI=nv9DgPb6$giz+R(8( zAutaL`!nO0%5R$ZwaS7taFxhQD77qxD&6~m3{X1IO|Z74=~qq6TJ5Iay%T|YQ0>t7FsF!1*tJ5N zKf8MZca#M~(V?iI_<$7_1Wgr(Hxo!mL`4TfR*^k_(3M;=Zz^@~1X4jMKxe}?e6_-zp*7X~N4j0B zY2-N^k&sAICAu8afM|t1BUmWL-ZN0 zLW5uL2~Z^XqWfWE-vPv+AG=|`+Q?e?AjU#cQ?=pa1P&6gNLqO1*N@No!coP@Y&b08 zjwD(H3;ZIQ78Zkui_I#yo7NkW5J{3OLK!am4S>hWVCp>_lK>z=#xM^ZLjs^XbM0o^ z5_z%i8VwgD45fYv4~JI}$qwUB9*8?cnP$mX5sQvUL#-lhk|~I>M4#r&*Ar`wI7h`6 zWen9tYDEKyZdng=K%hW_BwR(@B+a7d!|suXXdnOaX^PEOgd7P_v?;_E5rPHM+s6a3 znWp=WG%5~fCv=iLi`<73eC5G$rrvcNPE1&HX25W!-}M}hOh_gv5s?qi{KkXtEWb{d zBPhc7D}vNpLN-1FkA=Zlq`yBxO6eoT-+VB=#c$&d(Wklc4aD9fpirU7zKA2lEm5Vf zqKcA*iN{3Z;Il9q`}Xff(4exB-pd3;;-Ipy8msmnM)aXdlEz68L~|3VVG$q=(_lGK zY+Ls?Mx3B>k)BJ8#bjWz@NMVzW=6E4-jMD~(no0G)KMEd^(RFXp@w6miPOhxqSmqI zlNzh_A4epkmXOMKC2$j{bE7+PZtM2{iD*PUAzhHPjaZ^)NlaB;BB-MvxSk!kQH*mXw{$&}Zp1dFszpJj9=6Dh?RyjCe*xCMA;KkMbnA z65|Z+osF=VF*ng3M2N-3V&gX#ldZ^Da5C%JN)Z8OG_jl+FAup!9O2B;6uZc#XC$(e zU`h9oksAG@sXL!j4fnjv9uez57|aQaO!Ey6S1eBNX>sgCQ&DF+^GdNh#jVT9ZqW}ah>PFIIa~~7uSrhaAu^0d*8=txS z*lLCg{EhMc5PgIePCd1`(^yhQ(Z|#}Z75Si6ZJrn=Flv@;&@MkRKRa;nr+23k)z(s zylHi;c-(eyY_u;EFb;$S0T}*3l7<1TtZW+g`!nW@Ci@_B`Roy3YY>3$Ppk6$yNtF_ zx#c~knXY0>siPEQ0A}?tpvqBhtErc;bzP16AiLL(=R|F}v_Z|PWJbRzSXwf5Xf%3X zdxQz0(2JBs#j|)yq^L-mE>)N|SS_s7Re5Aet0-DpBh{XEO--UAMhUlKMzp9zI!&Lp zQ|+nrRt>kDRo1L!^lNG&ZGo!ut;$gi>rb=XQQ1^2+IqG9(lIqai8|WQQ+YnbVVKRp z?DwchsyJ=5T3V^C5~Lg?XI3Qr8$MNywnD9`;#3h*1`;+a7^O@drxhP8i_rk&vMQM+ zjhd#?(5k2vm&t0-h3dV2yeb}$2U0Zyj5?=c(%Psllvk=~)i{gpeYY=PRc@_v7T+r$ z9vX>*RQ{yq!NRnKm$K9Q+h3 zWRg4hBen-mls(KEVHT&FMZ~0VkUI8H%mPjUi@HhXpl9qiJai69E7^sNd^N1E)^(~T zfI;WjP`qe%EF1c1%_60|I*}bYb!*xAjA9l&ldwVA*pDSV$G+v*eCarU>?7WH_9iRa z#ihJD6_fNq`&hQ+=&!I}w9Kv7LC&?DsYVQ>9?9SQk7S_66(8S?jk2`liXY)QJ7#DLKs5WESM}Fs+NQlz8q@*aNgmg)-B7%Y--7PI3|DvDgfZzGf@z=9l^RgFvG57u6&oeX6 zJTp6QBuONGByl8RB&iaf648-xENU#8CaNad0O|l5FDfru1!@J_NgBQggS*^f|( zUTv!sxEqXIgxB42v3DprNB0tj=|`)la530{2$mbk62}|;;tCn7LO2f$SMOL##k-#=Vbp*$}gwYV}goKvA|l>xs6y8zP`dF(!keZtI#Y@2Vv_H|$8b4f~QC2$pcgwl zgmjw}KS;Hvz*Rw`7_q573(f%R5K(nYUlJQQz~{s^pm@f!;OMM9p8|J>QHlt1962!vt-DY3z1w%ol1Vt93Jjh5BT z7|>{-9rh4KF|VFeX|r)oGYHyfT-AIDS`SRc7NE2Tzqc(NH4biuKr=K=O1q7pH*-LT zfv(td6urDjPNhu+9C$}T!N3S?5=suRo^5HbacZ*%lo}{{(XWdY+7C3ten}C@OXkGg zY@FT92<-x%gs=fMFXoXe2_~6v4@?v`^FmXBRgt9l$kh%TofBovgwSIkIyMdk6_1d; zbKBL)f@UyuI>rwg3(Ut>p-ck{**U|n&XzY5hlMtKL$QFQ7eVAVc&iV--G)-hl<`cm*-4y!ywY_P*$PbcYvW>#OumN)yVzZsX*Vud>EhJ~lUJyRecn0Yg zkxeD4*VtC+7m%$bTGe!uH+cEypp zH@y}PV-Qe5*&E%1-L{&q|1i9| z<`Ew6m_fu^dX??^i)X>Dz^x)&bOvI5C1*kM(s4_Dq5dpNB@}_tSGbR8AWHfq$ zei;RBunbfdwedDQ4U+vK1kb;^V%!XV4BvyT`#z|+?N23l$!Z2uF5P_QU8LBn&ij$0 zZJkwQ{at;LzNyjI$qsNBs(4%|8LD_)&>6-pW-t!@If9sGSQ$KdK8ee%na()Mt(nXm zMvnG$-ibU4h?aD@!hp;D37g>+&nHE>OXf47kw^EUL&*-n4AL_uO2JgZX$(f4(N*LJ zq6{76-l5U{+@C-Utuq;sbse3DN!NrwAv19CxI{)Ll6fab>*{R{BbmKo@npFf$YLK@ zyY6?1QE+oeJ0|()IG?HFXciii?BmyHo|iGqkeqzYL*BBzek*2i%q7rV$FQ*`jVCs= z1MQ~Yb;Z|(sgHwH#_=#jw%kDr;mhGcyA48&3*B}VD1Z?&tis zf~$DP-!`Nq`vlI(pRgpVM^bcis`oxLl_QGPRgwhDw#N~fvE~(%X@V0>_c1LiU%j_& z(_x6Bxb^nlW4RmrQ-%1d_xEkv)*lF|&~=g?zkZhU+Ry;I)z|c5Vqc6!>YCGDh==_q z<7SHwKi`41={w|BcQ3NNsDT@qZfKC(1#(jS1clM88ogoHYCkKvb_gnALg0Vie+(w7az8zg~I^V#u|5av+w^xTb5KYTi;>qwugNOFOJHAJHki;ntHr z-RMV)nbZIJv5ezu=T+K*7g5WhPp9vy)Ez&yf11bfHZC}&Tut+F0ekX`n8MSG4QsNT zAsABKuN|2(n55YowupYHq`7EwSzI|czi^u`K0WWvfR;}RL{)LohE1F^H$Qj#SzLO; zn*j|U1BmMNMH_Z;hur)p+t1?DE8h(0_>4eQuPrXJic{z2=WM%u_Ib(Od~tw-NSPg; ziX&(*`fM!7gk+UR5UWyng?Q9djYqt8g?xI?zlZ|$>AGvjUP>Nmup|+aN$<^ZoVuoY z;zp_uU{xx?3u)GU^99Vs*4Y`>*~!+~f!3xrDb`pitiH-|PndOz!tM^rWb#i&F_S!1 z#vCQ|if?Mcb*OJjMg7Q8`u>tbMAH^B7Y2ui;s=Hei9lQo4gu9#jR|RFqxh)>twVy7 zNk!-IdOdgazV0!25F^SRdXkLXPn7ZF=F5GS^a`J$ro;L*sroev`ir-9Uc|*Smk-x5 zYA}9?mw{N$GcKy)fvl3#I%dR}=fT1cy1bR(W-gZqw}N8b)K&;4VY*x+vNu-<=Y5%4 zXNOy6$y;Z^EwgM*7Fe_8L*7r>6;xyN6$BJ`Si0&MYZ-@Gx+E23uGWB77vH4+Lok1<$7-SSa5{L&OkkT6;3`F2n(%*;-0Ox$b14+J*3g8Sh3@=47 zVL=AQ8iqIvw>YBO6T)x@X~ye_C1m_>98Uzu2a1Jh@TF$g5UoP+=QJc%NxeIBSu^O< zv$e=5*p~7N60_Yv#j5>zL=GzIMHea`Sxd-bu|fD-(}`9U`vZwErFHWb)WS>GZBRT1 zG>N>n-#IlYu={?xa5T=1?#&$lMaOSb3#Q=9M587P1t~Q#a)h!ag^=qZiR)qJ4@Zo+ z`TM-ep40IMN&p{EOgoDdhv@5}*qKllhhE$lTq7^Vgx{^0uz!y|-&Es#skiyS8R-Vb z^$Gg-7f4&h?6HES$7aoVVT-%vI`yKwV~dQUq`OYAai9Lmdb!yJl!rciFMKWaor(no zz#o(Ko@a}G{P?`o-|*i1JxP|BdhugPznv_JD^$%Zs=Wo2T_x(C!-GNnwPWwl4~p$E zDxmL-0XxH4`PP0o?4$ z#$vK2;c6|bTu@9BXHjPu{hSS^>kwBwmd!)fwc@)r66vDX85?xo$LmlXRaa$nr~&Fj{utDw>(t z3yi)m-t4^hB;;n*vBseNexN#=E@W5!o_Deym}Zuf<<9UYe51UyCC--yQ4)_D$QQiP z#HXh$6*3UZn>^%FaAxpli>YdsN7(k=BvH<{#2upTy*@qI7+U1Nl$g4pYhB&0!c?|g zH|u^>i8yY!JHA}_?e61UuN$tfT}x(bDqUU7*jFom5>)j^L{=e=AKRJa<)c-##aw>VRN)<8fn?m0(+fI02brU> z@3yB_G^R6vR^nna(x^4!QYc~!;;yeGC&m~wH#IfAuaBJVj2?6#q|qp7Ij($31?pY#5U-4ieQR52(5D9=eo@EIX>8 zC>Vm!k{J9r=6OPdgBHKoff$msl{((JlD7yiOSqCZ6`ShsQO!8BT8&sdY^9@`^EVEa z7Jj7zrNWs_OO0|C+N!j?+nPMzfG(1@m_^RuI&S8{p#4%u8fZ~zUg=v&B(SX}<{C+U zd%qmyWM=6+J!5jq%6Y=l+|2vrUb13}1rs_$&)&%ja7n55KAC>4UCExHwWI- z*Zb0IFeTdki~BABOpFf1M*)(+>uot$W|Q>bD)Sn6R|Wk=xxd6!SChq)lU0+ye@OSb zvhiat`+c$!2v5aRk-o>YAw`L)$Hl^1x`fO_u)UhhD8UDu%T{&WN9hM*ih}HVk%2aS zNcX$A$TBCkA@0mS_?HbJZn_!(0N5dX>?(i?U~b}O!e#1dW@O`NZsBFb1L6jOxg4F$ zEnK;{xe$M|F+;rj`Wff9&%XZE!i&qu%nf8_Y4MLvwe}xhnMljH{?I5TaVkYuBQDvX z7l1m}qZdV`KPIploonDfGCih_J<8!@!^VV-mx-Q5mJx``PD{m%Uto^mFV;KZg;F0^ zextw_s5O8@bP&^vd`~C>sAUM1uZI(~Upe zSJDqGljcPC_9)CcDrDr96KcFFy6^>C))S=yW1`oG-rUWv)SS#|UMC$P7X_HSN=bPB zgJNGu7vxIN0RTtDF%$oSVt>0!yieEZ9%Tn{hG6Yy{}=IVD@z>X2U@TvhAUfRkdZ;# zn@gR$2i10?23AJ)`7}kbOt9NB66D8VkV6yaqbyVdB`I1k6I_@G(tsMX9npwtW}W3A z50S=DA8rN;4S5;fdwa zHHvvIL{@BY*ris9yMAABXXr_lpUW(-=+0LB2f+sE^tPd#?42%;9R0`eCqqkvLpN#$ z=jx3$OL`ImV;HjsK99QIGW)du`O02%KMmvc)w!jSnwdZu9w+8}f-WDk z)fsR0HI5W0nU{M|Sdw;GSIS#r zSID=-%Ds@EN~R}&9&S#>1dSz0n0jx_r^`6PpRJrCKlPF>se38HoH=K_*-^(Mx~)%^ z$6`i3;T31h2F@0DTl9+R@;im@Qk93$Rm*t+CCgrSf~u${y#{#=65Ao{BGhuebbn~% zuxA(cZ8M>Lo;HUShujANyFA!=*vB9?@)tPQB=VZ$lKr68p~f2lS@|W=g=u&0N6xR| z^?6dN#Yrl@c}d@o10|`GmSVHus8=!dP#Rn#py(M7DWQB3ojd8eB!t69RROyEzON2> z@|{Aj80yIK-8K0WVkyGzB<+BtWUXgcG%Q3L@`R$nZden?U5Q`hygs+X_mt*l%lr%t z^&TTuf)_0>uri@~hSSdb9L` zzt@z(YQf84fv7`axO1-ypO8T|O9zx{UKr#o1~2Q}B~=MHqn<7vI4+%@M^K*9n6*}jm2TA$0n zE9;v0$C*a$iFYo`IXd2)+!|$V>LmU6#^&HT^lhW|Vh=)vUfP7K?=VQ_Kink`% zOIA$lb4-uM9Vhs9F6OzsTl7z39jlNHzpq2tYP#&^`uwKdRLC$Sn6IC2Q(Gj(cb_)!(kv58u z+NayC2!qDy;$kq=8b4pDQz8!m5A*ZVtUuv?hdoyN*-DpvHB|3Nw92C(X9@{akF9zV zUSxB}K=;iHl>wmg2fm!gTQ zYOwo;jn&zepG4YPs5x3_v-iAK;~avQ6N{FWl`rs2d>FS zn>6h-ZYQs0ApxCFGV@2-k=`7v3GxN?69F;qVrI^>GNT7r=uOk%nG=0b55XVxN0ov@ zg8~N71YZnLvZKQ~=50R-+4h^HXwG|jdF`XADbD(gg$hQgRA_9)jf^*{X)3}7iyGa^ zhU}jR3~6~FVb;9EnKva^FjTKwn`OcyW^Fd4q?MwEB|Rl1h>;L3;fkXK@Kj)Tj0_UR{`?Gn``ZBcPQephsa; z0*1-arvrMM38*(%OZt(fUr<1<(zWbiO-mEdaN2J?VpL@o*k7Bym>x4CMz?jZjR|)6 zNI;Wk{`2vRrydG{ghqD>8z1h^3u8uN&=&<^N_t>rW0m(R$k)-&STW+*k4?44YP~-p z*_os&x9CfF9L`I@+?&Rk%d1;h#oZJ|3B)HY!cnV|3B4g-lUd8X-V%h>aYJajr5wv@ zGl2avV{`c!M}@vXPdQowwb?Lc0?d4vEdds`gQJvHe06WMdb~i7f%*MbOwd#OX!q2% zJw;!+Dg7`?f+|Kw#iPu&d8P*1&1nKI2qHSqi1unPVYxBKDfCf0qFOd2KouE%bSn%O zY;5xALOFPPL3+OrN{HX&AmhBv32jzN z&_E>c4MR&7B^HC&He$cc;qmRoe24(0`zyl8$w0ud?}qlh7n2VbQ2n#T%P0CvsV6QVUa5*Lld96nDW%ytrx%$*Wcu@KiO}1Sa&kg? z5uIXw>YFXHuGTI!;`LJjMs-h(Ds-$YEOrPM;9ZI|fm3TXPbau*yFJ4UZ(ebHQtu?1 zmF`4KjN5loHA`7_5f|;j>!%Wrc0;Krp~YSk*g{o|>(lmGzQJ4K@DLHY;S-F6H&<LDLB|!`9N1AW>5XO&;N&S5Q>n|nV=%VDsDu%^1GpxtIa<~Rx975 z@U)cl)D+#R(%wvAgEFbKz_nR{=~-FnbXE$Mj<&ZHOdXL*vckfG z%Yu`GYs$(3g?X?0x`Y|tVivszQDF~xQyBTl88>l;G&ir>B5&>yQSB`0EOWxb>|FjM z7vUOUXd60u^@|r&h$t-x=|Y1p&k68{D6Q)xKC9y2iEG{e<+v7%J$kgsJ-Z3?VY6U6 z4Q_L#)n~9iMPyC&>CI|>ip`o5%ydH!_f@b2$s~c1qDn9QJRAw5MYIeMqaLY&|MRlumyCS&ZlEK8sBZ zvx*?k#aw<%aP9C|Kv&)^5~&Yb4oVcA4<3424KRJ`j(*m>h?^v(3Bk&JRwad-wH;%I zg;W(vR$C01i*%fc_T;J{E5-hsbV14{$K-M|UU>$#GOJzFE!ZR$Di~1{5ELu7bF=p~-AkX}UHfoy6bOwCH3V?4lFnz{Io`#M?AU)?IZ*v# zf}s5BD3epe*hV3Vqh!E+kqx(9DpSCTw$Raq%f#x1k=?{v$?-+JXg6}JZlo>m&kA=V zfAXgd2vemM;QRnjN*{2ilo2?l>_JT(^U&lkA$(^iN?o@gJ?yQh10fyW@+t8aY(%$XiyxIS#FgIkc7l` z4Fq4+!9q*J4YrTMgm9v3f4S=BQ$~jb8-qXQw$H&PXnVSX7S1}iWUVBTL-Hx`(Oa$E zCSV^oxzy6Nkp4&HEVva5I+kFp)N+>?aV>4h<(O=>3XSNF>jSS-#G-;SL;AD0tF-RY zMxfUg?A#eze{ccKAgAmu2QxXbgY9Jq>fJ+@o&^(-noNUp16kI6{7bi0_|y;!r$V6HTYhaUhppUh1Z zv6-==Y_rN0s6i$FrMXX9lLl0Q_1$ z$6dW|pX8!Dda~#DCAa%1gXj`$hdPmO*}+t>{>AJ;;V?4ZWBCa(ltx%V;W%~uHmIZ! zIW`Bj_H19JAD532LY_fADW&$#nm^nyO95I^>$ZM=(RgiT-6a~UxQbRGS=w?|ux^F76Hsg&4_Cgp~W+;nv5vQyEJ zUygIN9_;NHJ1lm5^0Cm#fG_t4WtKo>KL_Prioa8(Xw8*0*E(U;1jnO^l4C(ZQA+Fv z3TfoMN#*R>{b(8rFy0tIR(jjj{t-$UHXt%SQZ?c!G?{rPQ*H`kq7 z5GA;RwlkdTawivrqpSDTbRdM37)6*W#D~NOxM>OW6*jIlnJUink@E>zIcWC@lkFn6 zCnmAnv}Cq#KggBsDlE1U&TS{ZaaFj$)I%CYTv}RO8XnU-`gSU&Z4}v1nvf9742u`b z)y&L{&~kTwMx%b_nHKBKUSM_vFZt}`B~TX^MEO>aQlA2wM-NxGGDm+;pQ^&Fi_1lv zFkBpGcX#1T@BtbM(UEuIryqw;J{c7{7-IOmg3w>)cVZV;3o8c;M>kg^e$RgjVBqTC z0vC;5MAS0!W0JAQ+yD*$7O!DrN6rUgTh8szn9A|FM^j1Ub`^RT<^fN#0FUOcPyi@V z-x>xz6%S`z&0QEVyY~*xctayDNjEJv<5C9BTlF}-nB= zPERaMFt%zrtFxOxIQDM$MX_(v>=&sVV}BhiFCfGK0I1`=u6=#;pNsVGNaN{Z<7NS} zcQUj4stj9}md4s;+wrLBSaGWZ=wFY`%}c{I*nL72nVu66sg}p{EEv72D!R@HPR{eY5BoJ zPuB|I1~+2#V!8oHk!mSjkl2VFU0q8%n1PE_IyD6K3PhV9@+II{iGDi)axpt1)c1D$`H=*SE>vt(2kX{>P_c2^X{~rdswZn$*kD^Dh$`gpe3`7fAI+Mn1i(eeNoB` zH*ZgJ{-tLt*w&F6fZ)NClV0pA9|&A|2qQEj{ExpJ9|pXfA${#^K9RKhfc%VqkpIx8 zng7XJr>Xcq`wV)7HBQS97Ex0~LcWCZt^NLpfCeB#w29Lf9$;1S^!L}4zqS?{0EO=V zR~7NOs;+#m>c`cCU#Xh%T-8zktLkqH6F&p+V?(4q2QdBj0NjYShmhwld*?ruX8pmI zjOQRk5N+{q7gzphkI9{)5S>lP&)mldlH()`b6J*#6d8eiPy}*m2z%;$aQ|0F25` zlOf+b%Tpl?fxjfgH+Um6SCFMSVjxAdw4Y#s%h*L`gOI@vQO>jY67t(DyndEN$bewt z{wWKD3!Y~&8Tz{{91%yi{G1j?O=ZDC2o|FMrG;kLZ?bSaJ=_21SO{;w+=L()Aday4 zK?}6--)8aCT0F7;Or(hD;3p8}$~o`s`dt>MQ{iV{ zDU6id%`6-(__>X^LFP_oKTGKRqaV%^(t7_d68d>(Ie&WKSwh)M|0bcI_M7v^+?^#9 zzVh!8`g-Wy&-u{#BcaX`THpNl2z@;u>gNcZ-)VK05F07duZ;YE^!sO>+RX+rhx|E0 z=eOpZB@{;fTZI0zQRnAaoZs$pmPIYaZ?izG6#N{E^J{5mSUqQk-9`Im;r7>9<+@v_Z}%XV0==y!@Lie%>JGvy^8^WU~JTiE}y2zcb1O zL@4lANx`#BYB_#`$=MVkg2?|fcozF(Xg&>|g*bnS$oK5qKg7@9r1D1_@6w!sqkY?iun%}PN!Me;D6w8CI^PV`pf(m8e*yj05Btd O0E7U5J)%Yc;Qs)Z%y*ms literal 0 HcmV?d00001 diff --git a/core/src/test/resources/indices/bwc/index-2.1.0.zip b/core/src/test/resources/indices/bwc/index-2.1.0.zip new file mode 100644 index 0000000000000000000000000000000000000000..8c07e922260354a34f3c1212b4e9ecfedf068bb1 GIT binary patch literal 83669 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≀ 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

I^Bd`1w3q7^L^A&Okp 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 z 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

!8YQI43^9|8T1=p*1e zvBYwnTOB{yin+9$gkz*+0P-Z%#rvX8DdNqHexGZK8)}M;(T5q>Oy*-+@6p3=0FepK z{toDxT@RAj_R7DLVWSUW64&RNL3~5aOD|P}5%x?^kB?P(T z5(0sx`MW}#O$$AqN2h5ujvMA*)S-ozn-fuICHdSjxfWsuZlPoBK@5JkpWW|@#VQ6U zWKq7}6lzTon9=qwD$ZC@;|nphFt^zU{WvBma=gy&r0EW|x6nq}@!;^|nZ2k1X{vk0 zi`G~aEw72+^(yu*b(+a+g*hHYKWn;MFmbTM?Sl=R@r?ogE9S*_(4BO4ZUaU0P5z}x zA!aHF@5h_ZS!{XnVmbKPl|3lB3u_T-^;{9lLX80LdoNek!ZGM z{ZGFXLztGWWEa(iP&_u^uz{|!rbkKjip38z?DI)_Y4&S9<5Bup!~L=0r3)BMOJ~}o z#;uO{`w$5{IfVTfm;BZXqr+i57K3~&itp8V*~<<$h;c^m29^@Vsoe zkW-j~oRw&y_|rq~tprI#4!n=oG48myKL!W=S(Jff6urImN zv-P(jS%Ug0fJfKa1Wa0}5y*sSGtO=lc*Z@DTV5YgD!X=IdK5>88tyq-Se(pU_9LV5 z#VvWyRvxAp^)?%z-9MnemRMo*gzYvn-Sj&Uns;oei2Ei%K%Z~>o%6Qf$28f==zOEM zp4$A4p0KPMFhKD5{cHT02GdMvC5_D)9*;WrPr~E89QurUcqN3_Ly69AH}E_@Fd|OU`9N~JF>k9V zDx!tXKLeBiq({J4?G%7C`^+w8T}&}WVy~3kT^Gq*F=D8rR?}7!nl!=$9UJ3^4Gqj<+OE=II_DpFIOpD8xsAwd8Sq+n!syj7-#0S2- ztOj_ZSK!_>-eAN4Uoa}G1$vmCkLeA#@yi7|rW*N_NNQy3WJ!=NR%IQ)ol#-DZ@lA^lWh<58>SUegn*D^-Ma}ppMwotJ zx?cIjWIto#W|hsK05kp3a@k3E6s1bu0h_JMJnsxyDX8ot8-elMzW zgF(<)ex>D=r_e4HhW%sOVQ6oYUvGNJA%;{;AJn=6BViqqY&nXd*W+=*eM0D{l%CZ*0ZY15%~Cb_-5B%yU^ng_K!7F7>x{Ab)t z4mQYLHds8YO+?i?+DK|d+Si0r!x$?8AeLQSrwg0edeg67uLr4WimD;J^0Ux|U#@PaWdK~2g4u8TH8-REv_#>)`AU)UK?0ajXnf+)Bou6Z~=X%BS7*@$W%#SvL zppVxDfC4Zy9+glwXKP-1xkb|7gXJ+6k%5#igi5%J%o6-Kg~>wqiAD&}=0gxx^<7lH zk11-P&HG%xI@ky@Oeg^6P`bBS|3CyWsAU7SoyIUTtIrx7AP12F1(SyaAkXh{0!BpbnS)pdW`@(Bx-->>)i{TWmFM z5WJ(=z^S`*odNXY<S~?$X&Sb-B5~qaIoi%5MqA=j9|7wVGkpPjUH4j3u@liTCJZ zaRPODpa`p%V4^{<`N=_O)WwG(iOw-2rlF^BKm^){{EgKAwv@@>wMc-JQA0Prq8TObb1q`ejKgYY?1Zo}PRJ~?p znjsb8Kn%rb5zFLXYlO*pXpzC8@i^axxsOxt=;ZMtQB!ATkfvG~XPWEmZng7rk>=ip zsb))c@BA6M9XA13ojIw8?NRrOZ5aPlKMOdG@n-pKqg7nka3PrRhC^}J@UToE*xzb+ z28RA8F%An94h-418j=?Rj;UDf*c)U*h-0|R4ATcdkEEqdh=|S_k8$iSgK<4y=F~K+ zoz%uZ`tdGacA6`rvWE_};_WF_Qh%v3m^|>^gh0 zH5Q|Y9~64gYAK(cfcwP`4Klf+b17XI3=(<#0y~7}b6ICnE6!T(xEsPUh3O5!RK|Om z{9wa+ZV+^?vGGacaVZRUJ!CMYPHE0+t&z0&r~5G!Flgg*v_`cB|0Hc}C>$_WHp$?- z_#sf)WhVz?afX3=GE?k@8s6Gqi*UwoUH)u?tsm|hw6oOVG|~8<>Vo?3?H)hdb`oqn zCcZC#j;=tv!jb|t*?XDfiKK1BmMLNZ3)yRv@#Bv$!|v4CC#I0%bnb-}c$mXi412|S zwm1<+Ak4MKq!IqvA+P*Ptt*Y*>OsAJG{mof*ajRpYqa{>!JwF_hQ+SXO;EM8;cD@9 zi=i(G6RIN|KRci%9s*3xQn|C6<)<4JzGjk#>I3L?YkW)4Se%v%Yh6#+Y=R`f)kPol zPhGQW_M#6``a`HSZ`F*8htp}Rza{x=ewV+%Sb#FxLX~`9z%X)i0nsj|%_zDav^C4R zjx^~y1I!VkO z0sz%S3Y3C2S&5>2gEC&=UvxzCa~k>3h6~tSn?z9N@{xH;k04SO$XbGD=OP!uX zF)l6B4a#UrM6-dmgkGVbJfW<2%1R^OOk-Nnq1^cO%C_WwgBlR2rcWcB7|vD@_z{EQ zUyUL1V&yCFnDx-@FVRxvR68Jv3U$_~KAz%N`$binn3TK*6++>BTG=U~DBoF?TVzzr zltIiyvMQW;K!MIXihGYfS`pCEP6g5PYCDcDRmtl|JHWoM*{K%eCCSs^6>Fr$Kn|xk zp_kr8^`IUw+zocO-i}iMTe`m~DGr)$T9slB0L{XDOFg7;-4?psx;4izUq`_r!0Tx|%-0c`-KDpa4p26ZABE|LMsGq` z`w6sVb-C(AutQcVUGcb^6;vA)FCH*Rnl%fIZ?f06((TK;4(h|e9py9z%>p*$Uc435 zY?&uo03%IIW5PNCDx!Q;3xLR8Bz*(Ay%q`_^ESx#0idjvE>17m*F@oCS`eMgLU1$p zvMIC~)w?FyTGd)r($HO0v<4^Lt&2lx`N48!Ea{vGHNTtX0o>4s=#b(?+H?x$^ml4x zy3VHrz$I$;#A24}_FiPWOHius*l^b?>_90`*b>@)YtVos4*`~()u0Qi*R7x! z)x+|jn#;xk0#1#`ni$~%T#oAOq`I{E=Q$900|t)IaNSE)n1L7)q~p(UIkd*FxL{XV z_;scl6n`;AVGDMF-Htl260fwxpX$6>SZ14|{jO<>Z`VXK{+tsgzj1|ql?9c7L2$Y1 zC*P^@&j@=FYXrkl& zYB4Mi&>U25GlELapdf$hkc*FWEPJt+_6LG;A2h^UbyVXM(znOg^>`I}Ati6}6y48Z z59Y-lC8l=XaHcvP;`k}$M3MC6B{C6D~7slFvWE}ia5`99Tis0?sW`huh`3! z-iSc=i$EVKj-_lp*Gqx9NwGsOKc-Izqldkq`o$0*DId`QDee$Od{vWkL%d$^aiA-X z<|7!*Hd;$H^`QjD+>G9!T4j3G21P32?+L%yO6SXZ#A9S^Z8YgHC`VbCyk2)}OVq|J zi}o-^CB5W(Vk{{K9a2YLvTzdcSZ7c_CE#L-73MQ(73?URNXnTOmrlqu#-zTn#upEY z8*8Gra8lz|1N;*vn@rbY_JMeRAYzFVE|QxjlW zwt;^8p%Elk))^X1;`I*=A4O=+uzJ~ou-pK08PWM!o>*=Q*3tZILyaHecojNeEu`+9 z%~p2$BsaC0l$tOfHzFeH;4fXVeWy6s2~Yx&&n_`9;l$NUbmcT7wc?p$X1+3`C6 zPQO^|^JcY$-YPqqORK*IxpQE@Ujmlya>J55Yw00|kAJvd)V=636_4zp!;x|eT^!Hc zW^}yXIJU_@(nBajsV8Kb9?yad;0-k-2g;U#U&2;|U=u%f1T690tByKz`$2v|!^SCF z=ozcmct6V68ASEDY!*A3Bo7+EW8jcJp_(}M~{E+8YFtkmclu|-=DKil_BYNc-tb5n%*9s}II zTgMr*EIv74eU6-fNn@; z8f6RX|Dr95EpA4lZa%$asO~3(Qi?Q^V~ci89qxO54f(Lh1vXoHv?vNmlt%uoBj?j5 z73ooPJnxpt@6pln;D^JNIdrC?Q9(tfMtB9kyt(54mDdRVa4a%D6r zWO46s2N-sFcf0y&1z}PugPkjAz2yq&Oqv!+55PQ0PZQ+b0#7Yh>gQ?Xm8>+^ze`&g!-~C7&)GExnDkkS+XUi+wQFLH5w((yUk)Dq~+dFc(jmVwZ^BV5E1p& znj7k2b%o^)RTElcFO!rxSwhVe(mI9IfZ3nCVv$YM#Cx~Xh)lUHbnA<{I9r4HJE1|0 zuGZwH?l8W1vrKKeFsLROArbEo@VI`x89*L*(M(k)BE*U2!zhoD#*NOG=*wtp-A*6up8J{D$E2{AkXfs*Y`H|sg%OPprre1+$JBxy@+oAf07;K#>w$pS6;ta-H zkesdAa$gd>Nij+w6bKE$WAy~n-fP%k^1<|86WIK1xAt*rCE!6Dir7Uk&zoHKupbx)~ zX8JquH>RYPdO+iE9eHD8+s`LMj4!st95Q3?1Zf<>16bE#3K(WT1~A;s_-&kYG=!)# zA9RAQq0sE(4Z)tb`~qG4S%Xd3B8HW^Mr&b!x|do^&JCUIU2Dhr8j|heN0ec`PLa_D zw1t=MUF+iZeAAC7Gk%B>MljZ!(LOal{#Gq00QKNy;h_6(h8o?+WV`oBuLC$H-nYhe zGpr6bxbuYV$4`J{&bQgV5-gpU)jA4jH#kdh=b=e{YMMcuYBVQORFfQ}qiox#bAc`P z=n-so-G|i^q$la@=>|>1W<*oucMTd(!tIxtE(NHa79HmR3OR+!B`W_)gK}k@ryF!6 z+OFbt-Z!N!ke#gi|gWC ztE`~Bu_nXC?~tawz;0FNXpP-_ylDTL?A7ASwqKn#iBnZ>L7Ns7?Y`aNC+J~xBzK2s z4-AUy3R3Ait6FWHQime)9P&;=t2jHW^(Srqb<4}YZgs=-cFnISta`8^j@4afLZcI) zUNf0)ZLs}ot?EhJ{gDx7QyH(V(HfW$5GMNz&TguWWgR^4wI0ETU~%*sI0iERvA%^@ zI`rcQ!u_ekN*VI<;w@;e8PDNcGjTHOVat`>BdF?e&#fBbn?2l)v{vRfgXC~WJTM7Z zcLJ>fm?uGtm$24(+!!W4&XwWgvE*V6@4xmqT)nSHkU|7P|ZX@-O zH+6ZsYa$1V6Sf%wml@ zr?~Ahxz*uQbo+i+I_)n}TbVW`$Zj@hc{5u&fQRM{zSCrOt}P~@JTl5Jd9@yt6PlNv z;!3w{0VJZb6e9BZLBZ|_#xe}>k?MC18^$gLDZg&{Sf@v zbm|&P=#r^lv`ljT|BWW5#fP@>ivL42G5a@AWmP1jiB&aM8Lc}1TJ9(}BBd0rLhhB? z{rm&*(=hRV1!KHireIJl@1jwb$zAHZj@fBdvUw{8`rgoJNvZhjl%5jkc9}Y!%I~;b zrt+a;h4g!I$u?c88UoAs8Eq7mu24pz zwdx?WAWhL}WxPSA0+9=j!j^86ylVMcl>!vBYcrTiW3nQU+U{NYXr6Z$3=CCkRq{!d z#6%ip-mJw7ELO*>4xX4FYVfI9x{KO^+QY;O0qtbtDSou8MfLUwFi9EVSyU#@)f8(n z8Ayh+PNr#@$#6ZW*s(0dWo4|%HS(kdiAvY1(vFH@^URl*P=o+te=!A$7Sl#t zX!r3VJy&B37~0NoC=PnJ&Y>w6=&qNX+r9A!`2Zi45es`)Yb?u9W%Agic6ZqVIj||9 zhsPK1n$m=#VRJL>k`0mGRev3bb|{YX>@XW}To3m2^en@Oa$y1k5bVq8#=GF%XQKG8k5ul0$MQwLa6Lkg1n$rx8*Pq1kX1zeA^2A|ZRW z<`=3NM)S?EnF_;4H;qIvCU>zoTaDj#0}`Q9=q>Ji7C*nJQm`q60gL{4QS}SOdw_-#Q zY%5(_(&U3EHThu}`!Y+MKs!92$fjpWL=w8skug*9e;Q^hflffT93TW{M4PM#u%GP4 zZXju2(@%;9pQ(n?EQreo+_5YfFoI$UM(O#scnMX%m-$qbqKNDs>7w6Cmu0yHoO&58 zkZN@t##cf8&y=}J?01dnS>Aa`rS#}TnloDi6z|nJc|+GLT`lu8G)8_O3z9mm!E&3a z30AyE=SOkzpbG_gA})E=3bI=a_8P5J*VqSQJj-9JyLSUzQ179P_F>b=pAwejbgj+> z@76?sDZvH|86gEO0Vc1o*d~)4EtzvyjTb#Y14NU^gp!9Q5m!4W!t$v`82~3tZ+Bn{?FCB)jqC_TcsMRr zYpwK0hKqUi6Nfub+7zA&s>}}auQp&>zE|_f?~^RCAZ0kQVSFjza;D{_PuP?oikh^O z&VDui`$6&RNwjKoJ!O0DZMrL9eeFU!se*cPkaSRjXUP0u8%?xb zuXxPH)PW=;!!O6Ut#H1V-s()xP%Oq|q4c|d82q!)iNB)lWZp4b`OLcecSC$^ zSU9f__(|Ctr2jBN*oZ(dYb;NWWA56zhX#;V&RMV_k7Imp%_~DDo(Hc?^{B)Rbgx`i zlRM)c$Hww>Z@^>|8rNlir>*ox^dQDXo7d2@ulTZz|5lTJY4Y{w58Eh%eBZOicB*%G z-F=5%C!~GqEcO{kCVrHd{wa6F`Mrw$UxpNu2Mjfu%^<$c470hW>tMd8Q6q?-vsgYT z!(PRmZY%F`MkrnLd6;I;_632=+-3*U z3&8Y`mRM}1DJS#gkok90n!Es!)J(Gu1buVZOYhSu{gQ1G)AJ-jw~l)f>4JkRA-K#ft?ct9#WWq8#40hT(iksL1FxZ4a=;s4{L3WqUYD3bir;D*1MSMcD z&+YAQs0(u*9L-Pjyd))>f|`LPJ+sG!w!KT|>@M2g)()a|3j4yA-5kf~)y7wR?hJ|V zjBsa(6=t0VXCDm7G_rL{oeQE3ev|WKwXWaiJd+PzR5YFW|G>&nUkQ6mY*sXE=Dd?4d3A$W*qmMonSf zp@YEkytB~V?9)2GogPUm6}yo@%AQ{%zs&f0H+%jl3J4B&VQV-&>JjP1!V%#WuA^Kp z6iRX<*B1WBBbnqyS@&yXR@hXEL)Q9_T=Rc@TKR`IQq80P*BRH(s2&FmypBY>!{xeRQN)u_d ziM%;0mEF@)owZ46RV3A4R^4gj_!=&jQ&5s}$7l{ur3IMnB6?XRBV@E9t~+1Trj?Z0 z6?b#y$(2Cq;6*|UF5gk4)%cjEPfKZ!trS8jBYy&UdUHxU0!hfUqi#;ihu~<~JMY$ zySu?oW%4rjW>gaznLS6lUID(V&pGTWOQwZgZ?;h4Qd-#IhU~g%fcCRO*#l!%%6Y(as`?rZnL0jGqy;htU$J2X~jQv+z=SWg#8iPLJL$y`xh|L z%syhZaOi%g#;&$xLN|`47jbqX?3LFoyWi-3m*=MrE;G!L2-i(zK$@1nT0 zw}ZLA=#@t2q)UbDDE{$bK@-!jA4H07j9$R}%bv{wXCX@}ANCdB=% zMmq(Bjzp(38^i5nI%!*7VmJK9oEEhhX!1x~W=d;OvE7 z{?WQvJ&D&AtMzlVApfxumIuJv$d{n`SD7QET9*JZDGU7CdXT-WvPu0Y(VN*1gr8nD z7{D$;EBZbxW}^4}X`4G_Vd4-&?70RWW-y!(o$c~%nmFRl{2o-+4T=eu2E!AyQs&pF zKe+#6ewaOl8{qu>NW+Enp>8g}Zuxm`^H0>+J$=;n&hnlxN8M=}(L&8P{IMd347n1< z>L}yR!byI9jnCKhi0{^fvt^&3L)ffU6|t4hox*G7f33MF`K%DNU1hrew5AvR#E`S$ zw*l@&Mh!?g{y64(IpO;Gg?5lGz>NH+T+zgiMm;*|SN4=`6SX z^0zLo_VVx7WVS){n$;?2^#+{*gI(xRwgg)_d90u!>DPE%&L41NyG*XD^OchYOmx_g ze)ZQHM=#;OPK&pz?A9qkd@-mH@4#lXTE)lxAV18Ivn}6-HE@`mr?Jn5w_e8xiZz8+ zEe$|$0>p~4T*xf_JVu+{e<-;4Ar33b|FEV}%R2uCv4Zwo z0FvZDfzh~{FBdgZKg?Aqu)G^3PR~_Fi)b!oHtAC%nIuoNwH!91v|SZ`S&__5(tYh)h4 zv@BUpX)@z!xm=NKwT@l~V`G@y7dZa0A!HgBz%7U(`8Yh*Xrhdk0ouLjY_k8HJS7Z{Q^8^Ig)_{clO)r9O$u(^#-=NfQF!|;% zuUFn+0;@-1NShF$lnDVLhT{M@5)vj#-wckEomKWvB77fDrhLpNv@nHsWWTfJagg6= zhABDg(BeL(S^$>xD%%th2}@FyQPT-Zk63^+%WNm{;l@aOn<0+JtliCOC$tSo4&4g_ zcL+V`)3-sFDPcqg?-O<_dBWy@pyX%n90!y835d7UX79?+tTth;`H5Kzik(!U;Eb(V zD;d$y5nvpN&B+~5?x(N6p!wg}D zxK3>QotajUC$xDGnjDY7@kn_n4MDdV<2XY@-B@F5EwLqo>N{6!d`Iv@9WT40%bjtb zfs&xwfXRusAO}xY-eT}yaB&Y4&M$Z?yN9_e6n29t&eb&MW|-5k4ghs*iF`3yBb)Dw zCjXYnx+_80_@uEizaA86|aw^ z`o92V;ILDtpnH!n_)L{GYT`cKu<7XMK2KQu&-;Lfc^ z{Xr%_!%kbQkniIzy;bg{%CDgV`<#!}eH`-b8{#WAm&+{6ZvkYlv;eWfQ3iaBtZp9c zgUodvcKz}Toa9#O33jm2F0%=ZXSV&#y0}BvoE2uPyr0Rrdk5&{819z`8{)tkiBh-r zf?7Y=;P*2IvvxJq={M_Sii&-Q!M`wWmJLu2QCMkat-DI+PQ8(}f>I?(!YQOu|DYBm z_c1SCt;x{s8qKc~EvRGy3Gn}R$IrHJxU`dhpCP?X@7H9>;Z9hn5Dt&Qe7nuzd-jAd z+aMkGHvQ@(#_gIoH4rtsRtKkTlKVXjRo|@FPtt>Il(9!AQM!bb1QmqnZ4mE+(jDl` z>h-H54gRD??3iJ$+&bh}e;(jYP0%W;5>mCgp9KY)=YA%<=yj`AJvJ%GpMn|O^(M=; z9$%py+F=8p41v7Qz*yC}pYhp)WSV%<6ung)(hpb@EzZ68GTO3efzCfaBK8>&wH35# zhVQJ39|&Rp#cWk?P7cbd5k@aSbpAugtj{)gDE5F?T)?gfH)MW7@r4S(j4OFX#(txJK~JL3~*PlTl?kOmAu7U z6=wX$>S4Y>cbjPVb{2hR3cp*oz263VUiAD4E{=QWx{Z+nmBYwnCDVNvC8s=qPvaP%#$cGxI%8ZMgFW>|L5j^Yqs2g zi*Ts#^|>->e%fY!n%DJN(H~0OB0m^0(u~bC1-3e}8=gFB&F1|06`K)@a_*PfvRar@)))ItA=7 zSE1dg=7NuCSNk@7a8Z5;h#1FZGidLDOV#nbL&QT`f)ezGA(KW5;1=b_P-uwOJ)(Tu zf)bxQnv_n%DS4k@Jmi?44($^5q8enEgDfD98co=)?S#DXNwr?-Zo`^r-9eGOr2cPv zergdf(xBK^l3Q&hC}Rsb32vOos*Q>}EujT_IDv1(Irr&8dW*75a|aE{ zDo<)M{6HQsnR`vCum21cnP!k@V2=#9PSz>IC2bV34ss0iGmTal)VC(l9!9ip0#(*e zZMm~TNRIF(H0oHMN198u#+ytbL*racuAZH31=(X7gzQGzLH~ZeotLW=jwx9|f(X^Uo$qGvRDMzTo>vt0=b9wI+rsRh~RjW9hAHsSG(AHRwQ-W4s-GQ_xUu$4+X zj=q4a3N4HlG0t)j8-Q=QrHIo(I@NlMj>ofnxfLdJEdj%}Ox0N<2Fdzrjs>)W1ij93 z*V(k+H?j>k1;LuEa}*p<>cZDwEW7Uhs9_|;FZwu0z#HN-gO&Z`YS&0Y7)u2@wU zWU=|_;~J;+-xz@m12E0pAlgM`pRLJgCDeQRm^K3X7GDQhq!iz{*`P?R*a#i;!o%~aWTPqYQ7<4EY zpTV{sEH7_R2^wmTUh+W=##^(^1s|(>#pRTrp$&oosIUOI^oN+V!a9X@Z^ZA>!|Wc) zcUiC0r|=+|!oxC#7y!D`s^Rh_l>u*0()EGzLAC>~X*&EV+xmS2?bcIA6&`lI#IDIb zPylNMrXwb}7k{0+4B8+Jq3xrJN@>0Bemyj929robVR@I%!Jc>G)nQw-%jl*Wf29}l zT<)YnOHUVSVN6ZQqJo#Xm$3hIIW(3vDDkr^i9PM_B+i zhw^s^i#v6C)O$6#04q5ev*;V(i&rgLj<-i0R@M@AxH?aB4>8y)a#4e|tA#5nyxBoQ z>}_)UtsXR0^syfPa8tO$VlaN38Z*jlep5}{G{EhH1RXEXgB;qN3RrDC?i|B;pAo{y z5cWp1furqvz2Zm*_KI##_qr#{@jU=+*KwcQesm0Xf8PtGD{NOx&>21Uo;@<1V0uGd zF;ev#HdN*mP!-ALrXxNj6#FA`@tpmtg^I-cnf!p7*v}O9djlWCan^6R1BQqKZhgz# z2?c9amzIn=H`QA4zNQ<~H#};T^Jxuw(=_?529q8ro!w&i zF(4$jz3Oi1ylPS&A?P%lp2)VzyE;?cF#FLzB*; zl?s;+dU1E5+aPQ!Dg{1&#b%vJab# zov+w?%Vnt6(IdD=2Awxoan#8&FKaKlF1xTnsCXQ0DFJlO&bLQ0O|J8bpw*)YMd0)4 z4U9`}ZPlE&6)wpZ_WU!BNJ;U;R>|u!oqeC1=E?6dQu5XL|BMdyy*_{GjLrN+;l%m> z!mo?EQN{B&XV?$-AGvv33H+hlt<~LR`Ze9HxjyW^`Ve>hr+p!`_}|!tmyo&fa*OxT zy!dx=d`7!$QNm9qfvl4I3TV@ky!&NEnc_7;V9{u1>y_Q}M4h#sGU;i92mndL>nsC| z(FQ&7&gw)N&82-GXam*kGC)sCA0eVmh%nrSXpteUD6Do?DYwdPmM_4DenB0NO8N@S z3flci`W1%D_1%bLSjeRqwA&OaCbwR~hKCauvDwOw>(s_qF;tleEirX@0Ce1+Tv z^(ED%w4Y(J2p@&gq5ZJZ%PA(gPH{1CU~lqiQMOJdawT#*e(8GGrj_zL+W;#HR8`&e zEz6}cE8lv{g5k87>8u-#O%AwCx9TC=>_Xs5K68QM=eJG$T84C3uzO3;_~ zG)IGaPi@Mg3RC(NQo5ts&Z;wI4!d+gIeXETE!GJ2O|zZ& zb=se%o4gA77{ynp4Q3D@$>|GLZnK!7$^!aYxNx`^{YD$_l;_&+PGG+0 zRM*QDbF5R&H-qGPRqki}OUe`brH-?%sLOmhN*aoPVBjnmI_KH;qqM7$VJ}w4I@Me= zNIzxJnhmxKbWn$u0$}vhTKcthbOJf7DV8l@F<(wwMosS>Ntc`UKPY?+-buAF!e;*Y zzQOb-oIXO#meld&=zfkTXT#k(u6Wnvr(y(ro|9|R%THtDQSq+n_8Dx_knH0Va2BnSoI4<)g&dC? zhsVgmaKCPOq(~{(=6bUgb-WXmfY>%WF zAehx^t>{k9zf<$diAl1#oNz1xu5rAB1$bQ5)2?7Z@xu&uP$*Bh3^tR23A?!0i?6h# zC+>q5z@dJlNf*~|Xw2~JZ4Q7fxEMaZz0b)f-ys-D5+n!GEpSIVE*;l;3i9&po zl|^3)s-;JES0Ns`dKG!NZko4wTL_uIHEk}D);`l#FPnMA2NI)bztgVUi%uaJdql<= zDgA5F8yjC=vtq`@&i|hXVfEout^fCC4<9H=`ESIEXo283`CPiYnog@Wf1SETyUSP6 z=JfgH$~4-ItE|+ItW)F%@OFwioxK&;S*47nomEP!x?b_3>*ad;sa3j)7RXWHk#>M6 zD2sO^O6a>n@k{C`?d~bJ94cgVaP}v_qJw$l5ZMia z^c7WMutN%sHo_UsHqr+qH!72x=_~5)Nv_UXMIk_N)CS5X!j0&&MB_O~4V~yV^ZRrF z0xe`;1}2-LQ%GoPM4#WG7)6q3qa|zrxpyFah$vmF(kA^Ac`4ToUaF3zw44PXSkYE0 z`4qif!T6PKxDpl|WuMSm+7f4^ck8YPYj`@$aTFzZU2QKWfxU*1$=4L{E z`egIIK|qf?b;X)2_uw9aI;}qm?W361T7NKHrGMLk}$ z-W-b~R6m;lfZQRiVD=?8J&qy@n7v58qV61{ot*_xTuYaLhX4s0G{J+ryE_aJT!Xv2 zyGsb}5Zv9}g1ftWa0u?c^WOgZ@5}$H^0GTqJ#%ZS=6ttL_c^!woW8en=bH=aOdYue zYYL15#6~0r6Ryo01+Ds!RC(Atp{uXF%ezu5*?Kh?Ou1kVjd)p9$&BAsj;xjs%tX~R ztEBjTWFgZOD+Z7Ikp9ZE`{BvfMxN6*8qOF)_|gApkyfSPWTaQrHGr6}VpIpn3EClp zEAQRgEsmW2&X0DkLeSndUhUjXr`F6cgO>7vkS^)rbTY3nK5QivXA3)clOInpKd>mU zH+2woO@>exeq8YOnF+_l&IH{GFM?ILDrYQqsgChbT3h@WGX5dP!LWZM zrN!QAFZ1AS>KdHkd~%(kR{r|)CuROxoXbt1JW$os{1#d`&m;`5XOkbr^W5Ncz%rhD zVx`OOOGFR)=_3+#sLnDc1_YbLs66@uJ+Xv#`-soX9rOmxWaqho4Cs*wn<&0K4h=!? z87J~o_YWOzgd?Z6DegC5is?tTL7QX{;{Y4Oy6~RfQ&`i|J+`P)_Go<^)so;}yV8IK zzY@P@&=~BrLMmfrCw@-N-e;)u%vi_EwvRfRJQxlAo`EWtZ-0z7VX*LIiP(jCZwLSV z#n#vl%S;zWzWbu!2Pzo=t}oy1-2=lr=2?}6)9Mws+Zk>K_GidiQ1mGgHK*pxO54$|1!0H1KYl;qMH1q&z;cXkLEN8yVgTEuSwbt|sAhuJdjr zCgzI=%2X#&Yf~0RJ%yoKd5cC(vDt?yyLWgds_=J;%}a))2Vs=%JaLsGBo1rXEir;J zxEw-}J!Thi_u_t?OeVQiL*adq?Kv)OByHQ@zpZS3Lcz3xvS}Jhg;suBuKbAq=?61a z(iycNPlYkjS|+}?OSkOpnHxc<$zhqivR+6lo&|@kQOyz#ZzgIoC)qr8(g0buo~NV+ zTP#t1$YO&jgF!Gq*cTLIk>X~1T+%a-z#jak<%P;Q>1#|VI-+k|OOp(C@z*sW<}2P0 zz7%tu%RcmunnS5(!E2qj+3?zBjD81Ttix-asP03TA+!vwsnl<6x)CMz@5_^HO)hEg zA>8VmsDeCmFRUza42vx+Up`t9zn~*uNc1#`eX$s@eJcGd?~3g?kTJi2run?q#PxP? zGwDb0z~rkhd#H%pv{%*z>Uq<+m3J*PoI^1>y)o*Kw{!Td3^i@+<4=4S+?JG$j8MU^ z;qGLdN-fj?WklicrS54J?`z1q>lZee(iy7nBUD?=dxcNr=dG_3Z8bJRj~y>=sa;xz zltju_Q$l7|R6LIv8ZWIk0;#8ykJTs0m_P%V0`THk-=J<9A8h ziDP&ygP$NcGtXPhnx59ROES5S=17To2p$|g!t6s5hB48TMwYx2Yg(qXjv~>pw1GYi z&g93GXN1ag4Ad@9BDg`xhcawggVLT2d!Or0t-KgG)#ps}NrY^yE@S&k>^W#$obhcW zV}&UbR%&($XMUV(hNTZ?iuiy|5s%n(evJsiI46k{w!H`N&YtJU`|VL|nuM5;$SZ(x zHbZ_hNr?(FgAg4cZCV?59Rh*08xeCmCJA2l%0F+(F79ZvsQs}uf#rQ3HMq4z;d@&o zcHAs%x~ee~GwmtVdh|<;a>snePa8&Nj!r%L)wg~JPR|+V`9J71@~rD%fJ1ZCHwNPR zEdE_K?U_F$!pa3&((+FT6}dm-3f}aUx0i9l#-J{?+EnnHxtScvGiKuibE+2G1@xc` zzhYWEx1$n^u)Q5Huh}#I@fk4HQ}aV4=1!N=_(6OxC>D$VQaF_y`NCW(eVu0+n!USrII?HntmsXU zUOi7F(z|>PES}Hb0jhp2?}P2;Wiqz|?~_TA*`Cif&LHd%`S!^>eepVsprN#DMpNucxnu6|N2V9jU~2d{0fV z-?!I%W}W19(iT+Y(l+FCSIt?0xsxK8IVXu94D+2aE(mU{2jU!f#B<@@$x}hwJYNpQ ztVHc;uDFgw>u@dVY!E8Rs9P-f)#P$P`qNf;1kZG{0(yAl0z0Zu3XE7TH*i6ZMx(!v zoW*~3L=HSk?XN|3t!9(mF$&9oJ~}qEX9j32th0XAw27OUiE1<M!J2||CZ5VA*46-w6$r|J%tlMG)Y zOF1U=0twZl>b=4)n0!KkuUu7?+XTxeHS>$Nx(nX?!tP^DXm{$f`cXSZdNf{(bqI$$ z@Gam&4srWD2C$1y#OK(!f&9uI8!sw z(9zJ-($Q*ZnJ6ki1Hid56_oxc4$iOuFo-KK0N_t~%n2$#z|B+wjhdv4nxt zZcI2=miAc~Q_H5L=1hzhKeTuQkf4H~fzrwXp-9~9%U^);h}~o#CEzH0A!tEINPZ*& z?TCm(LYF|BJFPvpC(Unn=i4`2ZL4c76GvNX&(7PDRY}=<;*%U9SZ00FO z4S$tvK6|-h=W9w7vu8OmX_x|g6@DRl_y&s}-k;2V2A?oC)&TR4s#?_>FP zEr@?1{`KRq#_EDzX9c4Dn8(~u#z3ddi)yQVoDMg#gl@KK3kxe>*q}sl2n_s=D|r(F zioEf-`AyR|_2#1J_}Jk75n7u#=AvwNbJV$QriW^ia*p(6*==ZzZ@Ps9(|y}fUfh=I z1NJ8eaPuq&{KYyvRfJFHOy)tA$R?D1^OzJg2&?-f?8Omjeu$OzeC}W$>WUni7Rhc1 zi`$9P6K{qXMe-&+;EoD4vfHd#rO25EtRPY8iYPBhLj9ZQywe?~T9bPm4!_6yVG9K7gkETC{F0sPMTKUVxy64W+@HnrNw8o1c9sLotr?4Vb4o2U=5KCwa+xn zeV-Xr4L=e`iIGhvuHU?Xq{Si`W){4HGWcrqsbupt^B@7xNL+Eurc?jQwm=U`bxy^L zu6k^!*RXN!yHbgUL6TbZgxn2(J!zJyq?Jb+XX74LvWOz@Vhd9I9ku^poV{ME2L2r= z%2|+l#f3a%+^>T<{{C!|7~KCI&!Q91@k68-3Y8ADgx*chj*g z2thamX6gb;Cx!sw9eqh}9 zBs0-RE=441+`e^=qj9@~|hJCf5@OIa< z7LuZD*ftkZZ_)X@GRTrbxR}+mw>bIB3*VG89#vHTK_9f%n*v~tC-;ck6nxmJ{ zV`N!|`oUQnifEiFCjX!?y7%?6TeV)DY`GvC`awtTn3kkJbBiP}H%Gh!7#n*Qull6e zkF*@@9YIPGPk~jiJ4;E=+thdMBdNgYHBE4QPdy01iNCi%qhkVDLNs-MP)dYw@$R!T zN0%C1)(7?cL+F=z)X^qLLTyZ(a?IO_yOJ@HGOU#%qGb&tpZy2f|Z1+ z)8q9Lho@RyaCI{eBKCStUv{Cn&$iBT?gLXO3}I41o!PzXA?r-rFjGZ%mSQC&j*V=k zXk}RzZ5Wp4`|_&Uz9GV4WvqSGr49~m?IrY)QZb3{w30jbvuGKL;}R$SYaL%==C!~h zjD|H(1yp@w6pfRrx%ClPwaq%TujDYenpyFxEiguw=xDc=lHyrB3h)v4!j!WwbBBMZ zz8NCK@SE6>{iXP;e+8| zy=E|tUnNtj@?kJbL=JsH_$!*+3Zo{ywOy)yXfRj&@nlrrpd!$Yo7*Vp+~f;Oiy3C# z&b%nhQP^%7I7=fg!Vu~NX=XIM%}AX49lMoiZ#=5t(_&f?R^_ynVueUAxn$}l*EjYb zjnfcks)#|wAFE`KYTZR+qGK24SRI5brNDE z66ey(?&K!}yC)1%n~yc{!*X8l#s_<5X0dqi+v+#MR9`YY8q+J(eCXqEudm|H6n~{H z%L>h+5-G~Rv_n;*=$EcqE5jKLa?T9?=xcv@8E1y7Di z`JJ91UfVi_mqtr_QEND8p5&7pURd1%d0ub5`4AhD_;HI?zLrIAcY#qT?nPw^4=kzE z5DTEN!kVnxkg?Jg^Sw5z!i0;I+}aw4`g%ARUb=60Q@Cx^YZ$I;hbQ-*=4LPYXVth}ms)Pw z3wNK|4qlp0F4cr?&sCO4Gg%+|0^8&tpO@OMF53D%eck4~Jekk$Pdqn=PQpF5k`qtd zFDy8&KHu%mJzv`Gc5${ohu6nYUW){b9echwtv)rDzfA46-At^xovh#Yw4w1{nVgU| zU(A^8+PV+7>E4}a-K!m7mAfFEJX|?-@;)PaJ=S9041VIRE&X;v?Ui_cQ>*e0>rfnag_2qdr-!uNXIs$zD z4RRO86HtrZ8s2kf1@|sJ;{4?{d1#7M^C>Li9;kJXIn^*wr}DoD}f9Qvcq(fdem?t=q!y+1QD<+Ri>*Z6$>s%0S&P9YHr)|F;90#~ed zS3u4}igLk~K#0rD)a=x_B!;ph>>V&!RZq3r%^^Ee*zqmpg73NGeHD1cgG!K&z9z$^ zAEqM5#z%7tmc@@k`+7?S!%MT!l}Z3<&Ukj4w3+GGyyy1)hQLD-or<%}1y!?cwnB!= zi^+J~+5~x8L0);PNEPttnG-{Q4$V)j-32fuKDJm0mp6lr_G=7k+p@@9Xp)|H?P6X* zv_SkPLR*^9def&8H1@ZhSQt4PYR%RLqg{6U+QOzbNy60;*%9i?0vizE$p+TLuU|tN zb-S?Fm3;Xge62`s`U2Q*U7N4vQp>|WnNt&Shs@lJBB`8my_p0EBp)FclsybT=@Ot; zQ0su!VO5Q3&cb*Xfk_6CErdvH#APi-lb600Yi3zNM^$F(x>7lQ4|?!x+6cDNk4i-@ zre2B$qaVP+pioKt;i{HT@&`W32Y`!2Z=_WjmNjCC;UhDrJC`SJ9qVyb-) zM=Z-DX4!)js5}<*b-vlWVN0$Lj#J!VV=D@+fBw3B$KiRynaLp0H$ zpM$ow`+T}jXh8%r(yCKl=OBmP;p~qNkt6m<$$$gYjZV!8RD}87goo9>^r_ywAzAP$ z2MwSO^=F>k+j#PYs#>%=!rxxhM0p&1FfNTqv*${O zAw;0onU3=D_R`UiX_P$^Sb^=SG1NU&@NH_P4}~96aNoes67j8Mee*~xVypKPDFhYeJE2-ND{FwwPGgp4hRXZ zt9@ z8Joi>DqpOS3l%L@cH-n0KFNqp;s%o_ciY`C;f$K)H6gMnvU&>-Cu`eSCMfiE?lA4| zKm~&$Q+idc#|HQ0FrapZgoXnReTvy^0wDsFPELcYoU**j=ZZvCwJLLS(Oy&I)6o)31mJxAw4tu6A?-$YS>RyRvvTzCka|5H(7v`(rVEphj6{p-# zWlJMi4~bLT@p$MNTNJ();7`ET4YGZT434_y*fQckFA!$S6`hkLInG@E)>$zn$8DPM zO+z74ya@_DU?-^w+1{N)MY1Dx6&3eG_*;cA2TH(P3;+j)5ot!BT895qgED0eaQ=?N zM|F!1V%n9XJcF4J8d_K6YXau`d@Su8L}o9yCB*>J@CKGH&63n)AFql5%jFwH@ltzK zM!0V%DvSi+koxltzOYW)o@Ct(dk1+gX;J*Vq$bEv9jG@ZjS3W|C z8Qf1;RlzLAGY?L$L~~K0MsGrs zco`F1oP3;jAt#wIdT;*v027?d0La7{C=O?V|H%Of3+Y}`b|(o7`#QfFan;d?A%wh! z682&%RUcL(%=1ca(V{l$b=yWt1M?9a-)Pd+oGyHO?Sktbs?DfsxN{bOdsFC%FT;#Z ztxCDWQv!=Q1*<;T2C85~-r+WyY_o!uDLl{*Ec$5P2DLorW;ZuJIg!$&SY_tzy-oIh z&2(V9xm-|hH+rI@q`jLUf&R^hPhV*X1}P{cGQ}?vBhM!lcW~tKnz0vZuuDa zvWn1QAv%qyS7Domh6tw;Z_W7?pVEmA+tZ5m#Yb^)OY3VS2c z$X7zr*c6ej8=YYI_&J@KPT|Y@kVKZ)dn6jvjFr_Iq{0VEMGE3UF^N{5FVC$fFGf-? zmfZDUaMpFYh}ohpiDHL% zZWcw$Gm-$f*kHL>f_`Q!qznuIRx|8cdfqaXH13KJ4i@{CWd0FDJWpe-_3o$>uIIDJ zcJA1slb2^gI5ERzjBd=2wBda96fJP;ZFjrv@00KMUbTi`uUti>-+F-#JWW^SXA;3dzBi}&Mvzy z9EFA!WI`z6eT4IlxKN#fa(hOukSNzK)1Rzq(_Hl9`P~y5Nm<0@=O8K^R`s>l{`DF- z?~1N=nr7YeHOrsw&l9{zvJRiMme=sxaPq)(G8HZNUlTWgm+Ij4F&U2y95gC#%jLHg z%pfs=_B(vdimQv6cM418?xq&4iuajS0ISA9K%Q*5Y{pNg=jaW6sB)MDm*iC3i0weI zj{gBW_Fy=3qsWthpi2KD1v^qnW%DVlotP(#9?jRvUN`baG}~AgKi5sxd&1Pb{Sj4T zMqZD$mOWjwYr`@zyrz_4nl}4_?T!>5Tn`u1#M}0c_@xOBd*Quxds(UvE4T=+OV+&|+lMIh~%AcVVX(VA2u6?HwBoqhiUK8a3ZA_^SVz&m$ z%^VtMPB6OAfrdSjA5fjf_T9c8fY-j2pGq(^yPucWnCdj;z-o1)$s%vc?knB*db4jM zT8#QGR&bl$C0hx%e>7e>l)i27Yahx^x<@*+acr!PRr=lXh#*}Xd)MRlUd@dGx;Asd zHosZEm!tM@+s;Dy7t(%+Z%lWV0MSMX(ERs6K6ab1v4Zld8ehK8C^-q%D9||P4&TaB zXKqyZVf6>}#e@?v+a2vbR7V-@H!yW7m6Bmc6!xTx7!iGM)>4)x9AChHb}}Ra zJ67NzC&LJGG8DgdGIo|a*3|X}cJ^BIH2OOBzjQWnlIF`osC_qt4^fh^Sy6+P{0_4G z(^XCuMhW7XVXUiss)Iln{!*%PZcWZg?lPlqt1Bp3+k^xZuY`Jh1Qm0jI&$Cm`$xVC zT#ah54uln5W&^-0qI;PaIE73D1$1*XPDUSBFTTCFUF=*U%x)TNkVjp{Qj7^N4X z9;@4+Vtql!qpDWR%l2tq2LHg2Dfo_eMM(LqB2*G9r9X}9<~%o_w+Z<~b7R#i&+B&zJWxzN?-Zf4tVmFKYOWm2&&O zu3yrsi#W4)laISvjd!i49SitaH#(cGQAPWdVv@(wYvm|-NDQa^R(2f7m|Oe~)YXNw zCXa^;*0qPqv#sWPX)Ue6Gky}x0Ab_$*r-g%!CzmzW+H6?x{VIrLO3ELm`Nuq7 zbxpIHRkZGI=YHvo1Ij#S8&=J-n)5xNdw)s~__7Sk>XWFpMqEc!gRjC9P5ZSw@qz|F zyfhG>r+R9`$xBe{BOYCv2Mv1gKklU*!dVAz=mMRf>>gdku}?=i)FkmAv(Q^%5|Nob z{G6dvT8BnS`(d5(Ed#{TamZ)GW7cf#(cfP<>t;;{HU)%iT`1S3_!WFBDX`mJvMV1h zq2vxY1{3jHjk-w7Qq?}Dx>QGpbt6*=e=Crfd&ooxJ4~o_c|75czo-mNpn9f|Jzox6 z)&36YlKUO1{g4PSpoG{u$iO&0cVYkZF;dTmQo2=*TYfUsN$|t+l)F05>Qcr3E1kNP) zmJ}2d41Ej;N$C`0xD><$@AY!SBLlhQgba=0i#FxEr?z4_b>^$Z&-N#J6V$&%=c3~W zk}g1|U1s6b$h9`z4=~zbOrz0C0EuOZ^#Z5;*Ifa2g;gdJr$qWe6eXI3?weI}Q*-j) z7!Fu-671`s^ysmx!Q>=%d3ZE}I9y}au?$7VCmT2#w<};rEKruQ$x1jxH&m7Po_VPa z@tFK6oGRYi*?jBSdY+@s>)jR?tCvnIKsU1)@4P!iJD5{eqH6*$*^0Sie8er_j}Q|p zm(~xCWo@LDYFR_}F@?L6f;kC4PMuhpRxHgN%SYFnUZB&V;G~|wWzk-frr+^^AzI!> z$&~i++vFJh@?v+hy63xkxb_17vzs9tRMx`)<*ST9h3r>u#=^i}=Qo{yR+AHh{R8s(6H}hn^8X(#WLG|7pEg~)aQIx5?fb8$ot&_5&Wc`@)T;Fij57$ ziQ{HjdN(b5%-$_T29EUsL)1S?DBi#V``ChIdhu3rsZyi%>nk+>i3m6RD1Yy5zJymf zL`+BrX9%@=Z$(YXrrE8(*DYxdah`IlD9w2>Lr_;iIrq~Dymk4gOXNB_^b*q`gdLLB z%n+D`=Zvi0w|OyY?>>uh9he;?SWXlgZ6r9oGVImvm$%7Qc9Jjzx9y^MszdF+v%kUo%tBQJVo3 za)Pr}CFgFJ*ZC7*qO7qe%%c1J2Guz9IUstj3ayTqK2sI1Jj&?wV%#e*r0!7gQPBJN z2(_A(K2h_-jL!`8$Y)>wVDbKuQ;3rU7f|AvnLyEFKkHf>VwhZus|h4{+j%BOSb+B^ zqDG!>j#AuGZb5k(QQ4FPWto&Ht4gPmwg!}bN{S%bfniBSgXvS);2Be6=@D^$eq|KkKKmugM!Crj; zhXK_QWYwUQ_MZp;`hWzW|LX`5aK!(|;hza^MFq(J&SU>a4*NevnW=^Z{vqIx0`o6X zpbiYk@!|a+QGZT)epepoPyc?w|8#1}px=MWz5jniV*DiX`+ti3YdZh`BOdD~@ysAa z{B*{D6;DU|Yry|5KwuJ*!cPUADKALehkpb9P;v0D0a{w1ndYyW@qZZuFL9aGAcooB z7+$Y_SqUvI`rlpI-N8J;48g!SK5b_RHS0kDz*}g38ajih}(I z2IKECK2NbG-2R~}&~W@`1|!@*FqnRq!GVsi0|9Cay1%uDAN)Tsn17dnKs11E@<%=X zrmMBL|G;4RT}G+-J*qgU4(orbM+U+_Fj#+=k@{8qlYlq?fa~#}?I8$Sw(|=E)Y4-6 zUB+Ie-bpPH0I&<{SUdQYc^nRCt1$6@f4r2V>J|u$wfuaAqjK}uM z05*_qaQ@9c@QczEFbI!I52#Q)hItf1X0f7y2pf0tnbh}~@X!_Gna`nk=m zqW*zl^t%kZt62sTZva56@;@0~(f`0O{$0k;3-SJX{dhtK`?an>%kqBjI{0%e_pgi( z#J^3*O(RAHPTYc`EZ)ngQ*i lKabb{DtQs)3jVa0-_{W1YmiX@a6oTV(AZ#<9%LSX{{neKCD{M~ literal 0 HcmV?d00001 diff --git a/core/src/test/resources/indices/bwc/repo-2.1.0.zip b/core/src/test/resources/indices/bwc/repo-2.1.0.zip new file mode 100644 index 0000000000000000000000000000000000000000..2f287ea3481782bf1690ac0b36eb4a150e8bba62 GIT binary patch literal 81795 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

-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

Ew9RAL(&u6>@QCG$Pi9P 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

aF4(;!{=YZL=Lxnq~Gjx#Lb#8_8+Z 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 literal 0 HcmV?d00001 From 5750581175bb395fca43c9924cada74adce8381c Mon Sep 17 00:00:00 2001 From: Clinton Gormley Date: Tue, 24 Nov 2015 20:10:56 +0100 Subject: [PATCH 13/22] The RPM upload script should keep other existing RPM versions available --- dev-tools/prepare_release_candidate.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dev-tools/prepare_release_candidate.py b/dev-tools/prepare_release_candidate.py index d3a3e178961..31b07043389 100644 --- a/dev-tools/prepare_release_candidate.py +++ b/dev-tools/prepare_release_candidate.py @@ -356,7 +356,7 @@ if __name__ == "__main__": debs3_list_cmd = 'deb-s3 list -b %s --prefix %s' % (bucket, debs3_prefix) debs3_verify_cmd = 'deb-s3 verify -b %s --prefix %s' % (bucket, debs3_prefix) rpms3_prefix = 'elasticsearch/staging/%s-%s/repos/%s/centos' % (release_version, shortHash, package_repo_version) - rpms3_upload_cmd = 'rpm-s3 -v -b %s -p %s --sign --visibility public-read -k 0 %s' % (bucket, rpms3_prefix, rpm) + rpms3_upload_cmd = 'rpm-s3 -v -b %s -p %s --sign --visibility public-read -k 100 %s' % (bucket, rpms3_prefix, rpm) if deploy_s3: run(s3cmd_sync_to_staging_bucket_cmd) From 5fe3ce89e0e469d567538d63c5d1ad0541d5b1e1 Mon Sep 17 00:00:00 2001 From: Adrien Grand Date: Tue, 24 Nov 2015 20:40:02 +0100 Subject: [PATCH 14/22] Check that the declared versions match the backward indices. --- .../main/java/org/elasticsearch/Version.java | 6 +++--- .../OldIndexBackwardsCompatibilityIT.java | 20 +++++++++++++++++-- 2 files changed, 21 insertions(+), 5 deletions(-) diff --git a/core/src/main/java/org/elasticsearch/Version.java b/core/src/main/java/org/elasticsearch/Version.java index ca235d53fba..4e4ec3b614f 100644 --- a/core/src/main/java/org/elasticsearch/Version.java +++ b/core/src/main/java/org/elasticsearch/Version.java @@ -270,11 +270,11 @@ public class Version { public static final int V_2_0_2_ID = 2000299; public static final Version V_2_0_2 = new Version(V_2_0_2_ID, true, org.apache.lucene.util.Version.LUCENE_5_2_1); public static final int V_2_1_0_ID = 2010099; - public static final Version V_2_1_0 = new Version(V_2_1_0_ID, false, org.apache.lucene.util.Version.LUCENE_5_3_0); + public static final Version V_2_1_0 = new Version(V_2_1_0_ID, false, org.apache.lucene.util.Version.LUCENE_5_3_1); public static final int V_2_1_1_ID = 2010199; - public static final Version V_2_1_1 = new Version(V_2_1_1_ID, true, org.apache.lucene.util.Version.LUCENE_5_3_0); + public static final Version V_2_1_1 = new Version(V_2_1_1_ID, true, org.apache.lucene.util.Version.LUCENE_5_3_1); public static final int V_2_2_0_ID = 2020099; - public static final Version V_2_2_0 = new Version(V_2_2_0_ID, true, org.apache.lucene.util.Version.LUCENE_5_3_0); + public static final Version V_2_2_0 = new Version(V_2_2_0_ID, true, org.apache.lucene.util.Version.LUCENE_5_4_0); public static final int V_3_0_0_ID = 3000099; public static final Version V_3_0_0 = new Version(V_3_0_0_ID, true, org.apache.lucene.util.Version.LUCENE_5_4_0); public static final Version CURRENT = V_3_0_0; diff --git a/core/src/test/java/org/elasticsearch/bwcompat/OldIndexBackwardsCompatibilityIT.java b/core/src/test/java/org/elasticsearch/bwcompat/OldIndexBackwardsCompatibilityIT.java index 6459cc4f306..b72c0998898 100644 --- a/core/src/test/java/org/elasticsearch/bwcompat/OldIndexBackwardsCompatibilityIT.java +++ b/core/src/test/java/org/elasticsearch/bwcompat/OldIndexBackwardsCompatibilityIT.java @@ -24,6 +24,10 @@ import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.TestUtil; import org.elasticsearch.Version; import org.elasticsearch.action.admin.indices.get.GetIndexResponse; +import org.elasticsearch.action.admin.indices.segments.IndexSegments; +import org.elasticsearch.action.admin.indices.segments.IndexShardSegments; +import org.elasticsearch.action.admin.indices.segments.IndicesSegmentResponse; +import org.elasticsearch.action.admin.indices.segments.ShardSegments; import org.elasticsearch.action.admin.indices.upgrade.UpgradeIT; import org.elasticsearch.action.get.GetResponse; import org.elasticsearch.action.search.SearchRequestBuilder; @@ -38,6 +42,7 @@ import org.elasticsearch.common.util.MultiDataPathUpgrader; import org.elasticsearch.common.xcontent.XContentHelper; import org.elasticsearch.env.NodeEnvironment; import org.elasticsearch.index.engine.EngineConfig; +import org.elasticsearch.index.engine.Segment; import org.elasticsearch.index.mapper.string.StringFieldMapperPositionIncrementGapTests; import org.elasticsearch.index.query.QueryBuilders; import org.elasticsearch.index.shard.MergePolicyConfig; @@ -319,7 +324,7 @@ public class OldIndexBackwardsCompatibilityIT extends ESIntegTestCase { Version version = extractVersion(index); String indexName = loadIndex(index); importIndex(indexName); - assertIndexSanity(indexName); + assertIndexSanity(indexName, version); assertBasicSearchWorks(indexName); assertBasicAggregationWorks(indexName); assertRealtimeGetWorks(indexName); @@ -339,11 +344,22 @@ public class OldIndexBackwardsCompatibilityIT extends ESIntegTestCase { version.luceneVersion.minor == Version.CURRENT.luceneVersion.minor; } - void assertIndexSanity(String indexName) { + void assertIndexSanity(String indexName, Version indexCreated) { GetIndexResponse getIndexResponse = client().admin().indices().prepareGetIndex().addIndices(indexName).get(); assertEquals(1, getIndexResponse.indices().length); assertEquals(indexName, getIndexResponse.indices()[0]); + Version actualVersionCreated = Version.indexCreated(getIndexResponse.getSettings().get(indexName)); + assertEquals(indexCreated, actualVersionCreated); ensureYellow(indexName); + IndicesSegmentResponse segmentsResponse = client().admin().indices().prepareSegments(indexName).get(); + IndexSegments segments = segmentsResponse.getIndices().get(indexName); + for (IndexShardSegments indexShardSegments : segments) { + for (ShardSegments shardSegments : indexShardSegments) { + for (Segment segment : shardSegments) { + assertEquals(indexCreated.luceneVersion, segment.version); + } + } + } SearchResponse test = client().prepareSearch(indexName).get(); assertThat(test.getHits().getTotalHits(), greaterThanOrEqualTo(1l)); } From 1e0f9292812b2ffcb1279c6465f0c1150edfb561 Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Tue, 24 Nov 2015 12:34:15 -0800 Subject: [PATCH 15/22] Build: Simplify adding plugins that are another project in the build The current mechanism for adding plugins to the integTest cluster is to have a FileCollection. This works well for the integTests for a single plugin, which automatically adds itself to be installed. However, for qa tests where many plugins may be installed, and from other projects, it is cumbersome to add configurations, dependencies and dependsOn statements over and over. This simplifies installing a plugin from another project by moving this common setup into the cluster configuration code. --- .../gradle/test/ClusterConfiguration.groovy | 8 +++- .../gradle/test/ClusterFormationTasks.groovy | 43 ++++++++++++++++--- .../gradle/test/RestIntegTestTask.groovy | 4 +- qa/smoke-test-plugins/build.gradle | 5 +-- 4 files changed, 49 insertions(+), 11 deletions(-) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy index a6b59e58bf9..202d20c81a9 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy @@ -18,6 +18,7 @@ */ package org.elasticsearch.gradle.test +import org.gradle.api.Project import org.gradle.api.file.FileCollection import org.gradle.api.tasks.Input @@ -64,7 +65,7 @@ class ClusterConfiguration { Map settings = new HashMap<>() - LinkedHashMap plugins = new LinkedHashMap<>() + LinkedHashMap plugins = new LinkedHashMap<>() LinkedHashMap setupCommands = new LinkedHashMap<>() @@ -83,6 +84,11 @@ class ClusterConfiguration { plugins.put(name, file) } + @Input + void plugin(String name, Project pluginProject) { + plugins.put(name, pluginProject) + } + @Input void setupCommand(String name, Object... args) { setupCommands.put(name, args) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy index 43b9f8af3a7..9bcfd5f8660 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy @@ -21,7 +21,9 @@ package org.elasticsearch.gradle.test import org.apache.tools.ant.DefaultLogger import org.apache.tools.ant.taskdefs.condition.Os import org.elasticsearch.gradle.VersionProperties +import org.elasticsearch.gradle.plugin.PluginBuildPlugin import org.gradle.api.* +import org.gradle.api.artifacts.Configuration import org.gradle.api.file.FileCollection import org.gradle.api.logging.Logger import org.gradle.api.tasks.Copy @@ -102,14 +104,11 @@ class ClusterFormationTasks { setup = configureCopyPluginsTask(taskName(task, node, 'copyPlugins'), project, setup, node) // install plugins - for (Map.Entry plugin : node.config.plugins.entrySet()) { + for (Map.Entry plugin : node.config.plugins.entrySet()) { // replace every dash followed by a character with just the uppercase character String camelName = plugin.getKey().replaceAll(/-(\w)/) { _, c -> c.toUpperCase(Locale.ROOT) } String actionName = "install${camelName[0].toUpperCase(Locale.ROOT) + camelName.substring(1)}Plugin" - // delay reading the file location until execution time by wrapping in a closure within a GString - String file = "${-> new File(node.pluginsTmpDir, plugin.getValue().singleFile.getName()).toURI().toURL().toString()}" - Object[] args = [new File(node.homeDir, 'bin/plugin'), 'install', file] - setup = configureExecTask(taskName(task, node, actionName), project, setup, node, args) + setup = configureInstallPluginTask(taskName(task, node, actionName), project, setup, node, plugin.getValue()) } // extra setup commands @@ -183,12 +182,44 @@ class ClusterFormationTasks { return setup } + List pluginFiles = [] + for (Object plugin : node.config.plugins.values()) { + if (plugin instanceof Project) { + Project pluginProject = plugin + if (pluginProject.plugins.hasPlugin(PluginBuildPlugin) == false) { + throw new GradleException("Task ${name} cannot project ${pluginProject.path} which is not an esplugin") + } + String configurationName = "_plugin_${pluginProject.path}" + Configuration configuration = project.configurations.findByName(configurationName) + if (configuration == null) { + configuration = project.configurations.create(configurationName) + } + project.dependencies.add(configurationName, pluginProject) + setup.dependsOn(pluginProject.tasks.bundlePlugin) + plugin = configuration + } + pluginFiles.add(plugin) + } + return project.tasks.create(name: name, type: Copy, dependsOn: setup) { into node.pluginsTmpDir - from(node.config.plugins.values()) + from(pluginFiles) } } + static Task configureInstallPluginTask(String name, Project project, Task setup, NodeInfo node, Object plugin) { + FileCollection pluginZip + if (plugin instanceof Project) { + pluginZip = project.configurations.getByName("_plugin_${plugin.path}") + } else { + pluginZip = plugin + } + // delay reading the file location until execution time by wrapping in a closure within a GString + String file = "${-> new File(node.pluginsTmpDir, pluginZip.singleFile.getName()).toURI().toURL().toString()}" + Object[] args = [new File(node.homeDir, 'bin/plugin'), 'install', file] + return configureExecTask(name, project, setup, node, args) + } + /** Adds a task to execute a command to help setup the cluster */ static Task configureExecTask(String name, Project project, Task setup, NodeInfo node, Object[] execArgs) { return project.tasks.create(name: name, type: Exec, dependsOn: setup) { diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy index 7a3d067baab..47cbdd5cb48 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy @@ -67,7 +67,9 @@ class RestIntegTestTask extends RandomizedTestingTask { } RestIntegTestTask() { - project.afterEvaluate { + // this must run after all projects have been configured, so we know any project + // references can be accessed as a fully configured + project.gradle.projectsEvaluated { Task test = project.tasks.findByName('test') if (test != null) { mustRunAfter(test) diff --git a/qa/smoke-test-plugins/build.gradle b/qa/smoke-test-plugins/build.gradle index d93594bd6dc..864a58baf25 100644 --- a/qa/smoke-test-plugins/build.gradle +++ b/qa/smoke-test-plugins/build.gradle @@ -25,10 +25,9 @@ ext.pluginCount = 0 for (Project subproj : project.rootProject.subprojects) { if (subproj.path.startsWith(':plugins:')) { integTest { - def bundlePlugin = subproj.tasks.findByName('bundlePlugin') - dependsOn bundlePlugin cluster { - plugin subproj.name, bundlePlugin.outputs.files + // need to get a non-decorated project object, so must re-lookup the project by path + plugin subproj.name, project(subproj.path) } } pluginCount += 1 From 3a77d993fd30f35ffbe33f33ac3ea68f1b3b8df1 Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Tue, 24 Nov 2015 14:34:21 -0800 Subject: [PATCH 16/22] Build: Copy rest specs for plugins that are added to integ test cluster This change allows having rest tests using the api spec of plugins that the rest test is testing against. --- .../gradle/test/ClusterFormationTasks.groovy | 51 ++++++++++++++----- 1 file changed, 38 insertions(+), 13 deletions(-) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy index 9bcfd5f8660..51d6ee7b4b8 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy @@ -105,9 +105,7 @@ class ClusterFormationTasks { // install plugins for (Map.Entry plugin : node.config.plugins.entrySet()) { - // replace every dash followed by a character with just the uppercase character - String camelName = plugin.getKey().replaceAll(/-(\w)/) { _, c -> c.toUpperCase(Locale.ROOT) } - String actionName = "install${camelName[0].toUpperCase(Locale.ROOT) + camelName.substring(1)}Plugin" + String actionName = pluginTaskName('install', plugin.getKey(), 'Plugin') setup = configureInstallPluginTask(taskName(task, node, actionName), project, setup, node, plugin.getValue()) } @@ -176,16 +174,23 @@ class ClusterFormationTasks { } } - /** Adds a task to copy plugins to a temp dir, which they will later be installed from. */ + /** + * Adds a task to copy plugins to a temp dir, which they will later be installed from. + * + * For each plugin, if the plugin has rest spec apis in its tests, those api files are also copied + * to the test resources for this project. + */ static Task configureCopyPluginsTask(String name, Project project, Task setup, NodeInfo node) { if (node.config.plugins.isEmpty()) { return setup } + Copy copyPlugins = project.tasks.create(name: name, type: Copy, dependsOn: setup) List pluginFiles = [] - for (Object plugin : node.config.plugins.values()) { - if (plugin instanceof Project) { - Project pluginProject = plugin + for (Map.Entry plugin : node.config.plugins.entrySet()) { + FileCollection pluginZip + if (plugin.getValue() instanceof Project) { + Project pluginProject = plugin.getValue() if (pluginProject.plugins.hasPlugin(PluginBuildPlugin) == false) { throw new GradleException("Task ${name} cannot project ${pluginProject.path} which is not an esplugin") } @@ -196,15 +201,29 @@ class ClusterFormationTasks { } project.dependencies.add(configurationName, pluginProject) setup.dependsOn(pluginProject.tasks.bundlePlugin) - plugin = configuration + pluginZip = configuration + + // also allow rest tests to use the rest spec from the plugin + Copy copyRestSpec = null + for (File resourceDir : pluginProject.sourceSets.test.resources.srcDirs) { + File restApiDir = new File(resourceDir, 'rest-api-spec/api') + if (restApiDir.exists() == false) continue + if (copyRestSpec == null) { + copyRestSpec = project.tasks.create(name: pluginTaskName('copy', plugin.getKey(), 'PluginRestSpec'), type: Copy) + copyPlugins.dependsOn(copyRestSpec) + copyRestSpec.into(project.sourceSets.test.output.resourcesDir) + } + copyRestSpec.from(resourceDir).include('rest-api-spec/api/**') + } + } else { + pluginZip = plugin.getValue() } - pluginFiles.add(plugin) + pluginFiles.add(pluginZip) } - return project.tasks.create(name: name, type: Copy, dependsOn: setup) { - into node.pluginsTmpDir - from(pluginFiles) - } + copyPlugins.into(node.pluginsTmpDir) + copyPlugins.from(pluginFiles) + return copyPlugins } static Task configureInstallPluginTask(String name, Project project, Task setup, NodeInfo node, Object plugin) { @@ -449,6 +468,12 @@ class ClusterFormationTasks { } } + static String pluginTaskName(String action, String name, String suffix) { + // replace every dash followed by a character with just the uppercase character + String camelName = name.replaceAll(/-(\w)/) { _, c -> c.toUpperCase(Locale.ROOT) } + return action + camelName[0].toUpperCase(Locale.ROOT) + camelName.substring(1) + suffix + } + /** Runs an ant command, sending output to the given out and error streams */ static Object runAntCommand(Project project, Closure command, PrintStream outputStream, PrintStream errorStream) { DefaultLogger listener = new DefaultLogger( From 7b0a0ce0d9f757d65906d33a6fcf3c10d8633b71 Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Tue, 24 Nov 2015 15:19:51 -0800 Subject: [PATCH 17/22] Build: Add ability to specify extra configuration files for integ test This change allows copy extra files into the integ test cluster before it runs. However, it explicitly forbids overwriting elasticsearch.yml, since that is generated. --- .../gradle/test/ClusterConfiguration.groovy | 16 ++++++++++++++++ .../gradle/test/ClusterFormationTasks.groovy | 9 ++++++++- 2 files changed, 24 insertions(+), 1 deletion(-) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy index 202d20c81a9..79a199e98e4 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterConfiguration.groovy @@ -18,6 +18,7 @@ */ package org.elasticsearch.gradle.test +import org.gradle.api.GradleException import org.gradle.api.Project import org.gradle.api.file.FileCollection import org.gradle.api.tasks.Input @@ -65,6 +66,9 @@ class ClusterConfiguration { Map settings = new HashMap<>() + // map from destination path, to source file + Map extraConfigFiles = new HashMap<>() + LinkedHashMap plugins = new LinkedHashMap<>() LinkedHashMap setupCommands = new LinkedHashMap<>() @@ -93,4 +97,16 @@ class ClusterConfiguration { void setupCommand(String name, Object... args) { setupCommands.put(name, args) } + + /** + * Add an extra configuration file. The path is relative to the config dir, and the sourceFile + * is anything accepted by project.file() + */ + @Input + void extraConfigFile(String path, Object sourceFile) { + if (path == 'elasticsearch.yml') { + throw new GradleException('Overwriting elasticsearch.yml is not allowed, add additional settings using cluster { setting "foo", "bar" }') + } + extraConfigFiles.put(path, sourceFile) + } } diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy index 51d6ee7b4b8..fe92d9cdcfe 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy @@ -167,7 +167,14 @@ class ClusterFormationTasks { 'repositories.url.allowed_urls' : 'http://snapshot.test*' ] - return project.tasks.create(name: name, type: DefaultTask, dependsOn: setup) << { + Copy copyConfig = project.tasks.create(name: name, type: Copy, dependsOn: setup) + copyConfig.into(new File(node.homeDir, 'config')) // copy must always have a general dest dir, even though we don't use it + for (Map.Entry extraConfigFile : node.config.extraConfigFiles.entrySet()) { + copyConfig.from(extraConfigFile.getValue()) + .into(new File(node.homeDir, 'config/' + extraConfigFile.getKey())) + } + copyConfig.doLast { + // write elasticsearch.yml last, it cannot be overriden File configFile = new File(node.homeDir, 'config/elasticsearch.yml') logger.info("Configuring ${configFile}") configFile.setText(esConfig.collect { key, value -> "${key}: ${value}" }.join('\n'), 'UTF-8') From 84d6cbd32aa3a4c87188aa51b5c85e8fd8d4b9e8 Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Tue, 24 Nov 2015 15:59:54 -0800 Subject: [PATCH 18/22] Build: Fix extra config to create a file, not a directory for the destination file Also added some checks to catch misconfiguration (dir or non existing file). --- .../gradle/test/ClusterFormationTasks.groovy | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy index fe92d9cdcfe..c2dbc077ea4 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy @@ -170,8 +170,17 @@ class ClusterFormationTasks { Copy copyConfig = project.tasks.create(name: name, type: Copy, dependsOn: setup) copyConfig.into(new File(node.homeDir, 'config')) // copy must always have a general dest dir, even though we don't use it for (Map.Entry extraConfigFile : node.config.extraConfigFiles.entrySet()) { - copyConfig.from(extraConfigFile.getValue()) - .into(new File(node.homeDir, 'config/' + extraConfigFile.getKey())) + File srcConfigFile = project.file(extraConfigFile.getValue()) + if (srcConfigFile.isDirectory()) { + throw new GradleException("Source for extraConfigFile must be a file: ${srcConfigFile}") + } + if (srcConfigFile.exists() == false) { + throw new GradleException("Source file for extraConfigFile does not exist: ${srcConfigFile}") + } + File destConfigFile = new File(node.homeDir, 'config/' + extraConfigFile.getKey()) + copyConfig.from(srcConfigFile) + .into(destConfigFile.canonicalFile.parentFile) + .rename { destConfigFile.name } } copyConfig.doLast { // write elasticsearch.yml last, it cannot be overriden From d6969fcf3ab448b8a435d079aa41c2a1db98fcc5 Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Tue, 24 Nov 2015 16:37:32 -0800 Subject: [PATCH 19/22] Build: Split extra config files for integ test into separate task This doesn't work when there are no extra config files, since gradle sees the copy task and says "there is nothing to do". --- .../gradle/test/ClusterFormationTasks.groovy | 25 +++++++++++++------ 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy index c2dbc077ea4..c5c57057f02 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/test/ClusterFormationTasks.groovy @@ -101,6 +101,7 @@ class ClusterFormationTasks { setup = configureStopTask(taskName(task, node, 'stopPrevious'), project, setup, node) setup = configureExtractTask(taskName(task, node, 'extract'), project, setup, node) setup = configureWriteConfigTask(taskName(task, node, 'configure'), project, setup, node) + setup = configureExtraConfigFilesTask(taskName(task, node, 'extraConfig'), project, setup, node) setup = configureCopyPluginsTask(taskName(task, node, 'copyPlugins'), project, setup, node) // install plugins @@ -166,7 +167,20 @@ class ClusterFormationTasks { 'node.testattr' : 'test', 'repositories.url.allowed_urls' : 'http://snapshot.test*' ] + esConfig.putAll(node.config.settings) + Task writeConfig = project.tasks.create(name: name, type: DefaultTask, dependsOn: setup) + writeConfig.doFirst { + File configFile = new File(node.homeDir, 'config/elasticsearch.yml') + logger.info("Configuring ${configFile}") + configFile.setText(esConfig.collect { key, value -> "${key}: ${value}" }.join('\n'), 'UTF-8') + } + } + + static Task configureExtraConfigFilesTask(String name, Project project, Task setup, NodeInfo node) { + if (node.config.extraConfigFiles.isEmpty()) { + return setup + } Copy copyConfig = project.tasks.create(name: name, type: Copy, dependsOn: setup) copyConfig.into(new File(node.homeDir, 'config')) // copy must always have a general dest dir, even though we don't use it for (Map.Entry extraConfigFile : node.config.extraConfigFiles.entrySet()) { @@ -179,15 +193,10 @@ class ClusterFormationTasks { } File destConfigFile = new File(node.homeDir, 'config/' + extraConfigFile.getKey()) copyConfig.from(srcConfigFile) - .into(destConfigFile.canonicalFile.parentFile) - .rename { destConfigFile.name } - } - copyConfig.doLast { - // write elasticsearch.yml last, it cannot be overriden - File configFile = new File(node.homeDir, 'config/elasticsearch.yml') - logger.info("Configuring ${configFile}") - configFile.setText(esConfig.collect { key, value -> "${key}: ${value}" }.join('\n'), 'UTF-8') + .into(destConfigFile.canonicalFile.parentFile) + .rename { destConfigFile.name } } + return copyConfig } /** From b6da075505e656e0944807b0025af68a32eb61ed Mon Sep 17 00:00:00 2001 From: Jason Tedor Date: Tue, 24 Nov 2015 22:57:08 -0500 Subject: [PATCH 20/22] Fix typo in TTL field docs Closes #14994 --- docs/reference/mapping/fields/ttl-field.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/reference/mapping/fields/ttl-field.asciidoc b/docs/reference/mapping/fields/ttl-field.asciidoc index 07ce8a86b9e..d81582c9078 100644 --- a/docs/reference/mapping/fields/ttl-field.asciidoc +++ b/docs/reference/mapping/fields/ttl-field.asciidoc @@ -62,7 +62,7 @@ PUT my_index "my_type": { "_ttl": { "enabled": true, - "defaut": "5m" + "default": "5m" } } } From 1f94448e922c90205047abfd0f2a98b75c3d1585 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christoph=20B=C3=BCscher?= Date: Tue, 17 Nov 2015 21:42:43 +0100 Subject: [PATCH 21/22] Making EnvelopeBuilder writable and adding equals/hashCode --- .../common/geo/builders/CircleBuilder.java | 6 +- .../common/geo/builders/EnvelopeBuilder.java | 41 ++++++++++++ .../common/geo/builders/PointBuilder.java | 2 +- .../common/geo/builders/ShapeBuilder.java | 4 +- .../AbstractShapeBuilderTestCase.java | 43 +++++++----- .../geo/builders/EnvelopeBuilderTests.java | 66 +++++++++++++++++++ 6 files changed, 140 insertions(+), 22 deletions(-) create mode 100644 core/src/test/java/org/elasticsearch/common/geo/builders/EnvelopeBuilderTests.java diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java index c65b278c3c1..5f11d12a4bf 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java @@ -171,7 +171,9 @@ public class CircleBuilder extends ShapeBuilder { } @Override - public ShapeBuilder readFrom(StreamInput in) throws IOException { - return new CircleBuilder().center(readCoordinateFrom(in)).radius(in.readDouble(), DistanceUnit.readDistanceUnit(in)); + public CircleBuilder readFrom(StreamInput in) throws IOException { + return new CircleBuilder() + .center(readCoordinateFrom(in)) + .radius(in.readDouble(), DistanceUnit.readDistanceUnit(in)); } } diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java index 9acfdd2580e..62f29d2bad7 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java @@ -21,13 +21,19 @@ package org.elasticsearch.common.geo.builders; import com.spatial4j.core.shape.Rectangle; import com.vividsolutions.jts.geom.Coordinate; + +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentBuilder; import java.io.IOException; +import java.util.Locale; +import java.util.Objects; public class EnvelopeBuilder extends ShapeBuilder { public static final GeoShapeType TYPE = GeoShapeType.ENVELOPE; + public static final EnvelopeBuilder PROTOTYPE = new EnvelopeBuilder(); protected Coordinate topLeft; protected Coordinate bottomRight; @@ -62,6 +68,7 @@ public class EnvelopeBuilder extends ShapeBuilder { public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); builder.field(FIELD_TYPE, TYPE.shapeName()); + builder.field(FIELD_ORIENTATION, orientation.name().toLowerCase(Locale.ROOT)); builder.startArray(FIELD_COORDINATES); toXContent(builder, topLeft); toXContent(builder, bottomRight); @@ -78,4 +85,38 @@ public class EnvelopeBuilder extends ShapeBuilder { public GeoShapeType type() { return TYPE; } + + @Override + public int hashCode() { + return Objects.hash(orientation, topLeft, bottomRight); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null || getClass() != obj.getClass()) { + return false; + } + EnvelopeBuilder other = (EnvelopeBuilder) obj; + return Objects.equals(orientation, other.orientation) && + Objects.equals(topLeft, other.topLeft) && + Objects.equals(bottomRight, other.bottomRight); + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + out.writeBoolean(orientation == Orientation.RIGHT); + writeCoordinateTo(topLeft, out); + writeCoordinateTo(bottomRight, out); + } + + @Override + public EnvelopeBuilder readFrom(StreamInput in) throws IOException { + Orientation orientation = in.readBoolean() ? Orientation.RIGHT : Orientation.LEFT; + return new EnvelopeBuilder(orientation) + .topLeft(readCoordinateFrom(in)) + .bottomRight(readCoordinateFrom(in)); + } } diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java index 127124e599c..d6d62c28b8c 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/PointBuilder.java @@ -92,7 +92,7 @@ public class PointBuilder extends ShapeBuilder { } @Override - public ShapeBuilder readFrom(StreamInput in) throws IOException { + public PointBuilder readFrom(StreamInput in) throws IOException { return new PointBuilder().coordinate(readCoordinateFrom(in)); } } diff --git a/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java b/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java index 2c9f5b4f9bc..7f153a9197f 100644 --- a/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java +++ b/core/src/main/java/org/elasticsearch/common/geo/builders/ShapeBuilder.java @@ -843,13 +843,15 @@ public abstract class ShapeBuilder extends ToXContentToBytes implements NamedWri @Override public String getWriteableName() { - return type().shapename; + return type().shapeName(); } + // NORELEASE this should be deleted as soon as all shape builders implement writable @Override public void writeTo(StreamOutput out) throws IOException { } + // NORELEASE this should be deleted as soon as all shape builders implement writable @Override public ShapeBuilder readFrom(StreamInput in) throws IOException { return null; diff --git a/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java b/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java index f585215f9bd..d1f24bfb7d9 100644 --- a/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java +++ b/core/src/test/java/org/elasticsearch/common/geo/builders/AbstractShapeBuilderTestCase.java @@ -25,6 +25,7 @@ import org.elasticsearch.common.io.stream.NamedWriteableRegistry; import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.xcontent.*; import org.elasticsearch.test.ESTestCase; +import org.junit.AfterClass; import org.junit.BeforeClass; import java.io.IOException; @@ -34,36 +35,47 @@ import static org.hamcrest.Matchers.*; public abstract class AbstractShapeBuilderTestCase extends ESTestCase { private static final int NUMBER_OF_TESTBUILDERS = 20; - private static final NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(); + private static NamedWriteableRegistry namedWriteableRegistry; /** - * Setup for the whole base test class. + * setup for the whole base test class */ @BeforeClass public static void init() { - namedWriteableRegistry.registerPrototype(ShapeBuilder.class, PointBuilder.PROTOTYPE); - namedWriteableRegistry.registerPrototype(ShapeBuilder.class, CircleBuilder.PROTOTYPE); + if (namedWriteableRegistry == null) { + namedWriteableRegistry = new NamedWriteableRegistry(); + namedWriteableRegistry.registerPrototype(ShapeBuilder.class, PointBuilder.PROTOTYPE); + namedWriteableRegistry.registerPrototype(ShapeBuilder.class, CircleBuilder.PROTOTYPE); + namedWriteableRegistry.registerPrototype(ShapeBuilder.class, EnvelopeBuilder.PROTOTYPE); + } + } + + @AfterClass + public static void afterClass() throws Exception { + namedWriteableRegistry = null; } /** - * Create the shape that under test + * create random shape that is put under test */ protected abstract SB createTestShapeBuilder(); /** - * mutate the given query so the returned query is different + * mutate the given shape so the returned shape is different */ protected abstract SB mutate(SB original) throws IOException; /** - * Generic test that creates new shape from a random test shape and checks both for equality + * Test that creates new shape from a random test shape and checks both for equality */ public void testFromXContent() throws IOException { for (int runs = 0; runs < NUMBER_OF_TESTBUILDERS; runs++) { SB testShape = createTestShapeBuilder(); - XContentBuilder builder = toXContent(testShape, randomFrom(XContentType.values())); - builder = toXContent(testShape, randomFrom(XContentType.values())); - + XContentBuilder contentBuilder = XContentFactory.contentBuilder(randomFrom(XContentType.values())); + if (randomBoolean()) { + contentBuilder.prettyPrint(); + } + XContentBuilder builder = testShape.toXContent(contentBuilder, ToXContent.EMPTY_PARAMS); XContentParser shapeParser = XContentHelper.createParser(builder.bytes()); XContentHelper.createParser(builder.bytes()); shapeParser.nextToken(); @@ -74,14 +86,6 @@ public abstract class AbstractShapeBuilderTestCase exte } } - protected static XContentBuilder toXContent(ShapeBuilder shape, XContentType contentType) throws IOException { - XContentBuilder builder = XContentFactory.contentBuilder(contentType); - if (randomBoolean()) { - builder.prettyPrint(); - } - return shape.toXContent(builder, ToXContent.EMPTY_PARAMS); - } - /** * Test serialization and deserialization of the test shape. */ @@ -95,6 +99,9 @@ public abstract class AbstractShapeBuilderTestCase exte } } + /** + * Test equality and hashCode properties + */ public void testEqualsAndHashcode() throws IOException { for (int runs = 0; runs < NUMBER_OF_TESTBUILDERS; runs++) { SB firstShape = createTestShapeBuilder(); diff --git a/core/src/test/java/org/elasticsearch/common/geo/builders/EnvelopeBuilderTests.java b/core/src/test/java/org/elasticsearch/common/geo/builders/EnvelopeBuilderTests.java new file mode 100644 index 00000000000..e6f3db2f8af --- /dev/null +++ b/core/src/test/java/org/elasticsearch/common/geo/builders/EnvelopeBuilderTests.java @@ -0,0 +1,66 @@ +/* + * 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.common.geo.builders; + +import com.spatial4j.core.shape.Rectangle; +import com.vividsolutions.jts.geom.Coordinate; + +import org.elasticsearch.common.geo.builders.ShapeBuilder.Orientation; +import org.elasticsearch.test.geo.RandomShapeGenerator; + +import java.io.IOException; + +public class EnvelopeBuilderTests extends AbstractShapeBuilderTestCase { + + @Override + protected EnvelopeBuilder createTestShapeBuilder() { + EnvelopeBuilder envelope = new EnvelopeBuilder(randomFrom(Orientation.values())); + Rectangle box = RandomShapeGenerator.xRandomRectangle(getRandom(), RandomShapeGenerator.xRandomPoint(getRandom())); + envelope.topLeft(box.getMinX(), box.getMaxY()) + .bottomRight(box.getMaxX(), box.getMinY()); + return envelope; + } + + @Override + protected EnvelopeBuilder mutate(EnvelopeBuilder original) throws IOException { + EnvelopeBuilder mutation = copyShape(original); + if (randomBoolean()) { + // toggle orientation + mutation.orientation = (original.orientation == Orientation.LEFT ? Orientation.RIGHT : Orientation.LEFT); + } else { + // move one corner to the middle of original + switch (randomIntBetween(0, 3)) { + case 0: + mutation.topLeft(new Coordinate(randomDoubleBetween(-180.0, original.bottomRight.x, true), original.topLeft.y)); + break; + case 1: + mutation.topLeft(new Coordinate(original.topLeft.x, randomDoubleBetween(original.bottomRight.y, 90.0, true))); + break; + case 2: + mutation.bottomRight(new Coordinate(randomDoubleBetween(original.topLeft.x, 180.0, true), original.bottomRight.y)); + break; + case 3: + mutation.bottomRight(new Coordinate(original.bottomRight.x, randomDoubleBetween(-90.0, original.topLeft.y, true))); + break; + } + } + return mutation; + } +} From e8520bf5194bb3e346b74a0f62fe07c48fdbd428 Mon Sep 17 00:00:00 2001 From: Adrien Grand Date: Wed, 25 Nov 2015 11:46:19 +0100 Subject: [PATCH 22/22] Tests: For single data path for *FieldMapperUpgradeTests. --- .../mapper/murmur3/Murmur3FieldMapperUpgradeTests.java | 9 +++++++-- .../index/mapper/size/SizeFieldMapperUpgradeTests.java | 9 +++++++-- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java b/plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java index 8ede994e2f4..290280b9101 100644 --- a/plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java +++ b/plugins/mapper-murmur3/src/test/java/org/elasticsearch/index/mapper/murmur3/Murmur3FieldMapperUpgradeTests.java @@ -22,6 +22,7 @@ package org.elasticsearch.index.mapper.murmur3; import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.TestUtil; import org.elasticsearch.action.search.SearchResponse; +import org.elasticsearch.common.settings.Settings; import org.elasticsearch.env.NodeEnvironment; import org.elasticsearch.plugin.mapper.MapperMurmur3Plugin; import org.elasticsearch.plugins.Plugin; @@ -56,10 +57,14 @@ public class Murmur3FieldMapperUpgradeTests extends ESIntegTestCase { } assertTrue(Files.exists(unzipDataDir)); - final String node = internalCluster().startNode(); + Path dataPath = createTempDir(); + Settings settings = Settings.builder() + .put("path.data", dataPath) + .build(); + final String node = internalCluster().startNode(settings); Path[] nodePaths = internalCluster().getInstance(NodeEnvironment.class, node).nodeDataPaths(); assertEquals(1, nodePaths.length); - Path dataPath = nodePaths[0].resolve(NodeEnvironment.INDICES_FOLDER); + dataPath = nodePaths[0].resolve(NodeEnvironment.INDICES_FOLDER); assertFalse(Files.exists(dataPath)); Path src = unzipDataDir.resolve(indexName + "/nodes/0/indices"); Files.move(src, dataPath); diff --git a/plugins/mapper-size/src/test/java/org/elasticsearch/index/mapper/size/SizeFieldMapperUpgradeTests.java b/plugins/mapper-size/src/test/java/org/elasticsearch/index/mapper/size/SizeFieldMapperUpgradeTests.java index 4a5257784f8..b9902500376 100644 --- a/plugins/mapper-size/src/test/java/org/elasticsearch/index/mapper/size/SizeFieldMapperUpgradeTests.java +++ b/plugins/mapper-size/src/test/java/org/elasticsearch/index/mapper/size/SizeFieldMapperUpgradeTests.java @@ -22,6 +22,7 @@ package org.elasticsearch.index.mapper.size; import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.TestUtil; import org.elasticsearch.action.search.SearchResponse; +import org.elasticsearch.common.settings.Settings; import org.elasticsearch.env.NodeEnvironment; import org.elasticsearch.plugin.mapper.MapperSizePlugin; import org.elasticsearch.plugins.Plugin; @@ -57,10 +58,14 @@ public class SizeFieldMapperUpgradeTests extends ESIntegTestCase { } assertTrue(Files.exists(unzipDataDir)); - final String node = internalCluster().startNode(); + Path dataPath = createTempDir(); + Settings settings = Settings.builder() + .put("path.data", dataPath) + .build(); + final String node = internalCluster().startNode(settings); Path[] nodePaths = internalCluster().getInstance(NodeEnvironment.class, node).nodeDataPaths(); assertEquals(1, nodePaths.length); - Path dataPath = nodePaths[0].resolve(NodeEnvironment.INDICES_FOLDER); + dataPath = nodePaths[0].resolve(NodeEnvironment.INDICES_FOLDER); assertFalse(Files.exists(dataPath)); Path src = unzipDataDir.resolve(indexName + "/nodes/0/indices"); Files.move(src, dataPath);