private void checkContext() { if (context != Vertx.currentContext()) { throw new IllegalStateException("This operation must be called from the context thread"); } }
@Override public void stop() throws Exception { switch (stopAction) { case THROW_EXCEPTION: throw new Exception("BooFar!"); case THROW_ERROR: throw new Error("BooFar!"); default: stopCalled = true; stopContext = Vertx.currentContext(); } } }
@Override public Verticle createVerticle(String verticleName, ClassLoader classLoader) throws Exception { if (failInCreate) { throw new ClassNotFoundException("whatever"); } this.identifier = verticleName; this.createContext = Vertx.currentContext(); this.createWorkerThread = Context.isOnWorkerThread(); return verticle; }
@Override public void start() throws Exception { switch (startAction) { case THROW_EXCEPTION: throw new Exception("FooBar!"); case THROW_ERROR: throw new Error("FooBar!"); default: startCalled = true; startContext = Vertx.currentContext(); } deploymentID = Vertx.currentContext().deploymentID(); config = context.config(); }
@Override public synchronized void handleFailure(Throwable failure) { assertNull(Vertx.currentContext()); Pool<FakeConnection> pool = mgr.pool(); holdsLock.set(Thread.holdsLock(pool)); super.handleFailure(failure); } };
protected void assertOnIOContext(Context context) { Context current = Vertx.currentContext(); assertNotNull(current); assertEquals(context, current); for (StackTraceElement elt : Thread.currentThread().getStackTrace()) { if (elt.getMethodName().equals("executeFromIO")) { return; } } fail("Not from IO"); } }
@Test public void testNoContext() throws Exception { assertNull(Vertx.currentContext()); }
@Override Future<Void> handle(ReadStream<Buffer> stream) { Future<Void> fut = Future.future(); assert fetching.getAndSet(false); Vertx.currentContext().owner().setTimer(1, id -> { assert !fetching.getAndSet(true); stream.fetch(1); fut.complete(); }); return fut; } };
@Override Future<Void> handle(ReadStream<Buffer> stream) { Future<Void> fut = Future.future(); assert flowing.getAndSet(false); stream.pause(); Vertx.currentContext().owner().setTimer(1, id -> { assert !flowing.getAndSet(true); stream.resume(); fut.complete(); }); return fut; } },
@Test public void testFactory() throws Exception { AtomicReference<Thread> metricsThread = new AtomicReference<>(); AtomicReference<Context> metricsContext = new AtomicReference<>(); VertxMetricsFactory factory = (options) -> { metricsThread.set(Thread.currentThread()); metricsContext.set(Vertx.currentContext()); return DummyVertxMetrics.INSTANCE; }; vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(factory))); assertSame(Thread.currentThread(), metricsThread.get()); assertNull(metricsContext.get()); }
@Test public void testConsumerHandlesCompletionAsynchronously() { MessageConsumer<Object> consumer = eb.consumer(ADDRESS1); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); testComplete(); }); consumer.handler(msg -> { }); await(); }
@Test public void testTimeoutStreamEndCallbackAsynchronously() { TimeoutStream stream = vertx.timerStream(200); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); stream.endHandler(v2 -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); stream.handler(id -> { }); await(); }
@Test public void testConsumerHandlesCompletionAsynchronously2() { MessageConsumer<Object> consumer = eb.consumer(ADDRESS1); consumer.handler(msg -> { }); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); testComplete(); }); await(); }
@Test public void testConsumerHandlesCompletionAsynchronously1() { startNodes(2); MessageConsumer<Object> consumer = vertices[0].eventBus().consumer(ADDRESS1); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); consumer.handler(msg -> {}); await(); }
@Test public void testEndHandler() { ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); peer2 = vertx.createDatagramSocket(new DatagramSocketOptions()); peer2.listen(1234, "127.0.0.1", ar -> { assertTrue(ar.succeeded()); peer2.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); peer2.close(); }); await(); }
@Test public void testAsyncFileCloseHandlerIsAsync() throws Exception { String fileName = "some-file.dat"; createFileWithJunk(fileName, 100); AsyncFile file = vertx.fileSystem().openBlocking(testDir + pathSep + fileName, new OpenOptions()); ThreadLocal stack = new ThreadLocal(); stack.set(true); file.close(ar -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); testComplete(); }); await(); }
@Test public void testConsumerHandlesCompletionAsynchronously2() { startNodes(2); MessageConsumer<Object> consumer = vertices[0].eventBus().consumer(ADDRESS1); consumer.handler(msg -> { }); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); await(); }
@Test public void testContextExceptionHandler() { RuntimeException failure = new RuntimeException(); Context context = vertx.getOrCreateContext(); context.exceptionHandler(err -> { assertSame(context, Vertx.currentContext()); assertSame(failure, err); testComplete(); }); context.runOnContext(v -> { throw failure; }); await(); }
@Override protected <T> void sendOrPub(OutboundDeliveryContext<T> sendContext) { if (sendContext.options.isLocalOnly()) { if (metrics != null) { metrics.messageSent(sendContext.message.address(), !sendContext.message.isSend(), true, false); } deliverMessageLocally(sendContext); } else if (Vertx.currentContext() == null) { // Guarantees the order when there is no current context sendNoContext.runOnContext(v -> { subs.get(sendContext.message.address(), ar -> onSubsReceived(ar, sendContext)); }); } else { subs.get(sendContext.message.address(), ar -> onSubsReceived(ar, sendContext)); } }
@Test public void testConnectionFailed() throws Exception { client.get(4044, DEFAULT_HTTPS_HOST, "/somepath", onFailure(err -> { Context ctx = Vertx.currentContext(); assertOnIOContext(ctx); assertTrue(err instanceof ConnectException); testComplete(); })).end(); await(); }