Java ExceptionsHelper.status方法代码示例

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public NotSerializableExceptionWrapper(Throwable other) {
    super(ElasticsearchException.getExceptionName(other) +
                    ": " + other.getMessage(), other.getCause());
    this.name = ElasticsearchException.getExceptionName(other);
    this.status = ExceptionsHelper.status(other);
    setStackTrace(other.getStackTrace());
    for (Throwable otherSuppressed : other.getSuppressed()) {
        addSuppressed(otherSuppressed);
    }
    if (other instanceof ElasticsearchException) {
        ElasticsearchException ex = (ElasticsearchException) other;
        for (String key : ex.getHeaderKeys()) {
            this.addHeader(key, ex.getHeader(key));
        }
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public ShardSearchFailure(Exception e, @Nullable SearchShardTarget shardTarget) {
    final Throwable actual = ExceptionsHelper.unwrapCause(e);
    if (actual != null && actual instanceof SearchException) {
        this.shardTarget = ((SearchException) actual).shard();
    } else if (shardTarget != null) {
        this.shardTarget = shardTarget;
    }
    status = ExceptionsHelper.status(actual);
    this.reason = ExceptionsHelper.detailedMessage(e);
    this.cause = actual;
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
/**
 * Read from a stream.
 */
public Failure(StreamInput in) throws IOException {
    index = in.readString();
    type = in.readString();
    id = in.readOptionalString();
    cause = in.readException();
    status = ExceptionsHelper.status(cause);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public void testFailureToAndFromXContent() throws IOException {
    final XContentType xContentType = randomFrom(XContentType.values());

    int itemId = randomIntBetween(0, 100);
    String index = randomAsciiOfLength(5);
    String type = randomAsciiOfLength(5);
    String id = randomAsciiOfLength(5);
    DocWriteRequest.OpType opType = randomFrom(DocWriteRequest.OpType.values());

    final Tuple<Throwable, ElasticsearchException> exceptions = randomExceptions();

    Exception bulkItemCause = (Exception) exceptions.v1();
    Failure bulkItemFailure = new Failure(index, type, id, bulkItemCause);
    BulkItemResponse bulkItemResponse = new BulkItemResponse(itemId, opType, bulkItemFailure);
    Failure expectedBulkItemFailure = new Failure(index, type, id, exceptions.v2(), ExceptionsHelper.status(bulkItemCause));
    BulkItemResponse expectedBulkItemResponse = new BulkItemResponse(itemId, opType, expectedBulkItemFailure);
    BytesReference originalBytes = toXContent(bulkItemResponse, xContentType, randomBoolean());

    // Shuffle the XContent fields
    if (randomBoolean()) {
        try (XContentParser parser = createParser(xContentType.xContent(), originalBytes)) {
            originalBytes = shuffleXContent(parser, randomBoolean()).bytes();
        }
    }

    BulkItemResponse parsedBulkItemResponse;
    try (XContentParser parser = createParser(xContentType.xContent(), originalBytes)) {
        assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
        parsedBulkItemResponse = BulkItemResponse.fromXContent(parser, itemId);
        assertNull(parser.nextToken());
    }
    assertBulkItemResponse(expectedBulkItemResponse, parsedBulkItemResponse);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public ShardSearchFailure(Throwable t, @Nullable SearchShardTarget shardTarget) {
    Throwable actual = ExceptionsHelper.unwrapCause(t);
    if (actual != null && actual instanceof SearchException) {
        this.shardTarget = ((SearchException) actual).shard();
    } else if (shardTarget != null) {
        this.shardTarget = shardTarget;
    }
    status = ExceptionsHelper.status(actual);
    this.reason = ExceptionsHelper.detailedMessage(t);
    this.cause = actual;
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
private void doFinish() {
    if (finished.compareAndSet(false, true)) {
        setPhase(task, "finished");
        Releasables.close(indexShardReference);
        final ActionWriteResponse.ShardInfo.Failure[] failuresArray;
        if (!shardReplicaFailures.isEmpty()) {
            int slot = 0;
            failuresArray = new ActionWriteResponse.ShardInfo.Failure[shardReplicaFailures.size()];
            for (Map.Entry<String, Throwable> entry : shardReplicaFailures.entrySet()) {
                RestStatus restStatus = ExceptionsHelper.status(entry.getValue());
                failuresArray[slot++] = new ActionWriteResponse.ShardInfo.Failure(
                    shardId.getIndex(), shardId.getId(), entry.getKey(), entry.getValue(), restStatus, false
                );
            }
        } else {
            failuresArray = ActionWriteResponse.EMPTY;
        }
        finalResponse.setShardInfo(new ActionWriteResponse.ShardInfo(
                totalShards,
                success.get(),
                failuresArray

            )
        );
        try {
            channel.sendResponse(finalResponse);
        } catch (IOException responseException) {
            logger.warn("failed to send error message back to client for action [" + transportReplicaAction + "]", responseException);
        }
        if (logger.isTraceEnabled()) {
            logger.trace("action [{}] completed on all replicas [{}] for request [{}]", transportReplicaAction, shardId, replicaRequest);
        }
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public Failure(String index, String type, String id, Throwable t) {
    this.index = index;
    this.type = type;
    this.id = id;
    this.cause = t;
    this.status = ExceptionsHelper.status(t);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public BytesRestResponse(RestChannel channel, Exception e) throws IOException {
    this(channel, ExceptionsHelper.status(e), e);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public TaskOperationFailure(String nodeId, long taskId, Exception e) {
    this.nodeId = nodeId;
    this.taskId = taskId;
    this.reason = e;
    status = ExceptionsHelper.status(e);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public DefaultShardOperationFailedException(String index, int shardId, Throwable reason) {
    this.index = index;
    this.shardId = shardId;
    this.reason = reason;
    this.status = ExceptionsHelper.status(reason);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public void testToAndFromXContent() throws IOException {
    XContentType xContentType = randomFrom(XContentType.values());
    boolean humanReadable = randomBoolean();

    long took = randomFrom(randomNonNegativeLong(), -1L);
    long ingestTook = randomFrom(randomNonNegativeLong(), NO_INGEST_TOOK);
    int nbBulkItems = randomIntBetween(1, 10);

    BulkItemResponse[] bulkItems = new BulkItemResponse[nbBulkItems];
    BulkItemResponse[] expectedBulkItems = new BulkItemResponse[nbBulkItems];

    for (int i = 0; i < nbBulkItems; i++) {
        DocWriteRequest.OpType opType = randomFrom(DocWriteRequest.OpType.values());

        if (frequently()) {
            Tuple<? extends DocWriteResponse, ? extends DocWriteResponse> randomDocWriteResponses = null;
            if (opType == DocWriteRequest.OpType.INDEX || opType == DocWriteRequest.OpType.CREATE) {
                randomDocWriteResponses = IndexResponseTests.randomIndexResponse();
            } else if (opType == DocWriteRequest.OpType.DELETE) {
                randomDocWriteResponses = DeleteResponseTests.randomDeleteResponse();
            } else if (opType == DocWriteRequest.OpType.UPDATE) {
                randomDocWriteResponses = UpdateResponseTests.randomUpdateResponse(xContentType);
            } else {
                fail("Test does not support opType [" + opType + "]");
            }

            bulkItems[i] = new BulkItemResponse(i, opType, randomDocWriteResponses.v1());
            expectedBulkItems[i] = new BulkItemResponse(i, opType, randomDocWriteResponses.v2());
        } else {
            String index = randomAsciiOfLength(5);
            String type = randomAsciiOfLength(5);
            String id = randomAsciiOfLength(5);

            Tuple<Throwable, ElasticsearchException> failures = randomExceptions();

            Exception bulkItemCause = (Exception) failures.v1();
            bulkItems[i] = new BulkItemResponse(i, opType,
                    new BulkItemResponse.Failure(index, type, id, bulkItemCause));
            expectedBulkItems[i] = new BulkItemResponse(i, opType,
                    new BulkItemResponse.Failure(index, type, id, failures.v2(), ExceptionsHelper.status(bulkItemCause)));
        }
    }

    BulkResponse bulkResponse = new BulkResponse(bulkItems, took, ingestTook);
    BytesReference originalBytes = toXContent(bulkResponse, xContentType, humanReadable);

    if (randomBoolean()) {
        try (XContentParser parser = createParser(xContentType.xContent(), originalBytes)) {
            originalBytes = shuffleXContent(parser, randomBoolean()).bytes();
        }
    }

    BulkResponse parsedBulkResponse;
    try (XContentParser parser = createParser(xContentType.xContent(), originalBytes)) {
        parsedBulkResponse = BulkResponse.fromXContent(parser);
        assertNull(parser.nextToken());
    }

    assertEquals(took, parsedBulkResponse.getTookInMillis());
    assertEquals(ingestTook, parsedBulkResponse.getIngestTookInMillis());
    assertEquals(expectedBulkItems.length, parsedBulkResponse.getItems().length);

    for (int i = 0; i < expectedBulkItems.length; i++) {
        assertBulkItemResponse(expectedBulkItems[i], parsedBulkResponse.getItems()[i]);
    }

    BytesReference finalBytes = toXContent(parsedBulkResponse, xContentType, humanReadable);
    BytesReference expectedFinalBytes = toXContent(parsedBulkResponse, xContentType, humanReadable);
    assertToXContentEquivalent(expectedFinalBytes, finalBytes, xContentType);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public BytesRestResponse(RestChannel channel, Throwable t) throws IOException {
    this(channel, ExceptionsHelper.status(t), t);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public TaskOperationFailure(String nodeId, long taskId, Throwable t) {
    this.nodeId = nodeId;
    this.taskId = taskId;
    this.reason = t;
    status = ExceptionsHelper.status(t);
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public DefaultShardOperationFailedException(String index, int shardId, Throwable t) {
    this.index = index;
    this.shardId = shardId;
    this.reason = t;
    status = ExceptionsHelper.status(t);
}