Apache Solr open-source search software
SOLR-15745: Move public v2 "core-admin" APIs to annotation framework (#565)
Jason Gerlowskidf88d65a2a83
diff --git a/solr/core/src/java/org/apache/solr/handler/ClusterAPI.java b/solr/core/src/java/org/apache/solr/handler/ClusterAPI.javaindex a40acc04521..42f50821453 100644--- a/solr/core/src/java/org/apache/solr/handler/ClusterAPI.java+++ b/solr/core/src/java/org/apache/solr/handler/ClusterAPI.java@@ -17,9 +17,6 @@package org.apache.solr.handler;-import java.io.IOException;-import java.util.*;-import com.google.common.collect.Maps;import org.apache.solr.api.Command;import org.apache.solr.api.EndPoint;@@ -48,18 +45,21 @@ import org.apache.solr.request.SolrQueryRequest;import org.apache.solr.response.SolrQueryResponse;import org.apache.zookeeper.KeeperException;+import java.io.IOException;+import java.util.Collections;+import java.util.HashMap;+import java.util.List;+import java.util.Map;+import java.util.NoSuchElementException;+import java.util.Set;+import static org.apache.solr.client.solrj.SolrRequest.METHOD.DELETE;-import static org.apache.solr.client.solrj.SolrRequest.METHOD.GET;-import static org.apache.solr.client.solrj.SolrRequest.METHOD.POST;-import static org.apache.solr.client.solrj.SolrRequest.METHOD.PUT;+import static org.apache.solr.client.solrj.SolrRequest.METHOD.*;import static org.apache.solr.cloud.api.collections.CollectionHandlingUtils.REQUESTID;import static org.apache.solr.common.params.CollectionParams.ACTION;import static org.apache.solr.common.params.CollectionParams.CollectionAction.*;import static org.apache.solr.core.RateLimiterConfig.RL_CONFIG_KEY;-import static org.apache.solr.security.PermissionNameProvider.Name.COLL_EDIT_PERM;-import static org.apache.solr.security.PermissionNameProvider.Name.COLL_READ_PERM;-import static org.apache.solr.security.PermissionNameProvider.Name.CONFIG_EDIT_PERM;-import static org.apache.solr.security.PermissionNameProvider.Name.CONFIG_READ_PERM;+import static org.apache.solr.security.PermissionNameProvider.Name.*;/*** All V2 APIs that have a prefix of /api/cluster/@@ -293,7 +293,11 @@ public class ClusterAPI {ModifiableSolrParams solrParams = new ModifiableSolrParams();m.forEach((k, v) -> {if (v == null) return;- solrParams.add(k.toString(), String.valueOf(v));+ if (v instanceof String[]) {+ solrParams.add(k, (String[]) v);+ } else {+ solrParams.add(k, String.valueOf(v));+ }});DefaultSolrParams dsp = new DefaultSolrParams(req.getParams(), solrParams);req.setParams(dsp);diff --git a/solr/core/src/java/org/apache/solr/handler/admin/CoreAdminHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/CoreAdminHandler.javaindex 52b2944aa29..27e6116c5fa 100644--- a/solr/core/src/java/org/apache/solr/handler/admin/CoreAdminHandler.java+++ b/solr/core/src/java/org/apache/solr/handler/admin/CoreAdminHandler.java@@ -39,9 +39,15 @@ import org.apache.solr.handler.RequestHandlerBase;import org.apache.solr.handler.admin.api.AllCoresStatusAPI;import org.apache.solr.handler.admin.api.CreateCoreAPI;import org.apache.solr.handler.admin.api.InvokeClassAPI;+import org.apache.solr.handler.admin.api.MergeIndexesAPI;import org.apache.solr.handler.admin.api.OverseerOperationAPI;import org.apache.solr.handler.admin.api.RejoinLeaderElectionAPI;+import org.apache.solr.handler.admin.api.ReloadCoreAPI;+import org.apache.solr.handler.admin.api.RenameCoreAPI;import org.apache.solr.handler.admin.api.SingleCoreStatusAPI;+import org.apache.solr.handler.admin.api.SplitCoreAPI;+import org.apache.solr.handler.admin.api.SwapCoresAPI;+import org.apache.solr.handler.admin.api.UnloadCoreAPI;import org.apache.solr.logging.MDCLoggingContext;import org.apache.solr.metrics.SolrMetricManager;import org.apache.solr.metrics.SolrMetricsContext;@@ -429,6 +435,12 @@ public class CoreAdminHandler extends RequestHandlerBase implements PermissionNaapis.addAll(AnnotatedApi.getApis(new InvokeClassAPI(this)));apis.addAll(AnnotatedApi.getApis(new RejoinLeaderElectionAPI(this)));apis.addAll(AnnotatedApi.getApis(new OverseerOperationAPI(this)));+ apis.addAll(AnnotatedApi.getApis(new ReloadCoreAPI(this)));+ apis.addAll(AnnotatedApi.getApis(new SwapCoresAPI(this)));+ apis.addAll(AnnotatedApi.getApis(new RenameCoreAPI(this)));+ apis.addAll(AnnotatedApi.getApis(new UnloadCoreAPI(this)));+ apis.addAll(AnnotatedApi.getApis(new MergeIndexesAPI(this)));+ apis.addAll(AnnotatedApi.getApis(new SplitCoreAPI(this)));return apis;}diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/MergeIndexesAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/MergeIndexesAPI.javanew file mode 100644index 00000000000..21e77876521--- /dev/null+++ b/solr/core/src/java/org/apache/solr/handler/admin/api/MergeIndexesAPI.java@@ -0,0 +1,91 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF 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.apache.solr.handler.admin.api;++import org.apache.commons.collections4.CollectionUtils;+import org.apache.solr.api.Command;+import org.apache.solr.api.EndPoint;+import org.apache.solr.api.PayloadObj;+import org.apache.solr.common.annotation.JsonProperty;+import org.apache.solr.common.params.CoreAdminParams;+import org.apache.solr.common.params.UpdateParams;+import org.apache.solr.common.util.ReflectMapWriter;+import org.apache.solr.handler.admin.CoreAdminHandler;++import java.util.HashMap;+import java.util.List;+import java.util.Locale;+import java.util.Map;++import static org.apache.solr.client.solrj.SolrRequest.METHOD.POST;+import static org.apache.solr.handler.ClusterAPI.wrapParams;+import static org.apache.solr.security.PermissionNameProvider.Name.CORE_EDIT_PERM;++/**+ * V2 API for merging one or more Solr cores into the target core.+ *+ * The new API (POST /v2/cores/coreName {'merge-indexes': {...}}) is equivalent to the v1+ * /admin/cores?action=mergeindexes command.+ */+@EndPoint(+ path = {"/cores/{core}"},+ method = POST,+ permission = CORE_EDIT_PERM)+public class MergeIndexesAPI {+ private static final String V2_MERGE_INDEXES_CORE_CMD = "merge-indexes";++ private final CoreAdminHandler coreHandler;++ public MergeIndexesAPI(CoreAdminHandler coreHandler) {+ this.coreHandler = coreHandler;+ }++ @Command(name = V2_MERGE_INDEXES_CORE_CMD)+ public void mergeIndexesIntoCore(PayloadObj<MergeIndexesPayload> obj) throws Exception {+ final MergeIndexesPayload v2Body = obj.get();+ final Map<String, Object> v1Params = v2Body.toMap(new HashMap<>());+ v1Params.put(CoreAdminParams.ACTION, CoreAdminParams.CoreAdminAction.MERGEINDEXES.name().toLowerCase(Locale.ROOT));+ v1Params.put(CoreAdminParams.CORE, obj.getRequest().getPathTemplateValues().get(CoreAdminParams.CORE));+ if (! CollectionUtils.isEmpty(v2Body.indexDir)) {+ v1Params.put("indexDir", v2Body.indexDir.toArray(new String[v2Body.indexDir.size()]));+ }+ if (! CollectionUtils.isEmpty(v2Body.srcCore)) {+ v1Params.put("srcCore", v2Body.srcCore.toArray(new String[v2Body.srcCore.size()]));+ }+ // V1 API uses 'update.chain' instead of 'updateChain'.+ if (v2Body.updateChain != null) {+ v1Params.put(UpdateParams.UPDATE_CHAIN, v1Params.remove("updateChain"));+ }++ coreHandler.handleRequestBody(wrapParams(obj.getRequest(), v1Params), obj.getResponse());+ }++ public static class MergeIndexesPayload implements ReflectMapWriter {+ @JsonProperty+ public List<String> indexDir;++ @JsonProperty+ public List<String> srcCore;++ @JsonProperty+ public String updateChain;++ @JsonProperty+ public String async;+ }+}diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/ReloadCoreAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/ReloadCoreAPI.javanew file mode 100644index 00000000000..2ee076a1e66--- /dev/null+++ b/solr/core/src/java/org/apache/solr/handler/admin/api/ReloadCoreAPI.java@@ -0,0 +1,69 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF 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.apache.solr.handler.admin.api;++import org.apache.solr.api.Command;+import org.apache.solr.api.EndPoint;+import org.apache.solr.api.PayloadObj;+import org.apache.solr.common.params.CoreAdminParams;+import org.apache.solr.common.util.ReflectMapWriter;+import org.apache.solr.handler.admin.CoreAdminHandler;++import java.util.HashMap;+import java.util.Locale;+import java.util.Map;++import static org.apache.solr.client.solrj.SolrRequest.METHOD.POST;+import static org.apache.solr.common.params.CommonParams.ACTION;+import static org.apache.solr.handler.ClusterAPI.wrapParams;+import static org.apache.solr.security.PermissionNameProvider.Name.CORE_EDIT_PERM;++/**+ * V2 API for reloading an individual core.+ *+ * The new API (POST /v2/cores/coreName {'reload': {...}}) is equivalent to the v1+ * /admin/cores?action=reload command.+ *+ * @see ReloadCorePayload+ */+@EndPoint(+ path = {"/cores/{core}"},+ method = POST,+ permission = CORE_EDIT_PERM)+public class ReloadCoreAPI {+ private static final String V2_RELOAD_CORE_CMD = "reload";++ private final CoreAdminHandler coreHandler;++ public ReloadCoreAPI(CoreAdminHandler coreHandler) {+ this.coreHandler = coreHandler;+ }++ @Command(name = V2_RELOAD_CORE_CMD)+ public void reloadCore(PayloadObj<ReloadCorePayload> obj) throws Exception {+ final String coreName = obj.getRequest().getPathTemplateValues().get(CoreAdminParams.CORE);++ final Map<String, Object> v1Params = new HashMap<>();+ v1Params.put(ACTION, CoreAdminParams.CoreAdminAction.RELOAD.name().toLowerCase(Locale.ROOT));+ v1Params.put(CoreAdminParams.CORE, coreName);++ coreHandler.handleRequestBody(wrapParams(obj.getRequest(), v1Params), obj.getResponse());+ }++ public static class ReloadCorePayload implements ReflectMapWriter {}+}diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/RenameCoreAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/RenameCoreAPI.javanew file mode 100644index 00000000000..8782792bddf--- /dev/null+++ b/solr/core/src/java/org/apache/solr/handler/admin/api/RenameCoreAPI.java@@ -0,0 +1,72 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF 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.apache.solr.handler.admin.api;++import org.apache.solr.api.Command;+import org.apache.solr.api.EndPoint;+import org.apache.solr.api.PayloadObj;+import org.apache.solr.common.annotation.JsonProperty;+import org.apache.solr.common.params.CoreAdminParams;+import org.apache.solr.common.util.ReflectMapWriter;+import org.apache.solr.handler.admin.CoreAdminHandler;++import java.util.HashMap;+import java.util.Locale;+import java.util.Map;++import static org.apache.solr.client.solrj.SolrRequest.METHOD.POST;+import static org.apache.solr.handler.ClusterAPI.wrapParams;+import static org.apache.solr.security.PermissionNameProvider.Name.CORE_EDIT_PERM;++/**+ * V2 API for renaming an existing Solr core.+ *+ * The new API (POST /v2/cores/coreName {'rename': {...}}) is equivalent to the v1+ * /admin/cores?action=rename command.+ */+@EndPoint(+ path = {"/cores/{core}"},+ method = POST,+ permission = CORE_EDIT_PERM)+public class RenameCoreAPI {+ private static final String V2_RENAME_CORE_CMD = "rename";++ private final CoreAdminHandler coreHandler;++ public RenameCoreAPI(CoreAdminHandler coreHandler) {+ this.coreHandler = coreHandler;+ }++ @Command(name = V2_RENAME_CORE_CMD)+ public void renameCore(PayloadObj<RenameCorePayload> obj) throws Exception {+ final RenameCorePayload v2Body = obj.get();+ final Map<String, Object> v1Params = v2Body.toMap(new HashMap<>());+ v1Params.put(CoreAdminParams.ACTION, CoreAdminParams.CoreAdminAction.RENAME.name().toLowerCase(Locale.ROOT));+ v1Params.put(CoreAdminParams.CORE, obj.getRequest().getPathTemplateValues().get(CoreAdminParams.CORE));++ // V1 API uses 'other' instead of 'to' to represent the new core name.+ v1Params.put(CoreAdminParams.OTHER, v1Params.remove("to"));++ coreHandler.handleRequestBody(wrapParams(obj.getRequest(), v1Params), obj.getResponse());+ }++ public static class RenameCorePayload implements ReflectMapWriter {+ @JsonProperty(required = true)+ public String to;+ }+}diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/SplitCoreAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/SplitCoreAPI.javanew file mode 100644index 00000000000..6f9404adc7e--- /dev/null+++ b/solr/core/src/java/org/apache/solr/handler/admin/api/SplitCoreAPI.java@@ -0,0 +1,103 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF 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.apache.solr.handler.admin.api;++import org.apache.commons.collections4.CollectionUtils;+import org.apache.solr.api.Command;+import org.apache.solr.api.EndPoint;+import org.apache.solr.api.PayloadObj;+import org.apache.solr.common.annotation.JsonProperty;+import org.apache.solr.common.params.CoreAdminParams;+import org.apache.solr.common.util.ReflectMapWriter;+import org.apache.solr.handler.admin.CoreAdminHandler;++import java.util.HashMap;+import java.util.List;+import java.util.Locale;+import java.util.Map;++import static org.apache.solr.client.solrj.SolrRequest.METHOD.POST;+import static org.apache.solr.common.params.CommonAdminParams.SPLIT_KEY;+import static org.apache.solr.common.params.CommonParams.PATH;+import static org.apache.solr.common.params.CoreAdminParams.TARGET_CORE;+import static org.apache.solr.handler.ClusterAPI.wrapParams;+import static org.apache.solr.security.PermissionNameProvider.Name.CORE_EDIT_PERM;++/**+ * V2 API for splitting a single core into multiple pieces+ *+ * The new API (POST /v2/cores/coreName {'split': {...}}) is equivalent to the v1+ * /admin/cores?action=split command.+ */+@EndPoint(+ path = {"/cores/{core}"},+ method = POST,+ permission = CORE_EDIT_PERM)+public class SplitCoreAPI {+ private static final String V2_SPLIT_CORE_CMD = "split";++ private final CoreAdminHandler coreHandler;++ public SplitCoreAPI(CoreAdminHandler coreHandler) {+ this.coreHandler = coreHandler;+ }++ @Command(name = V2_SPLIT_CORE_CMD)+ public void splitCore(PayloadObj<SplitCorePayload> obj) throws Exception {+ final SplitCorePayload v2Body = obj.get();+ final Map<String, Object> v1Params = v2Body.toMap(new HashMap<>());+ v1Params.put(CoreAdminParams.ACTION, CoreAdminParams.CoreAdminAction.SPLIT.name().toLowerCase(Locale.ROOT));+ v1Params.put(CoreAdminParams.CORE, obj.getRequest().getPathTemplateValues().get(CoreAdminParams.CORE));++ if (! CollectionUtils.isEmpty(v2Body.path)) {+ v1Params.put(PATH, v2Body.path.toArray(new String[v2Body.path.size()]));+ }+ if (! CollectionUtils.isEmpty(v2Body.targetCore)) {+ v1Params.put(TARGET_CORE, v2Body.targetCore.toArray(new String[v2Body.targetCore.size()]));+ }++ if (v2Body.splitKey != null) {+ v1Params.put(SPLIT_KEY, v1Params.remove("splitKey"));+ }++ coreHandler.handleRequestBody(wrapParams(obj.getRequest(), v1Params), obj.getResponse());+ }++ public static class SplitCorePayload implements ReflectMapWriter {+ @JsonProperty+ public List<String> path;++ @JsonProperty+ public List<String> targetCore;++ @JsonProperty+ public String splitKey;++ @JsonProperty+ public String splitMethod;++ @JsonProperty+ public Boolean getRanges;++ @JsonProperty+ public String ranges;++ @JsonProperty+ public String async;+ }+}diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/SwapCoresAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/SwapCoresAPI.javanew file mode 100644index 00000000000..77a0a0b1910--- /dev/null+++ b/solr/core/src/java/org/apache/solr/handler/admin/api/SwapCoresAPI.java@@ -0,0 +1,77 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF 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.apache.solr.handler.admin.api;++import org.apache.solr.api.Command;+import org.apache.solr.api.EndPoint;+import org.apache.solr.api.PayloadObj;+import org.apache.solr.common.annotation.JsonProperty;+import org.apache.solr.common.params.CoreAdminParams;+import org.apache.solr.common.util.ReflectMapWriter;+import org.apache.solr.handler.admin.CoreAdminHandler;++import java.util.HashMap;+import java.util.Locale;+import java.util.Map;++import static org.apache.solr.client.solrj.SolrRequest.METHOD.POST;+import static org.apache.solr.handler.ClusterAPI.wrapParams;+import static org.apache.solr.security.PermissionNameProvider.Name.CORE_EDIT_PERM;++/**+ * V2 API for swapping two existing Solr cores.+ *+ * Not intended for use in SolrCloud mode.+ *+ * The new API (POST /v2/cores/coreName {'swap': {...}}) is equivalent to the v1+ * /admin/cores?action=swap command.+ */+@EndPoint(+ path = {"/cores/{core}"},+ method = POST,+ permission = CORE_EDIT_PERM)+public class SwapCoresAPI {+ private static final String V2_SWAP_CORES_CMD = "swap";++ private final CoreAdminHandler coreHandler;++ public SwapCoresAPI(CoreAdminHandler coreHandler) {+ this.coreHandler = coreHandler;+ }++ @Command(name = V2_SWAP_CORES_CMD)+ public void swapCores(PayloadObj<SwapCoresPayload> obj) throws Exception {+ final SwapCoresPayload v2Body = obj.get();+ final Map<String, Object> v1Params = v2Body.toMap(new HashMap<>());+ v1Params.put(CoreAdminParams.ACTION, CoreAdminParams.CoreAdminAction.SWAP.name().toLowerCase(Locale.ROOT));+ v1Params.put(CoreAdminParams.CORE, obj.getRequest().getPathTemplateValues().get(CoreAdminParams.CORE));++ // V1 API uses 'other' instead of 'with' to represent the second/replacement core.+ v1Params.put(CoreAdminParams.OTHER, v1Params.remove("with"));++ coreHandler.handleRequestBody(wrapParams(obj.getRequest(), v1Params), obj.getResponse());+ }++ public static class SwapCoresPayload implements ReflectMapWriter {+ @JsonProperty(required = true)+ public String with;++ @JsonProperty+ public String async;+ }+}diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/UnloadCoreAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/UnloadCoreAPI.javanew file mode 100644index 00000000000..91f6e06d790--- /dev/null+++ b/solr/core/src/java/org/apache/solr/handler/admin/api/UnloadCoreAPI.java@@ -0,0 +1,78 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF 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.apache.solr.handler.admin.api;++import org.apache.solr.api.Command;+import org.apache.solr.api.EndPoint;+import org.apache.solr.api.PayloadObj;+import org.apache.solr.common.annotation.JsonProperty;+import org.apache.solr.common.params.CoreAdminParams;+import org.apache.solr.common.util.ReflectMapWriter;+import org.apache.solr.handler.admin.CoreAdminHandler;++import java.util.HashMap;+import java.util.Locale;+import java.util.Map;++import static org.apache.solr.client.solrj.SolrRequest.METHOD.POST;+import static org.apache.solr.handler.ClusterAPI.wrapParams;+import static org.apache.solr.security.PermissionNameProvider.Name.CORE_EDIT_PERM;++/**+ * V2 API for renaming an existing Solr core.+ *+ * The new API (POST /v2/cores/coreName {'unload': {...}}) is equivalent to the v1+ * /admin/cores?action=unload command.+ */+@EndPoint(+ path = {"/cores/{core}"},+ method = POST,+ permission = CORE_EDIT_PERM)+public class UnloadCoreAPI {+ private static final String V2_UNLOAD_CORE_CMD = "unload";++ private final CoreAdminHandler coreHandler;++ public UnloadCoreAPI(CoreAdminHandler coreHandler) {+ this.coreHandler = coreHandler;+ }++ @Command(name = V2_UNLOAD_CORE_CMD)+ public void unloadCore(PayloadObj<UnloadCorePayload> obj) throws Exception {+ final UnloadCorePayload v2Body = obj.get();+ final Map<String, Object> v1Params = v2Body.toMap(new HashMap<>());+ v1Params.put(CoreAdminParams.ACTION, CoreAdminParams.CoreAdminAction.UNLOAD.name().toLowerCase(Locale.ROOT));+ v1Params.put(CoreAdminParams.CORE, obj.getRequest().getPathTemplateValues().get(CoreAdminParams.CORE));++ coreHandler.handleRequestBody(wrapParams(obj.getRequest(), v1Params), obj.getResponse());+ }++ public static class UnloadCorePayload implements ReflectMapWriter {+ @JsonProperty+ public Boolean deleteIndex;++ @JsonProperty+ public Boolean deleteDataDir;++ @JsonProperty+ public Boolean deleteInstanceDir;++ @JsonProperty+ public String async;+ }+}diff --git a/solr/core/src/test/org/apache/solr/handler/admin/api/V2CoreAPIMappingTest.java b/solr/core/src/test/org/apache/solr/handler/admin/api/V2CoreAPIMappingTest.javanew file mode 100644index 00000000000..7dbd3f7401e--- /dev/null+++ b/solr/core/src/test/org/apache/solr/handler/admin/api/V2CoreAPIMappingTest.java@@ -0,0 +1,203 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF 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.apache.solr.handler.admin.api;++import com.google.common.collect.Maps;+import org.apache.solr.SolrTestCaseJ4;+import org.apache.solr.api.Api;+import org.apache.solr.api.ApiBag;+import org.apache.solr.common.params.SolrParams;+import org.apache.solr.common.params.UpdateParams;+import org.apache.solr.common.util.CommandOperation;+import org.apache.solr.common.util.ContentStreamBase;+import org.apache.solr.handler.admin.CoreAdminHandler;+import org.apache.solr.request.LocalSolrQueryRequest;+import org.apache.solr.request.SolrQueryRequest;+import org.apache.solr.response.SolrQueryResponse;+import org.junit.Before;+import org.junit.BeforeClass;+import org.junit.Test;+import org.mockito.ArgumentCaptor;++import java.util.Arrays;+import java.util.Collections;+import java.util.HashMap;+import java.util.List;+import java.util.Map;++import static org.apache.solr.common.params.CommonAdminParams.ASYNC;+import static org.apache.solr.common.params.CommonAdminParams.SPLIT_KEY;+import static org.apache.solr.common.params.CommonParams.ACTION;+import static org.apache.solr.common.params.CommonParams.PATH;+import static org.apache.solr.common.params.CoreAdminParams.*;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verify;++/**+ * Unit tests for the V2 APIs found in {@link org.apache.solr.handler.admin.api} that use the /cores/{core} path.+ *+ * Note that the V2 requests made by these tests are not necessarily semantically valid. They shouldn't be taken as+ * examples. In several instances, mutually exclusive JSON parameters are provided. This is done to exercise conversion+ * of all parameters, even if particular combinations are never expected in the same request.+ */+public class V2CoreAPIMappingTest extends SolrTestCaseJ4 {+ private ApiBag apiBag;++ private ArgumentCaptor<SolrQueryRequest> queryRequestCaptor;++ private CoreAdminHandler mockCoreHandler;++ @BeforeClass+ public static void ensureWorkingMockito() {+ assumeWorkingMockito();+ }++ @Before+ public void setupApiBag() throws Exception {+ mockCoreHandler = mock(CoreAdminHandler.class);+ queryRequestCaptor = ArgumentCaptor.forClass(SolrQueryRequest.class);++ apiBag = new ApiBag(false);+ apiBag.registerObject(new ReloadCoreAPI(mockCoreHandler));+ apiBag.registerObject(new SwapCoresAPI(mockCoreHandler));+ apiBag.registerObject(new RenameCoreAPI(mockCoreHandler));+ apiBag.registerObject(new UnloadCoreAPI(mockCoreHandler));+ apiBag.registerObject(new MergeIndexesAPI(mockCoreHandler));+ apiBag.registerObject(new SplitCoreAPI(mockCoreHandler));+ }++ @Test+ public void testReloadCoreAllParams() throws Exception {+ final SolrParams v1Params = captureConvertedV1Params("/cores/coreName", "POST", "{\"reload\": {}}");++ assertEquals("reload", v1Params.get(ACTION));+ assertEquals("coreName", v1Params.get(CORE));+ }++ @Test+ public void testSwapCoresAllParams() throws Exception {+ final SolrParams v1Params = captureConvertedV1Params("/cores/coreName", "POST", "{\"swap\": {\"with\": \"otherCore\"}}");++ assertEquals("swap", v1Params.get(ACTION));+ assertEquals("coreName", v1Params.get(CORE));+ assertEquals("otherCore", v1Params.get(OTHER));+ }++ @Test+ public void testRenameCoreAllParams() throws Exception {+ final SolrParams v1Params = captureConvertedV1Params("/cores/coreName", "POST", "{\"rename\": {\"to\": \"otherCore\"}}");++ assertEquals("rename", v1Params.get(ACTION));+ assertEquals("coreName", v1Params.get(CORE));+ assertEquals("otherCore", v1Params.get(OTHER));+ }++ @Test+ public void testUnloadCoreAllParams() throws Exception {+ final SolrParams v1Params = captureConvertedV1Params("/cores/coreName", "POST",+ "{" ++ "\"unload\": {" ++ "\"deleteIndex\": true, " ++ "\"deleteDataDir\": true, " ++ "\"deleteInstanceDir\": true, " ++ "\"async\": \"someRequestId\"}}");++ assertEquals("unload", v1Params.get(ACTION));+ assertEquals("coreName", v1Params.get(CORE));+ assertEquals(true, v1Params.getBool(DELETE_INDEX));+ assertEquals(true, v1Params.getBool(DELETE_DATA_DIR));+ assertEquals(true, v1Params.getBool(DELETE_INSTANCE_DIR));+ assertEquals("someRequestId", v1Params.get(ASYNC));+ }++ @Test+ public void testMergeIndexesAllParams() throws Exception {+ final SolrParams v1Params = captureConvertedV1Params("/cores/coreName", "POST",+ "{" ++ "\"merge-indexes\": {" ++ "\"indexDir\": [\"dir1\", \"dir2\"], " ++ "\"srcCore\": [\"core1\", \"core2\"], " ++ "\"updateChain\": \"someUpdateChain\", " ++ "\"async\": \"someRequestId\"}}");++ assertEquals("mergeindexes", v1Params.get(ACTION));+ assertEquals("coreName", v1Params.get(CORE));+ assertEquals("someUpdateChain", v1Params.get(UpdateParams.UPDATE_CHAIN));+ assertEquals("someRequestId", v1Params.get(ASYNC));+ final List<String> indexDirs = Arrays.asList(v1Params.getParams("indexDir"));+ assertEquals(2, indexDirs.size());+ assertTrue(indexDirs.containsAll(List.of("dir1", "dir2")));+ final List<String> srcCores = Arrays.asList(v1Params.getParams("srcCore"));+ assertEquals(2, srcCores.size());+ assertTrue(srcCores.containsAll(List.of("core1", "core2")));+ }++ @Test+ public void testSplitCoreAllParams() throws Exception {+ final SolrParams v1Params = captureConvertedV1Params("/cores/coreName", "POST",+ "{" ++ "\"split\": {" ++ "\"path\": [\"path1\", \"path2\"], " ++ "\"targetCore\": [\"core1\", \"core2\"], " ++ "\"splitKey\": \"someSplitKey\", " ++ "\"getRanges\": true, " ++ "\"ranges\": \"range1,range2\", " ++ "\"async\": \"someRequestId\"}}");++ assertEquals("split", v1Params.get(ACTION));+ assertEquals("coreName", v1Params.get(CORE));+ assertEquals("someSplitKey", v1Params.get(SPLIT_KEY));+ assertEquals("range1,range2", v1Params.get(RANGES));+ assertEquals("someRequestId", v1Params.get(ASYNC));+ final List<String> pathEntries = Arrays.asList(v1Params.getParams(PATH));+ assertEquals(2, pathEntries.size());+ assertTrue(pathEntries.containsAll(List.of("path1", "path2")));+ final List<String> targetCoreEntries = Arrays.asList(v1Params.getParams(TARGET_CORE));+ assertEquals(2, targetCoreEntries.size());+ assertTrue(targetCoreEntries.containsAll(List.of("core1", "core2")));+ }++ private SolrParams captureConvertedV1Params(String path, String method, String v2RequestBody) throws Exception {+ final HashMap<String, String> parts = new HashMap<>();+ final Api api = apiBag.lookup(path, method, parts);+ final SolrQueryResponse rsp = new SolrQueryResponse();+ final LocalSolrQueryRequest req = new LocalSolrQueryRequest(null, Maps.newHashMap()) {+ @Override+ public List<CommandOperation> getCommands(boolean validateInput) {+ if (v2RequestBody == null) return Collections.emptyList();+ return ApiBag.getCommandOperations(new ContentStreamBase.StringStream(v2RequestBody), api.getCommandSchema(), true);+ }++ @Override+ public Map<String, String> getPathTemplateValues() {+ return parts;+ }++ @Override+ public String getHttpMethod() {+ return method;+ }+ };+++ api.call(req, rsp);+ verify(mockCoreHandler).handleRequestBody(queryRequestCaptor.capture(), any());+ return queryRequestCaptor.getValue().getParams();+ }+}diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/request/CoreApiMapping.java b/solr/solrj/src/java/org/apache/solr/client/solrj/request/CoreApiMapping.javaindex 52e78a686b4..fbd8444d324 100644--- a/solr/solrj/src/java/org/apache/solr/client/solrj/request/CoreApiMapping.java+++ b/solr/solrj/src/java/org/apache/solr/client/solrj/request/CoreApiMapping.java@@ -35,12 +35,6 @@ import static org.apache.solr.client.solrj.request.CoreApiMapping.EndPoint.*;*/public class CoreApiMapping {public enum Meta implements CommandMeta {- UNLOAD(PER_CORE_COMMANDS, POST, CoreAdminAction.UNLOAD, "unload", null),- RELOAD(PER_CORE_COMMANDS, POST, CoreAdminAction.RELOAD, "reload", null),- SWAP(PER_CORE_COMMANDS, POST, CoreAdminAction.SWAP, "swap", Collections.singletonMap("other", "with")),- RENAME(PER_CORE_COMMANDS, POST, CoreAdminAction.RENAME, "rename", Collections.singletonMap("other", "to")),- MERGEINDEXES(PER_CORE_COMMANDS, POST, CoreAdminAction.MERGEINDEXES, "merge-indexes", null),- SPLIT(PER_CORE_COMMANDS, POST, CoreAdminAction.SPLIT, "split", Collections.singletonMap("split.key", "splitKey")),PREPRECOVERY(PER_CORE_COMMANDS, POST, CoreAdminAction.PREPRECOVERY, "prep-recovery", null),REQUESTRECOVERY(PER_CORE_COMMANDS, POST, CoreAdminAction.REQUESTRECOVERY, "request-recovery", null),REQUESTSYNCSHARD(PER_CORE_COMMANDS, POST, CoreAdminAction.REQUESTSYNCSHARD, "request-sync-shard", null),diff --git a/solr/solrj/src/resources/apispec/cores.core.Commands.json b/solr/solrj/src/resources/apispec/cores.core.Commands.jsonindex 34a70d6d8b3..0afe98142f0 100644--- a/solr/solrj/src/resources/apispec/cores.core.Commands.json+++ b/solr/solrj/src/resources/apispec/cores.core.Commands.json@@ -10,99 +10,6 @@]},"commands": {- "reload": {- "type":"object",- "documentation": "https://solr.apache.org/guide/coreadmin-api.html#coreadmin-reload",- "description": "Reloads a core. This is useful when you have made changes on disk such as editing the schema or solrconfig.xml files. Most APIs reload cores automatically, so this should not be necessary if changes were made with those APIs."- },- "swap": {- "type":"object",- "documentation": "https://solr.apache.org/guide/coreadmin-api.html#coreadmin-swap",- "description": "Swaps the names of two existing Solr cores. This can be used to swap new content into production. The former core can be swapped back if necessary. Using this API is not supported in SolrCloud mode.",- "properties": {- "with": {- "type": "string",- "description": "The name of the other core to be swapped (the first core name is included in the request)."- },- "async": {- "type": "string",- "description": "Defines a request ID that can be used to track this action after it's submitted. The action will be processed asynchronously when this is defined."- }- },- "required": [- "with"- ]- },- "rename": {- "type": "object",- "documentation": "https://solr.apache.org/guide/coreadmin-api.html#coreadmin-rename",- "description": "Change the name of a core.",- "properties": {- "to": {- "type": "string",- "description": "The new name for the core."- },- "async": {- "type": "string",- "description": "Defines a request ID that can be used to track this action after it's submitted. The action will be processed asynchronously when this is defined."- }- },- "required": [- "to"- ]- },- "unload": {- "type": "object",- "documentation": "https://solr.apache.org/guide/coreadmin-api.html#coreadmin-unload",- "description": "Removes a core. Active requests would continue to be processed, but new requests will not be sent to the new core. If a core is registered under more than one name, only the name given in the request is removed.",- "properties": {- "deleteIndex": {- "type": "boolean",- "description": "If true, the index will be removed while unloading the core.",- "default": "false"- },- "deleteDataDir": {- "type": "boolean",- "description": "If true, the data directory and all sub-directories will be removed while unloading the core.",- "default": "false"- },- "deleteInstanceDir": {- "type": "boolean",- "description": "If true, everything related to the core, including the index, data, and conf directories, will be removed while unloading the core.",- "default": "false"- },- "async": {- "type": "string",- "description": "Defines a request ID that can be used to track this action after it's submitted. The action will be processed asynchronously when this is defined."- }- }- },- "merge-indexes": {- "type":"object",- "documentation": "https://solr.apache.org/guide/coreadmin-api.html#coreadmin-mergeindexes",- "description":"Merges one or more indexes to another index. The indexes must have completed commits, and should be locked against writes until the merge is complete to avoid index corruption. The target core (which is the core that should be used as the endpoint for this command) must exist before using this command. A commit should also be performed on this core after the merge is complete.",- "properties": {- "indexDir": {- "type": "array",- "description": "A comma-separated list index directories for each source core that will be merged with the target core.",- "items": {- "type": "string"- }- },- "srcCore": {- "type": "array",- "description": "A comma-separated list of the names of each source core to be merged with the target core.",- "items": {- "type": "string"- }- },- "async": {- "type": "string",- "description": "Defines a request ID that can be used to track this action after it's submitted. The action will be processed asynchronously when this is defined."- }- }- },- "split": { "#include": "cores.core.Commands.split"},"request-recovery": {"type":"object","documentation": "https://solr.apache.org/guide/coreadmin-api.html#coreadmin-requestrecovery",diff --git a/solr/solrj/src/resources/apispec/cores.core.Commands.split.json b/solr/solrj/src/resources/apispec/cores.core.Commands.split.jsondeleted file mode 100644index e20a0e524a1..00000000000--- a/solr/solrj/src/resources/apispec/cores.core.Commands.split.json+++ /dev/null@@ -1,34 +0,0 @@-{- "documentation": "https://solr.apache.org/guide/coreadmin-api.html#coreadmin-split",- "description": "Allows splitting an index into two or more new indexes.",- "type": "object",- "properties": {- "path": {- "type": "array",- "description": "Directory path(s) in which a piece of the index will be written. This allows splitting the index before creating the cores to contain them. Note if using this approach that the indexes will not be able to receive updates until a new core has been created to handle the incoming updates. If you have already created the new cores, you should define the targetCore property instead.",- "items": {- "type": "string"- }- },- "targetCore": {- "type": "array",- "description": "The target Solr core(s) to which a piece of the index will be merged (if the target core already contains data). This requires that the cores have already been created. If the cores have not yet been created, use the path property instead.",- "items": {- "type": "string"- }- },- "splitKey": {- "type":"string",- "description": "A route key to use for splitting the index. This parameter is optional, but should not be defined if the ranges parameter is also defined."- },- "ranges": {- "type": "string",- "description": "A comma-separated list of hexadecimal hash ranges that will be used to split the core. This parameter is optional, but should not be defined if the splitKey parameter is also defined."- },- "async": {- "type": "string",- "description": "Defines a request ID that can be used to track this action after it's submitted. The action will be processed asynchronously when this is defined. This command can be long-running, so running it asynchronously is recommended."- }- }--}diff --git a/solr/solrj/src/test/org/apache/solr/common/util/JsonValidatorTest.java b/solr/solrj/src/test/org/apache/solr/common/util/JsonValidatorTest.javaindex 10cc8667c5c..e4c280e58d2 100644--- a/solr/solrj/src/test/org/apache/solr/common/util/JsonValidatorTest.java+++ b/solr/solrj/src/test/org/apache/solr/common/util/JsonValidatorTest.java@@ -22,9 +22,6 @@ import org.apache.solr.SolrTestCaseJ4;import java.util.List;import java.util.Map;-import static org.apache.solr.common.util.Utils.toJSONString;-import static org.apache.solr.common.util.ValidatingJsonMap.NOT_NULL;-public class JsonValidatorTest extends SolrTestCaseJ4 {public void testSchema() {@@ -37,35 +34,13 @@ public class JsonValidatorTest extends SolrTestCaseJ4 {public void testSchemaValidation() {- // merge-indexes chosen to exercise string and array/list props.- ValidatingJsonMap spec = Utils.getSpec("cores.core.Commands").getSpec();- final Map<String, Object> mergeIndexesSchema = spec.getMap("commands", NOT_NULL).getMap("merge-indexes", NOT_NULL);- final JsonSchemaValidator mergeIndexesSchemaValidator = new JsonSchemaValidator(mergeIndexesSchema);-- List<String> errs = mergeIndexesSchemaValidator.validateJson(Utils.fromJSONString("{async : x, indexDir: [ c1 , c2]}"));- assertNull(toJSONString(errs), errs);- errs = mergeIndexesSchemaValidator.validateJson(Utils.fromJSONString("{async : x, indexDir: [c1] }"));- assertNull(toJSONString(errs), errs);- errs = mergeIndexesSchemaValidator.validateJson(Utils.fromJSONString("{async : x, x:y, indexDir: [ c1 , c2]}"));- assertNotNull(toJSONString(errs), errs);- assertTrue(toJSONString(errs), errs.get(0).contains("Unknown"));- errs = mergeIndexesSchemaValidator.validateJson(Utils.fromJSONString("{async : 123, indexDir: c1 }"));- assertNotNull(toJSONString(errs), errs);- assertTrue(toJSONString(errs), errs.get(0).contains("expected"));- errs = mergeIndexesSchemaValidator.validateJson(Utils.fromJSONString("{x:y, indexDir: [ c1 , c2]}"));- assertTrue(toJSONString(errs), StrUtils.join(errs, '|').contains("Unknown"));- errs = mergeIndexesSchemaValidator.validateJson(Utils.fromJSONString("{async : x, indexDir: [ 1 , 2]}"));- assertFalse(toJSONString(errs), errs.isEmpty());- assertTrue(toJSONString(errs), errs.get(0).contains("expected"));--final JsonSchemaValidator personSchemaValidator = new JsonSchemaValidator("{" +" type:object," +" properties: {" +" age : {type: number}," +" adult : {type: boolean}," +" name: {type: string}}}");- errs = personSchemaValidator.validateJson(Utils.fromJSONString("{name:x, age:21, adult:true}"));+ List<String> errs = personSchemaValidator.validateJson(Utils.fromJSONString("{name:x, age:21, adult:true}"));assertNull(errs);errs = personSchemaValidator.validateJson(Utils.fromJSONString("{name:x, age:'21', adult:'true'}"));assertNotNull(errs);