kandi background

vert.x | Vert.x is a toolkit for building reactive applications on the JVM | Reactive Programming library

by eclipse-vertx Java Version: Current License: Non-SPDX

by eclipse-vertx Java Version: Current License: Non-SPDX

Download this library from

kandi X-RAY | vert.x Summary

vert.x is a Java library typically used in Programming Style, Reactive Programming applications. vert.x has no bugs, it has build file available and it has high support. However vert.x has 5 vulnerabilities and it has a Non-SPDX License. You can download it from GitHub.

This is the repository for Vert.x core. Vert.x core contains fairly low-level functionality, including support for HTTP, TCP, file system access, and various other features. You can use this directly in your own applications, and it's used by many of the other components of Vert.x. For more information on Vert.x and where Vert.x core fits into the big picture please see the website.

Support

Support

Quality

Quality

Security

Security

License

License

Reuse

Reuse

kandi-support Support

vert.x has a highly active ecosystem.
It has 12848 star(s) with 1918 fork(s). There are 560 watchers for this library.
It had no major release in the last 12 months.
There are 175 open issues and 2181 have been closed. On average issues are closed in 20 days. There are 65 open pull requests and 0 closed requests.
It has a positive sentiment in the developer community.
The latest version of vert.x is current.

vert.x Support

Best in #Reactive Programming

Average in #Reactive Programming

vert.x Support

Best in #Reactive Programming

Average in #Reactive Programming

quality kandi Quality

vert.x has 0 bugs and 0 code smells.

vert.x Quality

Best in #Reactive Programming

Average in #Reactive Programming

vert.x Quality

Best in #Reactive Programming

Average in #Reactive Programming

security Security

vert.x has 5 vulnerability issues reported (2 critical, 1 high, 2 medium, 0 low).
vert.x code analysis shows 0 unresolved vulnerabilities.
There are 0 security hotspots that need review.

vert.x Security

Best in #Reactive Programming

Average in #Reactive Programming

vert.x Security

Best in #Reactive Programming

Average in #Reactive Programming

license License

vert.x has a Non-SPDX License.
Non-SPDX licenses can be open source with a non SPDX compliant license, or non open source licenses, and you need to review them closely before use.

vert.x License

Best in #Reactive Programming

Average in #Reactive Programming

vert.x License

Best in #Reactive Programming

Average in #Reactive Programming

build Reuse

vert.x releases are not available. You will need to build from source code and install.
Build file is available. You can build the component from source.
Installation instructions are not available. Examples and code snippets are available.
vert.x saves you 119662 person hours of effort in developing the same functionality from scratch.
It has 134974 lines of code, 13332 functions and 917 files.
It has high code complexity. Code complexity directly impacts maintainability of the code.

vert.x Reuse

Best in #Reactive Programming

Average in #Reactive Programming

vert.x Reuse

Best in #Reactive Programming

Average in #Reactive Programming

Top functions reviewed by kandi - BETA

kandi has reviewed vert.x and discovered the below as its top functions. This is intended to give you an instant insight into vert.x implemented functionality, and help decide if they suit your requirements.

Returns the string value for the specified key .
Renders the given options and arguments .
Send file .
Configure the pipeline .
Checks if there are any files in the directory and if so return true .
Handle proxy connect .
Handles a short and long option .
Returns the HttpMethod object corresponding to the given string value .
Handle parsing .
Dispatch command line arguments .

vert.x Key Features

Vert.x is a tool-kit for building reactive applications on the JVM

vert.x Examples and Code Snippets

See all related Code Snippets

Building Vert.x artifacts

Copy

Download

&gt; mvn package

Running tests

Copy

Download

&gt; mvn test

Building documentation

Copy

Download

&gt; mvn package -Pdocs -DskipTests

How to unregister two vertx consumers and returns an rxjava completable?

Copy

Download

@Override
public Completable deregisterKeyEvents(String subscriptionId) {

    MessageConsumer<JsonObject> messageConsumer = consumerMap.get(subscriptionId);
    MessageConsumer<JsonObject> subscriptionConsumer = subscriptionConsumerMap.get(subscriptionId);
    
    Completable c1;
    if( subscriptionConsumer != null) {
        subscriptionConsumerMap.remove(subscriptionId);
        c1 = CompletableHelper.toCompletable(handler -> subscriptionConsumer.unregister(handler))
            .doOnSuccess(() -> LOGGER.debug("Subscription channel consumer deregistered successfully!"))
            .doOnError(t-> LOGGER.error("Unable to de-register Subscription channel consumer", t));
    } else {
        c1 = Completable.complete();
    }
    
    Completable c2;
    if (messageConsumer != null) {
        consumerMap.remove(subscriptionId);
        c2 = CompletableHelper.toCompletable(handler -> messageConsumer.unregister(handler));
    } else {
        LOGGER.warn("There was no consumer registered!");
        c2 = Completable.error(new KvNoSuchElementException("Subscription '" + subscriptionId + "' not found"));

    }

    return c1.concatWith(c2);
}

Quarkus: The return value of "org.jboss.resteasy.reactive.server.mapping.RuntimeResource.getProduces()" is null

Copy

Download

@Produces(MediaType.APPLICATION_JSON)
// Each element will be sent as JSON
@RestSseElementType(MediaType.APPLICATION_JSON)

Spring Webflux: Extract a value from a Mono and save it into another variable

Copy

Download

    private Mono<String> generateToken(User user) {
        ArrayList<Long> usr_id = new ArrayList<Long>(Collections.singleton(user.getId()));
        ArrayList<String> usr_name = new ArrayList<String>(Collections.singleton(user.getName()));
        ArrayList<String> usr_lastname = new ArrayList<>(Collections.singleton(user.getLastName()));

        return myModelRepository.getMyModelInstance()
                .map(modelInstance -> {
                    Map<String, Object> claims = new HashMap<>();

                    //put all values you need in claims map...

                    //update doGenerateToken code to return a Mono<String>
                    return doGenerateToken(claims, user.getUsername());
                });
    }

How to subscribe to "HttpClientResponse::toFlowable()" outside of the vert.x "rxResponse().subscribe" callback

Copy

Download

package org.tests;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.RepeatedTest;

import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpClientRequest;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.net.NetServer;
import io.vertx.core.streams.ReadStream;

public class VxTestNonRx {
    static NetServer server;
    static HttpClient client;

    @BeforeAll
    static void setUp() throws InterruptedException {
        server = startServer();
        client = Vertx.vertx().createHttpClient();
    }

    @RepeatedTest(10000)
    void shouldReachOnNextAndOnError() throws Exception {
        CountDownLatch bodyReadLatch = new CountDownLatch(1);
        CountDownLatch responseReadyToRead = new CountDownLatch(1);
        AtomicReference<ReadStream<Buffer>> readStreamRef = new AtomicReference<>();
        AtomicInteger ab = new AtomicInteger(0);
        client.request(HttpMethod.GET,
                       server.actualPort(),
                       "localhost",
                       "/")
              .compose(HttpClientRequest::send)
              .onSuccess(response -> {
                  // Catches exceptions when they happen before we subscribed to the ReadStream
                  response.netSocket().exceptionHandler(t -> System.out.println("NET EXCEPTION HANDLER" + t.getMessage()));
                  //response.pause(); // Try to pause FIRST to avoid skipping buffers
                  // When handlers are set here : 
                  //  - with pause(): 100% times exceptionHandler only.
                  //  - without pause(): 100% times : handler, then exceptionHandler
                  readStreamRef.set(response);
                  responseReadyToRead.countDown();
              });
        responseReadyToRead.await();
        // When handlers are set here : 
        // - without pause() : 
        //     - 66% times : handler, then exceptionHandler
        //     - 33% times : only exceptionHandler gets called.
        // - with pause() : 
        //     - 99% times : only onError gets called 
        //     - 1% times  : netSocket().exceptionHandler, then handler gets called. (but neither endHandler nor exceptionHandler are called !)
        readStreamRef.get()
                     .handler(buffer -> {
                         System.out.println("HANDLER");
                         ab.addAndGet(1);
                     })
                     .endHandler(unused -> {
                         System.out.println("END HANDLER");
                         bodyReadLatch.countDown();
                     })
                     .exceptionHandler(t -> {
                         System.out.println("ERROR HANDLER");
                         ab.addAndGet(2);
                         bodyReadLatch.countDown();
                     });
        readStreamRef.get().resume();
        bodyReadLatch.await();
        // Should have been in onNext then onError callbacks.
        Assertions.assertThat(ab.get()).isEqualTo(3);
    }

