private <T> void reportResult(Context context, Handler<AsyncResult<T>> completionHandler, AsyncResult<T> result) { context.runOnContext(v -> { try { completionHandler.handle(result); } catch (Throwable t) { log.error("Failure in calling handler", t); throw t; } }); }
@Override public void get(Handler<AsyncResult<Long>> resultHandler) { Objects.requireNonNull(resultHandler, "resultHandler"); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter.get()))); }
@Override public void getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler) { Objects.requireNonNull(resultHandler, "resultHandler"); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter.getAndAdd(value)))); }
@Override public void decrementAndGet(Handler<AsyncResult<Long>> resultHandler) { Objects.requireNonNull(resultHandler, "resultHandler"); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter.decrementAndGet()))); }
@Override public void addAndGet(long value, Handler<AsyncResult<Long>> resultHandler) { Objects.requireNonNull(resultHandler, "resultHandler"); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter.addAndGet(value)))); }
@Override public synchronized MessageConsumer<T> endHandler(Handler<Void> endHandler) { if (endHandler != null) { // We should use the HandlerHolder context to properly do this (needs small refactoring) Context endCtx = vertx.getOrCreateContext(); this.endHandler = v1 -> endCtx.runOnContext(v2 -> endHandler.handle(null)); } else { this.endHandler = null; } return this; }
@Override public void incrementAndGet(Handler<AsyncResult<Long>> resultHandler) { Objects.requireNonNull(resultHandler, "resultHandler"); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter.incrementAndGet()))); }
@Override public void getAndIncrement(Handler<AsyncResult<Long>> resultHandler) { Objects.requireNonNull(resultHandler, "resultHandler"); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter.getAndIncrement()))); }
@Override public void compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler) { Objects.requireNonNull(resultHandler, "resultHandler"); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter.compareAndSet(expected, value)))); } }
private void checkCallDrainHandler() { if (overflow) { overflow = false; context.runOnContext(v -> { Handler<Void> drainHandler; synchronized (InboundBuffer.this) { drainHandler = this.drainHandler; } handleEvent(drainHandler, null); }); } }
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)); } } }
private void getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler) { Counter counter = localCounters.computeIfAbsent(name, n -> new AsynchronousCounter(vertx)); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(counter))); }
protected void startServer(Context context, HttpServer server) throws Exception { CountDownLatch latch = new CountDownLatch(1); context.runOnContext(v -> { server.listen(onSuccess(s -> latch.countDown())); }); awaitLatch(latch); }
@Override public void getCounter(String name, Handler<AsyncResult<Counter>> resultHandler) { AtomicLong counter = new AtomicLong(); AtomicLong prev = counters.putIfAbsent(name, counter); if (prev != null) { counter = prev; } AtomicLong theCounter = counter; Context context = vertx.getOrCreateContext(); context.runOnContext(v -> resultHandler.handle(Future.succeededFuture(new AsynchronousCounter(vertx, theCounter)))); }
protected void startServer(SocketAddress remoteAddress, Context context, NetServer server) throws Exception { CountDownLatch latch = new CountDownLatch(1); context.runOnContext(v -> { server.listen(remoteAddress, onSuccess(s -> latch.countDown())); }); awaitLatch(latch); }
@Override public void start() throws Exception { thread.set(Thread.currentThread()); assertTrue(Context.isOnVertxThread()); assertTrue(Context.isOnWorkerThread()); assertFalse(Context.isOnEventLoopThread()); assertTrue(Thread.currentThread().getName().startsWith(poolName + "-")); context.runOnContext(v -> { vertx.undeploy(context.deploymentID()); }); } }, new DeploymentOptions().setWorker(true).setWorkerPoolName(poolName), onSuccess(deployment::set));
@Test public void testExecuteBlockingThreadSyncComplete() throws Exception { Context context = vertx.getOrCreateContext(); context.<Void>runOnContext(v -> { Thread expected = Thread.currentThread(); context.executeBlocking(Future::complete, r -> { assertSame(expected, Thread.currentThread()); testComplete(); }); }); await(); }
@Test public void testDefaultContextExceptionHandler() { RuntimeException failure = new RuntimeException(); Context context = vertx.getOrCreateContext(); vertx.exceptionHandler(err -> { assertSame(failure, err); testComplete(); }); context.runOnContext(v -> { throw failure; }); await(); }
@Test public void testHighWaterMark() { context.runOnContext(v -> { buffer = new InboundBuffer<>(context, 4L); buffer.pause(); fill(); assertEquals(5, sequence.get()); testComplete(); }); await(); }
@Test public void testGettingContextContextUnderContextAnotherInstanceShouldReturnDifferentContext() throws Exception { Vertx other = vertx(); Context context = vertx.getOrCreateContext(); context.runOnContext(v -> { Context otherContext = other.getOrCreateContext(); assertNotSame(otherContext, context); testComplete(); }); await(); }