private static GetResult getResponseToGetResult(GetResponse response) { return new GetResult(response.getIndex(), response.getType(), response.getId(), response.getVersion(), response.isExists(), response.getSourceAsBytesRef(), response.getFields()); }
@Override public <T> LinkedList<T> mapResults(MultiGetResponse responses, Class<T> clazz) { LinkedList<T> list = new LinkedList<>(); for (MultiGetItemResponse response : responses.getResponses()) { if (!response.isFailed() && response.getResponse().isExists()) { T result = mapEntity(response.getResponse().getSourceAsString(), clazz); setPersistentEntityId(result, response.getResponse().getId(), clazz); setPersistentEntityVersion(result, response.getResponse().getVersion(), clazz); list.add(result); } } return list; }
private static Map<String, Object> getMap(GetResponse response) { Map<String, Object> map = null; if (response.isExists() && (map = response.getSourceAsMap()) != null) { map.put("$type", response.getType()); } return map; }
@Override public void onResponse(MultiGetResponse response) { MultiGetItemResponse[] responses = response.getResponses(); for (int i = 0; i < responses.length; i++) { MultiGetItemResponse singleResponse = responses[i]; if(singleResponse != null && !singleResponse.isFailed()) { GetResponse singleGetResponse = singleResponse.getResponse(); if(singleGetResponse.isExists() && !singleGetResponse.isSourceEmpty()) { //success final Tuple<Long, Settings> _settings = toSettings(singleGetResponse); if(_settings.v2() != null) { callback.success(singleGetResponse.getType(), _settings); } else { log.error("Cannot parse settings for "+singleGetResponse.getType()); } } else { //does not exist or empty source callback.noData(singleGetResponse.getType()); } } else { //failure callback.singleFailure(singleResponse==null?null:singleResponse.getFailure()); } } }
public Set<String> existBulk(String indexName, String typeName, final Collection<String> ids) { if (ids == null || ids.size() == 0) return new HashSet<>(); MultiGetResponse multiGetItemResponses = elasticsearchClient.prepareMultiGet() .add(indexName, typeName, ids) .get(); Set<String> er = new HashSet<>(); for (MultiGetItemResponse itemResponse : multiGetItemResponses) { GetResponse response = itemResponse.getResponse(); if (response.isExists()) { er.add(response.getId()); } } return er; }
private Optional<String> getMetadata(String id) { GetRequestBuilder request = esClient.prepareGet(MetadataIndexDefinition.INDEX_TYPE_METADATA, id) .setStoredFields(MetadataIndexDefinition.FIELD_VALUE); GetResponse response = request.get(); if (response.isExists()) { GetField field = response.getField(MetadataIndexDefinition.FIELD_VALUE); String value = String.valueOf(field.getValue()); return Optional.of(value); } return Optional.empty(); }
public static Status getRiverStatus(Client client, String riverName) { GetResponse statusResponse = client.prepareGet("_river", riverName, MongoDBRiver.STATUS_ID).get(); if (!statusResponse.isExists()) { return Status.UNKNOWN; } else { Object obj = XContentMapValues.extractValue(MongoDBRiver.TYPE + "." + MongoDBRiver.STATUS_FIELD, statusResponse.getSourceAsMap()); return Status.valueOf(obj.toString()); } }
@Override public Flux<GetResult> multiGet(HttpHeaders headers, MultiGetRequest multiGetRequest) { return sendRequest(multiGetRequest, RequestCreator.multiGet(), MultiGetResponse.class, headers) .map(MultiGetResponse::getResponses) // .flatMap(Flux::fromArray) // .filter(it -> !it.isFailed() && it.getResponse().isExists()) // .map(it -> DefaultReactiveElasticsearchClient.getResponseToGetResult(it.getResponse())); }
@Override public Map<String, Object> get(String index, String type, String id) throws IOException { GetRequest get = new GetRequest(index, type, id); GetResponse resp = highLevelClient.get(get, new Header[]{}); return resp.getSource(); }
@Override public void execute(Tuple tuple) { try { String index = mapper.getIndex(tuple); String type = mapper.getType(tuple); String id = mapper.getId(tuple); GetResponse response = client.prepareGet(index, type, id).execute() .actionGet(); collector.emit(esOutputDeclarer.getValues(response.getSource())); collector.ack(tuple); } catch (Exception e) { collector.fail(tuple); } }
@Override public <T> T mapResult(GetResponse response, Class<T> clazz) { T result = mapEntity(response.getSourceAsString(), clazz); if (result != null) { setPersistentEntityId(result, response.getId(), clazz); setPersistentEntityVersion(result, response.getVersion(), clazz); } return result; }
@Override public String toString() { StringBuilder message = new StringBuilder().append("ES get request"); message.append(String.format(" for key '%s'", request.id())); message.append(String.format(" on index '%s'", request.index())); message.append(String.format(" on type '%s'", request.type())); return message.toString(); }
/** * Checks for the existence of a document. Emits {@literal true} if it exists, {@literal false} otherwise. * * @param consumer never {@literal null}. * @return the {@link Mono} emitting {@literal true} if it exists, {@literal false} otherwise. */ default Mono<Boolean> exists(Consumer<GetRequest> consumer) { GetRequest request = new GetRequest(); consumer.accept(request); return exists(request); }
public static boolean isNeeded(GetRequest request) { return (request.fetchSourceContext() != null && (request.fetchSourceContext().includes() != null || request.fetchSourceContext() .excludes() != null)) || (request.storedFields() != null && request.storedFields().length > 0); }
@Override public void process(OutputStream out) throws IOException { out.write(getResponse.getSourceAsString().getBytes(charset)); } });
public SourceFieldsContext(GetRequest request) { if (request.fetchSourceContext() != null) { includes = request.fetchSourceContext().includes(); excludes = request.fetchSourceContext().excludes(); fetchSource = request.fetchSourceContext().fetchSource(); } //storedFields = request.storedFields(); }
@Override public void singleFailure(Failure failure) { log.error("Failure {} retrieving configuration for {} (index={})", failure==null?null:failure.getMessage(), Arrays.toString(events), searchguardIndex); }
/** * Verify the results in an Elasticsearch index. The results must first be produced into the index * using a {@link TestElasticsearchSinkFunction}; * * @param client The client to use to connect to Elasticsearch * @param index The index to check */ public static void verifyProducedSinkData(Client client, String index) { for (int i = 0; i < NUM_ELEMENTS; i++) { GetResponse response = client.get(new GetRequest(index, TYPE_NAME, Integer.toString(i))).actionGet(); Assert.assertEquals(DATA_PREFIX + i, response.getSource().get(DATA_FIELD_NAME)); } }
/** * Execute a {@link GetRequest} against the {@literal get} API to retrieve a document by id. * * @param consumer never {@literal null}. * @see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-get.html">Get API on * elastic.co</a> * @return the {@link Mono} emitting the {@link GetResult result}. */ default Mono<GetResult> get(Consumer<GetRequest> consumer) { GetRequest request = new GetRequest(); consumer.accept(request); return get(request); }
@Override public void singleFailure(Failure failure) { log.error("Failure {} retrieving configuration for {} (index={})", failure==null?null:failure.getMessage(), Arrays.toString(events), searchguardIndex); }