    // This starts a server synchronously.
    // It serves a static HTTP response with an illegal trailer name (making Vert.x fail)
    private static NetServer startServer() throws InterruptedException {
        CountDownLatch serverReady = new CountDownLatch(1);
        AtomicReference<NetServer> servRef = new AtomicReference<>();
        Vertx.vertx().createNetServer()
             .connectHandler(socket -> {
                 String content1 = "HTTP/1.1 200 OK\r\n"
                         + "transfer-encoding: chunked\r\n"
                         + "\r\n"
                         + "2\r\n"
                         + "OK"
                         + "\r\n"
                         + "0\r\n"
                         + "é: trailerValue\r\n" // é is an invalid trailer name
                         + "\r\n";
                 // Read the request content, then write content, then close the socket.
                 socket.handler(b -> socket.write(content1, ar -> socket.close()));
             })
             .listen()
             .onSuccess(netServer -> {
                 servRef.set(netServer);
                 serverReady.countDown();
             });
        serverReady.await();
        return servRef.get();
    }

How to record each throwable when using .onFailure().retry() with delay between retries

Copy

Download

service.apiMethod(key)
    .invoke(record -> logger.info("Succeeded to read record."))
    .onFailure()
        .invoke(exception -> logger.warn("Failed to read record."))
    .onFailure()
        .retry().withBackOff(delay).indefinitely();

Quarkus SQS consumer

Copy

Download

Uni.createFrom().item(returnDataFromDb());

-----------------------

import io.quarkus.scheduler.Scheduled
import io.quarkus.vertx.ConsumeEvent
import io.smallrye.mutiny.Uni
import io.vertx.mutiny.core.eventbus.EventBus
import org.eclipse.microprofile.config.inject.ConfigProperty
import org.jboss.logging.Logger
import software.amazon.awssdk.services.sqs.SqsAsyncClient
import software.amazon.awssdk.services.sqs.model.Message
import software.amazon.awssdk.services.sqs.model.ReceiveMessageResponse
import java.util.concurrent.CompletionStage
import javax.enterprise.context.ApplicationScoped
import javax.enterprise.inject.Instance

@ApplicationScoped
class SqsConsumer(
    private val eventBus: EventBus,
    private val logger: Logger,
    @ConfigProperty(name = "sqs.consumer.maxFetchedMessages")
    private val maxFetchedEvents: Int,
    private val handlers: Instance<MessageHandler>,
    private val sqsClient: SqsAsyncClient,
) {

    @Scheduled(every = "{sqs.consumer.interval}")
    fun execute() {
        handlers.stream().forEach { handler ->
            val handlerName = handler.javaClass.name
            logger.info("Fetching messages for $handlerName...")
            Uni
                .createFrom()
                .completionStage(fetchMessages(handler.queueUrl()))
                .subscribe()
                .with(
                    { response ->
                        val newEventsCount = response.messages().size
                        if (newEventsCount > 0) {
                            logger.info("$newEventsCount message(s) fetched for $handlerName.")
                            eventBus.send("receive-message-responses", ResponseHolder(handler, response))
                        } else {
                            logger.info("Queue was empty. Maybe next time.")
                        }
                    },
                    { logger.error("Error fetching messages!", it) }
                )
        }
    }

    @ConsumeEvent("receive-message-responses")
    fun processReceivedMessageResponse(holder: ResponseHolder): Uni<Void> {
        val handler = holder.handler
        val handlerName = handler.javaClass.name
        val messageResponse = holder.receiveMessageResponse
        logger.info("Processing messages for $handlerName...")
        return Uni
            .createFrom()
            .item(holder)
            .flatMap { handler.process(messageResponse.messages().map { message -> message.body() }) }
            .onItem()
            .invoke { _ ->
                logger.info("Processing succeeded. Deleting processed events from the queue...")
                messageResponse
                    .messages()
                    .forEach { eventBus.send("processed-messages", MessageHolder(handler, it)) }
            }
            .replaceWithVoid()
            .onFailure()
            .invoke { it -> logger.error("Error processing messages!", it) }
    }

    @ConsumeEvent("processed-messages")
    fun deleteProcessedMessages(holder: MessageHolder): Uni<Void> {
        val handler = holder.handler
        val message = holder.message
        return Uni
            .createFrom()
            .completionStage(
                sqsClient.deleteMessage {
                    it
                        .queueUrl(handler.queueUrl())
                        .receiptHandle(message.receiptHandle())
                }
            )
            .onItem()
            .invoke { _ -> logger.info("Message ${message.messageId()} deleted from the queue!") }
            .onFailure()
            .invoke { it -> logger.error("Could not delete message ${message.messageId()} from the queue!", it) }
            .replaceWithVoid()
    }

    private fun fetchMessages(queueUrl: String): CompletionStage<ReceiveMessageResponse> {
        return sqsClient
            .receiveMessage {
                it
                    .maxNumberOfMessages(maxFetchedEvents)
                    .queueUrl(queueUrl)
            }
    }
}

class ResponseHolder(
    val handler: MessageHandler,
    val receiveMessageResponse: ReceiveMessageResponse,
)

class MessageHolder(
    val handler: MessageHandler,
    val message: Message,
)

How to configure Axon 4 context in Vert.x

Copy

Download

config -> MongoTokenStore.builder()
                         .mongoTemplate(
                             DefaultMongoTemplate.builder()
                                                 // optionally choose collection names here
                                                 .mongoDatabase(mongoClient)
                                                 .build())
                         .serializer(Configuration::serializer)
                         .build()

Non-blocking gets on Hazelcast ReplicatedMap?

Copy

Download

DeploymentOptions options = new DeploymentOptions().setWorker(true);
vertx.deployVerticle("com.verticles.HazelcastVerticle", options);

Eclipse Vert.x : parsing java.time date with jackson

Copy

Download

ObjectMapper mapper = DatabindCodec.mapper();
mapper.registerModule(new JavaTimeModule());

ObjectMapper prettyMapper = DatabindCodec.prettyMapper();
prettyMapper.registerModule(new JavaTimeModule());

public class MainVerticle extends AbstractVerticle {

  // code already exists

