Refine search
@Override public String[] provide(String[] original, Object localRequest, boolean supportsReplace) { //CCS if((localRequest instanceof FieldCapabilitiesRequest || localRequest instanceof SearchRequest) && (request instanceof FieldCapabilitiesRequest || request instanceof SearchRequest)) { assert supportsReplace: localRequest.getClass().getName()+" does not support replace"; final Tuple<Boolean, String[]> ccsResult = handleCcs((Replaceable) localRequest); if(ccsResult.v1() == Boolean.TRUE) { if(ccsResult.v2() == null || ccsResult.v2().length == 0) { returnEmpty.set(true); } original = ccsResult.v2(); } } if(returnEmpty.get()) { if(log.isTraceEnabled()) { log.trace("CCS return empty indices for local node"); } } else { final Resolved iResolved = resolveIndexPatterns(original); if(log.isTraceEnabled()) { log.trace("Resolved patterns {} for {} ({}) to {}", original, localRequest.getClass().getSimpleName(), request.getClass().getSimpleName(), iResolved); } resolvedBuilder.add(iResolved); resolvedBuilder.addTypes(resolveTypes(localRequest)); } return IndicesProvider.NOOP; } }, false);
static InetSocketAddress parseSeedAddress(String remoteHost) { final Tuple<String, Integer> hostPort = parseHostPort(remoteHost); final String host = hostPort.v1(); assert hostPort.v2() != null : remoteHost; final int port = hostPort.v2(); InetAddress hostAddress; try { hostAddress = InetAddress.getByName(host); } catch (UnknownHostException e) { throw new IllegalArgumentException("unknown host [" + host + "]", e); } return new InetSocketAddress(hostAddress, port); }
/** * This configures the maximum script compilations per five minute window. * * @param newRate the new expected maximum number of compilations per five minute window */ void setMaxCompilationRate(Tuple<Integer, TimeValue> newRate) { this.rate = newRate; // Reset the counter to allow new compilations this.scriptsPerTimeWindow = rate.v1(); this.compilesAllowedPerNano = ((double) rate.v1()) / newRate.v2().nanos(); }
/** * @return a list of describing each permit that wasn't released yet. The description consist of the debugInfo supplied * when the permit was acquired plus a stack traces that was captured when the permit was request. */ List<String> getActiveOperations() { return issuedPermits.values().stream().map( t -> t.v1() + "\n" + ExceptionsHelper.formatStackTrace(t.v2())) .collect(Collectors.toList()); }
@Override protected void addCustomXContentFields(XContentBuilder builder, Params params) throws IOException { builder.startObject("upgraded_indices"); for (Map.Entry<String, Tuple<Version, String>> entry : versions.entrySet()) { builder.startObject(entry.getKey()); builder.field("upgrade_version", entry.getValue().v1()); builder.field("oldest_lucene_segment_version", entry.getValue().v2()); builder.endObject(); } builder.endObject(); }
/** * Lookup a value from the registry by name while checking that the name matches the ParseField. * * @param name The name of the thing to look up. * @return The value being looked up or null if it wasn't found. * @throws ParsingException if the named thing isn't in the registry or the name was deprecated and deprecated names aren't supported. */ public T lookupReturningNullIfNotFound(String name, DeprecationHandler deprecationHandler) { Tuple<ParseField, T> parseFieldAndValue = registry.get(name); if (parseFieldAndValue == null) { return null; } ParseField parseField = parseFieldAndValue.v1(); T value = parseFieldAndValue.v2(); boolean match = parseField.match(name, deprecationHandler); //this is always expected to match, ParseField is useful for deprecation warnings etc. here assert match : "ParseField did not match registered name [" + name + "][" + registryName + "]"; return value; } }
private void put(K key, V value, long now) { CacheSegment<K, V> segment = getCacheSegment(key); Tuple<Entry<K, V>, Entry<K, V>> tuple = segment.put(key, value, now); boolean replaced = false; try (ReleasableLock ignored = lruLock.acquire()) { if (tuple.v2() != null && tuple.v2().state == State.EXISTING) { if (unlink(tuple.v2())) { replaced = true; } } promote(tuple.v1(), now); } if (replaced) { removalListener.onRemoval(new RemovalNotification<>(tuple.v2().key, tuple.v2().value, RemovalNotification.RemovalReason.REPLACED)); } }
@Override public void writeTo(StreamOutput out) throws IOException { super.writeTo(out); out.writeVInt(versions.size()); for(Map.Entry<String, Tuple<Version, String>> entry : versions.entrySet()) { out.writeString(entry.getKey()); Version.writeVersion(entry.getValue().v1(), out); out.writeString(entry.getValue().v2()); } } }
/** * Registers this instance to listen to updates on the cluster settings. */ public void listenForUpdates(ClusterSettings clusterSettings) { clusterSettings.addAffixUpdateConsumer( RemoteClusterAware.REMOTE_CLUSTERS_PROXY, RemoteClusterAware.REMOTE_CLUSTERS_SEEDS, (key, value) -> updateRemoteCluster(key, value.v2(), value.v1()), (namespace, value) -> {}); clusterSettings.addAffixUpdateConsumer( RemoteClusterAware.SEARCH_REMOTE_CLUSTERS_PROXY, RemoteClusterAware.SEARCH_REMOTE_CLUSTERS_SEEDS, (key, value) -> updateRemoteCluster(key, value.v2(), value.v1()), (namespace, value) -> {}); }
@Override public void writeTo(StreamOutput out) throws IOException { super.writeTo(out); out.writeVInt(versions.size()); for(Map.Entry<String, Tuple<Version, String>> entry : versions.entrySet()) { out.writeString(entry.getKey()); Version.writeVersion(entry.getValue().v1(), out); out.writeString(entry.getValue().v2()); } }
public DocumentMapper parse(@Nullable String type, CompressedXContent source, String defaultSource) throws MapperParsingException { Map<String, Object> mapping = null; if (source != null) { Map<String, Object> root = XContentHelper.convertToMap(source.compressedReference(), true, XContentType.JSON).v2(); Tuple<String, Map<String, Object>> t = extractMapping(type, root); type = t.v1(); mapping = t.v2(); } if (mapping == null) { mapping = new HashMap<>(); } return parse(type, mapping, defaultSource); }
private void notifyListeners(final long globalCheckpoint, final IndexShardClosedException e) { assert Thread.holdsLock(this) : Thread.currentThread(); assertNotification(globalCheckpoint, e); final Map<GlobalCheckpointListener, Tuple<Long, ScheduledFuture<?>>> listenersToNotify; if (globalCheckpoint != UNASSIGNED_SEQ_NO) { listenersToNotify = listeners .entrySet() .stream() .filter(entry -> entry.getValue().v1() <= globalCheckpoint) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); listenersToNotify.keySet().forEach(listeners::remove); } else { listenersToNotify = new HashMap<>(listeners); listeners.clear(); } if (listenersToNotify.isEmpty() == false) { executor.execute(() -> listenersToNotify .forEach((listener, t) -> { /* * We do not want to interrupt any timeouts that fired, these will detect that the listener has been * notified and not trigger the timeout. */ FutureUtils.cancel(t.v2()); notifyListener(listener, globalCheckpoint, e); })); } }
private static Range parseIpRangeFromCidr(final XContentParser parser) throws IOException { final Tuple<InetAddress, Integer> cidr = InetAddresses.parseCidr(parser.text()); // create the lower value by zeroing out the host portion, upper value by filling it with all ones. byte[] lower = cidr.v1().getAddress(); byte[] upper = lower.clone(); for (int i = cidr.v2(); i < 8 * lower.length; i++) { int m = 1 << 7 - (i & 7); lower[i >> 3] &= ~m; upper[i >> 3] |= m; } try { return new Range(RangeType.IP, InetAddress.getByAddress(lower), InetAddress.getByAddress(upper), true, true); } catch (UnknownHostException bogus) { throw new AssertionError(bogus); } }