Reset the local idle timers, now that we have received some data.

If we have set an idle timeout the client must send some data at least that often,
we double the timeout before checking.
543990
private void resetReceiveIdleTimer(Event event) {
        final String methodName = "resetReceiveIdleTimer";
        logger.entry(this, methodName, event);

        if (receiveScheduledFuture != null) {
            receiveScheduledFuture.cancel(false);
        }

        final Transport transport = event.getTransport();
        if (transport != null) {
            final int localIdleTimeOut = transport.getIdleTimeout();
            if (localIdleTimeOut > 0) {
                Runnable receiveTimeout = new Runnable() {
                    @Override
                    public void run() {
                        final String methodName = "run";
                        logger.entry(this, methodName);
                        transport.process();
                        transport.tick(System.currentTimeMillis());
                        logger.exit(methodName);
                    }
                };
                receiveScheduledFuture = scheduler.schedule(receiveTimeout,
                        localIdleTimeOut, TimeUnit.MILLISECONDS);
            }
        }
        logger.exit(this, methodName);
    }
536520
public RiakNode setIdleTimeout(int idleTimeoutInMillis)
    {
        stateCheck(State.CREATED, State.RUNNING, State.HEALTH_CHECKING);
        this.idleTimeoutInNanos = TimeUnit.NANOSECONDS.convert(idleTimeoutInMillis, TimeUnit.MILLISECONDS);
        return this;
    }
426250
function resetKeepAlive() {
    if (keepAliveTimeoutId) {
        clearTimeout(keepAliveTimeoutId);
    }

    keepAliveTimeoutId = setTimeout(function () {
        exit.call(process, 1);
    }, keepAliveTimeout);
}
1054470
def _rx_timer_handler(self):
        """"""

        with self.rx_mutex:
            if self.rx_state == ISOTP_WAIT_DATA:
                # we did not get new data frames in time.
                # reset rx state
                self.rx_state = ISOTP_IDLE
                warning("RX state was reset due to timeout")
907015
def resetTimeout(self):
        """"""
        if self.__timeoutCall is not None and self.timeOut is not None:
            self.__timeoutCall.reset(self.timeOut)
1165769
function(time) {
        clearTimeout(this._restartTimeout);
        if (!time) {
            return;
        }
        if (!this._isShuttingDown) {
            this._restartTimeout = setTimeout(_.bind(this._onRestartTimeout, this), time * 1000);
        }
    }
448374
public synchronized void reset() {
		timeoutAt = 0;
		prevSeq = -1;
		pool.clear();
		stream.closed.set(false);
		stream.buffer.clear();
		stream.cause = null;
		stream.transferedBytes.set(0);
		inited.set(false);
	}
18090
function() {
        clearInterval(this._checkConnectionTimer);
        this._checkConnectionTimer = undefined;
        this.muc.joinedRooms = {};
        this._isLogout = true;
        this.helpers.setUserCurrentJid('');

        if (Utils.getEnv().browser) {
            this.connection.flush();
            this.connection.disconnect();
        } else {
            this.Client.end();
        }
    }
540166
def _reset(self):
        ''''''
        self._socket = None
        # The pending messages we have to send, and the current buffer we're
        # sending
        self._pending = deque()
        self._out_buffer = ''
        # Our read buffer
        self._buffer = ''
        # The identify response we last received from the server
        self._identify_response = {}
        # Our ready state
        self.last_ready_sent = 0
        self.ready = 0
960665
final void internalWait(long timeout) {
    int s;
    if ((s = status) >= 0 && // force completer to issue notify
        U.compareAndSwapInt(this, STATUS, s, s | SIGNAL)) {
      synchronized (this) {
        if (status >= 0)
          try {
            wait(timeout);
          } catch (InterruptedException ie) {
          }
        else
          notifyAll();
      }
    }
  }
1142661
def reset(self):
        
        logger.debug('DUT> reset')
        self._log and self.pause()
        self._sendline('reset')
        self._read()
        self._log and self.resume()
596800
def restart_inactivity_timer
      @inactivity_timer.cancel if @inactivity_timer
      @inactivity_timer = EM::Timer.new(@check_interval) do
        begin
          check(id = nil, max_ping_timeouts = 1)
        rescue Exception => e
          ErrorTracker.log(self, "Failed connectivity check", e)
        end
      end
      true
    end
1348986
def wait_for_idle(self):
        

        # Be mindful that this is being executed in a different greenlet than the work_* methods.

        while True:

            time.sleep(0.01)

            with self.work_lock:

                if self.status != "wait":
                    continue

                if len(self.gevent_pool) > 0:
                    continue

                # Force a refresh of the current subqueues, one might just have been created.
                self.refresh_queues()

                # We might be dequeueing a new subqueue. Double check that we don't have anything more to do
                outcome, dequeue_jobs = self.work_once(free_pool_slots=1, max_jobs=None)

                if outcome is "wait" and dequeue_jobs == 0:
                    break
1304921
def _attempt_set_timeout(self, timeout):
    """"""
    try:
      self.client.setTimeout(timeout)
    except Exception:
      self._logger.debug('failed to set post-startup watchman timeout to %s', self._timeout)
    else:
      self._logger.debug('set post-startup watchman timeout to %s', self._timeout)
1260148
def checkTimeout(self, now):
        """"""
        log.debug("checking for timeout on session %s", self)
        if now - self.last_update > self.timeout:
            raise TftpTimeout("Timeout waiting for traffic")
1324827
function checkQueue() {
    if(!inInterval()) {
      if(requestQueue.length) {
        var next = requestQueue.shift();
        sendRequest(next);
      } else if(timer) {
        clearInterval(timer); // No need to leave the timer running if we don't have any requests.
      }
    }
  }
113529
public void setTimeout(Duration timeout) {

        LettuceAssert.notNull(timeout, "Timeout must not be null");
        LettuceAssert.isTrue(!timeout.isNegative(), "Timeout must be greater or equal 0");

        this.timeout = timeout;
    }