@Override public XContentBuilder doXContentBody(XContentBuilder builder, Params params) throws IOException { if (keyed) { builder.startObject(CommonFields.BUCKETS); } else { builder.startArray(CommonFields.BUCKETS); } for (B bucket : buckets) { bucket.toXContent(builder, params); } if (keyed) { builder.endObject(); } else { builder.endArray(); } return builder; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); if (tokens != null) { builder.startArray(Fields.TOKENS); for (AnalyzeToken token : tokens) { token.toXContent(builder, params); } builder.endArray(); } if (detail != null) { builder.startObject(Fields.DETAIL); detail.toXContent(builder, params); builder.endObject(); } builder.endObject(); return builder; }
private static XContentBuilder createMappinmgWithCopyToInMultiField() throws IOException { XContentBuilder mapping = jsonBuilder(); mapping.startObject() .startObject("type") .startObject("properties") .startObject("a") .field("type", "text") .endObject() .startObject("b") .field("type", "text") .startObject("fields") .startObject("c") .field("type", "text") .field("copy_to", "a") .endObject() .endObject() .endObject() .endObject() .endObject() .endObject(); return mapping; }
@Override protected XContentBuilder doInternalXContent(XContentBuilder builder, Params params) throws IOException { // builder.startObject(); if (shardSize != SamplerParser.DEFAULT_SHARD_SAMPLE_SIZE) { builder.field(SamplerParser.SHARD_SIZE_FIELD.getPreferredName(), shardSize); } if (maxDocsPerValue != SamplerParser.MAX_DOCS_PER_VALUE_DEFAULT) { builder.field(SamplerParser.MAX_DOCS_PER_VALUE_FIELD.getPreferredName(), maxDocsPerValue); } if (executionHint != null) { builder.field(SamplerParser.EXECUTION_HINT_FIELD.getPreferredName(), executionHint); } return builder; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(Fields.ROUTING) .field(Fields.STATE, shardRouting.state()) .field(Fields.PRIMARY, shardRouting.primary()) .field(Fields.NODE, shardRouting.currentNodeId()) .field(Fields.RELOCATING_NODE, shardRouting.relocatingNodeId()) .endObject(); commonStats.toXContent(builder, params); if (commitStats != null) { commitStats.toXContent(builder, params); } builder.startObject(Fields.SHARD_PATH); builder.field(Fields.STATE_PATH, statePath); builder.field(Fields.DATA_PATH, dataPath); builder.field(Fields.IS_CUSTOM_DATA_PATH, isCustomDataPath); builder.endObject(); return builder; }
public void testSerializeDefaults() throws Exception { for (String type : TYPES) { String mapping = XContentFactory.jsonBuilder().startObject().startObject("type") .startObject("properties").startObject("field").field("type", type).endObject().endObject() .endObject().endObject().string(); DocumentMapper docMapper = parser.parse("type", new CompressedXContent(mapping)); RangeFieldMapper mapper = (RangeFieldMapper) docMapper.root().getMapper("field"); XContentBuilder builder = XContentFactory.jsonBuilder().startObject(); mapper.doXContentBody(builder, true, ToXContent.EMPTY_PARAMS); String got = builder.endObject().string(); // if type is date_range we check that the mapper contains the default format and locale // otherwise it should not contain a locale or format assertTrue(got, got.contains("\"format\":\"strict_date_optional_time||epoch_millis\"") == type.equals("date_range")); assertTrue(got, got.contains("\"locale\":" + "\"" + Locale.ROOT + "\"") == type.equals("date_range")); } }
@Override public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException { builder.startObject(Fields.INDEXING); totalStats.toXContent(builder, params); if (typeStats != null && !typeStats.isEmpty()) { builder.startObject(Fields.TYPES); for (Map.Entry<String, Stats> entry : typeStats.entrySet()) { builder.startObject(entry.getKey(), XContentBuilder.FieldCaseConversion.NONE); entry.getValue().toXContent(builder, params); builder.endObject(); } builder.endObject(); } builder.endObject(); return builder; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); builder.field("name", nodeName); builder.field("cluster_name", clusterName.value()); builder.field("cluster_uuid", clusterUuid); builder.startObject("version") .field("number", version.toString()) .field("build_hash", build.shortHash()) .field("build_date", build.date()) .field("build_snapshot", build.isSnapshot()) .field("lucene_version", version.luceneVersion.toString()) .endObject(); builder.field("tagline", "You Know, for Search"); builder.endObject(); return builder; }
public void testTwoAggs() throws Exception { assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled", XContent.isStrictDuplicateDetectionEnabled()); XContentBuilder source = JsonXContent.contentBuilder() .startObject() .startObject("by_date") .startObject("date_histogram") .field("field", "timestamp") .field("interval", "month") .endObject() .startObject("aggs") .startObject("tag_count") .startObject("cardinality") .field("field", "tag") .endObject() .endObject() .endObject() .startObject("aggs") // 2nd "aggs": illegal .startObject("tag_count2") .startObject("cardinality") .field("field", "tag") .endObject() .endObject() .endObject() .endObject() .endObject(); XContentParser parser = createParser(source); QueryParseContext parseContext = new QueryParseContext(parser); assertSame(XContentParser.Token.START_OBJECT, parser.nextToken()); Exception e = expectThrows(ParsingException.class, () -> AggregatorFactories.parseAggregators(parseContext)); assertThat(e.toString(), containsString("Found two sub aggregation definitions under [by_date]")); }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); builder.startArray(Fields.DOCS); for (MultiTermVectorsItemResponse response : responses) { if (response.isFailed()) { builder.startObject(); Failure failure = response.getFailure(); builder.field(Fields._INDEX, failure.getIndex()); builder.field(Fields._TYPE, failure.getType()); builder.field(Fields._ID, failure.getId()); ElasticsearchException.generateFailureXContent(builder, params, failure.getCause(), true); builder.endObject(); } else { TermVectorsResponse getResponse = response.getResponse(); getResponse.toXContent(builder, params); } } builder.endArray(); builder.endObject(); return builder; }
/** * builds an array of coordinates to a {@link XContentBuilder} * * @param builder builder to use * @param closed repeat the first point at the end of the array if it's not already defines as last element of the array * @return the builder */ protected XContentBuilder coordinatesToXcontent(XContentBuilder builder, boolean closed) throws IOException { builder.startArray(); for(Coordinate point : points) { toXContent(builder, point); } if(closed) { Coordinate start = points.get(0); Coordinate end = points.get(points.size()-1); if(start.x != end.x || start.y != end.y) { toXContent(builder, points.get(0)); } } builder.endArray(); return builder; }
public XContentBuilder createIndexMapping() { try { XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject(CITY_TYPE) .startObject("properties") // city .startObject("name") .field("type", "string") .endObject() // country .startObject("country") .field("type", "string") .field("index", "not_analyzed") .endObject() .endObject() .endObject().endObject(); return mapping; } catch(IOException ioe) { throw new TechnicalException(String.format("Error while getting mapping for index [%s/%s]: %s", INDEX, CITY_TYPE, ioe.getMessage()), ioe); } }
public void testPipelineQueryParameterIsError() throws IOException { RestReindexAction action = new RestReindexAction(Settings.EMPTY, mock(RestController.class)); FakeRestRequest.Builder request = new FakeRestRequest.Builder(xContentRegistry()); try (XContentBuilder body = JsonXContent.contentBuilder().prettyPrint()) { body.startObject(); { body.startObject("source"); { body.field("index", "source"); } body.endObject(); body.startObject("dest"); { body.field("index", "dest"); } body.endObject(); } body.endObject(); request.withContent(body.bytes(), body.contentType()); } request.withParams(singletonMap("pipeline", "doesn't matter")); Exception e = expectThrows(IllegalArgumentException.class, () -> action.buildRequest(request.build())); assertEquals("_reindex doesn't support [pipeline] as a query parmaeter. Specify it in the [dest] object instead.", e.getMessage()); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { 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())); return channel -> 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); } }); }
public void testConditionsParsing() throws Exception { final RolloverRequest request = new RolloverRequest(randomAsciiOfLength(10), randomAsciiOfLength(10)); final XContentBuilder builder = XContentFactory.jsonBuilder() .startObject() .startObject("conditions") .field("max_age", "10d") .field("max_docs", 100) .endObject() .endObject(); RolloverRequest.PARSER.parse(createParser(builder), request, null); Set<Condition> conditions = request.getConditions(); assertThat(conditions.size(), equalTo(2)); for (Condition condition : conditions) { if (condition instanceof MaxAgeCondition) { MaxAgeCondition maxAgeCondition = (MaxAgeCondition) condition; assertThat(maxAgeCondition.value.getMillis(), equalTo(TimeValue.timeValueHours(24 * 10).getMillis())); } else if (condition instanceof MaxDocsCondition) { MaxDocsCondition maxDocsCondition = (MaxDocsCondition) condition; assertThat(maxDocsCondition.value, equalTo(100L)); } else { fail("unexpected condition " + condition); } } }
public void testMultiFieldWithDot() throws IOException { XContentBuilder mapping = jsonBuilder(); mapping.startObject() .startObject("my_type") .startObject("properties") .startObject("city") .field("type", "text") .startObject("fields") .startObject("raw.foo") .field("type", "text") .field("index", "not_analyzed") .endObject() .endObject() .endObject() .endObject() .endObject() .endObject(); MapperService mapperService = createIndex("test").mapperService(); try { mapperService.documentMapperParser().parse("my_type", new CompressedXContent(mapping.string())); fail("this should throw an exception because one field contains a dot"); } catch (MapperParsingException e) { assertThat(e.getMessage(), equalTo("Field name [raw.foo] which is a multi field of [city] cannot contain '.'")); } }
@Override public final XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(getName()); if (this.metaData != null) { builder.field("meta", this.metaData); } builder.startObject(type); if (bucketsPaths != null) { builder.startArray(PipelineAggregator.Parser.BUCKETS_PATH.getPreferredName()); for (String path : bucketsPaths) { builder.value(path); } builder.endArray(); } internalXContent(builder, params); builder.endObject(); return builder.endObject(); }
public void testContainsShapeQuery() throws Exception { // Create a random geometry collection. Rectangle mbr = xRandomRectangle(random(), xRandomPoint(random()), true); GeometryCollectionBuilder gcb = createGeometryCollectionWithin(random(), mbr); client().admin().indices().prepareCreate("test").addMapping("type", "location", "type=geo_shape,tree=quadtree" ) .execute().actionGet(); XContentBuilder docSource = gcb.toXContent(jsonBuilder().startObject().field("location"), null).endObject(); client().prepareIndex("test", "type", "1").setSource(docSource).setRefreshPolicy(IMMEDIATE).get(); // index the mbr of the collection EnvelopeBuilder env = new EnvelopeBuilder(new Coordinate(mbr.getMinX(), mbr.getMaxY()), new Coordinate(mbr.getMaxX(), mbr.getMinY())); docSource = env.toXContent(jsonBuilder().startObject().field("location"), null).endObject(); client().prepareIndex("test", "type", "2").setSource(docSource).setRefreshPolicy(IMMEDIATE).get(); ShapeBuilder filterShape = (gcb.getShapeAt(randomIntBetween(0, gcb.numShapes() - 1))); GeoShapeQueryBuilder filter = QueryBuilders.geoShapeQuery("location", filterShape) .relation(ShapeRelation.CONTAINS); SearchResponse response = client().prepareSearch("test").setTypes("type").setQuery(QueryBuilders.matchAllQuery()) .setPostFilter(filter).get(); assertSearchResponse(response); assertThat(response.getHits().getTotalHits(), greaterThan(0L)); }
public void testLatLonInOneValueArray() throws Exception { XContentBuilder xContentBuilder = XContentFactory.jsonBuilder().startObject().startObject("type") .startObject("properties").startObject("point").field("type", "geo_point").field("doc_values", false); String mapping = xContentBuilder.field("store", true).endObject().endObject().endObject().endObject().string(); DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type", new CompressedXContent(mapping)); ParsedDocument doc = defaultMapper.parse("test", "type", "1", XContentFactory.jsonBuilder() .startObject() .startArray("point") .value("1.2,1.3") .value("1.4,1.5") .endArray() .endObject() .bytes()); // doc values are enabled by default, but in this test we disable them; we should only have 2 points assertThat(doc.rootDoc().getFields("point"), notNullValue()); assertThat(doc.rootDoc().getFields("point").length, equalTo(4)); }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(Fields.TRANSPORT); builder.array(Fields.BOUND_ADDRESS, (Object[]) address.boundAddresses()); builder.field(Fields.PUBLISH_ADDRESS, address.publishAddress().toString()); builder.startObject(Fields.PROFILES); if (profileAddresses != null && profileAddresses.size() > 0) { for (Map.Entry<String, BoundTransportAddress> entry : profileAddresses.entrySet()) { builder.startObject(entry.getKey()); builder.array(Fields.BOUND_ADDRESS, (Object[]) entry.getValue().boundAddresses()); builder.field(Fields.PUBLISH_ADDRESS, entry.getValue().publishAddress().toString()); builder.endObject(); } } builder.endObject(); builder.endObject(); return builder; }
public void testFromXContent() throws IOException { final XContent xContent = randomFrom(XContentType.values()).xContent(); XContentBuilder builder = XContentBuilder.builder(xContent) .startObject() .field("type", "foo") .field("reason", "something went wrong") .field("stack_trace", "...") .endObject(); ElasticsearchException parsed; try (XContentParser parser = createParser(xContent, builder.bytes())) { assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken()); parsed = ElasticsearchException.fromXContent(parser); assertEquals(XContentParser.Token.END_OBJECT, parser.currentToken()); assertNull(parser.nextToken()); } assertNotNull(parsed); assertEquals(parsed.getMessage(), "Elasticsearch exception [type=foo, reason=something went wrong, stack_trace=...]"); }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject() .field("state", state()) .field("primary", primary()) .field("node", currentNodeId()) .field("relocating_node", relocatingNodeId()) .field("shard", shardId().id()) .field("index", shardId().index().name()) .field("version", version); if (expectedShardSize != UNAVAILABLE_EXPECTED_SHARD_SIZE) { builder.field("expected_shard_size_in_bytes", expectedShardSize); } if (restoreSource() != null) { builder.field("restore_source"); restoreSource().toXContent(builder, params); } if (allocationId != null) { allocationId.toXContent(builder, params); } if (unassignedInfo != null) { unassignedInfo.toXContent(builder, params); } return builder.endObject(); }
/** * Statis toXContent helper method that also renders non {@link org.elasticsearch.ElasticsearchException} instances as XContent. */ public static void toXContent(XContentBuilder builder, Params params, Throwable ex) throws IOException { ex = ExceptionsHelper.unwrapCause(ex); if (ex instanceof ElasticsearchException) { ((ElasticsearchException) ex).toXContent(builder, params); } else { builder.field("type", getExceptionName(ex)); builder.field("reason", ex.getMessage()); if (ex.getCause() != null) { builder.field("caused_by"); builder.startObject(); toXContent(builder, params, ex.getCause()); builder.endObject(); } if (params.paramAsBoolean(REST_EXCEPTION_SKIP_STACK_TRACE, REST_EXCEPTION_SKIP_STACK_TRACE_DEFAULT) == false) { builder.field("stack_trace", ExceptionsHelper.stackTrace(ex)); } } }
@Override public void handleRequest(final RestRequest request, final RestChannel channel, Client client) { DeleteIndexedScriptRequest deleteIndexedScriptRequest = new DeleteIndexedScriptRequest(getScriptLang(request), request.param("id")); deleteIndexedScriptRequest.version(request.paramAsLong("version", deleteIndexedScriptRequest.version())); deleteIndexedScriptRequest.versionType(VersionType.fromString(request.param("version_type"), deleteIndexedScriptRequest.versionType())); client.deleteIndexedScript(deleteIndexedScriptRequest, new RestBuilderListener<DeleteIndexedScriptResponse>(channel) { @Override public RestResponse buildResponse(DeleteIndexedScriptResponse result, XContentBuilder builder) throws Exception { builder.startObject() .field(Fields.FOUND, result.isFound()) .field(Fields._INDEX, result.getIndex()) .field(Fields._TYPE, result.getType()) .field(Fields._ID, result.getId()) .field(Fields._VERSION, result.getVersion()) .endObject(); RestStatus status = OK; if (!result.isFound()) { status = NOT_FOUND; } return new BytesRestResponse(status, builder); } }); }
private static String arrayToParsableString(String[] array) { try { XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent()); builder.startArray(); for (String element : array) { builder.value(element); } builder.endArray(); return builder.string(); } catch (IOException ex) { throw new ElasticsearchException(ex); } }
public void testExceptionForCopyToInMultiFields() throws IOException { XContentBuilder mapping = createMappinmgWithCopyToInMultiField(); // first check that for newer versions we throw exception if copy_to is found withing multi field MapperService mapperService = MapperTestUtils.newMapperService(xContentRegistry(), createTempDir(), Settings.EMPTY); try { mapperService.parse("type", new CompressedXContent(mapping.string()), true); fail("Parsing should throw an exception because the mapping contains a copy_to in a multi field"); } catch (MapperParsingException e) { assertThat(e.getMessage(), equalTo("copy_to in multi fields is not allowed. Found the copy_to in field [c] which is within a multi field.")); } }
public static void addMapping(ESDriver es, String index, String type) { XContentBuilder Mapping; try { Mapping = jsonBuilder().startObject().startObject(type).startObject("properties").startObject("concept_A").field("type", "string").field("index", "not_analyzed").endObject() .startObject("concept_B").field("type", "string").field("index", "not_analyzed").endObject() .endObject().endObject().endObject(); es.getClient().admin().indices().preparePutMapping(index).setType(type).setSource(Mapping).execute().actionGet(); } catch (IOException e) { e.printStackTrace(); } }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); builder.field(CLUSTER_NAME, getClusterName()); builder.field(STATUS, getStatus().name().toLowerCase(Locale.ROOT)); builder.field(TIMED_OUT, isTimedOut()); builder.field(NUMBER_OF_NODES, getNumberOfNodes()); builder.field(NUMBER_OF_DATA_NODES, getNumberOfDataNodes()); builder.field(ACTIVE_PRIMARY_SHARDS, getActivePrimaryShards()); builder.field(ACTIVE_SHARDS, getActiveShards()); builder.field(RELOCATING_SHARDS, getRelocatingShards()); builder.field(INITIALIZING_SHARDS, getInitializingShards()); builder.field(UNASSIGNED_SHARDS, getUnassignedShards()); builder.field(DELAYED_UNASSIGNED_SHARDS, getDelayedUnassignedShards()); builder.field(NUMBER_OF_PENDING_TASKS, getNumberOfPendingTasks()); builder.field(NUMBER_OF_IN_FLIGHT_FETCH, getNumberOfInFlightFetch()); builder.timeValueField(TASK_MAX_WAIT_TIME_IN_QUEUE_IN_MILLIS, TASK_MAX_WAIT_TIME_IN_QUEUE, getTaskMaxWaitingTime()); builder.percentageField(ACTIVE_SHARDS_PERCENT_AS_NUMBER, ACTIVE_SHARDS_PERCENT, getActiveShardsPercent()); String level = params.param("level", "cluster"); boolean outputIndices = "indices".equals(level) || "shards".equals(level); if (outputIndices) { builder.startObject(INDICES); for (ClusterIndexHealth indexHealth : clusterStateHealth.getIndices().values()) { builder.startObject(indexHealth.getIndex()); indexHealth.toXContent(builder, params); builder.endObject(); } builder.endObject(); } builder.endObject(); return builder; }
@Override protected void doXContent(XContentBuilder builder, ToXContent.Params params) throws IOException { builder.startObject("memgraph_query_string"); super.doXContent(builder, params); builder.startArray("authorizations"); for (String authorization : authorizations.getAuthorizations()) { builder.value(authorization); } builder.endArray(); builder.endObject(); }
@Override protected XContentBuilder internalXContent(XContentBuilder builder, Params params) throws IOException { if (format != null) { builder.field(DerivativeParser.FORMAT.getPreferredName(), format); } if (gapPolicy != null) { builder.field(DerivativeParser.GAP_POLICY.getPreferredName(), gapPolicy.getName()); } if (unit != null) { builder.field(DerivativeParser.UNIT.getPreferredName(), unit); } return builder; }
public void testThatToXContentWritesOutUnboundedCorrectly() throws Exception { ThreadPool.Info info = new ThreadPool.Info("foo", threadPoolType, 1, 10, TimeValue.timeValueMillis(3000), null); XContentBuilder builder = jsonBuilder(); builder.startObject(); info.toXContent(builder, ToXContent.EMPTY_PARAMS); builder.endObject(); Map<String, Object> map = XContentHelper.convertToMap(builder.bytes(), false, builder.contentType()).v2(); assertThat(map, hasKey("foo")); map = (Map<String, Object>) map.get("foo"); assertThat(map, hasKey("queue_size")); assertThat(map.get("queue_size").toString(), is("-1")); }
/** * Return a {@link String} that is the json representation of the provided * {@link ToXContent}. */ public static String toString(ToXContent toXContent) { try { XContentBuilder builder = JsonXContent.contentBuilder(); toXContent.toXContent(builder, ToXContent.EMPTY_PARAMS); return builder.string(); } catch (IOException e) { throw new AssertionError("Cannot happen", e); } }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); builder.field(FIELD_TYPE, TYPE.shapename); builder.startArray(FIELD_COORDINATES); for(BasePolygonBuilder<?> polygon : polygons) { builder.startArray(); polygon.coordinatesArray(builder, params); builder.endArray(); } builder.endArray(); return builder.endObject(); }
@Override public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException { builder.startObject(Fields.SHARDS_STATS); builder.field(Fields.INITIALIZING, getInitializingShards()); builder.field(Fields.STARTED, getStartedShards()); builder.field(Fields.FINALIZING, getFinalizingShards()); builder.field(Fields.DONE, getDoneShards()); builder.field(Fields.FAILED, getFailedShards()); builder.field(Fields.TOTAL, getTotalShards()); builder.endObject(); return builder; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { return builder.startObject() .field("repository", snapshotId.getRepository()) .field("snapshot", snapshotId.getSnapshot()) .field("version", version.toString()) .field("index", index) .endObject(); }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(Fields.CPU).field(Fields.PERCENT, cpuPercent).endObject(); if (count > 0) { builder.startObject(Fields.OPEN_FILE_DESCRIPTORS); builder.field(Fields.MIN, getMinOpenFileDescriptors()); builder.field(Fields.MAX, getMaxOpenFileDescriptors()); builder.field(Fields.AVG, getAvgOpenFileDescriptors()); builder.endObject(); } return builder; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(Fields.STORE); builder.byteSizeField(Fields.SIZE_IN_BYTES, Fields.SIZE, sizeInBytes); builder.timeValueField(Fields.THROTTLE_TIME_IN_MILLIS, Fields.THROTTLE_TIME, throttleTime()); builder.endObject(); return builder; }
@Override public final XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { if (weight != null) { builder.field(FunctionScoreQueryBuilder.WEIGHT_FIELD.getPreferredName(), weight); } doXContent(builder, params); return builder; }
public void testShardStats() throws IOException { IndexShard shard = newStartedShard(); ShardStats stats = new ShardStats(shard.routingEntry(), shard.shardPath(), new CommonStats(new IndicesQueryCache(Settings.EMPTY), shard, new CommonStatsFlags()), shard.commitStats(), shard.seqNoStats()); assertEquals(shard.shardPath().getRootDataPath().toString(), stats.getDataPath()); assertEquals(shard.shardPath().getRootStatePath().toString(), stats.getStatePath()); assertEquals(shard.shardPath().isCustomDataPath(), stats.isCustomDataPath()); if (randomBoolean() || true) { // try to serialize it to ensure values survive the serialization BytesStreamOutput out = new BytesStreamOutput(); stats.writeTo(out); StreamInput in = out.bytes().streamInput(); stats = ShardStats.readShardStats(in); } XContentBuilder builder = jsonBuilder(); builder.startObject(); stats.toXContent(builder, EMPTY_PARAMS); builder.endObject(); String xContent = builder.string(); StringBuilder expectedSubSequence = new StringBuilder("\"shard_path\":{\"state_path\":\""); expectedSubSequence.append(shard.shardPath().getRootStatePath().toString()); expectedSubSequence.append("\",\"data_path\":\""); expectedSubSequence.append(shard.shardPath().getRootDataPath().toString()); expectedSubSequence.append("\",\"is_custom_data_path\":").append(shard.shardPath().isCustomDataPath()).append("}"); if (Constants.WINDOWS) { // Some path weirdness on windows } else { assertTrue(xContent.contains(expectedSubSequence)); } closeShards(shard); }
public void testContextFuzzy() throws Exception { LinkedHashMap<String, ContextMapping> map = new LinkedHashMap<>(); map.put("cat", ContextBuilder.category("cat").field("cat").build()); boolean addAnotherContext = randomBoolean(); if (addAnotherContext) { map.put("type", ContextBuilder.category("type").field("type").build()); } final CompletionMappingBuilder mapping = new CompletionMappingBuilder().context(map); createIndexAndMapping(mapping); int numDocs = 10; List<IndexRequestBuilder> indexRequestBuilders = new ArrayList<>(); for (int i = 0; i < numDocs; i++) { XContentBuilder source = jsonBuilder() .startObject() .startObject(FIELD) .field("input", "sugxgestion" + i) .field("weight", i + 1) .endObject() .field("cat", "cat" + i % 2); if (addAnotherContext) { source.field("type", "type" + i % 3); } source.endObject(); indexRequestBuilders.add(client().prepareIndex(INDEX, TYPE, "" + i) .setSource(source)); } indexRandom(true, indexRequestBuilders); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg", Fuzziness.ONE); assertSuggestions("foo", prefix, "sugxgestion9", "sugxgestion8", "sugxgestion7", "sugxgestion6", "sugxgestion5"); }