@Override public long sleep(long pause, int tries) { return ConnectionUtils.getPauseTime(pause, tries); }
@Override public long sleep(long pause, int tries) { return ConnectionUtils.getPauseTime(pause, tries); }
@Override public long sleep(long pause, int tries) { return ConnectionUtils.getPauseTime(pause, tries); }
@Override public long sleep(long pause, int tries) { return ConnectionUtils.getPauseTime(pause, tries); }
static void sleepIgnoreInterrupt(int retry) { try { Thread.sleep(ConnectionUtils.getPauseTime(100, retry)); } catch (InterruptedException e) { } } }
@Override public boolean retryRequest(IOException exception, int executionCount, HttpContext context) { // Don't sleep for retrying the first time if (executionCount > 1 && pause > 0) { try { long sleepTime = ConnectionUtils.getPauseTime(pause, executionCount - 1); Thread.sleep(sleepTime); } catch (InterruptedException ie) { //reset interrupt marker Thread.currentThread().interrupt(); } } return super.retryRequest(exception, executionCount, context); }
/** * Calculates the back-off time for a retrying request to a particular server. * * @param server The server in question. * @param basePause The default hci pause. * @return The time to wait before sending next request. */ long calculateBackoffTime(ServerName server, long basePause) { long result; ServerErrors errorStats = errorsByServer.get(server); if (errorStats != null) { result = ConnectionUtils.getPauseTime(basePause, Math.max(0, errorStats.getCount() - 1)); } else { result = 0; // yes, if the server is not in our list we don't wait before retrying. } return result; }
private void tryResubmit(Stream<Action> actions, int tries) { long delayNs; if (operationTimeoutNs > 0) { long maxDelayNs = remainingTimeNs() - SLEEP_DELTA_NS; if (maxDelayNs <= 0) { failAll(actions, tries); return; } delayNs = Math.min(maxDelayNs, getPauseTime(pauseNs, tries - 1)); } else { delayNs = getPauseTime(pauseNs, tries - 1); } retryTimer.newTimeout(t -> groupAndSend(actions, tries + 1), delayNs, TimeUnit.NANOSECONDS); }
serverTrackerTimeout = serverTrackerTimeout + ConnectionUtils.getPauseTime(this.pause, i);
private void tryScheduleRetry(Throwable error, Consumer<Throwable> updateCachedLocation) { long delayNs; if (operationTimeoutNs > 0) { long maxDelayNs = remainingTimeNs() - SLEEP_DELTA_NS; if (maxDelayNs <= 0) { completeExceptionally(); return; } delayNs = Math.min(maxDelayNs, getPauseTime(pauseNs, tries - 1)); } else { delayNs = getPauseTime(pauseNs, tries - 1); } tries++; retryTimer.newTimeout(t -> doCall(), delayNs, TimeUnit.NANOSECONDS); }
@Override protected AsyncWriter createWriterInstance(Path path) throws IOException { AsyncWriter localWriter = super.createWriterInstance(path); // retry forever if we can not create the remote writer to prevent aborting the RS due to log // rolling error, unless the skipRemoteWal is set to true. // TODO: since for now we only have one thread doing log rolling, this may block the rolling for // other wals Path remoteWAL = new Path(remoteWALDir, path.getName()); for (int retry = 0;; retry++) { if (skipRemoteWAL) { return localWriter; } AsyncWriter remoteWriter; try { remoteWriter = createAsyncWriter(remoteFs, remoteWAL); } catch (IOException e) { LOG.warn("create remote writer {} failed, retry = {}", remoteWAL, retry, e); try { Thread.sleep(ConnectionUtils.getPauseTime(100, retry)); } catch (InterruptedException ie) { // restore the interrupt state Thread.currentThread().interrupt(); Closeables.close(localWriter, true); throw (IOException) new InterruptedIOException().initCause(ie); } continue; } return createCombinedAsyncWriter(localWriter, remoteWriter); } }
@Test public void testRetryTimeJitter() { long[] retries = new long[200]; long baseTime = 1000000; //Larger number than reality to help test randomness. long maxTimeExpected = (long) (baseTime * 1.01f); for (int i = 0; i < retries.length; i++) { retries[i] = ConnectionUtils.getPauseTime(baseTime, 0); } Set<Long> retyTimeSet = new TreeSet<>(); for (long l : retries) { /*make sure that there is some jitter but only 1%*/ assertTrue(l >= baseTime); assertTrue(l <= maxTimeExpected); // Add the long to the set retyTimeSet.add(l); } //Make sure that most are unique. some overlap will happen assertTrue(retyTimeSet.size() > (retries.length * 0.80)); }
@Test public void testGetPauseTime() { long pauseTime; long baseTime = 100; pauseTime = ConnectionUtils.getPauseTime(baseTime, -1); assertTrue(pauseTime >= (baseTime * HConstants.RETRY_BACKOFF[0])); assertTrue(pauseTime <= (baseTime * HConstants.RETRY_BACKOFF[0] * 1.01f)); for (int i = 0; i < HConstants.RETRY_BACKOFF.length; i++) { pauseTime = ConnectionUtils.getPauseTime(baseTime, i); assertTrue(pauseTime >= (baseTime * HConstants.RETRY_BACKOFF[i])); assertTrue(pauseTime <= (baseTime * HConstants.RETRY_BACKOFF[i] * 1.01f)); } int length = HConstants.RETRY_BACKOFF.length; pauseTime = ConnectionUtils.getPauseTime(baseTime, length); assertTrue(pauseTime >= (baseTime * HConstants.RETRY_BACKOFF[length - 1])); assertTrue(pauseTime <= (baseTime * HConstants.RETRY_BACKOFF[length - 1] * 1.01f)); } }
if (pause) { pauseTime = ConnectionUtils.getPauseTime(INIT_PAUSE_TIME_MS, tries); } else {
private void getProcedureResult(long procId, CompletableFuture<Void> future, int retries) { addListener( this.<GetProcedureResultResponse> newMasterCaller() .action((controller, stub) -> this .<GetProcedureResultRequest, GetProcedureResultResponse, GetProcedureResultResponse> call( controller, stub, GetProcedureResultRequest.newBuilder().setProcId(procId).build(), (s, c, req, done) -> s.getProcedureResult(c, req, done), (resp) -> resp)) .call(), (response, error) -> { if (error != null) { LOG.warn("failed to get the procedure result procId={}", procId, ConnectionUtils.translateException(error)); retryTimer.newTimeout(t -> getProcedureResult(procId, future, retries + 1), ConnectionUtils.getPauseTime(pauseNs, retries), TimeUnit.NANOSECONDS); return; } if (response.getState() == GetProcedureResultResponse.State.RUNNING) { retryTimer.newTimeout(t -> getProcedureResult(procId, future, retries + 1), ConnectionUtils.getPauseTime(pauseNs, retries), TimeUnit.NANOSECONDS); return; } if (response.hasException()) { IOException ioe = ForeignExceptionUtil.toIOException(response.getException()); future.completeExceptionally(ioe); } else { future.complete(null); } }); }
return; delayNs = Math.min(maxDelayNs, getPauseTime(pauseNs, tries - 1)); } else { delayNs = getPauseTime(pauseNs, tries - 1);
Thread.sleep(ConnectionUtils.getPauseTime(100, retry)); } catch (InterruptedException ie) { throw new InterruptedIOException();
if (pause) { pauseTime = ConnectionUtils.getPauseTime(INIT_PAUSE_TIME_MS, tries); } else {
Thread.sleep(ConnectionUtils.getPauseTime(pauseBase, tries)); } catch (InterruptedException e) { throw new InterruptedIOException("Giving up trying to location region in " +
long expectedSleep = 0L; for (int i = 0; i < retries; i++) { expectedSleep += ConnectionUtils.getPauseTime(specialPause, i); expectedSleep = 0L; for (int i = 0; i < retries; i++) { expectedSleep += ConnectionUtils.getPauseTime(normalPause, i);