// Real onFailure
protected void onFailure(
FetchException e, Object token, ObjectContainer container, ClientContext context) {
if (persistent) {
container.activate(segment, 1);
container.activate(parent, 1);
container.activate(segment.errors, 1);
}
boolean forceFatal = false;
if (parent.isCancelled()) {
if (Logger.shouldLog(Logger.MINOR, this)) Logger.minor(this, "Failing: cancelled");
e = new FetchException(FetchException.CANCELLED);
forceFatal = true;
}
segment.errors.inc(e.getMode());
if (e.isFatal() && token == null) {
segment.fail(e, container, context, false);
} else if (e.isFatal() || forceFatal) {
segment.onFatalFailure(e, ((MySendableRequestItem) token).x, this, container, context);
} else {
segment.onNonFatalFailure(e, ((MySendableRequestItem) token).x, this, container, context);
}
removeBlockNum(((MySendableRequestItem) token).x, container, false);
if (persistent) {
container.deactivate(segment, 1);
container.deactivate(parent, 1);
container.deactivate(segment.errors, 1);
}
}
public void onFailure(
FetchException e, Object token, ObjectContainer container, ClientContext context) {
if (persistent) {
container.activate(segment, 1);
container.activate(parent, 1);
container.activate(segment.errors, 1);
}
boolean forceFatal = false;
if (parent.isCancelled()) {
if (logMINOR) Logger.minor(this, "Failing: cancelled");
e = new FetchException(FetchException.CANCELLED);
forceFatal = true;
}
segment.errors.inc(e.getMode());
if (persistent) segment.errors.storeTo(container);
if (e.isFatal() && token == null) {
segment.fail(e, container, context, false);
} else if (e.isFatal() || forceFatal) {
segment.onFatalFailure(
e, ((SplitFileFetcherSegmentSendableRequestItem) token).blockNum, container, context);
} else {
segment.onNonFatalFailure(
e, ((SplitFileFetcherSegmentSendableRequestItem) token).blockNum, container, context);
}
if (persistent) {
container.deactivate(segment, 1);
container.deactivate(parent, 1);
container.deactivate(segment.errors, 1);
}
}
public void onFailure(
BulkCallFailureItem[] items, ObjectContainer container, ClientContext context) {
FetchException[] fetchExceptions = new FetchException[items.length];
int countFatal = 0;
if (persistent) {
container.activate(blockNums, 2);
}
for (int i = 0; i < items.length; i++) {
fetchExceptions[i] = translateException(items[i].e);
if (fetchExceptions[i].isFatal()) countFatal++;
removeBlockNum(((MySendableRequestItem) items[i].token).x, container, true);
}
if (persistent) {
container.store(blockNums);
container.deactivate(blockNums, 2);
container.activate(segment, 1);
container.activate(parent, 1);
container.activate(segment.errors, 1);
}
if (parent.isCancelled()) {
if (Logger.shouldLog(Logger.MINOR, this)) Logger.minor(this, "Failing: cancelled");
// Fail the segment.
segment.fail(new FetchException(FetchException.CANCELLED), container, context, false);
// FIXME do we need to free the keyNum's??? Or will that happen later anyway?
return;
}
for (int i = 0; i < fetchExceptions.length; i++)
segment.errors.inc(fetchExceptions[i].getMode());
int nonFatalExceptions = items.length - countFatal;
int[] blockNumbers = new int[nonFatalExceptions];
if (countFatal > 0) {
FetchException[] newFetchExceptions = new FetchException[items.length - countFatal];
// Call the fatal callbacks directly.
int x = 0;
for (int i = 0; i < items.length; i++) {
int blockNum = ((MySendableRequestItem) items[i].token).x;
if (fetchExceptions[i].isFatal()) {
segment.onFatalFailure(fetchExceptions[i], blockNum, this, container, context);
} else {
blockNumbers[x] = blockNum;
newFetchExceptions[x] = fetchExceptions[i];
x++;
}
}
fetchExceptions = newFetchExceptions;
} else {
for (int i = 0; i < blockNumbers.length; i++)
blockNumbers[i] = ((MySendableRequestItem) items[i].token).x;
}
segment.onNonFatalFailure(fetchExceptions, blockNumbers, this, container, context);
if (persistent) {
container.deactivate(segment, 1);
container.deactivate(parent, 1);
container.deactivate(segment.errors, 1);
}
}
