com.landawn.abacus.util.Retry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of abacus-android Show documentation
Show all versions of abacus-android Show documentation
A general and simple library for Android
/*
* Copyright (C) 2016 HaiYang Li
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.landawn.abacus.util;
import java.util.Iterator;
import java.util.concurrent.Callable;
import com.landawn.abacus.logging.Logger;
import com.landawn.abacus.logging.LoggerFactory;
import com.landawn.abacus.util.function.BiPredicate;
import com.landawn.abacus.util.function.Predicate;
/**
*
* @since 0.8
*
* @author Haiyang Li
*/
public final class Retry {
private static final Logger logger = LoggerFactory.getLogger(Retry.class);
private final int retryTimes;
private final long retryInterval;
private final Predicate retryCondition;
private final BiPredicate retryCondition2;
Retry(final int retryTimes, final long retryInterval, final Predicate retryCondition,
final BiPredicate retryCondition2) {
this.retryTimes = retryTimes;
this.retryInterval = retryInterval;
this.retryCondition = retryCondition;
this.retryCondition2 = retryCondition2;
}
public static Retry of(final int retryTimes, final long retryInterval, final Predicate retryCondition) {
if (retryTimes < 0 || retryInterval < 0) {
throw new IllegalArgumentException("'retryTimes' and 'retryInterval' can't be negative");
}
N.checkArgNotNull(retryCondition);
return new Retry(retryTimes, retryInterval, retryCondition, null);
}
public static Retry of(final int retryTimes, final long retryInterval, final BiPredicate retryCondition) {
if (retryTimes < 0 || retryInterval < 0) {
throw new IllegalArgumentException("'retryTimes' and 'retryInterval' can't be negative");
}
N.checkArgNotNull(retryCondition);
return new Retry(retryTimes, retryInterval, null, retryCondition);
}
public void run(final Try.Runnable cmd) throws Exception {
try {
cmd.run();
} catch (Exception e) {
logger.error("AutoRetry", e);
int retriedTimes = 0;
Exception throwable = e;
while (retriedTimes++ < retryTimes
&& ((retryCondition != null && retryCondition.test(throwable)) || (retryCondition2 != null && retryCondition2.test(null, throwable)))) {
try {
if (retryInterval > 0) {
N.sleep(retryInterval);
}
cmd.run();
return;
} catch (Exception e2) {
logger.error("AutoRetry", e2);
throwable = e2;
}
}
throw throwable;
}
}
public T call(final Callable callable) throws Exception {
T result = null;
int retriedTimes = 0;
try {
result = callable.call();
while (retriedTimes++ < retryTimes && (retryCondition2 != null && retryCondition2.test(result, null))) {
if (retryInterval > 0) {
N.sleep(retryInterval);
}
result = callable.call();
if (retryCondition2 == null || retryCondition2.test(result, null) == false) {
return result;
}
}
} catch (Exception e) {
logger.error("AutoRetry", e);
Exception throwable = e;
while (retriedTimes++ < retryTimes
&& ((retryCondition != null && retryCondition.test(throwable)) || (retryCondition2 != null && retryCondition2.test(null, throwable)))) {
try {
if (retryInterval > 0) {
N.sleep(retryInterval);
}
result = callable.call();
if (retryCondition2 == null || retryCondition2.test(result, null) == false) {
return result;
}
} catch (Exception e2) {
logger.error("AutoRetry", e2);
throwable = e2;
}
}
throw throwable;
}
if (retryTimes > 0 && (retryCondition2 != null && retryCondition2.test(result, null))) {
throw new RuntimeException("Still failed after retried " + retryTimes + " times for result: " + N.toString(result));
}
return result;
}
/**
*
* @param iter
* @return
* @deprecated replaced by {@code Retry#iterate(Iterator, int)}.
*/
@Deprecated
public Iterator iterate(final Iterator iter) {
return iterate(iter, Integer.MAX_VALUE);
}
public Iterator iterate(final Iterator iter, final int totalRetryTimes) {
N.checkArgPositive(totalRetryTimes, "totalRetryTimes");
return new Iterator() {
private int totalRetriedTimes = 0;
@Override
public boolean hasNext() {
try {
return iter.hasNext();
} catch (RuntimeException e) {
logger.error("hasNext", e);
int retriedTimes = 0;
RuntimeException throwable = e;
while (totalRetriedTimes < totalRetryTimes && retriedTimes++ < retryTimes && ((retryCondition != null && retryCondition.test(throwable))
|| (retryCondition2 != null && retryCondition2.test(null, throwable)))) {
totalRetriedTimes++;
try {
if (retryInterval > 0) {
N.sleep(retryInterval);
}
return iter.hasNext();
} catch (RuntimeException e2) {
logger.error("hasNext", e2);
throwable = e2;
}
}
throw throwable;
}
}
@Override
public E next() {
try {
return iter.next();
} catch (RuntimeException e) {
logger.error("next", e);
int retriedTimes = 0;
RuntimeException throwable = e;
while (totalRetriedTimes < totalRetryTimes && retriedTimes++ < retryTimes && ((retryCondition != null && retryCondition.test(throwable))
|| (retryCondition2 != null && retryCondition2.test(null, throwable)))) {
totalRetriedTimes++;
try {
if (retryInterval > 0) {
N.sleep(retryInterval);
}
return iter.next();
} catch (RuntimeException e2) {
logger.error("next", e2);
throwable = e2;
}
}
throw throwable;
}
}
@Override
public void remove() {
try {
iter.remove();
} catch (RuntimeException e) {
logger.error("remove", e);
int retriedTimes = 0;
RuntimeException throwable = e;
while (totalRetriedTimes < totalRetryTimes && retriedTimes++ < retryTimes && ((retryCondition != null && retryCondition.test(throwable))
|| (retryCondition2 != null && retryCondition2.test(null, throwable)))) {
totalRetriedTimes++;
try {
if (retryInterval > 0) {
N.sleep(retryInterval);
}
iter.remove();
} catch (RuntimeException e2) {
logger.error("remove", e2);
throwable = e2;
}
}
throw throwable;
}
}
};
}
}