@Override public void remove(final K k, Handler<AsyncResult<V>> resultHandler) { Holder<V> previous = map.remove(k); if (previous != null) { if (previous.expires()) { vertx.cancelTimer(previous.timerId); } resultHandler.handle(Future.succeededFuture(previous.value)); } else { resultHandler.handle(Future.succeededFuture()); } }
@Override public void replace(K k, V v, Handler<AsyncResult<V>> resultHandler) { Holder<V> previous = map.replace(k, new Holder<>(v)); if (previous != null) { if (previous.expires()) { vertx.cancelTimer(previous.timerId); } resultHandler.handle(Future.succeededFuture(previous.value)); } else { resultHandler.handle(Future.succeededFuture()); } }
@Override public void put(final K k, final V v, Handler<AsyncResult<Void>> resultHandler) { Holder<V> previous = map.put(k, new Holder<>(v)); if (previous != null && previous.expires()) { vertx.cancelTimer(previous.timerId); } resultHandler.handle(Future.succeededFuture()); }
@Override public void removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler) { AtomicBoolean result = new AtomicBoolean(); map.computeIfPresent(k, (key, holder) -> { if (holder.value.equals(v)) { result.compareAndSet(false, true); if (holder.expires()) { vertx.cancelTimer(holder.timerId); } return null; } return holder; }); resultHandler.handle(Future.succeededFuture(result.get())); }
public void handle(Long timerID) { assertEquals(id.get(), timerID.longValue()); count++; if (count == numFires) { vertx.cancelTimer(timerID); setEndTimer(); } if (count > numFires) { fail("Fired too many times"); } } }));
@Override public void putIfAbsent(K k, V v, long timeout, Handler<AsyncResult<V>> completionHandler) { long timestamp = System.nanoTime(); long timerId = vertx.setTimer(timeout, l -> removeIfExpired(k)); Holder<V> existing = map.putIfAbsent(k, new Holder<>(v, timerId, timeout, timestamp)); if (existing != null) { if (existing.expires()) { vertx.cancelTimer(timerId); } completionHandler.handle(Future.succeededFuture(existing.value)); } else { completionHandler.handle(Future.succeededFuture()); } }
@Override public void put(K k, V v, long timeout, Handler<AsyncResult<Void>> completionHandler) { long timestamp = System.nanoTime(); long timerId = vertx.setTimer(timeout, l -> removeIfExpired(k)); Holder<V> previous = map.put(k, new Holder<>(v, timerId, timeout, timestamp)); if (previous != null && previous.expires()) { vertx.cancelTimer(previous.timerId); } completionHandler.handle(Future.succeededFuture()); }
@Override public void replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler) { Holder<V> h = new Holder<>(newValue); Holder<V> result = map.computeIfPresent(k, (key, holder) -> { if (holder.value.equals(oldValue)) { if (holder.expires()) { vertx.cancelTimer(holder.timerId); } return h; } return holder; }); resultHandler.handle(Future.succeededFuture(h == result)); }
void acquireLock() { if (status.compareAndSet(Status.WAITING, Status.ACQUIRED)) { if (timerId != null) { context.owner().cancelTimer(timerId); } context.runOnContext(v -> handler.handle(Future.succeededFuture(new AsyncLock(lockName)))); } else { context.runOnContext(v -> nextWaiter(lockName)); } } }
void close() { if (timeoutID != -1) { vertx.cancelTimer(timeoutID); } if (pingTimeoutID != -1) { vertx.cancelTimer(pingTimeoutID); } try { client.close(); } catch (Exception ignore) { } // The holder can be null or different if the target server is restarted with same serverid // before the cleanup for the previous one has been processed if (eventBus.connections().remove(serverID, this)) { if (log.isDebugEnabled()) { log.debug("Cluster connection closed for server " + serverID); } } }
@Override public void start() throws Exception { long id = vertx.setTimer(100, id_ -> { fail(); }); Thread.sleep(200); assertTrue(vertx.cancelTimer(id)); testComplete(); } }, new DeploymentOptions().setWorker(true));
private void fail(Throwable cause) { inProgressMap.remove(msg.id()); if (timerID >= 0) { vertx.cancelTimer(timerID); } fut.tryFail(cause); }
void handle(DnsResponse msg) { DnsResponseCode code = DnsResponseCode.valueOf(msg.code().intValue()); if (code == DnsResponseCode.NOERROR) { inProgressMap.remove(msg.id()); if (timerID >= 0) { vertx.cancelTimer(timerID); } int count = msg.count(DnsSection.ANSWER); List<T> records = new ArrayList<>(count); for (int idx = 0;idx < count;idx++) { DnsRecord a = msg.recordAt(DnsSection.ANSWER, idx); T record = RecordDecoder.decode(a); if (isRequestedType(a.type(), types)) { records.add(record); } } if (records.size() > 0 && (records.get(0) instanceof MxRecordImpl || records.get(0) instanceof SrvRecordImpl)) { Collections.sort((List) records); } actualCtx.executeFromIO(v -> { fut.tryComplete(records); }); } else { actualCtx.executeFromIO(new DnsException(code), this::fail); } }
@Test /** * Test the timers fire with approximately the correct delay */ public void testTimings() throws Exception { final long start = System.currentTimeMillis(); final long delay = 2000; vertx.setTimer(delay, timerID -> { long dur = System.currentTimeMillis() - start; assertTrue(dur >= delay); long maxDelay = delay * 2; assertTrue("Timer accuracy: " + dur + " vs " + maxDelay, dur < maxDelay); // 100% margin of error (needed for CI) vertx.cancelTimer(timerID); testComplete(); }); await(); }
private synchronized void connected(NetSocket socket) { this.socket = socket; connected = true; socket.exceptionHandler(t -> close()); socket.closeHandler(v -> close()); socket.handler(data -> { // Got a pong back vertx.cancelTimer(timeoutID); schedulePing(); }); // Start a pinger schedulePing(); if (pending != null) { if (log.isDebugEnabled()) { log.debug("Draining the queue for server " + serverID); } for (ClusteredMessage message : pending) { Buffer data = message.encodeToWire(); if (metrics != null) { metrics.messageWritten(message.address(), data.length()); } socket.write(data); } } pending = null; }
@Test public void testIdleTimeoutInfiniteSkipOfControlCharactersState() throws Exception { server.close(); server = vertx.createHttpServer(new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setHost(DEFAULT_HTTP_HOST) .setIdleTimeout(1)); server.requestHandler(req -> { testComplete(); }); startServer(); NetClient client = vertx.createNetClient(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> { long id = vertx.setPeriodic(1, timerID -> { so.write(Buffer.buffer().setInt(0, 0xD)); }); so.closeHandler(v -> { vertx.cancelTimer(id); testComplete(); }); })); await(); }
private void drainingServer(Consumer<Future<Void>> consumer) { Future<Void> resumeFuture = Future.future(); server.requestHandler(req -> { req.response().setChunked(true); assertFalse(req.response().writeQueueFull()); req.response().setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); //Send data until the buffer is full vertx.setPeriodic(1, id -> { req.response().write(buff); if (req.response().writeQueueFull()) { vertx.cancelTimer(id); req.response().drainHandler(v -> { assertFalse(req.response().writeQueueFull()); testComplete(); }); // Tell the client to resume resumeFuture.complete(); } }); }); server.listen(onSuccess(s -> consumer.accept(resumeFuture))); }
@Test public void testClientDrainHandler() { pausingServer(resumeFuture -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); req.setChunked(true); assertFalse(req.writeQueueFull()); req.setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); vertx.setPeriodic(1, id -> { req.write(buff); if (req.writeQueueFull()) { vertx.cancelTimer(id); req.drainHandler(v -> { assertFalse(req.writeQueueFull()); testComplete(); }); // Tell the server to resume resumeFuture.complete(); } }); }); await(); }
void drainingServer(Handler<AsyncResult<NetServer>> listenHandler) { server.connectHandler(sock -> { assertFalse(sock.writeQueueFull()); sock.setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); //Send data until the buffer is full vertx.setPeriodic(1, id -> { sock.write(buff.copy()); if (sock.writeQueueFull()) { vertx.cancelTimer(id); sock.drainHandler(v -> { assertFalse(sock.writeQueueFull()); // End test after a short delay to give the client some time to read the data vertx.setTimer(100, id2 -> testComplete()); }); // Tell the client to resume vertx.eventBus().send("client_resume", ""); } }); }).listen(testAddress, listenHandler); }
@Test public void testClientDrainHandler() { pausingServer((s) -> { client.connect(testAddress, onSuccess(sock -> { assertFalse(sock.writeQueueFull()); sock.setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); vertx.setPeriodic(1, id -> { sock.write(buff.copy()); if (sock.writeQueueFull()) { vertx.cancelTimer(id); sock.drainHandler(v -> { assertFalse(sock.writeQueueFull()); testComplete(); }); // Tell the server to resume vertx.eventBus().send("server_resume", ""); } }); })); }); await(); }