下面列出了org.apache.lucene.index.IndexFormatTooOldException#org.elasticsearch.common.xcontent.XContentType 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@SuppressWarnings("unchecked")
public void testInsertIntoXContent() throws IOException {
XContentBuilder builder = JsonXContent.contentBuilder();
builder.startObject();
builder.endObject();
builder = XContentTestUtils.insertIntoXContent(XContentType.JSON.xContent(), BytesReference.bytes(builder),
Collections.singletonList(""), () -> "inn.er1", () -> new HashMap<>());
builder = XContentTestUtils.insertIntoXContent(XContentType.JSON.xContent(), BytesReference.bytes(builder),
Collections.singletonList(""), () -> "field1", () -> "value1");
builder = XContentTestUtils.insertIntoXContent(XContentType.JSON.xContent(), BytesReference.bytes(builder),
Collections.singletonList("inn\\.er1"), () -> "inner2", () -> new HashMap<>());
builder = XContentTestUtils.insertIntoXContent(XContentType.JSON.xContent(), BytesReference.bytes(builder),
Collections.singletonList("inn\\.er1"), () -> "field2", () -> "value2");
try (XContentParser parser = XContentHelper.createParser(NamedXContentRegistry.EMPTY,
DeprecationHandler.THROW_UNSUPPORTED_OPERATION, BytesReference.bytes(builder), builder.contentType())) {
Map<String, Object> map = parser.map();
assertEquals(2, map.size());
assertEquals("value1", map.get("field1"));
assertThat(map.get("inn.er1"), instanceOf(Map.class));
Map<String, Object> innerMap = (Map<String, Object>) map.get("inn.er1");
assertEquals(2, innerMap.size());
assertEquals("value2", innerMap.get("field2"));
assertThat(innerMap.get("inner2"), instanceOf(Map.class));
assertEquals(0, ((Map<String, Object>) innerMap.get("inner2")).size());
}
}
/**
* Creates the index with optionally the mapping and a number of docs
* @param index
* @param type
* @param withMapping
* @param nrDocs
* @throws IOException
*/
protected void createIndexTypeWithDocs(String index, String type, boolean withMapping, int nrDocs) throws IOException{
if(withMapping){
String mapping = AccessController.doPrivileged(new PrivilegedAction<String>(){
@Override
public String run() {
try {
return new String(Files.readAllBytes(Paths.get("src/test/resources/TestDocumentMapping.json")));
} catch (IOException e) {
return null;
}
}
});
if(mapping == null) throw new IOException("Unable to read TestDocumentMapping.json");
client().admin().indices().prepareCreate(index).addMapping(type, mapping, XContentType.JSON).get(); //.execute().actionGet();
}else{
createIndex(index);
}
if(nrDocs > 0) addDocs(index, type, nrDocs);
refresh();
}
private void indexObject(final String index, final String docType, final String docId, final Object doc) {
byte[] docBytes;
try {
docBytes = objectMapper.writeValueAsBytes(doc);
} catch (JsonProcessingException e) {
logger.error("Failed to convert {} '{}' to byte string", docType, docId);
return;
}
IndexRequest request = new IndexRequest(index, docType, docId);
request.source(docBytes, XContentType.JSON);
if(bulkRequests.get(docType) == null) {
bulkRequests.put(docType, new BulkRequests(System.currentTimeMillis(), new BulkRequest()));
}
bulkRequests.get(docType).getBulkRequest().add(request);
if (bulkRequests.get(docType).getBulkRequest().numberOfActions() >= this.indexBatchSize) {
indexBulkRequest(docType);
}
}
/**
* Submit a search query to Elasticsearch.
*
* @param indexName The name of the index to search.
* @param query The query to search.
* @return The search response returned by Elasticsearch.
* @throws IOException
*/
private SearchResponse search(String indexName, String query) throws IOException {
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
try (XContentParser parser = XContentFactory.xContent(XContentType.JSON).createParser(new NamedXContentRegistry(searchModule
.getNamedXContents()), DeprecationHandler.THROW_UNSUPPORTED_OPERATION, query)) {
searchSourceBuilder.parseXContent(parser);
}
SearchRequestBuilder searchRequestBuilder = new SearchRequestBuilder(client, SearchAction.INSTANCE);
searchRequestBuilder.setIndices(indexName).setSource(searchSourceBuilder);
if (this.searchAllowPartialSearchResults != null)
searchRequestBuilder.setAllowPartialSearchResults(this.searchAllowPartialSearchResults);
if (this.searchBatchedReduceSize != null)
searchRequestBuilder.setBatchedReduceSize(this.searchBatchedReduceSize);
if (this.searchMaxConcurrentShardRequests != null)
searchRequestBuilder.setMaxConcurrentShardRequests(this.searchMaxConcurrentShardRequests);
if (this.searchPreFilterShardSize != null)
searchRequestBuilder.setPreFilterShardSize(this.searchPreFilterShardSize);
if (this.searchPreference != null)
searchRequestBuilder.setPreference(this.searchPreference);
if (this.searchRequestCache != null)
searchRequestBuilder.setRequestCache(this.searchRequestCache);
if (this.maxTimePerQuery != null)
searchRequestBuilder.setTimeout(TimeValue.parseTimeValue(this.maxTimePerQuery, "timeout"));
return searchRequestBuilder.execute().actionGet();
}
private static void prepareAccountsIndex() {
String dataMapping = "{ \"account\": {" +
" \"properties\": {\n" +
" \"gender\": {\n" +
" \"type\": \"text\",\n" +
" \"fielddata\": true\n" +
" }," +
" \"address\": {\n" +
" \"type\": \"text\",\n" +
" \"fielddata\": true\n" +
" }," +
" \"state\": {\n" +
" \"type\": \"text\",\n" +
" \"fielddata\": true\n" +
" }" +
" }"+
" }" +
"}";
client.admin().indices().preparePutMapping(TEST_INDEX_ACCOUNT).setType("account").setSource(dataMapping, XContentType.JSON).execute().actionGet();
}
@Override
public final void writeRawField(String fieldName, BytesReference content, OutputStream bos) throws IOException {
XContentType contentType = XContentFactory.xContentType(content);
if (contentType != null) {
writeObjectRaw(fieldName, content, bos);
} else {
writeFieldName(fieldName);
// we could potentially optimize this to not rely on exception logic...
String sValue = content.toUtf8();
try {
writeNumber(Long.parseLong(sValue));
} catch (NumberFormatException e) {
try {
writeNumber(Double.parseDouble(sValue));
} catch (NumberFormatException e1) {
writeString(sValue);
}
}
}
}
@Override
public Map<String, Object> generateSourceAndCheckConstraints(Object[] values) {
String rawSource = (String) values[0];
Map<String, Object> source = XContentHelper.toMap(new BytesArray(rawSource), XContentType.JSON);
mixinDefaults(source, defaults);
for (int i = 0; i < expressions.size(); i++) {
expressions.get(i).setNextRow(source);
}
for (Map.Entry<Reference, Input<?>> entry : generatedCols.entrySet()) {
var reference = entry.getKey();
var value = entry.getValue().value();
var valueForInsert = reference
.valueType()
.valueForInsert(value);
source.putIfAbsent(reference.column().fqn(), valueForInsert);
}
return source;
}
public static void sink2es(SingleOutputStreamOperator<LogEvent> logDataStream, ParameterTool parameterTool) {
List<HttpHost> esAddresses;
try {
esAddresses = ESSinkUtil.getEsAddresses(parameterTool.get(ELASTICSEARCH_HOSTS));
} catch (MalformedURLException e) {
log.error("get es address has an error", e);
return;
}
int bulkSize = parameterTool.getInt(ELASTICSEARCH_BULK_FLUSH_MAX_ACTIONS, 40);
int sinkParallelism = parameterTool.getInt(STREAM_SINK_PARALLELISM, 5);
ESSinkUtil.addSink(esAddresses, bulkSize, sinkParallelism, logDataStream,
(LogEvent logEvent, RuntimeContext runtimeContext, RequestIndexer requestIndexer) -> {
requestIndexer.add(Requests.indexRequest()
.index("zhisheng_log")
.type(ZHISHENG)
.source(GsonUtil.toJSONBytes(logEvent), XContentType.JSON));
},
parameterTool);
}
@Override
public void addMessage(String queue, Message message) {
try {
long startTime = Instant.now().toEpochMilli();
Map<String, Object> doc = new HashMap<>();
doc.put("messageId", message.getId());
doc.put("payload", message.getPayload());
doc.put("queue", queue);
doc.put("created", System.currentTimeMillis());
String docType = StringUtils.isBlank(docTypeOverride) ? MSG_DOC_TYPE : docTypeOverride;
UpdateRequest req = new UpdateRequest(messageIndexName, docType, message.getId());
req.doc(doc, XContentType.JSON);
req.upsert(doc, XContentType.JSON);
indexObject(req, MSG_DOC_TYPE);
long endTime = Instant.now().toEpochMilli();
LOGGER.debug("Time taken {} for indexing message: {}", endTime - startTime, message.getId());
Monitors.recordESIndexTime("add_message", MSG_DOC_TYPE, endTime - startTime);
} catch (Exception e) {
LOGGER.error("Failed to index message: {}", message.getId(), e);
}
}
@Override
protected void populateData(TransportClient tc) {
tc.index(new IndexRequest("deals").type("deals").id("0").setRefreshPolicy(RefreshPolicy.IMMEDIATE)
.source("{\"amount\": 10}", XContentType.JSON)).actionGet();
tc.index(new IndexRequest("deals").type("deals").id("1").setRefreshPolicy(RefreshPolicy.IMMEDIATE)
.source("{\"amount\": 1500}", XContentType.JSON)).actionGet();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("q");
System.out.println(Strings.toString(tc.search(new SearchRequest().indices(".opendistro_security")).actionGet()));
tc.search(new SearchRequest().indices("deals")).actionGet();
}
@Override
public String explain() {
try {
XContentBuilder firstBuilder = XContentFactory.contentBuilder(XContentType.JSON).prettyPrint();
firstTable.getRequestBuilder().request().source().toXContent(firstBuilder, ToXContent.EMPTY_PARAMS);
XContentBuilder secondBuilder = XContentFactory.contentBuilder(XContentType.JSON).prettyPrint();
secondTable.getRequestBuilder().request().source().toXContent(secondBuilder, ToXContent.EMPTY_PARAMS);
String explained = String.format(" first query:\n%s\n second query:\n%s", BytesReference.bytes(firstBuilder).utf8ToString(), BytesReference.bytes(secondBuilder).utf8ToString());
return explained;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
@Override
public void putTemplate(String name, JsonObject source, TemplateOptions options, Handler<AsyncResult<Void>> resultHandler) {
final PutIndexTemplateRequestBuilder builder = new PutIndexTemplateRequestBuilder(service.getClient(), PutIndexTemplateAction.INSTANCE, name)
.setSource(source.encode().getBytes(Charsets.UTF_8), XContentType.JSON);
builder.execute(new ActionListener<PutIndexTemplateResponse>() {
@Override
public void onResponse(PutIndexTemplateResponse putIndexTemplateResponse) {
resultHandler.handle(Future.succeededFuture());
}
@Override
public void onFailure(Exception e) {
resultHandler.handle(Future.failedFuture(e));
}
});
}
@Override
public void proceed(List content) {
try {
logger.info("Transferring data began to elasticsearch.");
final String indexName = config.getMisc().getDindex().getAs();
final String typeName = config.getMisc().getCtype().getAs();
for (Object o : content) {
Document doc = (Document) o;
Object id = doc.get("_id");
IndexRequest indexRequest = new IndexRequest(indexName, typeName, String.valueOf(id));
doc.remove("_id");
indexRequest.source(doc.toJson(encoder), XContentType.JSON);
bulkProcessor.add(indexRequest);
}
} catch (Exception ex) {
logger.debug(ex.getMessage(), ex);
}
}
/**
* Asserts that the provided {@link BytesReference}s created through
* {@link org.elasticsearch.common.xcontent.ToXContent#toXContent(XContentBuilder, ToXContent.Params)} hold the same content.
* The comparison is done by parsing both into a map and comparing those two, so that keys ordering doesn't matter.
* Also binary values (byte[]) are properly compared through arrays comparisons.
*/
public static void assertToXContentEquivalent(BytesReference expected, BytesReference actual, XContentType xContentType)
throws IOException {
//we tried comparing byte per byte, but that didn't fly for a couple of reasons:
//1) whenever anything goes through a map while parsing, ordering is not preserved, which is perfectly ok
//2) Jackson SMILE parser parses floats as double, which then get printed out as double (with double precision)
//Note that byte[] holding binary values need special treatment as they need to be properly compared item per item.
Map<String, Object> actualMap = null;
Map<String, Object> expectedMap = null;
try (XContentParser actualParser = xContentType.xContent()
.createParser(NamedXContentRegistry.EMPTY, DeprecationHandler.THROW_UNSUPPORTED_OPERATION, actual.streamInput())) {
actualMap = actualParser.map();
try (XContentParser expectedParser = xContentType.xContent()
.createParser(NamedXContentRegistry.EMPTY, DeprecationHandler.THROW_UNSUPPORTED_OPERATION, expected.streamInput())) {
expectedMap = expectedParser.map();
try {
assertMapEquals(expectedMap, actualMap);
} catch (AssertionError error) {
NotEqualMessageBuilder message = new NotEqualMessageBuilder();
message.compareMaps(actualMap, expectedMap);
throw new AssertionError("Error when comparing xContent.\n" + message.toString(), error);
}
}
}
}
protected Tuple<XContentType, Map<String, Object>> parseSource(BytesReference source) {
// nothing to parse...
if (source == null || source.length() == 0) {
return null;
}
try {
Tuple<XContentType, Map<String, Object>> parsedSource = XContentHelper.convertToMap(source, false);
logger.debug("{}: Parsed source: {}", Thread.currentThread().getName(), parsedSource);
return parsedSource;
}
catch (Throwable e) {
String sSource = "_na_";
try {
sSource = XContentHelper.convertToJson(source, false);
}
catch (Throwable e1) { /* ignore */ }
throw new ElasticsearchParseException("Failed to parse source [" + sSource + "]", e);
}
}
/**
* 获取新增请求
*
* @param esObject 更新请求参数
* @return UpdateRequestBuilder 更新请求
*/
private IndexRequestBuilder getIndexRequest(SaveESObject esObject) {
String dataId = getId(esObject.getUkMap());
byte[] dataBytes = null;
try {
dataBytes = OBJECT_MAPPER.writeValueAsBytes(esObject.getDataMap());
} catch (JsonProcessingException e) {
// never hapened
SearchLogger.error("", e);
}
IndexRequestBuilder indexRequestBuilder = transportClient.prepareIndex().setIndex(esObject.getIndexName())
.setType(esObject.getTypeName());
if (StringUtils.isNotBlank(dataId)) {
indexRequestBuilder.setId(dataId);
}
// TODO 替换
// indexRequestBuilder.setSource(esObject.getDataMap());
indexRequestBuilder.setSource(dataBytes, XContentType.JSON);
return indexRequestBuilder;
}
public void indexDocumentBoardComment(EsComment esComment) {
String id = esComment.getId();
String parentBoardId = esComment.getArticle().getId();
try {
IndexResponse response = client.prepareIndex()
.setIndex(elasticsearchProperties.getIndexBoard())
.setType(Constants.ES_TYPE_COMMENT)
.setId(id)
.setParent(parentBoardId)
.setSource(ObjectMapperUtils.writeValueAsString(esComment), XContentType.JSON)
.get();
} catch (IOException e) {
throw new ServiceException(ServiceError.ELASTICSEARCH_INDEX_FAILED, e.getCause());
}
}
@Override
public void init() {
boolean indexExistsAlready = clientProvider.getClient()
.admin()
.indices()
.exists(new IndicesExistsRequest(index))
.actionGet()
.isExists();
if (!indexExistsAlready) {
CreateIndexRequest request = new CreateIndexRequest(index);
request.mapping(ELASTICSEARCH_TYPE, MAPPING, XContentType.JSON);
clientProvider.getClient().admin().indices().create(request).actionGet();
}
}
/**
* Maps document Object to Json and creates and new index request
*
* @param indexName
* - index name
* @param documentType
* - document type
* @param uid
* - unique identifier
* @param object
* - object that represents the structure of a document for indexing
* @return
* @return IndexResponse
* @throws IOException
*/
private static void index(String indexName, String documentType, String uid, String document) {
try {
GetRequest getRequest = new GetRequest(indexName, documentType, uid).fetchSourceContext(fetchSourceContext).storedFields("_none_");
if(highLevelClient.exists(getRequest, getReadHeaders()))
{
UpdateRequest request = new UpdateRequest(indexName, documentType, uid);
request.doc(document, XContentType.JSON);
logger.info("Document (uid: " + uid + ") has been updated");
}
else
{
IndexRequest indexRequest = new IndexRequest();
indexRequest .index(indexName).type(documentType).id(uid).source(document,XContentType.JSON);
logger.info("Document (uid: " + uid + ") has been " +
highLevelClient.index(indexRequest, getWriteHeaders()).getResult().toString().toLowerCase());
}
} catch (IOException io) {
logger.error("Method index has experienced an IO error\n" + io);
}
}
private static void prepareDogsIndex() {
String dataMapping = "{ \"dog\": {" +
" \"properties\": {\n" +
" \"dog_name\": {\n" +
" \"type\": \"text\",\n" +
" \"fielddata\": true\n" +
" }"+
" }"+
" }" +
"}";
client.admin().indices().preparePutMapping(TEST_INDEX_DOG).setType("dog").setSource(dataMapping, XContentType.JSON).execute().actionGet();
}
/**
* Adds mapping that will be added when the index gets created.
*
* @param type The mapping type
* @param source The mapping source
* @param xContentType the content type of the mapping source
*/
private CreateIndexRequest mapping(String type, BytesReference source, XContentType xContentType) {
if (mappings.containsKey(type)) {
throw new IllegalStateException("mappings for type \"" + type + "\" were already defined");
}
Objects.requireNonNull(xContentType);
try {
mappings.put(type, XContentHelper.convertToJson(source, xContentType));
return this;
} catch (IOException e) {
throw new UncheckedIOException("failed to convert to json", e);
}
}
private static void prepareGameOfThronesIndex() {
String dataMapping = "{ \"gotCharacters\": { " +
" \"properties\": {\n" +
" \"nickname\": {\n" +
"\"type\":\"text\", "+
"\"fielddata\":true"+
"},\n"+
" \"name\": {\n" +
"\"properties\": {\n" +
"\"firstname\": {\n" +
"\"type\": \"text\",\n" +
" \"fielddata\": true\n" +
"},\n" +
"\"lastname\": {\n" +
"\"type\": \"text\",\n" +
" \"fielddata\": true\n" +
"},\n" +
"\"ofHerName\": {\n" +
"\"type\": \"integer\"\n" +
"},\n" +
"\"ofHisName\": {\n" +
"\"type\": \"integer\"\n" +
"}\n" +
"}\n" +
"}"+
"} } }";
client.admin().indices().preparePutMapping(TEST_INDEX_GAME_OF_THRONES).setType("gotCharacters").setSource(dataMapping, XContentType.JSON).execute().actionGet();
}
/**
* Loads all data from the json into the test
* elasticsearch cluster, using TEST_INDEX
* @param jsonPath the json file represents the bulk
* @param defaultIndex
* @throws Exception
*/
public static void loadBulk(String jsonPath, String defaultIndex) throws Exception {
System.out.println(String.format("Loading file %s into elasticsearch cluster", jsonPath));
BulkRequestBuilder bulkBuilder = client.prepareBulk();
byte[] buffer = ByteStreams.toByteArray(new FileInputStream(jsonPath));
bulkBuilder.add(buffer, 0, buffer.length, defaultIndex, XContentType.JSON);
BulkResponse response = bulkBuilder.get();
if(response.hasFailures()) {
throw new Exception(String.format("Failed during bulk load of file %s. failure message: %s", jsonPath, response.buildFailureMessage()));
}
}
private void withContent(RestRequest restRequest, CheckedConsumer<XContentParser, IOException> withParser)
throws IOException {
BytesReference content = restRequest.content();
XContentType xContentType = XContentType.JSON;
if (content.length() > 0) {
try (XContentParser parser = xContentType.xContent().createParser(restRequest.getXContentRegistry(),
DeprecationHandler.THROW_UNSUPPORTED_OPERATION, content.streamInput())) {
withParser.accept(parser);
}
} else {
withParser.accept(null);
}
}
@Test
public void testSeserialization() throws Exception {
List<RolesMapping> mappings = new RolesMappingBuilder()
.addUser("foo", "user_of_foo")
.expire("12345")
.build();
SearchGuardRolesMapping sgMapping = new SearchGuardRolesMapping();
sgMapping.addAll(mappings);
final String out = XContentHelper.toString(sgMapping);
Map<String, Object> in = XContentHelper.convertToMap(new BytesArray(out), true, XContentType.JSON).v2();
SearchGuardRolesMapping inMapping = new SearchGuardRolesMapping().load(in);
assertEquals("Exp serialization to equal derialization", out, XContentHelper.toString(inMapping));
}
@Override
public void indexWorkflow(Workflow workflow) {
try {
long startTime = Instant.now().toEpochMilli();
String id = workflow.getWorkflowId();
WorkflowSummary summary = new WorkflowSummary(workflow);
byte[] doc = objectMapper.writeValueAsBytes(summary);
UpdateRequest request = new UpdateRequest(indexName, WORKFLOW_DOC_TYPE, id);
request.doc(doc, XContentType.JSON);
request.upsert(doc, XContentType.JSON);
request.retryOnConflict(5);
new RetryUtil<UpdateResponse>().retryOnException(
() -> elasticSearchClient.update(request).actionGet(),
null,
null,
RETRY_COUNT,
"Indexing workflow document: " + workflow.getWorkflowId(),
"indexWorkflow"
);
long endTime = Instant.now().toEpochMilli();
logger.debug("Time taken {} for indexing workflow: {}", endTime - startTime, workflow.getWorkflowId());
Monitors.recordESIndexTime("index_workflow", WORKFLOW_DOC_TYPE, endTime - startTime);
Monitors.recordWorkerQueueSize("indexQueue", ((ThreadPoolExecutor) executorService).getQueue().size());
} catch (Exception e) {
Monitors.error(className, "indexWorkflow");
logger.error("Failed to index workflow: {}", workflow.getWorkflowId(), e);
}
}
@Override
public void binaryField(final FieldInfo fieldInfo, final byte[] value) throws IOException {
if (fieldInfo.name.equals("_source")) {
final BytesReference bytesRef = new BytesArray(value);
final Tuple<XContentType, Map<String, Object>> bytesRefTuple = XContentHelper.convertToMap(bytesRef, false, XContentType.JSON);
Map<String, Object> filteredSource = bytesRefTuple.v2();
MapUtils.deepTraverseMap(filteredSource, HASH_CB);
final XContentBuilder xBuilder = XContentBuilder.builder(bytesRefTuple.v1().xContent()).map(filteredSource);
delegate.binaryField(fieldInfo, BytesReference.toBytes(BytesReference.bytes(xBuilder)));
} else {
delegate.binaryField(fieldInfo, value);
}
}
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
String[] text = request.paramAsStringArrayOrEmptyIfAll("text");
ExtendedAnalyzeRequest analyzeRequest = new ExtendedAnalyzeRequest(request.param("index"));
analyzeRequest.text(text);
analyzeRequest.analyzer(request.param("analyzer"));
analyzeRequest.field(request.param("field"));
analyzeRequest.tokenizer(request.param("tokenizer"));
analyzeRequest.tokenFilters(request.paramAsStringArray("token_filters", request.paramAsStringArray("filters", analyzeRequest.tokenFilters())));
analyzeRequest.charFilters(request.paramAsStringArray("char_filters", analyzeRequest.charFilters()));
analyzeRequest.attributes(request.paramAsStringArray("attributes", null));
analyzeRequest.shortAttributeName(request.paramAsBoolean("use_short_attr", false));
if (request.hasContent() || request.hasParam("source")) {
XContentType type = guessBodyContentType(request);
if (type == null) {
if (text == null || text.length == 0) {
text = new String[]{ RestActions.getRestContent(request).toUtf8()};
analyzeRequest.text(text);
}
} else {
buildFromContent(RestActions.getRestContent(request), analyzeRequest);
}
}
client.admin().indices().execute(ExtendedAnalyzeAction.INSTANCE, analyzeRequest, new RestToXContentListener<ExtendedAnalyzeResponse>(channel));
}
private void populateUpdateRequestBuilder(UpdateRequestBuilder builder, UpdateOptions options) {
if (options != null) {
if (options.getRouting() != null) builder.setRouting(options.getRouting());
if (options.getParent() != null) builder.setParent(options.getParent());
if (options.getRefreshPolicy() != null)
builder.setRefreshPolicy(WriteRequest.RefreshPolicy.valueOf(options.getRefreshPolicy().name()));
if (options.getWaitForActiveShard() != null)
builder.setWaitForActiveShards(options.getWaitForActiveShard());
if (options.getVersion() != null) builder.setVersion(options.getVersion());
if (options.getVersionType() != null) builder.setVersionType(options.getVersionType());
if (options.getTimeout() != null) builder.setTimeout(options.getTimeout());
if (options.getRetryOnConflict() != null) builder.setRetryOnConflict(options.getRetryOnConflict());
if (options.getDoc() != null) builder.setDoc(options.getDoc().encode(), XContentType.JSON);
if (options.getUpsert() != null) builder.setUpsert(options.getUpsert().encode(), XContentType.JSON);
if (options.getDocAsUpsert() != null) builder.setDocAsUpsert(options.getDocAsUpsert());
if (options.getDetectNoop() != null) builder.setDetectNoop(options.getDetectNoop());
if (options.getScriptedUpsert() != null) builder.setScriptedUpsert(options.getScriptedUpsert());
if (options.getScript() != null) {
builder.setScript(createScript(Optional.ofNullable(options.getScriptType()), Optional.ofNullable(options.getScriptLang()), Optional.ofNullable(options.getScriptParams()), options.getScript()));
}
if (!options.getFields().isEmpty()) {
builder.setFields(options.getFields().toArray(new String[options.getFields().size()]));
}
}
}
protected void populateData(TransportClient tc) {
tc.index(new IndexRequest("deals").type("deals").id("0").setRefreshPolicy(RefreshPolicy.IMMEDIATE)
.source("{\"customer\": {\"name\":\"cust1\"}, \"zip\": \"12345\",\"secret\": \"tellnoone\",\"amount\": 10}", XContentType.JSON)).actionGet();
tc.index(new IndexRequest("deals").type("deals").id("1").setRefreshPolicy(RefreshPolicy.IMMEDIATE)
.source("{\"customer\": {\"name\":\"cust2\", \"ctype\":\"industry\"}, \"amount\": 1500}", XContentType.JSON)).actionGet();
}