  @Override
  public void start() {
      ObjectMapper mapper = DatabindCodec.mapper();
      mapper.registerModule(new JavaTimeModule());
 
      ObjectMapper prettyMapper = DatabindCodec.prettyMapper();
      prettyMapper.registerModule(new JavaTimeModule());
  
  
  // code already exists

-----------------------

ObjectMapper mapper = DatabindCodec.mapper();
mapper.registerModule(new JavaTimeModule());

ObjectMapper prettyMapper = DatabindCodec.prettyMapper();
prettyMapper.registerModule(new JavaTimeModule());

public class MainVerticle extends AbstractVerticle {

  // code already exists

  @Override
  public void start() {
      ObjectMapper mapper = DatabindCodec.mapper();
      mapper.registerModule(new JavaTimeModule());
 
      ObjectMapper prettyMapper = DatabindCodec.prettyMapper();
      prettyMapper.registerModule(new JavaTimeModule());
  
  
  // code already exists

-----------------------

// Converting Date to timestamp and sending in Json
timestamp = Date().getTime()
new JsonObject().put("date", timestamp)


// Converting the timestamp to Date
Date(timestamp)

How to start multiple message consumers in Quarkus?

Copy

Download

@ApplicationScoped
public class CoffeeRepositoryService {

    public CoffeeRepositoryService() {
        System.out.println("Injection succeeded!");
    }
}

package org.acme;

import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.vertx.core.AbstractVerticle;
import io.vertx.core.impl.logging.Logger;
import io.vertx.core.impl.logging.LoggerFactory;
import io.vertx.mutiny.core.eventbus.EventBus;
import io.vertx.mutiny.rabbitmq.RabbitMQClient;
import io.vertx.mutiny.rabbitmq.RabbitMQConsumer;
import io.vertx.rabbitmq.QueueOptions;
import io.vertx.rabbitmq.RabbitMQOptions;

public class RQVerticle extends AbstractVerticle {

  private final Logger LOGGER = LoggerFactory.getLogger(org.acme.RQVerticle.class);

  //This doesn't work - returns null
  @Inject
  CoffeeRepositoryService coffeeRepositoryService;

  RQVerticle() {} // dummy constructor needed
   
  @Inject // constructor injection - this does work
  RQVerticle(CoffeeRepositoryService coffeeRepositoryService) {
    //Here coffeeRepositoryService is injected properly
  }

  @Override
  public Uni<Void> asyncStart() {
    LOGGER.info(
        "Creating RabbitMQ Connection after Quarkus successful initialization");

    RabbitMQOptions config = new RabbitMQOptions();
    config.setUri("amqp://localhost:5672");
    RabbitMQClient client = RabbitMQClient.create(vertx, config);
    
    Uni<Void> clientResp = client.start();
    clientResp.subscribe()
        .with(asyncResult -> {
          LOGGER.info("RabbitMQ successfully connected!");
              
        });

      return clientResp;
  }
}

package org.acme;

import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.annotations.QuarkusMain;
import io.vertx.core.DeploymentOptions;
import io.vertx.mutiny.core.Vertx;

@QuarkusMain
public class Main {

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

  public static class MyApp implements QuarkusApplication {

    @Override
    public int run(String... args) throws Exception {
      var vertx = Vertx.vertx();
      System.out.println("Deployment Starting");

      DeploymentOptions options = new DeploymentOptions()
          .setInstances(2);
      vertx.deployVerticleAndAwait(RQVerticle::new, options);

      System.out.println("Deployment completed");

      Quarkus.waitForExit();
      return 0;
    }
  }
}

package org.acme;

import io.quarkus.runtime.StartupEvent;
import io.vertx.mutiny.core.Vertx;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Observes;
import org.jboss.logging.Logger;

@ApplicationScoped
public class MainVerticles {

  private static final Logger LOGGER = Logger.getLogger(MainVerticles.class);

  public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    DeploymentOptions options = new DeploymentOptions()
    .setInstances(2);
    vertx.deployVerticle(verticle,options).await().indefinitely();
  }
}

-----------------------

@ApplicationScoped
public class CoffeeRepositoryService {

    public CoffeeRepositoryService() {
        System.out.println("Injection succeeded!");
    }
}

package org.acme;

import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.vertx.core.AbstractVerticle;
import io.vertx.core.impl.logging.Logger;
import io.vertx.core.impl.logging.LoggerFactory;
import io.vertx.mutiny.core.eventbus.EventBus;
import io.vertx.mutiny.rabbitmq.RabbitMQClient;
import io.vertx.mutiny.rabbitmq.RabbitMQConsumer;
import io.vertx.rabbitmq.QueueOptions;
import io.vertx.rabbitmq.RabbitMQOptions;

public class RQVerticle extends AbstractVerticle {

  private final Logger LOGGER = LoggerFactory.getLogger(org.acme.RQVerticle.class);

  //This doesn't work - returns null
  @Inject
  CoffeeRepositoryService coffeeRepositoryService;

  RQVerticle() {} // dummy constructor needed
   
  @Inject // constructor injection - this does work
  RQVerticle(CoffeeRepositoryService coffeeRepositoryService) {
    //Here coffeeRepositoryService is injected properly
  }

  @Override
  public Uni<Void> asyncStart() {
    LOGGER.info(
        "Creating RabbitMQ Connection after Quarkus successful initialization");

    RabbitMQOptions config = new RabbitMQOptions();
    config.setUri("amqp://localhost:5672");
    RabbitMQClient client = RabbitMQClient.create(vertx, config);
    
    Uni<Void> clientResp = client.start();
    clientResp.subscribe()
        .with(asyncResult -> {
          LOGGER.info("RabbitMQ successfully connected!");
              
        });

      return clientResp;
  }
}

package org.acme;

import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.annotations.QuarkusMain;
import io.vertx.core.DeploymentOptions;
import io.vertx.mutiny.core.Vertx;

@QuarkusMain
public class Main {

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

  public static class MyApp implements QuarkusApplication {

    @Override
    public int run(String... args) throws Exception {
      var vertx = Vertx.vertx();
      System.out.println("Deployment Starting");

      DeploymentOptions options = new DeploymentOptions()
          .setInstances(2);
      vertx.deployVerticleAndAwait(RQVerticle::new, options);

      System.out.println("Deployment completed");

      Quarkus.waitForExit();
      return 0;
    }
  }
}

package org.acme;

import io.quarkus.runtime.StartupEvent;
import io.vertx.mutiny.core.Vertx;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Observes;
import org.jboss.logging.Logger;

@ApplicationScoped
public class MainVerticles {

  private static final Logger LOGGER = Logger.getLogger(MainVerticles.class);

  public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    DeploymentOptions options = new DeploymentOptions()
    .setInstances(2);
    vertx.deployVerticle(verticle,options).await().indefinitely();
  }
}

-----------------------

@ApplicationScoped
public class CoffeeRepositoryService {

    public CoffeeRepositoryService() {
        System.out.println("Injection succeeded!");
    }
}

package org.acme;

import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.vertx.core.AbstractVerticle;
import io.vertx.core.impl.logging.Logger;
import io.vertx.core.impl.logging.LoggerFactory;
import io.vertx.mutiny.core.eventbus.EventBus;
import io.vertx.mutiny.rabbitmq.RabbitMQClient;
import io.vertx.mutiny.rabbitmq.RabbitMQConsumer;
import io.vertx.rabbitmq.QueueOptions;
import io.vertx.rabbitmq.RabbitMQOptions;

public class RQVerticle extends AbstractVerticle {

  private final Logger LOGGER = LoggerFactory.getLogger(org.acme.RQVerticle.class);

  //This doesn't work - returns null
  @Inject
  CoffeeRepositoryService coffeeRepositoryService;

  RQVerticle() {} // dummy constructor needed
   
  @Inject // constructor injection - this does work
  RQVerticle(CoffeeRepositoryService coffeeRepositoryService) {
    //Here coffeeRepositoryService is injected properly
  }

  @Override
  public Uni<Void> asyncStart() {
    LOGGER.info(
        "Creating RabbitMQ Connection after Quarkus successful initialization");

    RabbitMQOptions config = new RabbitMQOptions();
    config.setUri("amqp://localhost:5672");
    RabbitMQClient client = RabbitMQClient.create(vertx, config);
    
    Uni<Void> clientResp = client.start();
    clientResp.subscribe()
        .with(asyncResult -> {
          LOGGER.info("RabbitMQ successfully connected!");
              
        });

      return clientResp;
  }
}

package org.acme;

import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.annotations.QuarkusMain;
import io.vertx.core.DeploymentOptions;
import io.vertx.mutiny.core.Vertx;

@QuarkusMain
public class Main {

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

  public static class MyApp implements QuarkusApplication {

    @Override
    public int run(String... args) throws Exception {
      var vertx = Vertx.vertx();
      System.out.println("Deployment Starting");

      DeploymentOptions options = new DeploymentOptions()
          .setInstances(2);
      vertx.deployVerticleAndAwait(RQVerticle::new, options);

      System.out.println("Deployment completed");

      Quarkus.waitForExit();
      return 0;
    }
  }
}

package org.acme;

import io.quarkus.runtime.StartupEvent;
import io.vertx.mutiny.core.Vertx;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Observes;
import org.jboss.logging.Logger;

@ApplicationScoped
public class MainVerticles {

  private static final Logger LOGGER = Logger.getLogger(MainVerticles.class);

  public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    DeploymentOptions options = new DeploymentOptions()
    .setInstances(2);
    vertx.deployVerticle(verticle,options).await().indefinitely();
  }
}

-----------------------

@ApplicationScoped
public class CoffeeRepositoryService {

    public CoffeeRepositoryService() {
        System.out.println("Injection succeeded!");
    }
}

package org.acme;

import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.vertx.core.AbstractVerticle;
import io.vertx.core.impl.logging.Logger;
import io.vertx.core.impl.logging.LoggerFactory;
import io.vertx.mutiny.core.eventbus.EventBus;
import io.vertx.mutiny.rabbitmq.RabbitMQClient;
import io.vertx.mutiny.rabbitmq.RabbitMQConsumer;
import io.vertx.rabbitmq.QueueOptions;
import io.vertx.rabbitmq.RabbitMQOptions;

public class RQVerticle extends AbstractVerticle {

  private final Logger LOGGER = LoggerFactory.getLogger(org.acme.RQVerticle.class);

  //This doesn't work - returns null
  @Inject
  CoffeeRepositoryService coffeeRepositoryService;

  RQVerticle() {} // dummy constructor needed
   
  @Inject // constructor injection - this does work
  RQVerticle(CoffeeRepositoryService coffeeRepositoryService) {
    //Here coffeeRepositoryService is injected properly
  }

  @Override
  public Uni<Void> asyncStart() {
    LOGGER.info(
        "Creating RabbitMQ Connection after Quarkus successful initialization");

    RabbitMQOptions config = new RabbitMQOptions();
    config.setUri("amqp://localhost:5672");
    RabbitMQClient client = RabbitMQClient.create(vertx, config);
    
    Uni<Void> clientResp = client.start();
    clientResp.subscribe()
        .with(asyncResult -> {
          LOGGER.info("RabbitMQ successfully connected!");
              
        });

      return clientResp;
  }
}

package org.acme;

import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.annotations.QuarkusMain;
import io.vertx.core.DeploymentOptions;
import io.vertx.mutiny.core.Vertx;

@QuarkusMain
public class Main {

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

  public static class MyApp implements QuarkusApplication {

    @Override
    public int run(String... args) throws Exception {
      var vertx = Vertx.vertx();
      System.out.println("Deployment Starting");

      DeploymentOptions options = new DeploymentOptions()
          .setInstances(2);
      vertx.deployVerticleAndAwait(RQVerticle::new, options);

      System.out.println("Deployment completed");

      Quarkus.waitForExit();
      return 0;
    }
  }
}

package org.acme;

import io.quarkus.runtime.StartupEvent;
import io.vertx.mutiny.core.Vertx;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Observes;
import org.jboss.logging.Logger;

@ApplicationScoped
public class MainVerticles {

  private static final Logger LOGGER = Logger.getLogger(MainVerticles.class);

