/**
* Extracts all the required fields from the RestRequest 'h' parameter. In order to support
* wildcards like 'bulk.*' this needs potentially parse all the configured headers and its aliases
* and needs to ensure that everything is only added once to the returned headers, even if
* 'h=bulk.*.bulk.*' is specified or some headers are contained twice due to matching aliases
*/
private static Set<String> expandHeadersFromRequest(Table table, RestRequest request) {
Set<String> headers = new LinkedHashSet<>(table.getHeaders().size());
// check headers and aliases
for (String header : Strings.splitStringByCommaToArray(request.param("h"))) {
if (Regex.isSimpleMatchPattern(header)) {
for (Table.Cell tableHeaderCell : table.getHeaders()) {
String configuredHeader = tableHeaderCell.value.toString();
if (Regex.simpleMatch(header, configuredHeader)) {
headers.add(configuredHeader);
} else if (tableHeaderCell.attr.containsKey("alias")) {
String[] aliases = Strings.splitStringByCommaToArray(tableHeaderCell.attr.get("alias"));
for (String alias : aliases) {
if (Regex.simpleMatch(header, alias)) {
headers.add(configuredHeader);
break;
}
}
}
}
} else {
headers.add(header);
}
}
return headers;
}
@Override
public void handleRequest(final RestRequest request, final RestChannel channel) {
MultiSearchRequest multiSearchRequest = new MultiSearchRequest();
multiSearchRequest.listenerThreaded(false);
String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
String[] types = Strings.splitStringByCommaToArray(request.param("type"));
IndicesOptions indicesOptions =
IndicesOptions.fromRequest(request, multiSearchRequest.indicesOptions());
try {
multiSearchRequest.add(
request.content(),
request.contentUnsafe(),
indices,
types,
request.param("search_type"),
request.param("routing"),
indicesOptions,
allowExplicitIndex);
} catch (Exception e) {
try {
XContentBuilder builder = restContentBuilder(request);
channel.sendResponse(
new XContentRestResponse(
request,
BAD_REQUEST,
builder.startObject().field("error", e.getMessage()).endObject()));
} catch (IOException e1) {
logger.error("Failed to send failure response", e1);
}
return;
}
client.multiSearch(
multiSearchRequest,
new ActionListener<MultiSearchResponse>() {
@Override
public void onResponse(MultiSearchResponse response) {
try {
XContentBuilder builder = restContentBuilder(request);
builder.startObject();
response.toXContent(builder, request);
builder.endObject();
channel.sendResponse(new XContentRestResponse(request, OK, builder));
} catch (Throwable e) {
onFailure(e);
}
}
@Override
public void onFailure(Throwable e) {
try {
channel.sendResponse(new XContentThrowableRestResponse(request, e));
} catch (IOException e1) {
logger.error("Failed to send failure response", e1);
}
}
});
}
private static void replacePromptPlaceholders(Settings.Builder settings, Terminal terminal) {
List<String> secretToPrompt = new ArrayList<>();
List<String> textToPrompt = new ArrayList<>();
for (Map.Entry<String, String> entry : settings.internalMap().entrySet()) {
switch (entry.getValue()) {
case SECRET_PROMPT_VALUE:
secretToPrompt.add(entry.getKey());
break;
case TEXT_PROMPT_VALUE:
textToPrompt.add(entry.getKey());
break;
}
}
for (String setting : secretToPrompt) {
String secretValue = promptForValue(setting, terminal, true);
if (Strings.hasLength(secretValue)) {
settings.put(setting, secretValue);
} else {
// TODO: why do we remove settings if prompt returns empty??
settings.remove(setting);
}
}
for (String setting : textToPrompt) {
String textValue = promptForValue(setting, terminal, false);
if (Strings.hasLength(textValue)) {
settings.put(setting, textValue);
} else {
// TODO: why do we remove settings if prompt returns empty??
settings.remove(setting);
}
}
}
/** Warn about the given disk usage if the low or high watermark has been passed */
private void warnAboutDiskIfNeeded(DiskUsage usage) {
// Check absolute disk values
if (usage.getFreeBytes() < DiskThresholdDecider.this.freeBytesThresholdHigh.bytes()) {
logger.warn(
"high disk watermark [{}] exceeded on {}, shards will be relocated away from this node",
DiskThresholdDecider.this.freeBytesThresholdHigh,
usage);
} else if (usage.getFreeBytes() < DiskThresholdDecider.this.freeBytesThresholdLow.bytes()) {
logger.info(
"low disk watermark [{}] exceeded on {}, replicas will not be assigned to this node",
DiskThresholdDecider.this.freeBytesThresholdLow,
usage);
}
// Check percentage disk values
if (usage.getFreeDiskAsPercentage() < DiskThresholdDecider.this.freeDiskThresholdHigh) {
logger.warn(
"high disk watermark [{}] exceeded on {}, shards will be relocated away from this node",
Strings.format1Decimals(100.0 - DiskThresholdDecider.this.freeDiskThresholdHigh, "%"),
usage);
} else if (usage.getFreeDiskAsPercentage() < DiskThresholdDecider.this.freeDiskThresholdLow) {
logger.info(
"low disk watermark [{}] exceeded on {}, replicas will not be assigned to this node",
Strings.format1Decimals(100.0 - DiskThresholdDecider.this.freeDiskThresholdLow, "%"),
usage);
}
}
List<String> getIndexSettingsValidationErrors(Settings settings) {
String customPath = IndexMetaData.INDEX_DATA_PATH_SETTING.get(settings);
List<String> validationErrors = new ArrayList<>();
if (Strings.isEmpty(customPath) == false && env.sharedDataFile() == null) {
validationErrors.add("path.shared_data must be set in order to use custom data paths");
} else if (Strings.isEmpty(customPath) == false) {
Path resolvedPath = PathUtils.get(new Path[] {env.sharedDataFile()}, customPath);
if (resolvedPath == null) {
validationErrors.add(
"custom path ["
+ customPath
+ "] is not a sub-path of path.shared_data ["
+ env.sharedDataFile()
+ "]");
}
}
// norelease - this can be removed?
Integer number_of_primaries = settings.getAsInt(IndexMetaData.SETTING_NUMBER_OF_SHARDS, null);
Integer number_of_replicas = settings.getAsInt(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, null);
if (number_of_primaries != null && number_of_primaries <= 0) {
validationErrors.add("index must have 1 or more primary shards");
}
if (number_of_replicas != null && number_of_replicas < 0) {
validationErrors.add("index must have 0 or more replica shards");
}
return validationErrors;
}
public static String generateNodeId(Settings settings) {
String seed = settings.get("discovery.id.seed");
if (seed != null) {
Strings.randomBase64UUID(new Random(Long.parseLong(seed)));
}
return Strings.randomBase64UUID();
}
private final String getNodeUUID(Settings settings) {
String seed = settings.get("discovery.id.seed");
if (seed != null) {
logger.trace("using stable discover node UUIDs with seed: [{}]", seed);
Strings.randomBase64UUID(new Random(Long.parseLong(seed)));
}
return Strings.randomBase64UUID();
}
public Builder(String field, String geohash, boolean neighbors) {
if (Strings.isEmpty(field)) {
throw new IllegalArgumentException("fieldName must not be null");
}
if (Strings.isEmpty(geohash)) {
throw new IllegalArgumentException("geohash or point must be defined");
}
this.fieldName = field;
this.geohash = geohash;
this.neighbors = neighbors;
}
private static List<DisplayHeader> buildDisplayHeaders(Table table, RestRequest request) {
String pHeaders = request.param("h");
List<DisplayHeader> display = new ArrayList<DisplayHeader>();
if (pHeaders != null) {
for (String possibility : Strings.splitStringByCommaToArray(pHeaders)) {
DisplayHeader dispHeader = null;
if (table.getAsMap().containsKey(possibility)) {
dispHeader = new DisplayHeader(possibility, possibility);
} else {
for (Table.Cell headerCell : table.getHeaders()) {
String aliases = headerCell.attr.get("alias");
if (aliases != null) {
for (String alias : Strings.splitStringByCommaToArray(aliases)) {
if (possibility.equals(alias)) {
dispHeader = new DisplayHeader(headerCell.value.toString(), alias);
break;
}
}
}
}
}
if (dispHeader != null) {
// We know we need the header asked for:
display.add(dispHeader);
// Look for accompanying sibling column
Table.Cell hcell = table.getHeaderMap().get(dispHeader.name);
String siblingFlag = hcell.attr.get("sibling");
if (siblingFlag != null) {
// ...link the sibling and check that its flag is set
String sibling = siblingFlag + "." + dispHeader.name;
Table.Cell c = table.getHeaderMap().get(sibling);
if (c != null && request.paramAsBoolean(siblingFlag, false)) {
display.add(
new DisplayHeader(c.value.toString(), siblingFlag + "." + dispHeader.display));
}
}
}
}
} else {
for (Table.Cell cell : table.getHeaders()) {
String d = cell.attr.get("default");
if (Booleans.parseBoolean(d, true)) {
display.add(new DisplayHeader(cell.value.toString(), cell.value.toString()));
}
}
}
return display;
}
@Override
protected Settings nodeSettings(int nodeOrdinal) {
Settings.Builder settings =
Settings.builder()
.put(super.nodeSettings(nodeOrdinal))
.put(Environment.PATH_HOME_SETTING.getKey(), createTempDir())
.extendArray("plugin.types", Ec2DiscoveryPlugin.class.getName())
.put("cloud.aws.test.random", randomInt())
.put("cloud.aws.test.write_failures", 0.1)
.put("cloud.aws.test.read_failures", 0.1);
// if explicit, just load it and don't load from env
try {
if (Strings.hasText(System.getProperty("tests.config"))) {
settings.loadFromPath(PathUtils.get(System.getProperty("tests.config")));
} else {
throw new IllegalStateException(
"to run integration tests, you need to set -Dtest.thirdparty=true and -Dtests.config=/path/to/elasticsearch.yml");
}
} catch (SettingsException exception) {
throw new IllegalStateException(
"your test configuration file is incorrect: " + System.getProperty("tests.config"),
exception);
}
return settings.build();
}
@Override
public String[] getAsArray(String settingPrefix, String[] defaultArray) throws SettingsException {
List<String> result = Lists.newArrayList();
if (get(settingPrefix) != null) {
String[] strings = Strings.splitStringByCommaToArray(get(settingPrefix));
if (strings.length > 0) {
for (String string : strings) {
result.add(string.trim());
}
}
}
int counter = 0;
while (true) {
String value = get(settingPrefix + '.' + (counter++));
if (value == null) {
break;
}
result.add(value.trim());
}
if (result.isEmpty()) {
return defaultArray;
}
return result.toArray(new String[result.size()]);
}
@Override
@SuppressWarnings("unchecked")
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext)
throws MapperParsingException {
TokenCountFieldMapper.Builder builder = tokenCountField(name);
for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<String, Object> entry = iterator.next();
String propName = Strings.toUnderscoreCase(entry.getKey());
Object propNode = entry.getValue();
if (propName.equals("null_value")) {
builder.nullValue(nodeIntegerValue(propNode));
iterator.remove();
} else if (propName.equals("analyzer")) {
NamedAnalyzer analyzer = parserContext.analysisService().analyzer(propNode.toString());
if (analyzer == null) {
throw new MapperParsingException(
"Analyzer [" + propNode.toString() + "] not found for field [" + name + "]");
}
builder.analyzer(analyzer);
iterator.remove();
}
}
parseNumberField(builder, name, node, parserContext);
if (builder.analyzer() == null) {
throw new MapperParsingException(
"Analyzer must be set for field [" + name + "] but wasn't.");
}
return builder;
}
@Override
public MetadataFieldMapper.Builder parse(
String name, Map<String, Object> node, ParserContext parserContext)
throws MapperParsingException {
Builder builder = new Builder(parserContext.type());
for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<String, Object> entry = iterator.next();
String fieldName = Strings.toUnderscoreCase(entry.getKey());
Object fieldNode = entry.getValue();
if (fieldName.equals("type")) {
builder.type(fieldNode.toString());
iterator.remove();
} else if (fieldName.equals("postings_format")
&& parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) {
// ignore before 2.0, reject on and after 2.0
iterator.remove();
} else if (fieldName.equals("fielddata")) {
// Only take over `loading`, since that is the only option now that is configurable:
Map<String, String> fieldDataSettings =
SettingsLoader.Helper.loadNestedFromMap(nodeMapValue(fieldNode, "fielddata"));
if (fieldDataSettings.containsKey(MappedFieldType.Loading.KEY)) {
Settings settings =
settingsBuilder()
.put(
MappedFieldType.Loading.KEY,
fieldDataSettings.get(MappedFieldType.Loading.KEY))
.build();
builder.fieldDataSettings(settings);
}
iterator.remove();
}
}
return builder;
}
@Override
public Mapper.Builder<?, ?> parse(
String name, Map<String, Object> node, ParserContext parserContext)
throws MapperParsingException {
DateFieldMapper.Builder builder = dateField(name);
parseNumberField(builder, name, node, parserContext);
for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<String, Object> entry = iterator.next();
String propName = Strings.toUnderscoreCase(entry.getKey());
Object propNode = entry.getValue();
if (propName.equals("null_value")) {
if (propNode == null) {
throw new MapperParsingException("Property [null_value] cannot be null.");
}
builder.nullValue(propNode.toString());
iterator.remove();
} else if (propName.equals("format")) {
builder.dateTimeFormatter(parseDateTimeFormatter(propNode));
iterator.remove();
} else if (propName.equals("numeric_resolution")) {
builder.timeUnit(TimeUnit.valueOf(propNode.toString().toUpperCase(Locale.ROOT)));
iterator.remove();
} else if (propName.equals("locale")) {
builder.locale(LocaleUtils.parse(propNode.toString()));
iterator.remove();
}
}
return builder;
}
private RestChannelConsumer parseExistingDocPercolate(
PercolateRequest percolateRequest, RestRequest restRequest, NodeClient client) {
String index = restRequest.param("index");
String type = restRequest.param("type");
percolateRequest.indices(
Strings.splitStringByCommaToArray(restRequest.param("percolate_index", index)));
percolateRequest.documentType(restRequest.param("percolate_type", type));
GetRequest getRequest = new GetRequest(index, type, restRequest.param("id"));
getRequest.routing(restRequest.param("routing"));
getRequest.preference(restRequest.param("preference"));
getRequest.refresh(restRequest.paramAsBoolean("refresh", getRequest.refresh()));
getRequest.realtime(restRequest.paramAsBoolean("realtime", getRequest.realtime()));
getRequest.version(RestActions.parseVersion(restRequest));
getRequest.versionType(
VersionType.fromString(restRequest.param("version_type"), getRequest.versionType()));
percolateRequest.getRequest(getRequest);
percolateRequest.routing(restRequest.param("percolate_routing"));
percolateRequest.preference(restRequest.param("percolate_preference"));
percolateRequest.source(restRequest.contentOrSourceParam());
percolateRequest.indicesOptions(
IndicesOptions.fromRequest(restRequest, percolateRequest.indicesOptions()));
return channel -> executePercolate(client, percolateRequest, channel);
}
@Override
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext)
throws MapperParsingException {
TTLFieldMapper.Builder builder = ttl();
for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<String, Object> entry = iterator.next();
String fieldName = Strings.toUnderscoreCase(entry.getKey());
Object fieldNode = entry.getValue();
if (fieldName.equals("enabled")) {
EnabledAttributeMapper enabledState =
nodeBooleanValue(fieldNode)
? EnabledAttributeMapper.ENABLED
: EnabledAttributeMapper.DISABLED;
builder.enabled(enabledState);
iterator.remove();
} else if (fieldName.equals("default")) {
TimeValue ttlTimeValue = nodeTimeValue(fieldNode, null);
if (ttlTimeValue != null) {
builder.defaultTTL(ttlTimeValue.millis());
}
iterator.remove();
}
}
return builder;
}
public static void parseTermVector(
String fieldName, String termVector, FieldMapper.Builder builder)
throws MapperParsingException {
termVector = Strings.toUnderscoreCase(termVector);
if ("no".equals(termVector)) {
builder.storeTermVectors(false);
} else if ("yes".equals(termVector)) {
builder.storeTermVectors(true);
} else if ("with_offsets".equals(termVector)) {
builder.storeTermVectorOffsets(true);
} else if ("with_positions".equals(termVector)) {
builder.storeTermVectorPositions(true);
} else if ("with_positions_offsets".equals(termVector)) {
builder.storeTermVectorPositions(true);
builder.storeTermVectorOffsets(true);
} else if ("with_positions_payloads".equals(termVector)) {
builder.storeTermVectorPositions(true);
builder.storeTermVectorPayloads(true);
} else if ("with_positions_offsets_payloads".equals(termVector)) {
builder.storeTermVectorPositions(true);
builder.storeTermVectorOffsets(true);
builder.storeTermVectorPayloads(true);
} else {
throw new MapperParsingException(
"wrong value for termVector [" + termVector + "] for field [" + fieldName + "]");
}
}
public Table addCell(Object value, String attributes) {
if (!inHeaders) {
if (currentCells.size() == headers.size()) {
throw new ElasticSearchIllegalArgumentException(
"can't add more cells to a row than the header");
}
}
Map<String, String> mAttr;
if (attributes.length() == 0) {
if (inHeaders) {
mAttr = ImmutableMap.of();
} else {
// get the attributes of the header cell we are going to add to
mAttr = headers.get(currentCells.size()).attr;
}
} else {
mAttr = new HashMap<String, String>();
if (!inHeaders) {
// get the attributes of the header cell we are going to add
mAttr.putAll(headers.get(currentCells.size()).attr);
}
String[] sAttrs = Strings.splitStringToArray(attributes, ';');
for (String sAttr : sAttrs) {
if (sAttr.length() == 0) {
continue;
}
int idx = sAttr.indexOf(':');
mAttr.put(sAttr.substring(0, idx), sAttr.substring(idx + 1));
}
}
addCell(new Cell(value, mAttr));
return this;
}
public String[] paramAsStringArrayOrEmptyIfAll(String key) {
String[] params = paramAsStringArray(key, Strings.EMPTY_ARRAY);
if (Strings.isAllOrWildcard(params)) {
return Strings.EMPTY_ARRAY;
}
return params;
}
@Override
public void handleRequest(
final RestRequest request, final RestChannel channel, final NodeClient client) {
ForceMergeRequest mergeRequest =
new ForceMergeRequest(Strings.splitStringByCommaToArray(request.param("index")));
mergeRequest.indicesOptions(IndicesOptions.fromRequest(request, mergeRequest.indicesOptions()));
mergeRequest.maxNumSegments(
request.paramAsInt("max_num_segments", mergeRequest.maxNumSegments()));
mergeRequest.onlyExpungeDeletes(
request.paramAsBoolean("only_expunge_deletes", mergeRequest.onlyExpungeDeletes()));
mergeRequest.flush(request.paramAsBoolean("flush", mergeRequest.flush()));
client
.admin()
.indices()
.forceMerge(
mergeRequest,
new RestBuilderListener<ForceMergeResponse>(channel) {
@Override
public RestResponse buildResponse(
ForceMergeResponse response, XContentBuilder builder) throws Exception {
builder.startObject();
buildBroadcastShardsHeader(builder, request, response);
builder.endObject();
return new BytesRestResponse(OK, builder);
}
});
}
@Override
public XContentBuilder newBuilder(@Nullable BytesReference autoDetectSource, boolean useFiltering)
throws IOException {
XContentType contentType = XContentType.fromMediaTypeOrFormat(format);
if (contentType == null) {
// try and guess it from the auto detect source
if (autoDetectSource != null) {
contentType = XContentFactory.xContentType(autoDetectSource);
}
}
if (contentType == null) {
// default to JSON
contentType = XContentType.JSON;
}
Set<String> includes = Collections.emptySet();
Set<String> excludes = Collections.emptySet();
if (useFiltering) {
Set<String> filters = Strings.splitStringByCommaToSet(filterPath);
includes = filters.stream().filter(INCLUDE_FILTER).collect(toSet());
excludes = filters.stream().filter(EXCLUDE_FILTER).map(f -> f.substring(1)).collect(toSet());
}
XContentBuilder builder =
new XContentBuilder(
XContentFactory.xContent(contentType), bytesOutput(), includes, excludes);
if (pretty) {
builder.prettyPrint().lfAtEnd();
}
builder.humanReadable(human);
return builder;
}
public static int flagsFromString(String flags) {
int pFlags = 0;
for (String s : Strings.delimitedListToStringArray(flags, "|")) {
if (s.isEmpty()) {
continue;
}
if ("CASE_INSENSITIVE".equalsIgnoreCase(s)) {
pFlags |= Pattern.CASE_INSENSITIVE;
} else if ("MULTILINE".equalsIgnoreCase(s)) {
pFlags |= Pattern.MULTILINE;
} else if ("DOTALL".equalsIgnoreCase(s)) {
pFlags |= Pattern.DOTALL;
} else if ("UNICODE_CASE".equalsIgnoreCase(s)) {
pFlags |= Pattern.UNICODE_CASE;
} else if ("CANON_EQ".equalsIgnoreCase(s)) {
pFlags |= Pattern.CANON_EQ;
} else if ("UNIX_LINES".equalsIgnoreCase(s)) {
pFlags |= Pattern.UNIX_LINES;
} else if ("LITERAL".equalsIgnoreCase(s)) {
pFlags |= Pattern.LITERAL;
} else if ("COMMENTS".equalsIgnoreCase(s)) {
pFlags |= Pattern.COMMENTS;
} else {
throw new ElasticSearchIllegalArgumentException("Unknown regex flag [" + s + "]");
}
}
return pFlags;
}
private SegmenterFactory buildSegmenterFactory() {
FieldOptions options = context.field.fieldOptions();
if (options.numberOfFragments() == 0) {
return new WholeSourceSegmenterFactory();
}
if (options.fragmenter() == null || options.fragmenter().equals("scan")) {
// TODO boundaryChars
return new CharScanningSegmenterFactory(
options.fragmentCharSize(), options.boundaryMaxScan());
}
if (options.fragmenter().equals("sentence")) {
String localeString = (String) getOption("locale");
Locale locale;
if (localeString == null) {
locale = Locale.US;
} else {
locale = Strings.parseLocaleString(localeString);
}
return new SentenceIteratorSegmenterFactory(locale, options.boundaryMaxScan());
}
if (options.fragmenter().equals("none")) {
return new WholeSourceSegmenterFactory();
}
throw new IllegalArgumentException(
"Unknown fragmenter: '"
+ options.fragmenter()
+ "'. Options are 'scan' or 'sentence'.");
}
public static void parseNumberField(
NumberFieldMapper.Builder builder,
String name,
Map<String, Object> numberNode,
Mapper.TypeParser.ParserContext parserContext) {
parseField(builder, name, numberNode, parserContext);
for (Iterator<Map.Entry<String, Object>> iterator = numberNode.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<String, Object> entry = iterator.next();
String propName = Strings.toUnderscoreCase(entry.getKey());
Object propNode = entry.getValue();
if (propName.equals("precision_step")) {
builder.precisionStep(nodeIntegerValue(propNode));
iterator.remove();
} else if (propName.equals("ignore_malformed")) {
builder.ignoreMalformed(nodeBooleanValue(propNode));
iterator.remove();
} else if (propName.equals("coerce")) {
builder.coerce(nodeBooleanValue(propNode));
iterator.remove();
} else if (propName.equals("omit_norms")) {
builder.omitNorms(nodeBooleanValue(propNode));
iterator.remove();
} else if (propName.equals("similarity")) {
builder.similarity(parserContext.similarityLookupService().similarity(propNode.toString()));
iterator.remove();
} else if (parseMultiField(builder, name, parserContext, propName, propNode)) {
iterator.remove();
}
}
}
@Override
public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext)
throws MapperParsingException {
if (parserContext.indexVersionCreated().before(Version.V_1_3_0)) {
throw new IllegalArgumentException(
"type="
+ CONTENT_TYPE
+ " is not supported on indices created before version 1.3.0. Is your cluster running multiple datanode versions?");
}
FieldNamesFieldMapper.Builder builder = fieldNames();
if (parserContext.indexVersionCreated().before(Version.V_2_0_0)) {
parseField(builder, builder.name, node, parserContext);
}
for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<String, Object> entry = iterator.next();
String fieldName = Strings.toUnderscoreCase(entry.getKey());
Object fieldNode = entry.getValue();
if (fieldName.equals("enabled")) {
builder.enabled(nodeBooleanValue(fieldNode));
iterator.remove();
}
}
return builder;
}
public static Settings processSettings(Settings settings) {
if (settings.get(TRIBE_NAME) != null) {
// if its a node client started by this service as tribe, remove any tribe group setting
// to avoid recursive configuration
Settings.Builder sb = Settings.builder().put(settings);
for (String s : settings.getAsMap().keySet()) {
if (s.startsWith("tribe.") && !s.equals(TRIBE_NAME)) {
sb.remove(s);
}
}
return sb.build();
}
Map<String, Settings> nodesSettings = settings.getGroups("tribe", true);
if (nodesSettings.isEmpty()) {
return settings;
}
// its a tribe configured node..., force settings
Settings.Builder sb = Settings.builder().put(settings);
sb.put(Node.NODE_CLIENT_SETTING.getKey(), true); // this node should just act as a node client
sb.put(
DiscoveryModule.DISCOVERY_TYPE_SETTING.getKey(),
"local"); // a tribe node should not use zen discovery
sb.put(
DiscoveryService.INITIAL_STATE_TIMEOUT_SETTING.getKey(),
0); // nothing is going to be discovered, since no master will be elected
if (sb.get("cluster.name") == null) {
sb.put(
"cluster.name",
"tribe_"
+ Strings
.randomBase64UUID()); // make sure it won't join other tribe nodes in the same JVM
}
sb.put(TransportMasterNodeReadAction.FORCE_LOCAL_SETTING, true);
return sb.build();
}
public String[] paramAsStringArray(String key, String[] defaultValue) {
String value = param(key);
if (value == null) {
return defaultValue;
}
return Strings.splitStringByCommaToArray(value);
}
/** A helper method for checking if all mandatory apps are present. */
private void checkMandatory() {
String[] mandatoryApps = settings.getAsArray("apps.mandatory", null);
if (mandatoryApps != null) {
Set<String> missingApps = Sets.newHashSet();
for (String mandatoryApp : mandatoryApps) {
boolean found = false;
// do not check versions
for (App app : apps.values()) {
String appName = app.groupId() + ":" + app.artifactId();
if (mandatoryApp.startsWith(appName)) {
found = true;
}
}
if (!found && !missingApps.contains(mandatoryApp)) {
missingApps.add(mandatoryApp);
}
}
if (!missingApps.isEmpty()) {
throw new ElasticSearchException(
"Missing mandatory apps ["
+ Strings.collectionToDelimitedString(missingApps, ", ")
+ "]");
}
}
}
static void addBindPermissions(Permissions policy, Settings settings) throws IOException {
// http is simple
String httpRange = HttpTransportSettings.SETTING_HTTP_PORT.get(settings).getPortRangeString();
// listen is always called with 'localhost' but use wildcard to be sure, no name service is
// consulted.
// see SocketPermission implies() code
policy.add(new SocketPermission("*:" + httpRange, "listen,resolve"));
// transport is waaaay overengineered
Map<String, Settings> profiles =
TransportSettings.TRANSPORT_PROFILES_SETTING.get(settings).getAsGroups();
if (!profiles.containsKey(TransportSettings.DEFAULT_PROFILE)) {
profiles = new HashMap<>(profiles);
profiles.put(TransportSettings.DEFAULT_PROFILE, Settings.EMPTY);
}
// loop through all profiles and add permissions for each one, if its valid.
// (otherwise NettyTransport is lenient and ignores it)
for (Map.Entry<String, Settings> entry : profiles.entrySet()) {
Settings profileSettings = entry.getValue();
String name = entry.getKey();
String transportRange = profileSettings.get("port", TransportSettings.PORT.get(settings));
// a profile is only valid if its the default profile, or if it has an actual name and
// specifies a port
boolean valid =
TransportSettings.DEFAULT_PROFILE.equals(name)
|| (Strings.hasLength(name) && profileSettings.get("port") != null);
if (valid) {
// listen is always called with 'localhost' but use wildcard to be sure, no name service is
// consulted.
// see SocketPermission implies() code
policy.add(new SocketPermission("*:" + transportRange, "listen,resolve"));
}
}
}
private static long clusterSeed() {
String property = System.getProperty(TESTS_CLUSTER_SEED);
if (!Strings.hasLength(property)) {
return System.nanoTime();
}
return SeedUtils.parseSeed(property);
}
