private void replaceScheduledFuture(final SchedulerKey key, final Timeout newTimeout) { final Timeout oldTimeout; if (newTimeout.isExpired()) { // no need to put already expired timeout to scheduledFutures map. // simply remove old timeout oldTimeout = scheduledFutures.remove(key); } else { oldTimeout = scheduledFutures.put(key, newTimeout); } // if there was old timeout, cancel it if (oldTimeout != null) { oldTimeout.cancel(); } } }
@Override public void schedule(final SchedulerKey key, final Runnable runnable, long delay, TimeUnit unit) { Timeout timeout = executorService.newTimeout(new TimerTask() { @Override public void run(Timeout timeout) throws Exception { try { runnable.run(); } finally { scheduledFutures.remove(key); } } }, delay, unit); if (!timeout.isExpired()) { scheduledFutures.put(key, timeout); } }
@Override public void scheduleCallback(final SchedulerKey key, final Runnable runnable, long delay, TimeUnit unit) { Timeout timeout = executorService.newTimeout(new TimerTask() { @Override public void run(Timeout timeout) throws Exception { ctx.executor().execute(new Runnable() { @Override public void run() { try { runnable.run(); } finally { scheduledFutures.remove(key); } } }); } }, delay, unit); if (!timeout.isExpired()) { scheduledFutures.put(key, timeout); } }
public void refreshHeartbeat(T key, TimerTask task, long timeout, TimeUnit unit) { Timeout context = timer.newTimeout(task, timeout, unit); final Timeout old = timeouts.put(key, context); if (old != null && !old.isCancelled() && !old.isExpired()) { old.cancel(); } }
void startReadTimeout(ReadTimeoutTimerTask task) { if (requestTimeout == null || (!requestTimeout.isExpired() && readTimeoutValue < (requestTimeoutMillisTime - unpreciseMillisTime()))) { // only schedule a new readTimeout if the requestTimeout doesn't happen first if (task == null) { // first call triggered from outside (else is read timeout is re-scheduling itself) task = new ReadTimeoutTimerTask(nettyResponseFuture, requestSender, this, readTimeoutValue); } this.readTimeout = newTimeout(task, readTimeoutValue); } else if (task != null) { // read timeout couldn't re-scheduling itself, clean up task.clean(); } }
public void cancelPeriodicTransmissionTimeout(Timeout timeout) { if (timeout != null) { synchronized (timeout) { if (!timeout.isExpired()) { timeout.cancel(); } } } } }
private void replaceScheduledFuture(final SchedulerKey key, final Timeout newTimeout) { final Timeout oldTimeout; if (newTimeout.isExpired()) { // no need to put already expired timeout to scheduledFutures map. // simply remove old timeout oldTimeout = scheduledFutures.remove(key); } else { oldTimeout = scheduledFutures.put(key, newTimeout); } // if there was old timeout, cancel it if (oldTimeout != null) { oldTimeout.cancel(); } } }
@Override public void schedule(final SchedulerKey key, final Runnable runnable, long delay, TimeUnit unit) { Timeout timeout = executorService.newTimeout(new TimerTask() { @Override public void run(Timeout timeout) throws Exception { try { runnable.run(); } finally { scheduledFutures.remove(key); } } }, delay, unit); if (!timeout.isExpired()) { scheduledFutures.put(key, timeout); } }
@Override public void scheduleCallback(final SchedulerKey key, final Runnable runnable, long delay, TimeUnit unit) { Timeout timeout = executorService.newTimeout(new TimerTask() { @Override public void run(Timeout timeout) throws Exception { ctx.executor().execute(new Runnable() { @Override public void run() { try { runnable.run(); } finally { scheduledFutures.remove(key); } } }); } }, delay, unit); if (!timeout.isExpired()) { scheduledFutures.put(key, timeout); } }
public Timeout setPeriodicWhileTimer(long delay){ LOG.debug("Entering setPeriodicWhileTimer for switchid={} port={}",swId,portId); if((periodicTimeout != null) && (!periodicTimeout.isExpired())){ periodicTimeout.cancel(); } LacpWheelTimer instance = TimerFactory.LacpWheelTimer.getInstance(Utils.timerWheeltype.PERIODIC_TIMER); periodicTimeout=instance.registerPortForPeriodicTimer(periodicTimer,delay, TimeUnit.SECONDS); LOG.debug("Exiting setPeriodicWhileTimer for switchid={} port={}",swId,portId); return periodicTimeout; }
public Timeout setCurrentWhileTimer(long delay){ LOG.debug("Entering setCurrentWhileTimer for switchid={} port={}",swId,portId); if((currWhileTimeout!= null) && (!currWhileTimeout.isExpired())){ currWhileTimeout.cancel(); } LacpWheelTimer instance = TimerFactory.LacpWheelTimer.getInstance(Utils.timerWheeltype.CURRENT_WHILE_TIMER); currWhileTimeout=instance.registerPortForCurrentWhileTimer(currentWhileTimer,delay, TimeUnit.SECONDS); LOG.debug("Exiting setCurrentWhileTimer for switchid={} port={}",swId,portId); return currWhileTimeout; }
public Timeout setWaitWhileTimer(long delay){ LOG.debug("Entering setWaitWhileTimer for switchid={} port={}",swId,portId); if((waitWhileTimeout!= null) && (!waitWhileTimeout.isExpired())){ waitWhileTimeout.cancel(); } LacpWheelTimer instance = TimerFactory.LacpWheelTimer.getInstance(Utils.timerWheeltype.WAIT_WHILE_TIMER); waitWhileTimeout=instance.registerPortForWaitWhileTimer(waitWhileTimer,delay, TimeUnit.SECONDS); LOG.debug("Exiting setWaitWhileTimer for switchid={} port={}",swId,portId); return waitWhileTimeout; }
public void executeStateAction(PeriodicTxContext obj, LacpPort portObjRef,LacpBpduInfo pdu) { LacpConst.PERIODIC_STATES flag = LacpConst.PERIODIC_STATES.SLOW_PERIODIC; LOG.debug("Entering PeriodicTxPeriodicState executeStateAction, setting ntt to true for port={}", portObjRef.slaveGetPortId()); if(!portObjRef.getPeriodicWhileTimer().isExpired()){ portObjRef.getPeriodicWhileTimer().cancel(); } portObjRef.setNtt(true); if (!LacpUtil.isFast(portObjRef.portPartnerOperGetPortState())) { flag = LacpConst.PERIODIC_STATES.SLOW_PERIODIC; } else { flag = LacpConst.PERIODIC_STATES.FAST_PERIODIC; } obj.setState(portObjRef.getPeriodicTxState(flag)); obj.getState().executeStateAction(obj, portObjRef, pdu); }
|| (rxContext.getState().getStateFlag() == LacpConst.RX_STATES.RX_CURRENT))){ if(!currWhileTimeout.isExpired()){ currWhileTimeout.cancel();