  public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    public void init(@Observes StartupEvent e, Vertx vertx, RQVerticle verticle) {
    DeploymentOptions options = new DeploymentOptions()
    .setInstances(2);
    vertx.deployVerticle(verticle,options).await().indefinitely();
  }
}

See all related Code Snippets

Community Discussions

Trending Discussions on vert.x

How to list all consumers that are listening to an address on a vertex event bus?
How to unregister two vertx consumers and returns an rxjava completable?
Quarkus: The return value of "org.jboss.resteasy.reactive.server.mapping.RuntimeResource.getProduces()" is null
Spring Webflux: Extract a value from a Mono and save it into another variable
How to subscribe to "HttpClientResponse::toFlowable()" outside of the vert.x "rxResponse().subscribe" callback
starting with reactive DB access in a blocking monolith
How to record each throwable when using .onFailure().retry() with delay between retries
Quarkus SQS consumer
How to configure Axon 4 context in Vert.x
How to use Axon with Vert.X

Trending Discussions on vert.x

QUESTION

How to list all consumers that are listening to an address on a vertex event bus?

Asked 2022-Mar-29 at 14:13

I have a vert.x program. I am creating a message consumer and attach it to listen on an address on the vertx event bus . later in the program I am unregistering that consumer . How do I know if the consumer is unregistered successfully ?

following code snippet shows how i register a consumer on an address on vertex event bus

MessageConsumer<JsonObject> consumer = vertx.eventBus().consumer("my_channel", eventHandler)

later after sometime i am unregistering the consumer

consumer.unregister( res -> {
  if(res.succeeded()) { System.out.println("consumer deregistered")}
});

so my question is suppose i have reference to an vertx event bus vert.eventBus() object how can i verify it if there any consumers on it ?

ANSWER

Answered 2022-Mar-29 at 14:13

As for the first question, you can safely assume consumer is unregistered successfully when res.succeeded() returns true inside unregister handler (as per your example).

For the second part, afaik the event bus does not maintain the list of consumers registered to it, you have to maintain it yourself. The goal would be to have a map or some other collection where you store references for consumers when you register them with .consumer(...) method and remove them after unregister handler returns succeeded.

I think this would be the issue you are referring to (with the advice by the lead architect of vertx): https://groups.google.com/g/vertx/c/d70YlHLL7KU?pli=1

Source https://stackoverflow.com/questions/71650514

QUESTION

How to unregister two vertx consumers and returns an rxjava completable?

Asked 2022-Mar-28 at 13:18

I need a small help with Rxjava . currently I have two hash maps . Each hash map contains vertex message consumers against a subscription key. I want to return a completable object only if I am able to unregister both vertex message consumers. How can I achieve it .

I can post the code i am working on.

@Override public Completable deregisterKeyEvents(String subscriptionId) {

MessageConsumer<JsonObject> messageConsumer = consumerMap.get(subscriptionId);
MessageConsumer<JsonObject> subscriptionConsumer = subscriptionConsumerMap.get(subscriptionId);


if( subscriptionConsumer != null) {
    subscriptionConsumerMap.remove(subscriptionId);
    subscriptionConsumer.unregister( res-> {
        
        if(res.succeeded()) {
            LOGGER.debug("Subscription channel consumer deregistered successfully!");
        } else {
            LOGGER.error("Unable to de-register Subscription channel consumer");
        }
        
    });
}

if (messageConsumer != null) {
    
    consumerMap.remove(subscriptionId);
    
    return Completable.create(emitter -> {
        
        messageConsumer.unregister(res -> {
            if (res.succeeded()) {
                emitter.onComplete();
            } else {
                emitter.onError(res.cause());
            }
        });
    });
} else {
    LOGGER.warn("There was no consumer registered!");
    return Completable.create(emitter -> emitter.onError(new KvNoSuchElementException("Subscription '" + subscriptionId + "' not found")));
}

}

I want to rewrite the above code in such a way

subscriptionConsumer.unregister() & messageConsumer.unregister() is successful then return a completable

The MessageConsumer class is from vert.x libary io.vertx.core.eventbus.MessageConsumer. appreciate if you can help thank you

ANSWER

Answered 2022-Mar-28 at 13:18

If you're willing to add Vert.x RxJava2 to your dependencies, you could do this with toCompletable:

@Override
public Completable deregisterKeyEvents(String subscriptionId) {

    MessageConsumer<JsonObject> messageConsumer = consumerMap.get(subscriptionId);
    MessageConsumer<JsonObject> subscriptionConsumer = subscriptionConsumerMap.get(subscriptionId);
    
    Completable c1;
    if( subscriptionConsumer != null) {
        subscriptionConsumerMap.remove(subscriptionId);
        c1 = CompletableHelper.toCompletable(handler -> subscriptionConsumer.unregister(handler))
            .doOnSuccess(() -> LOGGER.debug("Subscription channel consumer deregistered successfully!"))
            .doOnError(t-> LOGGER.error("Unable to de-register Subscription channel consumer", t));
    } else {
        c1 = Completable.complete();
    }
    
    Completable c2;
    if (messageConsumer != null) {
        consumerMap.remove(subscriptionId);
        c2 = CompletableHelper.toCompletable(handler -> messageConsumer.unregister(handler));
    } else {
        LOGGER.warn("There was no consumer registered!");
        c2 = Completable.error(new KvNoSuchElementException("Subscription '" + subscriptionId + "' not found"));

    }

    return c1.concatWith(c2);
}

Note that this is a bit different than your original code because:

the messageConsumer unregistration happens only after the unregistration of subscriptionConsumer,
the messageConsumer unregistration happens only if unregistration of subscriptionConsumer was successful.

You can use a different method of Completable if that's not the behavior you want.

Source https://stackoverflow.com/questions/71647713

QUESTION

Quarkus: The return value of "org.jboss.resteasy.reactive.server.mapping.RuntimeResource.getProduces()" is null

Asked 2022-Mar-07 at 09:38

I created Reactive SQL client on Quarkus using this official guide, but while making GET request on http://localhost:8080/hello trying to query data from database, I get such an error:

2022-03-06 13:18:53,051 ERROR [io.qua.ver.htt.run.QuarkusErrorHandler] (vert.x-eventloop-thread-5) HTTP Request to /hello failed, error id: 2796a874-61d9-43ee-bd87-6f098cffa484-2: java.lang.NullPointerException: Cannot invoke "org.jboss.resteasy.reactive.common.util.ServerMediaType.getSortedMediaTypes()" because the return value of "org.jboss.resteasy.reactive.server.mapping.RuntimeResource.getProduces()" is null
    at org.jboss.resteasy.reactive.server.handlers.PublisherResponseHandler.handle(PublisherResponseHandler.java:203)
    at org.jboss.resteasy.reactive.server.handlers.PublisherResponseHandler.handle(PublisherResponseHandler.java:30)
    at org.jboss.resteasy.reactive.common.core.AbstractResteasyReactiveContext.run(AbstractResteasyReactiveContext.java:141)
    at org.jboss.resteasy.reactive.server.handlers.RestInitialHandler.beginProcessing(RestInitialHandler.java:49)
    at org.jboss.resteasy.reactive.server.vertx.ResteasyReactiveVertxHandler.handle(ResteasyReactiveVertxHandler.java:17)
    at org.jboss.resteasy.reactive.server.vertx.ResteasyReactiveVertxHandler.handle(ResteasyReactiveVertxHandler.java:7)
    at io.vertx.ext.web.impl.RouteState.handleContext(RouteState.java:1212)
    at io.vertx.ext.web.impl.RoutingContextImplBase.iterateNext(RoutingContextImplBase.java:163)
    at io.vertx.ext.web.impl.RoutingContextImpl.next(RoutingContextImpl.java:141)
    at io.quarkus.vertx.http.runtime.StaticResourcesRecorder$2.handle(StaticResourcesRecorder.java:67)
    at io.quarkus.vertx.http.runtime.StaticResourcesRecorder$2.handle(StaticResourcesRecorder.java:55)
    at io.vertx.ext.web.impl.RouteState.handleContext(RouteState.java:1212)
    at io.vertx.ext.web.impl.RoutingContextImplBase.iterateNext(RoutingContextImplBase.java:126)
    at io.vertx.ext.web.impl.RoutingContextImpl.next(RoutingContextImpl.java:141)
    at io.vertx.ext.web.handler.impl.StaticHandlerImpl.lambda$sendStatic$1(StaticHandlerImpl.java:274)
    at io.vertx.core.impl.future.FutureImpl$3.onSuccess(FutureImpl.java:141)
    at io.vertx.core.impl.future.FutureBase.lambda$emitSuccess$0(FutureBase.java:54)
    at io.netty.util.concurrent.AbstractEventExecutor.safeExecute(AbstractEventExecutor.java:164)
    at io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:469)
    at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:503)
    at io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:986)
    at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
    at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
    at java.base/java.lang.Thread.run(Thread.java:833)

ANSWER

Answered 2022-Mar-07 at 09:38

You need to add something like:

@Produces(MediaType.APPLICATION_JSON)
// Each element will be sent as JSON
@RestSseElementType(MediaType.APPLICATION_JSON)

to your JAX-RS method.

However, you most likely also need to include quarkus-resteasy-reactive-jackson. Furthermore, you might want to revisit the use of Multi as a return type as you are likely looking for something like Uni<List<Address>>.

Source https://stackoverflow.com/questions/71368733

QUESTION

Spring Webflux: Extract a value from a Mono and save it into another variable

Asked 2022-Mar-04 at 15:34

The stack used in the API is: Spring-boot, Spring Webflux, Hibernate Reactive 1.1.3 and Postgresql.

I'd like to extract a string value from a Mono called desiredField and add it to a hashmap. I'm showing the DB, model, repository and the util module where all this is happening.

The JWTUtil is used to generate a JWT token for login purposes in the API. The JWTController is working fine, coming the token in response! The only thing is that a cannot extract de string value from a Mono.

I've tried two approaches. The reactive way, using the subscribe method. And the blocking way using the block method. These two approches are shown below with their own console prints.

In the first approach (the reactive way) I couldn't extract the desiredField from the Mono. The token comes in the response but without the desiredField in the token claims. The desiredField live only inside de stream (see console log prints), outside is null.

In the second approach (blocking way) there are an infinite loop error without getting the token in the response.

