The current operation requires a safe (isolated) Vert.x sub-context,

Question

I am trying to run a reactive method from QuarkusMain method and get the above error.

• I use quarkus 2.16.0.Final
• My intention is to run this application as a task when required. Alternatively schedule it as a CronJob on kubernetes or standalone. For this reason I do not want to introduce @Scheduled annotation.
• My application will compile as uber-jar and will be dockerized and run on different targets

My main class looks something like this

@QuarkusMain
public class Main implements QuarkusApplication {

    @Inject
    io.quarkus.mailer.reactive.ReactiveMailer mailer;

    @Inject
    AggregationHandler aggregationHandler;

    public static void main(String... args) {
        Quarkus.run(Main.class);
    }

    @Override
    public int run(String... args) throws Exception {
         aggregationHandler.aggregate()
            .onSubscription().invoke(this::logStarted) // logs status at start
            .onFailure().invoke(this::logFailure)      // logs status on error. Calls Quarkus.asyncExit();
            .subscribe().with(i -> logSuccess());      // logs status on completion. Calls Quarkus.asyncExit();

        Quarkus.waitForExit();
        return 0;
    }

}

The aggregation class looks like below

@ApplicationScoped
public class AggregationHandler {

    @Inject
    AggregationService aggregationService;

    public Uni<Void> aggregate() {
        return Uni.createFrom().voidItem()
            // stages below call other reactive methods
            .onItem().call(i -> aggregationService.download_item_1())
            .onItem().call(i -> aggregationService.download_item_2())
            .onItem().call(i -> aggregationService.download_item_3())
            .onItem().call(i -> aggregationService.download_item_4());
    }
}

Edit1: Some more context on the problem. The methods download_item_1() ... use reactive-rest-client to fetch data from a source and then save the data to database using hibernate-reactive.

The download_item_1() method calls a repository, which looks like

@ApplicationScoped
public class AccProdRepository {
    @Inject
    Mutiny.SessionFactory sessionFactory;

   
    public Uni<Void> mergeCategories() {
        return sessionFactory
            .withTransaction(s -> s.createNativeQuery(SQLConstant.MERGE_CATEGORIES).executeUpdate())
            .onItem().transformToUni(i -> Uni.createFrom().voidItem());
    }
}

This used to work before, when I had @Scheduled annotation on the aggregate() method. But then after some consultation within the team, we changed the design to trigger the aggregation using the main method. Since then, we get the below stacktrace.

2024-01-12 10:59:54,572 ERROR [io.qua.mut.run.MutinyInfrastructure] (vert.x-eventloop-thread-4) Mutiny had to drop the following exception: java.lang.IllegalStateException: The curre
nt operation requires a safe (isolated) Vert.x sub-context, but the current context hasn't been flagged as such. You can still use Hibernate Reactive, you just need to avoid using th
e methods which implicitly require accessing the stateful context, such as MutinySessionFactory#withTransaction and #withSession.
        at io.quarkus.vertx.core.runtime.context.VertxContextSafetyToggle.checkIsSafe(VertxContextSafetyToggle.java:89)
        at io.quarkus.vertx.core.runtime.context.VertxContextSafetyToggle.validateContextIfExists(VertxContextSafetyToggle.java:72)
        at io.quarkus.hibernate.reactive.runtime.customized.CheckingVertxContext.get(CheckingVertxContext.java:46)
        at org.hibernate.reactive.mutiny.impl.MutinySessionFactoryImpl.withSession(MutinySessionFactoryImpl.java:193)
        at org.hibernate.reactive.mutiny.impl.MutinySessionFactoryImpl.withTransaction(MutinySessionFactoryImpl.java:265)
        at org.hibernate.reactive.mutiny.Mutiny$SessionFactory.withTransaction(Mutiny.java:1877)
        at org.hibernate.reactive.mutiny.impl.ReactiveSessionFactoryProducer_ProducerMethod_mutinySessionFactory_f400be8ad6884ffa846bcddd4116ae0c9f200ae3_ClientProxy.withTransaction(
Unknown Source)
        at xxx.xxx.support.aggregation.repository.AccProdRepository.mergeCategories(AccProdRepository.java:39)

Edit 2 : I can confirm now, if I drop the approach of using the main method and re-enable the @Scheduled annotation, the aggregation works just fine as before. I feel that there is some disconnect in my understanding of how to call a reactive method inside QuarkusMain, which prepares the vertx context in a different way. But I could be wrong