for (BulkItemResponse r: bulkResponse.getItems()) { String id = r.getId(); ActionWriteResponse response = r.getResponse(); if (response instanceof IndexResponse) { if (((IndexResponse) response).isCreated()) result.getCreated().add(id);
@Override public void setForcedRefresh(boolean forcedRefresh) { /* * Each DocWriteResponse already has a location for whether or not it forced a refresh so we just set that information on the * response. */ for (BulkItemResponse response : responses) { DocWriteResponse r = response.getResponse(); if (r != null) { r.setForcedRefresh(forcedRefresh); } } }
@Override public void onResponse(BulkShardResponse bulkShardResponse) { for (BulkItemResponse bulkItemResponse : bulkShardResponse.getResponses()) { // we may have no response if item failed if (bulkItemResponse.getResponse() != null) { bulkItemResponse.getResponse().setShardInfo(bulkShardResponse.getShardInfo()); } responses.set(bulkItemResponse.getItemId(), bulkItemResponse); } if (counter.decrementAndGet() == 0) { finishHim(); } }
private void setupElasticsearchToSucceed() throws IOException { final String documentId = UUID.randomUUID().toString(); final boolean isFailed = false; final int itemID = 0; // the write response will contain what is used as the document ID DocWriteResponse writeResponse = mock(DocWriteResponse.class); when(writeResponse.getId()).thenReturn(documentId); // define the item level response BulkItemResponse itemResponse = mock(BulkItemResponse.class); when(itemResponse.isFailed()).thenReturn(isFailed); when(itemResponse.getItemId()).thenReturn(itemID); when(itemResponse.getResponse()).thenReturn(writeResponse); List<BulkItemResponse> itemsResponses = Collections.singletonList(itemResponse); // define the bulk response to indicate success BulkResponse response = mock(BulkResponse.class); when(response.iterator()).thenReturn(itemsResponses.iterator()); when(response.hasFailures()).thenReturn(isFailed); // have the client return the mock response when(highLevelClient.bulk(any(BulkRequest.class))).thenReturn(response); }
for (BulkItemResponse r: bulkResponse.getItems()) { String id = r.getId(); DocWriteResponse response = r.getResponse(); if (response.getResult() == DocWriteResponse.Result.CREATED) result.created.add(id); String err = r.getFailureMessage();
public static <Response extends ReplicationResponse & WriteResponse> ActionListener<BulkResponse> wrapBulkResponse(ActionListener<Response> listener) { return ActionListener.wrap(bulkItemResponses -> { assert bulkItemResponses.getItems().length == 1 : "expected only one item in bulk request"; BulkItemResponse bulkItemResponse = bulkItemResponses.getItems()[0]; if (bulkItemResponse.isFailed() == false) { final DocWriteResponse response = bulkItemResponse.getResponse(); listener.onResponse((Response) response); } else { listener.onFailure(bulkItemResponse.getFailure().getCause()); } }, listener::onFailure); }
/** * Determines whether a bulk item request should be executed on the replica. * * @return {@link ReplicaItemExecutionMode#NORMAL} upon normal primary execution with no failures * {@link ReplicaItemExecutionMode#FAILURE} upon primary execution failure after sequence no generation * {@link ReplicaItemExecutionMode#NOOP} upon primary execution failure before sequence no generation or * when primary execution resulted in noop (only possible for write requests from pre-6.0 nodes) */ static ReplicaItemExecutionMode replicaItemExecutionMode(final BulkItemRequest request, final int index) { final BulkItemResponse primaryResponse = request.getPrimaryResponse(); assert primaryResponse != null : "expected primary response to be set for item [" + index + "] request [" + request.request() + "]"; if (primaryResponse.isFailed()) { return primaryResponse.getFailure().getSeqNo() != SequenceNumbers.UNASSIGNED_SEQ_NO ? ReplicaItemExecutionMode.FAILURE // we have a seq no generated with the failure, replicate as no-op : ReplicaItemExecutionMode.NOOP; // no seq no generated, ignore replication } else { // TODO: once we know for sure that every operation that has been processed on the primary is assigned a seq# // (i.e., all nodes on the cluster are on v6.0.0 or higher) we can use the existence of a seq# to indicate whether // an operation should be processed or be treated as a noop. This means we could remove this method and the // ReplicaItemExecutionMode enum and have a simple boolean check for seq != UNASSIGNED_SEQ_NO which will work for // both failures and indexing operations. return primaryResponse.getResponse().getResult() != DocWriteResponse.Result.NOOP ? ReplicaItemExecutionMode.NORMAL // execution successful on primary : ReplicaItemExecutionMode.NOOP; // ignore replication } }
public static Translog.Location performOnReplica(BulkShardRequest request, IndexShard replica) throws Exception { Translog.Location location = null; for (int i = 0; i < request.items().length; i++) { BulkItemRequest item = request.items()[i]; final Engine.Result operationResult; DocWriteRequest docWriteRequest = item.request(); switch (replicaItemExecutionMode(item, i)) { case NORMAL: final DocWriteResponse primaryResponse = item.getPrimaryResponse().getResponse(); operationResult = performOpOnReplica(primaryResponse, docWriteRequest, replica); assert operationResult != null : "operation result must never be null when primary response has no failure"; location = syncOperationResultOrThrow(operationResult, location); break; case NOOP: break; case FAILURE: final BulkItemResponse.Failure failure = item.getPrimaryResponse().getFailure(); assert failure.getSeqNo() != SequenceNumbers.UNASSIGNED_SEQ_NO : "seq no must be assigned"; operationResult = replica.markSeqNoAsNoop(failure.getSeqNo(), failure.getMessage()); assert operationResult != null : "operation result must never be null when primary response has no failure"; location = syncOperationResultOrThrow(operationResult, location); break; default: throw new IllegalStateException("illegal replica item execution mode for: " + docWriteRequest); } } return location; }
@Override protected WritePrimaryResult<Request, Response> shardOperationOnPrimary( Request request, final IndexShard primary) throws Exception { BulkItemRequest[] itemRequests = new BulkItemRequest[1]; WriteRequest.RefreshPolicy refreshPolicy = request.getRefreshPolicy(); request.setRefreshPolicy(WriteRequest.RefreshPolicy.NONE); itemRequests[0] = new BulkItemRequest(0, ((DocWriteRequest) request)); BulkShardRequest bulkShardRequest = new BulkShardRequest(request.shardId(), refreshPolicy, itemRequests); WritePrimaryResult<BulkShardRequest, BulkShardResponse> bulkResult = shardBulkAction.shardOperationOnPrimary(bulkShardRequest, primary); assert bulkResult.finalResponseIfSuccessful.getResponses().length == 1 : "expected only one bulk shard response"; BulkItemResponse itemResponse = bulkResult.finalResponseIfSuccessful.getResponses()[0]; final Response response; final Exception failure; if (itemResponse.isFailed()) { failure = itemResponse.getFailure().getCause(); response = null; } else { response = (Response) itemResponse.getResponse(); failure = null; } return new WritePrimaryResult<>(request, response, bulkResult.location, failure, primary, logger); }
private String getItemId(BulkItemResponse response) { String id = response.getId(); if (response.getResponse() instanceof UpdateResponse) { id = ((UpdateResponse) response.getResponse()).getId(); } else if (response.getResponse() instanceof IndexResponse) { id = ((IndexResponse) response.getResponse()).getId(); } return id; }
/** * Handles the {@link BulkResponse} received from Elasticsearch. * @param bulkResponse The response received from Elasticsearch. * @param documents The documents included in the bulk request. * @param results The writer results. */ private void handleBulkResponse(BulkResponse bulkResponse, List<Indexable> documents, BulkDocumentWriterResults<D> results) { if (bulkResponse.hasFailures()) { // interrogate the response to distinguish between those that succeeded and those that failed for(BulkItemResponse response: bulkResponse) { if(response.isFailed()) { // request failed D failed = getDocument(response.getItemId()); Exception cause = response.getFailure().getCause(); String message = response.getFailureMessage(); results.addFailure(failed, cause, message); } else { // request succeeded D success = getDocument(response.getItemId()); success.setDocumentID(response.getResponse().getId()); results.addSuccess(success); } } } else { // all requests succeeded for(Indexable success: documents) { results.addSuccess(success.document); } } }
@Override public void setForcedRefresh(boolean forcedRefresh) { /* * Each DocWriteResponse already has a location for whether or not it forced a refresh so we just set that information on the * response. */ for (BulkItemResponse response : responses) { DocWriteResponse r = response.getResponse(); if (r != null) { r.setForcedRefresh(forcedRefresh); } } }
@Override public void setForcedRefresh(boolean forcedRefresh) { /* * Each DocWriteResponse already has a location for whether or not it forced a refresh so we just set that information on the * response. */ for (BulkItemResponse response : responses) { DocWriteResponse r = response.getResponse(); if (r != null) { r.setForcedRefresh(forcedRefresh); } } }
if (translatedResult == DocWriteResponse.Result.CREATED || translatedResult == DocWriteResponse.Result.UPDATED) { final IndexRequest updateIndexRequest = translate.action(); final IndexResponse indexResponse = operationResponse.getResponse(); updateResponse = new UpdateResponse(indexResponse.getShardInfo(), indexResponse.getShardId(), indexResponse.getType(), indexResponse.getId(), indexResponse.getSeqNo(), indexResponse.getPrimaryTerm(), final DeleteResponse deleteResponse = operationResponse.getResponse(); updateResponse = new UpdateResponse(deleteResponse.getShardInfo(), deleteResponse.getShardId(), deleteResponse.getType(), deleteResponse.getId(), deleteResponse.getSeqNo(), deleteResponse.getPrimaryTerm(),
executionResult.getResponse().setShardInfo(new ReplicationResponse.ShardInfo()); locationToSync = TransportWriteAction.locationToSync(locationToSync, result.getTranslogLocation()); break;
@Override public void onResponse(BulkShardResponse bulkShardResponse) { for (BulkItemResponse bulkItemResponse : bulkShardResponse.getResponses()) { // we may have no response if item failed if (bulkItemResponse.getResponse() != null) { bulkItemResponse.getResponse().setShardInfo(bulkShardResponse.getShardInfo()); } responses.set(bulkItemResponse.getItemId(), bulkItemResponse); } if (counter.decrementAndGet() == 0) { finishHim(); } }
/** * . * @param response . * @return . */ public static DcBulkItemResponse getInstance(BulkItemResponse response) { if (response == null) { return null; } return new DcBulkItemResponseImpl(response.getItemId(), response.getOpType(), response.getResponse()); }
public static <Response extends ReplicationResponse & WriteResponse> ActionListener<BulkResponse> wrapBulkResponse(ActionListener<Response> listener) { return ActionListener.wrap(bulkItemResponses -> { assert bulkItemResponses.getItems().length == 1 : "expected only one item in bulk request"; BulkItemResponse bulkItemResponse = bulkItemResponses.getItems()[0]; if (bulkItemResponse.isFailed() == false) { final DocWriteResponse response = bulkItemResponse.getResponse(); listener.onResponse((Response) response); } else { listener.onFailure(bulkItemResponse.getFailure().getCause()); } }, listener::onFailure); }
public static <Response extends ReplicationResponse & WriteResponse> ActionListener<BulkResponse> wrapBulkResponse(ActionListener<Response> listener) { return ActionListener.wrap(bulkItemResponses -> { assert bulkItemResponses.getItems().length == 1 : "expected only one item in bulk request"; BulkItemResponse bulkItemResponse = bulkItemResponses.getItems()[0]; if (bulkItemResponse.isFailed() == false) { final DocWriteResponse response = bulkItemResponse.getResponse(); listener.onResponse((Response) response); } else { listener.onFailure(bulkItemResponse.getFailure().getCause()); } }, listener::onFailure); }
private ActionListener<BulkResponse> wrapBulkResponse(ActionListener<Response> listener) { return ActionListener.wrap(bulkItemResponses -> { assert bulkItemResponses.getItems().length == 1 : "expected only one item in bulk request"; BulkItemResponse bulkItemResponse = bulkItemResponses.getItems()[0]; if (bulkItemResponse.isFailed() == false) { final DocWriteResponse response = bulkItemResponse.getResponse(); listener.onResponse((Response) response); } else { listener.onFailure(bulkItemResponse.getFailure().getCause()); } }, listener::onFailure); }