Could you help me to extract this value from the Mono?

Thanks in advance!

Postgres:

############
# my_table #
############

id  |  desired_column
-------------------------------
 1  |  "I am the desired value"

Model:

@Data
@Entity(name = "MyModel")
@Table(name = "my_table")
public class MyModel{
    @Id
    @GeneratedValue
    private long id;

    @Column(name="desired_column")
    private String desiredField;
}

Repository:

@Slf4j
@Repository
public class MyModelRepository {

    public Mono<MyModel> getMyModelInstance() {
        try{
            EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistance");
            Mutiny.SessionFactory factory = emf.unwrap(Mutiny.SessionFactory.class);

            CriteriaBuilder builder = factory.getCriteriaBuilder();
            CriteriaQuery<MyModel> criteria = builder.createQuery(MyModel.class);
            Root<MyModel> root = criteria.from(MyModel.class);
            criteria.where(builder.equal(root.get("id"), "1"));

            Uni<MyModel> myModelInstanceUni= factory.withSession(
                    session -> session
                            .createQuery(criteria)
                            .getSingleResult()
            );

            return myModelInstanceUni
                    .convert()
                    .with(UniReactorConverters.toMono());

        } catch(Exception ex) {
            log.error("There is an error: {}", ex.getMessage());
            return null;
        }
    }
}

WAY 1: REACTIVE WAY

Util:


@Slf4j
@Component
public class JWTUtil {

    @Autowired
    private MyModelRepository myModelRepository;

    @Value("${springbootwebfluxjjwt.jjwt.secret}")
    private String secret;

    @Value("${springbootwebfluxjjwt.jjwt.expiration}")
    private String expirationTime;

    private Key key;


    @PostConstruct
    public void init(){
        this.key = Keys.hmacShaKeyFor(secret.getBytes());
    }


    public Claims getAllClaimsFromToken(String token) {
        // Here get token claims
    }


    public String getUsernameFromToken(String token) {
        // Here get token username
    }


    public Date getExpirationDateFromToken(String token) {
        // Here get expiration date from token;
    }


    private Boolean isTokenExpired(String token) {
        // Here validates token
    }


    public String generateToken (User user) {

        ArrayList<Long> usr_id = new ArrayList<Long>(Collections.singleton(user.getId()));
        ArrayList<String> usr_name = new ArrayList<String>(Collections.singleton(user.getName()));
        ArrayList<String> usr_lastname = new ArrayList<>(Collections.singleton(user.getLastName()));

        Map<String, Object> claims = new HashMap<>();
        claims.put("usr_id", usu_id);
        claims.put("usr_name", usu_name);
        claims.put("usr_lastname", usu_lastname);

        String[] desiredValueFromInside= {null};

        Disposable myInstance= myModelRepository.getMyModelInstance()
                .log()
                .subscribeOn(Schedulers.parallel())
                .subscribe(
                    // On next
                    instance-> {
                        desiredValueFromInside[0] = instance.getDesiredField();
                        claims.put("desiredField", instance.getDesiredField());

                        log.info("SUBSCRIBING, instance.getDesiredField() IS: {}", impuesto.getImp_tasa());
                        log.info("SUBSCRIBING, THE VAR desiredValueFromInsideIS: {}", impuestoFromInside[0]);
                    },
                    // On error
                    error -> log.error("THERE S A PROBLEM: {}", error),
                    // On complete
                    () -> log.info("WE ARE DONE!")
                );

        log.info("DEBUGGING, FROM OUTSIDE desiredValueFromInside IS: {}", desiredValueFromInside[0]);
        log.info("DEBUGGING, FROM OUTSIDE claims.get(\"desiredField\") IS: {}", claims.get("desiredField"));

        return doGenerateToken(claims, user.getUsername());
    }


    private String doGenerateToken(Map<String, Object> claims, String username) {
        // Here generate token
    }


    public Boolean validateToken(String token) {
        // Here validates token
    }
}

Console:

