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