public void registerConsumersAfterDeploymentValidation(@Observes AfterDeploymentValidation afterDeploymentValidation, BeanManager beanManager) { if (vertx != null) { registerConsumers(vertx, BeanManagerProxy.unwrap(beanManager).event()); } asyncReferenceQualifiers.clear(); }
public void registerBeansAfterBeanDiscovery(@Observes AfterBeanDiscovery event) { if (vertx == null) { // Do no register beans - no Vertx instance available during bootstrap return; } // Allow to inject Vertx used to deploy the WeldVerticle event.addBean(new VertxBean<Vertx>(getBeanTypes(vertx.getClass(), Vertx.class)) { @Override public Vertx create(CreationalContext<Vertx> creationalContext) { return vertx; } }); // Allow to inject Context of the WeldVerticle event.addBean(new VertxBean<Context>(getBeanTypes(context.getClass(), Context.class)) { @Override public Context create(CreationalContext<Context> creationalContext) { return context; } }); }
private String getVertxAddress(ObserverMethod<?> observerMethod) { Annotation qualifier = getQualifier(observerMethod, VertxConsumer.class); return qualifier != null ? ((VertxConsumer) qualifier).value() : null; }
@Test public void testConsumers() throws InterruptedException { try (WeldContainer weld = new Weld().disableDiscovery().addExtension(new VertxExtension()).addPackage(false, RegisterConsumersAfterBootstrapTest.class) .initialize()) { Vertx vertx = Vertx.vertx(); try { weld.select(VertxExtension.class).get().registerConsumers(vertx, weld.event()); vertx.eventBus().send(HelloObserver.HELLO_ADDRESS, "hello"); assertEquals("hello", SYNCHRONIZER.poll(Timeouts.DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS)); } finally { vertx.close(); } } }
@Override public void start(Future<Void> startFuture) throws Exception { Weld weld = this.weld != null ? this.weld : createDefaultWeld(); if (weld.getContainerId() == null) { weld.containerId(deploymentID()); } weld.addExtension(new VertxExtension(vertx, context)); configureWeld(weld); // Bootstrap can take some time to complete vertx.executeBlocking(future -> { try { this.weldContainer = weld.initialize(); future.complete(); } catch (Exception e) { future.fail(e); } }, result -> { if (result.succeeded()) { LOGGER.info("Weld verticle started for deployment {0}", deploymentID()); startFuture.complete(); } else { startFuture.fail(result.cause()); } }); }
public void processVertxEventObserver(@Observes ProcessObserverMethod<VertxEvent, ?> event) { String vertxAddress = getVertxAddress(event.getObserverMethod()); if (vertxAddress == null) { LOGGER.warn("VertxEvent observer found but no @VertxConsumer declared: {0}", event.getObserverMethod()); return; } LOGGER.debug("Vertx message consumer found: {0}", event.getObserverMethod()); consumerAddresses.add(vertxAddress); }
@Inject public AsyncReferenceImpl(InjectionPoint injectionPoint, Vertx vertx, BeanManager beanManager) { this.isDone = new AtomicBoolean(false); this.future = new VertxCompletableFuture<>(vertx); this.creationalContext = beanManager.createCreationalContext(null); ParameterizedType parameterizedType = (ParameterizedType) injectionPoint.getType(); Type requiredType = parameterizedType.getActualTypeArguments()[0]; // First check if there is a relevant async producer method available List<AsyncProducerMetadata> foundMetadata = beanManager.getExtension(VertxExtension.class).getAsyncProducerMetadata(requiredType, injectionPoint.getQualifiers()); if (foundMetadata.size() > 1) { failure(new AmbiguousResolutionException( "Ambiguous async producer methods for type " + requiredType + " with qualifiers " + injectionPoint.getQualifiers())); } else if (foundMetadata.size() == 1) { // Use the produced CompletionStage initWithCompletionStage(foundMetadata.get(0), beanManager); } else { // Use Vertx worker thread initWithWorker(injectionPoint, vertx, beanManager, requiredType); } }
@Override public void start(Future<Void> startFuture) throws Exception { Weld weld = this.weld != null ? this.weld : createDefaultWeld(); if (weld.getContainerId() == null) { weld.containerId(deploymentID()); } weld.addExtension(new VertxExtension(vertx, context)); configureWeld(weld); // Bootstrap can take some time to complete vertx.executeBlocking(future -> { try { this.weldContainer = weld.initialize(); future.complete(); } catch (Exception e) { future.fail(e); } }, result -> { if (result.succeeded()) { LOGGER.info("Weld verticle started for deployment {0}", deploymentID()); startFuture.complete(); } else { startFuture.fail(result.cause()); } }); }
public void processVertxEventObserver(@Observes ProcessObserverMethod<VertxEvent, ?> event) { String vertxAddress = getVertxAddress(event.getObserverMethod()); if (vertxAddress == null) { LOGGER.warn("VertxEvent observer found but no @VertxConsumer declared: {0}", event.getObserverMethod()); return; } LOGGER.debug("Vertx message consumer found: {0}", event.getObserverMethod()); consumerAddresses.add(vertxAddress); }
public void registerConsumersAfterDeploymentValidation(@Observes AfterDeploymentValidation afterDeploymentValidation, BeanManager beanManager) { if (vertx != null) { registerConsumers(vertx, BeanManagerProxy.unwrap(beanManager).event()); } asyncReferenceQualifiers.clear(); }
weld.addExtension(new VertxExtension()); weld.initialize();
public void registerBeansAfterBeanDiscovery(@Observes AfterBeanDiscovery event) { if (vertx == null) { // Do no register beans - no Vertx instance available during bootstrap return; } // Allow to inject Vertx used to deploy the WeldVerticle event.addBean().types(getBeanTypes(vertx.getClass(), Vertx.class)).addQualifiers(Any.Literal.INSTANCE, Default.Literal.INSTANCE) .scope(ApplicationScoped.class).createWith(c -> vertx); // Allow to inject Context of the WeldVerticle event.addBean().types(getBeanTypes(context.getClass(), Context.class)).addQualifiers(Any.Literal.INSTANCE, Default.Literal.INSTANCE) .scope(ApplicationScoped.class).createWith(c -> context); }
private String getVertxAddress(ObserverMethod<?> observerMethod) { Annotation qualifier = getQualifier(observerMethod, VertxConsumer.class); return qualifier != null ? ((VertxConsumer) qualifier).value() : null; }
@Override public Completable init() { return Completable.defer(() -> { // Setup the Vertx-CDI integration VertxExtension vertxExtension = CDI.current().select(VertxExtension.class).get(); BeanManager beanManager = CDI.current().getBeanManager(); // has to be done in a blocking thread Vertx vertx = AppGlobals.get().getVertx(); return vertx.rxExecuteBlocking(future -> { vertxExtension.registerConsumers(vertx.getDelegate(), BeanManagerProxy.unwrap(beanManager).event()); future.complete(); }).ignoreElement(); }); }