.
.
.
2022-03-02 11:21:02.485  INFO 44752 --- [ntloop-thread-0] .r.p.i.DefaultSqlClientPoolConfiguration : HR000025: Connection pool size: 100
2022-03-02 11:21:02.500  INFO 44752 --- [ntloop-thread-0] c.a.o.configuration.security.JWTUtil     : DEBUGGING, FROM OUTSIDE desiredValueFromInside IS: null
2022-03-02 11:21:02.500  INFO 44752 --- [ntloop-thread-0] c.a.o.configuration.security.JWTUtil     : DEBUGGING, FROM OUTSIDE claims.get(\"desiredField\") IS: null
2022-03-02 11:21:02.500  INFO 44752 --- [     parallel-2] reactor.Mono.FromPublisher.1             : onSubscribe(MonoNext.NextSubscriber)
2022-03-02 11:21:02.507  INFO 44752 --- [     parallel-2] reactor.Mono.FromPublisher.1             : request(unbounded)
.
.
.
2022-03-02 11:21:03.834  INFO 44752 --- [ntloop-thread-1] reactor.Mono.FromPublisher.1             : onNext(MyModel(id=1, desired_field="I am the desired value")
2022-03-02 11:21:03.849  INFO 44752 --- [ntloop-thread-1] c.a.o.configuration.security.JWTUtil     : SUBSCRIBING, instance.getDesiredField() IS: "I am the desired value"
2022-03-02 11:21:03.849  INFO 44752 --- [ntloop-thread-1] c.a.o.configuration.security.JWTUtil     : SUBSCRIBING, THE VAR desiredValueFromInsideIS: "I am the desired value"
2022-03-02 11:21:03.849  INFO 44752 --- [ntloop-thread-1] c.a.o.configuration.security.JWTUtil     : "WE ARE DONE!"
2022-03-02 11:21:03.849  INFO 44752 --- [ntloop-thread-1] reactor.Mono.FromPublisher.1             : onComplete()

WAY 2: BLOCKING WAY

Util:


@Slf4j
@Component
public class JWTUtil {

    @Autowired
    private MyModelRepository myModelRepository;

    @Value("${springbootwebfluxjjwt.jjwt.secret}")
    private String secret;

    @Value("${springbootwebfluxjjwt.jjwt.expiration}")
    private String expirationTime;

    private Key key;


    @PostConstruct
    public void init(){
        this.key = Keys.hmacShaKeyFor(secret.getBytes());
    }


    public Claims getAllClaimsFromToken(String token) {
        // Here get token claims
    }


    public String getUsernameFromToken(String token) {
        // Here get token username
    }


    public Date getExpirationDateFromToken(String token) {
        // Here get expiration date from token;
    }


    private Boolean isTokenExpired(String token) {
        // Here validates token
    }


    public String generateToken (User user) {

        ArrayList<Long> usr_id = new ArrayList<Long>(Collections.singleton(user.getId()));
        ArrayList<String> usr_name = new ArrayList<String>(Collections.singleton(user.getName()));
        ArrayList<String> usr_lastname = new ArrayList<>(Collections.singleton(user.getLastName()));

        Map<String, Object> claims = new HashMap<>();
        claims.put("usr_id", usu_id);
        claims.put("usr_name", usu_name);
        claims.put("usr_lastname", usu_lastname);

        String[] desiredValueFromInside= {null};

        String desiredField = myModelRepository.getMyModelInstance()
                .map(MyModel::getDesiredField)
                .share()
                .block();

        desiredValueFromInside[0] = instance.getDesiredField();
        claims.put("desiredField", instance.getDesiredField());

        log.info("DEBUGGING, FROM OUTSIDE desiredValueFromInside IS: {}", desiredValueFromInside[0]);
        log.info("DEBUGGING, FROM OUTSIDE claims.get(\"desiredField\") IS: {}", claims.get("desiredField"));

        return doGenerateToken(claims, user.getUsername());
    }


    private String doGenerateToken(Map<String, Object> claims, String username) {
        // Here generate token
    }


    public Boolean validateToken(String token) {
        // Here validates token
    }
}

Console: There are and infinite loop of this console log.

.
.
.
2022-03-02 11:40:58.640  WARN 38436 --- [-thread-checker] io.vertx.core.impl.BlockedThreadChecker  : Thread Thread[vert.x-eventloop-thread-0,5,main] has been blocked for 9212 ms, time limit is 2000 ms

io.vertx.core.VertxException: Thread blocked
    at java.base@11.0.12/java.lang.Thread.sleep(Native Method) ~[na:na]
    at app//reactor.core.publisher.NextProcessor.block(NextProcessor.java:135) ~[reactor-core-3.4.14.jar:3.4.14]
    at app//reactor.core.publisher.MonoProcessor.block(MonoProcessor.java:116) ~[reactor-core-3.4.14.jar:3.4.14]
.
.
.

ANSWER

Answered 2022-Mar-04 at 15:34

The main point here i think is the way you are organizing the code, it seems to me that you are using a reactive framework, but thinking and coding in an imperative way.

If you change the generateToken and doGenerateToken to return a Mono, you can do something like the following:

    private Mono<String> generateToken(User user) {
        ArrayList<Long> usr_id = new ArrayList<Long>(Collections.singleton(user.getId()));
        ArrayList<String> usr_name = new ArrayList<String>(Collections.singleton(user.getName()));
        ArrayList<String> usr_lastname = new ArrayList<>(Collections.singleton(user.getLastName()));

        return myModelRepository.getMyModelInstance()
                .map(modelInstance -> {
                    Map<String, Object> claims = new HashMap<>();

                    //put all values you need in claims map...

                    //update doGenerateToken code to return a Mono<String>
                    return doGenerateToken(claims, user.getUsername());
                });
    }

Source https://stackoverflow.com/questions/71326490

QUESTION

How to subscribe to "HttpClientResponse::toFlowable()" outside of the vert.x "rxResponse().subscribe" callback

Asked 2022-Mar-03 at 16:24

I'm trying to use the content of an HttpClientResponse.toFlowable() outside of the event loop, using an AtomicReference to hold the Flowable.

So, I've set up a test which returns the body, then fails during the trailer decoding. Thus, my subscription to the flowable should receive the response body, then an error.

That's what I observe when I subscribe to the Flowable right after (still in the callback), but not when subscribing to the flow outside of the callback. In the latter case my test pass 1/3 of the time...

The vertx-rx doc clearly says that it's a hot flowable and should be either subscribed in the event loop OR paused.

So, I've tried to pause the response before subscribing but I get the same test results : only 1/3 of my runs got both the body and the exception.

Moreover, when looking at the Vert.x HttpClientResponse::toFlowable() implementation, I can see that a readStream.pause() is made anyway.

So my question is ... Am I missing something ? Or could it be a Vert.x bug ?

Here is the code I'm using :

package my.tests;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.RepeatedTest;

import io.reactivex.rxjava3.core.Flowable;
import io.vertx.core.http.HttpMethod;
import io.vertx.rxjava3.core.Vertx;
import io.vertx.rxjava3.core.buffer.Buffer;
import io.vertx.rxjava3.core.http.HttpClient;
import io.vertx.rxjava3.core.net.NetServer;

public class VxTestRx3 {
    static NetServer server;
    static HttpClient client;

    @BeforeAll
    static void setUp() throws InterruptedException {
        server = startServer();
        client = Vertx.vertx()
                      .createHttpClient();
    }

    @RepeatedTest(1000)
    void shouldReachOnNextAndOnError() throws Exception {

        CountDownLatch bodyReadLatch = new CountDownLatch(1);
        CountDownLatch responseReadyToRead = new CountDownLatch(1);
        AtomicReference<Flowable<Buffer>> flowableRef = new AtomicReference<>();
        AtomicInteger ab = new AtomicInteger(0);
        client.rxRequest(HttpMethod.GET,
                         server.actualPort(),
                         "localhost",
                         "/")
              .subscribe(request -> {
                  request.rxResponse()
                         .subscribe(response -> {
                             // even with "response.pause()" here, the test is failing.
                             flowableRef.set(response.toFlowable());
                             responseReadyToRead.countDown();
                             // If the Flowable is subscribed here : I get my onNext & onError called.
                             /*flowableRef.get()
                                        .doOnComplete(bodyReadLatch::countDown)
                                        .subscribe(buffer -> ab.addAndGet(1),
                                                   t -> {
                                                       ab.addAndGet(2);
                                                       bodyReadLatch.countDown();
                                                   });*/
                         });
                  Flowable.<Buffer>empty().subscribe(request.toSubscriber());
              });
        responseReadyToRead.await();
        // If the Flowable is subscribed here : the behaviour is not stable.
        flowableRef.get()
                   .doOnComplete(bodyReadLatch::countDown)
                   .subscribe(buffer -> ab.addAndGet(1),
                              t -> {
                                  ab.addAndGet(2);
                                  bodyReadLatch.countDown();
                              });
        bodyReadLatch.await();
        // Should have been in onNext then onError callbacks.
        Assertions.assertThat(ab.get()).isEqualTo(3);
    }

    // This starts a server synchronously.
    // It serves a static HTTP response with an illegal trailer name (making Vert.x fail)
    private static NetServer startServer() throws InterruptedException {
        CountDownLatch serverReady = new CountDownLatch(1);
        AtomicReference<NetServer> servRef = new AtomicReference<>();
        Vertx.vertx().createNetServer()
                                .connectHandler(socket -> {
                                    String content1 = "HTTP/1.1 200 OK\r\n"
                                            + "transfer-encoding: chunked\r\n"
                                            + "\r\n"
                                            + "2\r\n"
                                            + "OK"
                                            + "\r\n"
                                            + "0\r\n"
                                            + "é: trailerValue\r\n" // é is an invalid trailer name
                                            + "\r\n";
                                    // Read the request content, then write content, then close the socket.
                                    socket.handler(b -> socket.write(content1).subscribe(socket::close));
                                })
                                .listen()
                .subscribe(netServer -> {
                    servRef.set(netServer);
                    serverReady.countDown();
                });
        serverReady.await();
        return servRef.get();
    }
}

ANSWER

Answered 2022-Mar-03 at 16:24

Ok, after more searches I've found out what happened.

Simplification

First, I've re-created a test removing the use of rx-vert, and added an exception handler on the socket :

package org.tests;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.RepeatedTest;

import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpClientRequest;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.net.NetServer;
import io.vertx.core.streams.ReadStream;

public class VxTestNonRx {
    static NetServer server;
    static HttpClient client;

    @BeforeAll
    static void setUp() throws InterruptedException {
        server = startServer();
        client = Vertx.vertx().createHttpClient();
    }

    @RepeatedTest(10000)
    void shouldReachOnNextAndOnError() throws Exception {
        CountDownLatch bodyReadLatch = new CountDownLatch(1);
        CountDownLatch responseReadyToRead = new CountDownLatch(1);
        AtomicReference<ReadStream<Buffer>> readStreamRef = new AtomicReference<>();
        AtomicInteger ab = new AtomicInteger(0);
        client.request(HttpMethod.GET,
                       server.actualPort(),
                       "localhost",
                       "/")
              .compose(HttpClientRequest::send)
              .onSuccess(response -> {
                  // Catches exceptions when they happen before we subscribed to the ReadStream
                  response.netSocket().exceptionHandler(t -> System.out.println("NET EXCEPTION HANDLER" + t.getMessage()));
                  //response.pause(); // Try to pause FIRST to avoid skipping buffers
                  // When handlers are set here : 
                  //  - with pause(): 100% times exceptionHandler only.
                  //  - without pause(): 100% times : handler, then exceptionHandler
                  readStreamRef.set(response);
                  responseReadyToRead.countDown();
              });
        responseReadyToRead.await();
        // When handlers are set here : 
        // - without pause() : 
        //     - 66% times : handler, then exceptionHandler
        //     - 33% times : only exceptionHandler gets called.
        // - with pause() : 
        //     - 99% times : only onError gets called 
        //     - 1% times  : netSocket().exceptionHandler, then handler gets called. (but neither endHandler nor exceptionHandler are called !)
        readStreamRef.get()
                     .handler(buffer -> {
                         System.out.println("HANDLER");
                         ab.addAndGet(1);
                     })
                     .endHandler(unused -> {
                         System.out.println("END HANDLER");
                         bodyReadLatch.countDown();
                     })
                     .exceptionHandler(t -> {
                         System.out.println("ERROR HANDLER");
                         ab.addAndGet(2);
                         bodyReadLatch.countDown();
                     });
        readStreamRef.get().resume();
        bodyReadLatch.await();
        // Should have been in onNext then onError callbacks.
        Assertions.assertThat(ab.get()).isEqualTo(3);
    }

    // This starts a server synchronously.
    // It serves a static HTTP response with an illegal trailer name (making Vert.x fail)
    private static NetServer startServer() throws InterruptedException {
        CountDownLatch serverReady = new CountDownLatch(1);
        AtomicReference<NetServer> servRef = new AtomicReference<>();
        Vertx.vertx().createNetServer()
             .connectHandler(socket -> {
                 String content1 = "HTTP/1.1 200 OK\r\n"
                         + "transfer-encoding: chunked\r\n"
                         + "\r\n"
                         + "2\r\n"
                         + "OK"
                         + "\r\n"
                         + "0\r\n"
                         + "é: trailerValue\r\n" // é is an invalid trailer name
                         + "\r\n";
                 // Read the request content, then write content, then close the socket.
                 socket.handler(b -> socket.write(content1, ar -> socket.close()));
             })
             .listen()
             .onSuccess(netServer -> {
                 servRef.set(netServer);
                 serverReady.countDown();
             });
        serverReady.await();
        return servRef.get();
    }

Observations

As written in java comments, here are my findings :

When ReadStream handlers are set right after getting the response:
- When pause()ing the ReadStream first: I don't get any buffers, ReadStream.exceptionHandler is ALWAYS called.
- without pause(): I ALWAYS receive the body buffer in ReadStream.handler, then ReadStream.exceptionHandler gets called.
When handlers are set outside of the response received callback context:
- When pause()ing the ReadStream first (still in the callback context):
  - 99% of the time: only ReadStream.exceptionHandler gets called
  - 1% of the time: netSocket().exceptionHandler is called, then handler gets called but neither ReadStream.endHandler nor ReadStream.exceptionHandler get called, the stream "never ends" !!
- without pause()ing:
  - 66% of the time: ReadStream.handler is called, then ReadStream.exceptionHandler.
  - 33% of the time: ONLY ReadStream.exceptionHandler gets called.

Explanations

When setting the handlers directly in the "response received" callback, the behaviour is stable, and this can help to understand how ReadStream.pause() work.

When pausing, Vert.x will not stop to read the response content. It will buffer the ByteBuffers to be able to serve them either on ReadStream.fetch(x) or ReadStream.resume(). But when it encounters an error (in my case, while reading the trailers, after the body buffers) it will still call the callback set with ReadStream.exceptionHandler. In that case, the body has not been read (because of the pause), but the pre-defined exceptionHandler has been called.

However, without any ReadStream.pause(), as soon as the event "response received" ends, the request's buffers (that's another eventloop event) will be sent to the registered ReadStream.handler directly, then vert.x will find the error out and calls the registered ReadStream.exceptionHandler.

This explains my stable cases nicely. Now, let's explain the unstable ones !

When setting the ReadStream's Handlers outside of the scope of the "response received" promise, it's possible to miss some events. That's quite simple, when vert.x gets out of the "response received" scope, that's the end of an event, then :

Vert.x process the buffers (or skip them and save them when pausing) as part of other events, probably on the same event loop, but the ReadStream.handler registration is made outside of the context this time ! That's another thread and this code may have not run already ! So buffers sent to the ReadStream will be lost.
Worse, when the trailer error is found out, if there is no exception handler set already, Vert.x will fall back on the next exception handler it can get : the TCP connection one (response.netSocket().exceptionHandler), or if not set neither... the event loop exception handler, and so on. So the error is ... lost, even when pausing the stream.

This explains why, when defining my handlers outside of the "response received event" context, my registered ReadStream.handler was not always called (the buffer event had been sent before the registration). But luckily the exception happened after my exception handler registration in 99% of the time. The last 1% is now explained, neither the handler, nor the exceptionHandler had been registered while vert.x processed the exception...

How does that apply to the initial rx-vertx issue ?

Well... calling response.toFlowable() maps the ReadStream handlers to Flowables upcoming subscription. But again, the subscription to the resulting Flowable happened outside of the scope of "response received event". Thus events may have flowed before actually subscribing !

Eventually, is that a vert.x issue ?

Well... No. I was misusing it.

But it could be good to fail the ReadStream's handler/endHandler/exceptionHandler registration when ReadStream terminal methods (endHandler/exceptionHandler) have been called already. Thus we would never wait forever for a ReadStream to publish Buffers, and could get clearer exception messages !

Source https://stackoverflow.com/questions/71321877

QUESTION

starting with reactive DB access in a blocking monolith

Asked 2022-Feb-24 at 11:58

In a DB heavy monolith based on wildfly. does it make sense to transform the DB access to reactive one for starters? should I see performance benefits?

also, the DB is sybase and the only 'generic' jdbc driver I know is from vert.x but this implies that I will have to put vert.x inside my wildfly. I understand that they are sort of alternatives but I cant find any other options.

I would love to hear your thoughts about the 2 points I am raising. In general, I cant commit to a full transition from wildfly to quarkus/vert.x from the get go as it will take lots of resources so I thought I could start smaller...

ANSWER

Answered 2022-Feb-24 at 11:58

Vert.x is a toolkit, which means, for example, you do not need to use the web server it provides, nor any other module. It's also very lightweight, so you will only add a few more dependencies to your application. So, yes it can make sense to integrate Vert.x.

vertx-jdbc-client however, cannot magically transform blocking calls into non-blocking calls. Instead, it will off-load the blocking calls onto Vert.x' worker thread pool. That will lead to another effect: The DB call you used to wait for, will immediately return, leaving you with nothing but a Future. That Future will eventually have the expected result.

Going further upstream in your code (the direction where your user's request came from), this means that you will have to

either defer processing of the result via Future.map() or Future.compose()
block the thread to get the result immediately

You will win nothing by (2), so rule that out.

When you go for (1), you must defer all further processing, up to the point where the incoming request is originally handled. If that is, for example, a Servlet, you have to use Asynchronous Processing to make sure that Wildfly does not commit the response after the doGet, doPost etc. method exits.

The result of all this will be that Wildfly now handles your request asynchronously, with Vert.x managing the DB interaction. You can do that. But it would be more idiomatic to your current setup to just use Asynchronous Processing (or Spring's @Async feature) and wrap all of your code in a Runnable. Both approaches will not speed up request processing itself, because the processing depends on the slower DB. However, Wildfly will be able to process more requests because the threads it assigns to requests will not be blocked anymore.

Having all that said, if you want to migrate to Quarkus in small steps, you should do that service by service. Identify the Servlets (or Controllers) which do the work, and port them one by one to Quarkus. If sessions are your problem, then you could possibly share them between Wildfly and Quarkus, using Infinispan.

Source https://stackoverflow.com/questions/71221017

QUESTION

How to configure Axon 4 context in Vert.x

Asked 2022-Feb-18 at 08:06

I'm using Axon for implementation of CQRS/Event sourcing in my Vert.X microservice. In the bootstrap of my Verticle I have a createInfra methid for creation of my Axon context. When I try to get a ressource from ny projection I have no result and the request executed without end. When I check the QueryGateway, in the SimpleGatewayBus I have no subscription.

If someone can help me for fix my Axon configuration ? And I have a trouble with MongoDB Eventstore configuration.

Verticle

package com.omb..restadapter;

import com.omb..domain.commands.MyAggregate;
import com.omb..infra.repositories.MongoAggregateProjector;
import com.omb..infra.repositories.MongoAggregateRepository;
import com.omb..restadapter.handler.MyCommandHandler;
import com.omb..restadapter.handler.MyQueryHandler;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.core.Promise;
import io.vertx.ext.auth.PubSecKeyOptions;
import io.vertx.ext.auth.jwt.JWTAuth;
import io.vertx.ext.auth.jwt.JWTAuthOptions;
import io.vertx.ext.healthchecks.HealthCheckHandler;
import io.vertx.ext.healthchecks.Status;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.BodyHandler;
import io.vertx.ext.web.handler.CorsHandler;
import io.vertx.ext.web.handler.JWTAuthHandler;
import io.vertx.ext.web.handler.StaticHandler;
import org.axonframework.config.AggregateConfigurer;
import org.axonframework.config.Configuration;
import org.axonframework.config.Configurer;
import org.axonframework.config.DefaultConfigurer;
import org.axonframework.eventhandling.tokenstore.jpa.JpaTokenStore;
import org.axonframework.eventsourcing.EventSourcingRepository;
import org.axonframework.extensions.mongo.eventsourcing.tokenstore.MongoTokenStore;

import java.util.logging.Logger;

public class MyVerticle extends AbstractVerticle {

    private MyCommandHandler MyCommandHandler;
    private MyQueryHandler MyQueryHandler;
    private static final String APP_JSON = "application/json";
    private static final Logger log = Logger.getLogger(MyVerticle.class.getName());

    public static final String RESOURCE_NAME = "My";

    /**
     * Convenience method so you can run it in your IDE
     *
     * @param args
     */
    public static void main(String[] args) {
        Runner.runExample(MyVerticle.class);
    }

    /**
     * Start the verticle
     */
    @Override
    public void start(Promise<Void> startFuture) throws Exception {

        Future<Void> steps = createInfra().compose(t -> createRouter());

        steps.onComplete(ar -> {
            if(ar.succeeded()) {
                startFuture.complete();
            } else {
                log.throwing(MyVerticle.class.getName(), "start", ar.cause());
                startFuture.fail(ar.cause());
            }
        });
    }

    /**
     * Stop the Verticle
     */
    @Override
    public void stop() throws Exception {
        super.stop();
    }

    /**
     * Create the server
     *
     * @return
     */
    private Future<Void> createRouter() {
        return Future.future(promise -> {
            final Router router = Router.router(vertx);

            final JWTAuth authProvider = JWTAuth.create(vertx, getJWTAuthOptions());

            // allow route for CORS
            router.route()
                    .handler(CorsHandler.create(".*.").allowedMethod(io.vertx.core.http.HttpMethod.GET)
                            .allowedMethod(io.vertx.core.http.HttpMethod.POST)
                            .allowedMethod(io.vertx.core.http.HttpMethod.DELETE)
                            .allowedMethod(io.vertx.core.http.HttpMethod.PUT).allowCredentials(true)
                            .allowedHeader("Access-Control-Allow-Method").allowedHeader("Authorization")
                            .allowedHeader("idPartner").allowedHeader("Access-Control-Allow-Origin")
                            .allowedHeader("Access-Control-Allow-Credentials").allowedHeader("Content-Type"));

            router.route().handler(BodyHandler.create()).failureHandler(new FailureHandler());

            router.get("/my-reources").produces(APP_JSON).handler(MyQueryHandler::getAllResource);
            router.post("/my-resources").consumes(APP_JSON).produces(APP_JSON).handler(MyCommandHandler::createMy);
            

            // Healthcheck
            router.get("/health*").handler(HealthCheckHandler.create(vertx).register("health", res -> res.complete(Status.OK())));

            // Swagger
            router.route("/*").handler(StaticHandler.create());

            vertx.createHttpServer().requestHandler(router).listen(8083);
            promise.complete();
        });
    }

    private Future<Void> createInfra() {
        return Future.future(promise -> {

            MongoClient mongoClient = new MongoClient(config().getString(ConfigResource.CONFIG_MONGODB_URL));
            MongoDatabase database = mongoClient.getDatabase("resource");
            MongoAggregateRepository repository = new MongoMyRepository(database);
            MongoAggregateProjector MyProjector = new MongoAggregateProjector(repository);

            Configuration configuration = DefaultConfigurer
                    .defaultConfiguration()
                    .configureAggregate(MyAggregate.class)
                    .eventProcessing(conf -> conf.registerTokenStore(config -> MongoTokenStore.builder().build()))
                    .registerEventHandler(conf -> MyProjector)
                    .registerQueryHandler(conf -> MyProjector)
                    .buildConfiguration();

            // Write
            MyCommandHandler = new MyCommandHandler(configuration.commandGateway());

            // Read
            MyQueryHandler = new MyQueryHandler(configuration.queryGateway());

            promise.complete();
        });
    }
}

Projector

package com.omb..infra.repositories;

import com.omb..domain.events.AggregateCreatedEvent;
import com.omb..domain.events.AggregateUpdatedEvent;
import com.omb..domain.queries.FindAggregateQuery;
import com.omb..domain.queries.FindAggregatesQuery;
import com.omb..domain.queries.IAggregateProjector;
import com.omb..domain.queries.AggregateView;
import org.axonframework.eventhandling.EventHandler;
import org.axonframework.queryhandling.QueryHandler;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class MongoAggregateProjector implements IAggregateProjector {

    private MongoAggregateRepository repository;

    public MongoAggregateProjector(MongoAggregateRepository repository) {
        this.repository = repository;
    }

    @Override
    @EventHandler
    public void on(AggregateCreatedEvent event) {
        AggregateDocument AggregateDocument = new AggregateDocument(event.getId(), event.getName());
        repository.addAggregate(AggregateDocument);
    }

    @Override
    @EventHandler
    public void on(AggregateUpdatedEvent event) {
        AggregateDocument AggregateDocument = new AggregateDocument(event.getId(), event.getName());
        repository.updateAggregate(AggregateDocument);
    }

    @Override
    @QueryHandler
    public Optional<AggregateView> handle(FindAggregateQuery query) {
        return repository.getAggregate(query.getAggregateId()).map(AggregateDocument::toView);
    }

    @Override
    @QueryHandler
    public List<AggregateView> handle(FindAggregatesQuery query) {
        return repository.getAggregates().stream().map(AggregateDocument::toView).collect(Collectors.toList());
    }
}

Aggregate

package com.omb..domain.commands;

import com.omb..domain.events.AggregateCreatedEvent;
import com.omb..domain.events.AggregateUpdatedEvent;
import org.axonframework.commandhandling.CommandHandler;
import org.axonframework.eventsourcing.EventSourcingHandler;
import org.axonframework.modelling.command.AggregateIdentifier;

import static org.axonframework.modelling.command.AggregateLifecycle.apply;

public class MyAggregate {

    @AggregateIdentifier
    private String myAggregateId;
    private String name;

    public Aggregate() {}

    @CommandHandler
    public Aggregate(CreateAggregateCommand command) {
        apply(new AggregateCreatedEvent(command.getId(), command.getName()));
    }

    @CommandHandler
    public void handle(UpdateAggregateCommand command) {
        apply(new AggregateUpdatedEvent(command.getId(), command.getName()));
    }

    @EventSourcingHandler
    public void on(AggregateCreatedEvent event) {
        AggregateId = event.getId();
        name = event.getName();
    }

    @EventSourcingHandler
    public void on(AggregateUpdatedEvent event) {
        AggregateId = event.getId();
        name = event.getName();
    }
}

ANSWER

Answered 2022-Feb-18 at 08:06

I see 2 problems in the configuration:

You just "build" the configuration, but don't start it. After buildConfiguration(), make sure to call 'start()' on the returned Configuration instance. Alternatively, directly call start() on the Configurer. It returns a started configuration instance.

That should resolve the registrations not coming through. But it will probably trigger an exception related to the next issue....
Your MongoTokenStore configuration is incomplete. The TokenStore needs at least a serializer and a MongoTemplate instance. The latter tells the Axon which collections you want to certain types of information in. In your case, only the TrackingTokenCollection would be relant.

config -> MongoTokenStore.builder()
                         .mongoTemplate(
                             DefaultMongoTemplate.builder()
                                                 // optionally choose collection names here
                                                 .mongoDatabase(mongoClient)
                                                 .build())
                         .serializer(Configuration::serializer)
                         .build()

I recommend checking the options in the builders to ensure you don't need to configure any other things that are specific to your environment. The default work in generic cases, but may not be valid for you.

Source https://stackoverflow.com/questions/71162708

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

CVE-2019-17640 CRITICAL

In Eclipse Vert.x 3.4.x up to 3.9.4, 4.0.0.milestone1, 4.0.0.milestone2, 4.0.0.milestone3, 4.0.0.milestone4, 4.0.0.milestone5, 4.0.0.Beta1, 4.0.0.Beta2, and 4.0.0.Beta3, StaticHandler doesn't correctly processes back slashes on Windows Operating systems, allowing, escape the webroot folder to the current working directory.

CVE-2018-12544 CRITICAL

In version from 3.5.Beta1 to 3.5.3 of Eclipse Vert.x, the OpenAPI XML type validator creates XML parsers without taking appropriate defense against XML attacks. This mechanism is exclusively when the developer uses the Eclipse Vert.x OpenAPI XML type validator to validate a provided schema.

CVE-2018-12542 CRITICAL

In version from 3.0.0 to 3.5.3 of Eclipse Vert.x, the StaticHandler uses external input to construct a pathname that should be within a restricted directory, but it does not properly neutralize '\' (forward slashes) sequences that can resolve to a location that is outside of that directory when running on Windows Operating Systems.

CVE-2018-12541 MEDIUM

In version from 3.0.0 to 3.5.3 of Eclipse Vert.x, the WebSocket HTTP upgrade implementation buffers the full http request before doing the handshake, holding the entire request body in memory. There should be a reasonnable limit (8192 bytes) above which the WebSocket gets an HTTP response with the 413 status code and the connection gets closed.

CVE-2018-12540 HIGH

In version from 3.0.0 to 3.5.2 of Eclipse Vert.x, the CSRFHandler do not assert that the XSRF Cookie matches the returned XSRF header/form parameter. This allows replay attacks with previously issued tokens which are not expired yet.

CVE-2018-12537 MEDIUM

In Eclipse Vert.x version 3.0 to 3.5.1, the HttpServer response headers and HttpClient request headers do not filter carriage return and line feed characters from the header value. This allow unfiltered values to inject a new header in the client request or server response.

Install vert.x

You can download it from GitHub.
You can use vert.x like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the vert.x component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

Support

Open target/docs/vertx-core/java/index.html with your browser.

DOWNLOAD this Library from

Reuse Trending Solutions

14 best Python Telegram Bot

21 best C# Game Development

Build AI Fake News Detector

Build Text Summarizer in Python

Getting Started with Web3

24 best Python Blockchain

26 best Python Face Recognition

Build Ludo Game in Python

Build Location Based AR App

Build AI Study Assistant Bot

Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
over 430 million Knowledge Items

Find more libraries

Reuse Solution Kits and Libraries Curated by Popular Use Cases

Save this library and start creating your kit

Explore Related Topics

Programming Style

Reactive Programming

Share this Page

Reuse Java Kits

17 best Java Video Player

Implementing 2FA

7 best Java Recommender System libr

22 best Java Blockchain

11 best Java Ethereum

See all related Kits

Consider Popular Reactive Programming Libraries

async

by caolan

rxjs

by ReactiveX

mobx

by mobxjs

RxSwift

by ReactiveX

ReactiveCocoa

by ReactiveCocoa

See all Reactive Programming Libraries

Try Top Libraries by eclipse-vertx

vertx-sql-client

by eclipse-vertx Java

vertx-codegen

by eclipse-vertx Java

vertx-junit5

by eclipse-vertx Java

vertx-json-schema

by eclipse-vertx Java

vertx-http-proxy

by eclipse-vertx Java

See all Libraries by this author

Compare Reactive Programming Libraries with Highest Support

bluebird

by petkaantonov

starlette

by encode

vert.x

by eclipse-vertx

uvicorn

by encode

httpx

by encode

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Highest Quality

SuperS3t

by spartango

vertx-memcached

by ashertarno

vertx-gradle-template

by vert-x

playVertX

by fmasion

rxjava-android-example

by andrewhr

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Highest Security

JActor2

by laforge49

mod-rxvertx

by vert-x

mod-rxjava

by meez

JavaWebsocketClient

by jacek-marchwicki

vertx-elasticsearch-service

by ef-labs

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Permissive License

vertx-when

by ef-labs

humanize

by mfornos

parseq

by linkedin

SuperS3t

by spartango

jdeferred

by jdeferred

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Highest Reuse

vlingo-cluster

by vlingo

RxJavaFileUtils

by ReactiveX

future

by traneio

RxJavaReactiveStreams

by ReactiveX

smallrye-reactive-streams-operators

by smallrye

See all Reactive Programming Libraries

Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
over 430 million Knowledge Items

Find more libraries

Reuse Solution Kits and Libraries Curated by Popular Use Cases

Save this library and start creating your kit

© 2022 Open Weaver Inc.

© 2022 Open Weaver Inc.