Mutiny.SessionFactory#withTransaction doesn't propagate the error sometimes

[DavideD]

See the topic on Zulip

[DavideD]

I've tried the following test:

	@Test
	public void testExceptionPropagation(VertxTestContext context) {
		test( context, getMutinySessionFactory()
				.withTransaction( session -> {
					int loop = 5000;
					Uni<?> uni = Uni.createFrom().voidItem();
					for ( int i = 0; i < loop; i++ ) {
						final int index = i;
						uni = uni.invoke( () -> System.out.println( index ) );
					}
					System.out.println("Finished chaining uni");
					return uni;
				} )
				.invoke( () -> System.out.println("End") )
		);
	}

and it gets stuck until until the timeout is reached:

The test execution timed out. Make sure your asynchronous code includes calls to either VertxTestContext#completeNow(), VertxTestContext#failNow() or Checkpoint#flag()

Unsatisfied checkpoints diagnostics:

java.util.concurrent.TimeoutException: The test execution timed out. Make sure your asynchronous code includes calls to either VertxTestContext#completeNow(), VertxTestContext#failNow() or Checkpoint#flag()

Unsatisfied checkpoints diagnostics:

	at io.vertx.junit5.VertxExtension.joinActiveTestContexts(VertxExtension.java:216)
	at io.vertx.junit5.VertxExtension.interceptTestMethod(VertxExtension.java:143)
	at 

The same test passes if the loop variable is smaller.
It also works when we use a trampoline:

	@Test
	public void testExceptionPropagationWithLoop(VertxTestContext context) {
		test( context, getMutinySessionFactory()
				.withTransaction( session -> Uni.createFrom().completionStage( loop(
						0, 50000, i -> true, i -> {
							System.out.println( i );
							return completedFuture( i );
						}
				) ) )
				.invoke( () -> System.out.println("End") )
		);
	}

I think what's happening is that the number of chained uni is too big and Mutiny doesn't throw any exception and gets stuck instead (completion stages would throw a StackOverflow exception).

@tsegismont, any idea about how to make the error clearer to the user? Maybe there's an option in Mutiny? Thanks

I've added the tests to the latest main here: https://github.com/DavideD/hibernate-reactive/commits/1808/

[gavinking]

This relates to what we were discussing recently, @DavideD:

• should we expose our trampoline to users, or
• does Mutiny have some alternative built in?

[DavideD]

should we expose our trampoline to users, or

I think we should do it. We need to have a version for Mutiny and one for Stage (at least the API).

does Mutiny have some alternative built in?

I don't think it does. But what I don't understand is: why does it get stuck without printing any error?

[tsegismont]

I took a look at the reproducer. It gets stuck because the chain of unis is too big and a StackOverflowError is thrown.

The reason why the error is not displayed is it's caught in java.util.concurrent.CompletableFuture#uniWhenComplete:

            } catch (Throwable ex) {
                if (x == null)
                    x = ex;
                else if (x != ex)
                    x.addSuppressed(ex);
            }
            completeThrowable(x, r);

It's caught after the CompletableFuture has been completed, when a callback is invoked.

You can observe the same behavior with this:

		CompletableFuture<Object> cf = CompletableFuture.completedFuture( null )
				.whenComplete( (v, ex) -> {
					throw new AssertionError();
				} );

		// Reaches this point

		System.out.println( "cf = " + cf );

And you will see:

cf = java.util.concurrent.CompletableFuture@2a8d172f[Completed exceptionally: java.util.concurrent.CompletionException: java.lang.AssertionError]

[gavinking]

@tsegismont The question is: does Mutiny provide any way to write loops without causing stack overflows? Maybe ... something involving Multi? I dunno...

If it doesn't, then we're considering exposing our trampoline that we use internally.