private void executeCloseDone(final ContextInternal closeContext, final Handler<AsyncResult<Void>> done, final Exception e) { if (done != null) { Future<Void> fut = e != null ? Future.failedFuture(e) : Future.succeededFuture(); closeContext.runOnContext((v) -> done.handle(fut)); } }
private void executeCloseDone(ContextInternal closeContext, Handler<AsyncResult<Void>> done, Exception e) { if (done != null) { Future<Void> fut = e == null ? Future.succeededFuture() : Future.failedFuture(e); closeContext.runOnContext(v -> done.handle(fut)); } }
private void queueForWrite(Object msg, ChannelPromise promise) { writeInProgress++; context.runOnContext(v -> { synchronized (ConnectionBase.this) { writeInProgress--; write(msg, promise); } }); }
public void inProgressQueries(Handler<Integer> handler) { actualCtx.runOnContext(v -> { handler.handle(inProgressMap.size()); }); }
private synchronized void checkNextTick() { // Check if there are more pending messages in the queue that can be processed next time around if (!pending.isEmpty() && demand > 0L) { handlerContext.runOnContext(v -> { Message<T> message; Handler<Message<T>> theHandler; ContextInternal ctx; synchronized (HandlerRegistration.this) { if (demand == 0L || (message = pending.poll()) == null) { return; } if (demand != Long.MAX_VALUE) { demand--; } theHandler = handler; ctx = handlerContext; } deliver(theHandler, message, ctx); }); } }
actualCtx.runOnContext((v) -> handler.handle(Future.failedFuture(e)));
@Override void handleClose() { if (pendingPushes.remove(this)) { completionHandler.fail("Push reset by client"); } else { concurrentStreams--; while ((maxConcurrentStreams == null || concurrentStreams < maxConcurrentStreams) && pendingPushes.size() > 0) { Push push = pendingPushes.pop(); concurrentStreams++; context.runOnContext(v -> { push.complete(); }); } response.handleClose(); } }
private void handleNext(HttpServerRequestImpl request) { responseInProgress = request; getContext().runOnContext(v -> responseInProgress.handlePipelined()); }
public void resolveHostname(String hostname, Handler<AsyncResult<InetAddress>> resultHandler) { ContextInternal callback = (ContextInternal) vertx.getOrCreateContext(); io.netty.resolver.AddressResolver<InetSocketAddress> resolver = resolverGroup.getResolver(callback.nettyEventLoop()); io.netty.util.concurrent.Future<InetSocketAddress> fut = resolver.resolve(InetSocketAddress.createUnresolved(hostname, 0)); fut.addListener(a -> { callback.runOnContext(v -> { if (a.isSuccess()) { InetSocketAddress address = fut.getNow(); resultHandler.handle(Future.succeededFuture(address.getAddress())); } else { resultHandler.handle(Future.failedFuture(a.cause())); } }); }); }
@Override public HttpServerResponse drainHandler(Handler<Void> handler) { synchronized (conn) { if (handler != null) { checkValid(); } drainHandler = handler; conn.getContext().runOnContext(v -> conn.handleInterestedOpsChanged()); return this; } }
void run() { inProgressMap.put(msg.id(), this); timerID = vertx.setTimer(options.getQueryTimeout(), id -> { timerID = -1; actualCtx.runOnContext(v -> { fail(new VertxException("DNS query timeout for " + name)); }); }); channel.writeAndFlush(msg).addListener((ChannelFutureListener) future -> { if (!future.isSuccess()) { actualCtx.executeFromIO(future.cause(), this::fail); } }); }
context.runOnContext(v -> { if (!paused.get()) { socket.resume();
context.runOnContext(v -> { done.handle(Future.succeededFuture()); });
if (resultHandler != null) { ContextInternal ctx = vertx.getOrCreateContext(); ctx.runOnContext((v) -> resultHandler.handle(Future.failedFuture(new FileNotFoundException()))); } else { log.error("File not found: " + filename); ctx.runOnContext((v) -> resultHandler.handle(Future.failedFuture(e))); } else { log.error("Failed to send file", e);
listening = false; listenContext.runOnContext((v) -> listenHandler.handle(res)); } else if (future.failed()) { listening = false;
listenContext.runOnContext(v -> listenHandler.handle(ares)); } else if (res.failed()) {
AtomicReference<Thread> contextThread = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); context.runOnContext(v -> { contextThread.set(Thread.currentThread()); latch.countDown();
private void executeCloseDone(ContextInternal closeContext, Handler<AsyncResult<Void>> done, Exception e) { if (done != null) { Future<Void> fut = e == null ? Future.succeededFuture() : Future.failedFuture(e); closeContext.runOnContext(v -> done.handle(fut)); } }
private void queueForWrite(Object msg, ChannelPromise promise) { writeInProgress++; context.runOnContext(v -> { synchronized (ConnectionBase.this) { writeInProgress--; write(msg, promise); } }); }
private void handleNext(HttpServerRequestImpl request) { responseInProgress = request; getContext().runOnContext(v -> responseInProgress.handlePipelined()); }