Move keystore-cli to its own tools project (#40787)

This commit moves the keystore cli into its own project, so that the
test dependencies can be isolated from the rest of server.

distribution/build.gradle

@@ -296,6 +296,9 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
           from { project(':distribution:tools:plugin-cli').jar }
           from { project(':distribution:tools:plugin-cli').configurations.runtime }
         }
+        into('tools/keystore-cli') {
+          from { project(':distribution:tools:keystore-cli').jar }
+        }
         if (oss == false) {
           into('tools/security-cli') {
             from { project(':x-pack:plugin:security:cli').jar }

distribution/src/bin/elasticsearch-keystore

@@ -1,5 +1,6 @@
 #!/bin/bash
 
 ES_MAIN_CLASS=org.elasticsearch.common.settings.KeyStoreCli \
+  ES_ADDITIONAL_CLASSPATH_DIRECTORIES=lib/tools/keystore-cli \
   "`dirname "$0"`"/elasticsearch-cli \
   "$@"

distribution/src/bin/elasticsearch-keystore.bat

@@ -4,6 +4,7 @@ setlocal enabledelayedexpansion
 setlocal enableextensions
 
 set ES_MAIN_CLASS=org.elasticsearch.common.settings.KeyStoreCli
+set ES_ADDITIONAL_CLASSPATH_DIRECTORIES=lib/tools/keystore-cli
 call "%~dp0elasticsearch-cli.bat" ^
   %%* ^
   || goto exit

distribution/tools/keystore-cli/build.gradle

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+apply plugin: 'elasticsearch.build'
+
+dependencies {
+  compileOnly "org.elasticsearch:elasticsearch:${version}"
+  compileOnly "org.elasticsearch:elasticsearch-cli:${version}"
+  testCompile "org.elasticsearch.test:framework:${version}"
+  testCompile 'com.google.jimfs:jimfs:1.1'
+  testCompile 'com.google.guava:guava:18.0'
+}

server/build.gradle

@@ -132,8 +132,6 @@ dependencies {
       exclude group: 'org.elasticsearch', module: 'elasticsearch'
     }
   }
-  testCompile 'com.google.jimfs:jimfs:1.1'
-  testCompile 'com.google.guava:guava:18.0'
 }
 
 if (isEclipse) {

server/src/test/java/org/elasticsearch/cluster/metadata/MetaDataIndexStateServiceTests.java

@@ -19,7 +19,6 @@
 
 package org.elasticsearch.cluster.metadata;
 
-import com.google.common.collect.ImmutableList;
 import org.elasticsearch.Version;
 import org.elasticsearch.action.support.master.AcknowledgedResponse;
 import org.elasticsearch.cluster.ClusterName;
@@ -375,7 +374,8 @@ public class MetaDataIndexStateServiceTests extends ESTestCase {
 
         final Snapshot snapshot = new Snapshot(randomAlphaOfLength(10), new SnapshotId(randomAlphaOfLength(5), randomAlphaOfLength(5)));
         final RestoreInProgress.Entry entry =
-            new RestoreInProgress.Entry("_uuid", snapshot, RestoreInProgress.State.INIT, ImmutableList.of(index), shardsBuilder.build());
+            new RestoreInProgress.Entry("_uuid", snapshot, RestoreInProgress.State.INIT,
+                Collections.singletonList(index), shardsBuilder.build());
         return ClusterState.builder(newState)
             .putCustom(RestoreInProgress.TYPE, new RestoreInProgress.Builder().add(entry).build())
             .build();

server/src/test/java/org/elasticsearch/index/mapper/ObjectMapperMergeTests.java

@@ -18,7 +18,6 @@
  */
 package org.elasticsearch.index.mapper;
 
-import com.google.common.collect.ImmutableMap;
 import org.elasticsearch.Version;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.index.mapper.FieldMapper.CopyTo;
@@ -27,6 +26,8 @@ import org.elasticsearch.index.mapper.TextFieldMapper.TextFieldType;
 import org.elasticsearch.test.ESTestCase;
 import org.junit.AfterClass;
 
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 
 import static java.util.Collections.emptyMap;
@@ -38,11 +39,7 @@ public class ObjectMapperMergeTests extends ESTestCase {
     private static FieldMapper barFieldMapper = createTextFieldMapper("bar");
     private static FieldMapper bazFieldMapper = createTextFieldMapper("baz");
 
-    private static RootObjectMapper rootObjectMapper = createRootObjectMapper(
-        "type1", true, ImmutableMap.of(
-            "disabled", createObjectMapper("disabled", false, emptyMap()),
-            "foo", createObjectMapper("foo", true, ImmutableMap.of(
-                "bar", barFieldMapper))));
+    private static RootObjectMapper rootObjectMapper = createMapping(false, true, true, false);
 
     @AfterClass
     public static void cleanupReferences() {
@@ -51,14 +48,24 @@ public class ObjectMapperMergeTests extends ESTestCase {
         rootObjectMapper = null;
     }
 
+    private static RootObjectMapper createMapping(boolean disabledFieldEnabled, boolean fooFieldEnabled,
+                                                  boolean includeBarField, boolean includeBazField) {
+        Map<String, Mapper> mappers = new HashMap<>();
+        mappers.put("disabled", createObjectMapper("disabled", disabledFieldEnabled, emptyMap()));
+        Map<String, Mapper> fooMappers = new HashMap<>();
+        if (includeBarField) {
+            fooMappers.put("bar", barFieldMapper);
+        }
+        if (includeBazField) {
+            fooMappers.put("baz", bazFieldMapper);
+        }
+        mappers.put("foo", createObjectMapper("foo", fooFieldEnabled,  Collections.unmodifiableMap(fooMappers)));
+        return createRootObjectMapper("type1", true, Collections.unmodifiableMap(mappers));
+    }
+
     public void testMerge() {
         // GIVEN an enriched mapping with "baz" new field
-        ObjectMapper mergeWith = createRootObjectMapper(
-            "type1", true, ImmutableMap.of(
-                "disabled", createObjectMapper("disabled", false, emptyMap()),
-                "foo", createObjectMapper("foo", true, ImmutableMap.of(
-                    "bar", barFieldMapper,
-                    "baz", bazFieldMapper))));
+        ObjectMapper mergeWith = createMapping(false, true, true, true);
 
         // WHEN merging mappings
         final ObjectMapper merged = rootObjectMapper.merge(mergeWith);
@@ -71,10 +78,7 @@ public class ObjectMapperMergeTests extends ESTestCase {
 
     public void testMergeWhenDisablingField() {
         // GIVEN a mapping with "foo" field disabled
-        ObjectMapper mergeWith = createRootObjectMapper(
-            "type1", true, ImmutableMap.of(
-                "disabled", createObjectMapper("disabled", false, emptyMap()),
-                "foo", createObjectMapper("foo", false, emptyMap())));
+        ObjectMapper mergeWith = createMapping(false, false, false, false);
 
         // WHEN merging mappings
         // THEN a MapperException is thrown with an excepted message
@@ -84,11 +88,7 @@ public class ObjectMapperMergeTests extends ESTestCase {
 
     public void testMergeWhenEnablingField() {
         // GIVEN a mapping with "disabled" field enabled
-        ObjectMapper mergeWith = createRootObjectMapper(
-            "type1", true, ImmutableMap.of(
-                "disabled", createObjectMapper("disabled", true, emptyMap()),
-                "foo", createObjectMapper("foo", true, ImmutableMap.of(
-                    "bar", barFieldMapper))));
+        ObjectMapper mergeWith = createMapping(true, true, true, false);
 
         // WHEN merging mappings
         // THEN a MapperException is thrown with an excepted message

server/src/test/java/org/elasticsearch/search/aggregations/bucket/composite/InternalCompositeTests.java

@@ -19,7 +19,6 @@
 
 package org.elasticsearch.search.aggregations.bucket.composite;
 
-import com.google.common.collect.Lists;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.common.time.DateFormatter;
@@ -36,6 +35,7 @@ import org.junit.After;
 import java.io.IOException;
 import java.time.ZoneOffset;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -251,11 +251,11 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeyBiggerFieldName() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{1, 2}
         );
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field3", "field2"),
+            Arrays.asList("field3", "field2"),
             new Comparable[]{1, 2}
         );
         assertThat(key1.compareTo(key2), lessThan(0));
@@ -263,11 +263,11 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeySmallerFieldName() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field3", "field2"),
+            Arrays.asList("field3", "field2"),
             new Comparable[]{1, 2}
         );
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{1, 2}
         );
         assertThat(key1.compareTo(key2), greaterThan(0));
@@ -275,11 +275,11 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeyBiggerValue() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{1, 2}
         );
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field3", "field2"),
+            Arrays.asList("field3", "field2"),
             new Comparable[]{2, 3}
         );
         assertThat(key1.compareTo(key2), lessThan(0));
@@ -287,11 +287,11 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeySmallerValue() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field3", "field2"),
+            Arrays.asList("field3", "field2"),
             new Comparable[]{1, 2}
         );
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{2, 3}
         );
         assertThat(key1.compareTo(key2), greaterThan(0));
@@ -299,11 +299,11 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeyNullValueIsSmaller1() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{null, 20}
         );
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{1, 2}
         );
         assertThat(key1.compareTo(key2), lessThan(0));
@@ -311,11 +311,11 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeyNullValueIsSmaller2() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{1, 2}
         );
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{null, 20}
         );
         assertThat(key1.compareTo(key2), greaterThan(0));
@@ -323,29 +323,29 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeyMoreFieldsIsGreater() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{1, 2}
         );
-        InternalComposite.ArrayMap key2 = createMap(Lists.newArrayList("field1", "field2", "field3"),new Comparable[]{1, 2, null});
+        InternalComposite.ArrayMap key2 = createMap(Arrays.asList("field1", "field2", "field3"),new Comparable[]{1, 2, null});
         assertThat(key1.compareTo(key2), lessThan(0));
     }
 
     public void testCompareCompositeKeyLessFieldsIsLesser() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2", "field3"),
+            Arrays.asList("field1", "field2", "field3"),
             new Comparable[]{1, 2, null}
         );
-        InternalComposite.ArrayMap key2 = createMap(Lists.newArrayList("field1", "field2"),new Comparable[]{1, 2});
+        InternalComposite.ArrayMap key2 = createMap(Arrays.asList("field1", "field2"),new Comparable[]{1, 2});
         assertThat(key1.compareTo(key2), greaterThan(0));
     }
 
     public void testCompareCompositeKeyEqual() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2", "field3"),
+            Arrays.asList("field1", "field2", "field3"),
             new Comparable[]{null, 1, 2}
         );
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field1", "field2", "field3"),
+            Arrays.asList("field1", "field2", "field3"),
             new Comparable[]{null, 1, 2}
         );
         assertThat(key1.compareTo(key1), equalTo(0));
@@ -358,12 +358,12 @@ public class InternalCompositeTests extends InternalMultiBucketAggregationTestCa
 
     public void testCompareCompositeKeyValuesHaveDifferentTypes() {
         InternalComposite.ArrayMap key1 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{1, 2}
         );
 
         InternalComposite.ArrayMap key2 = createMap(
-            Lists.newArrayList("field1", "field2"),
+            Arrays.asList("field1", "field2"),
             new Comparable[]{"1", 2}
         );
 

settings.gradle

@@ -44,6 +44,7 @@ List projects = [
   'distribution:tools:java-version-checker',
   'distribution:tools:launchers',
   'distribution:tools:plugin-cli',
+  'distribution:tools:keystore-cli',
   'server',
   'server:cli',
   'test:framework',