Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Adds qualifier of vertx instance #22

Merged
merged 1 commit into from
Sep 26, 2024
Merged

Adds qualifier of vertx instance #22

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions subsystem/src/main/java/org/wildfly/extension/vertx/VertxConstants.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,6 +27,7 @@ public interface VertxConstants {

String[] TIME_UNITS = Arrays.stream(TimeUnit.values()).map(Enum::toString).collect(Collectors.toList()).toArray(new String[0]);

String CDI_NAMED_QUALIFIER = "vertx";
String VERTX_SERVICE = "vertx";
String ELEMENT_VERTX = "vertx";

Expand Down
4 changes: 4 additions & 0 deletions subsystem/src/main/java/org/wildfly/extension/vertx/logging/VertxLogger.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -58,4 +58,8 @@ public interface VertxLogger extends BasicLogger {
@LogMessage(level = INFO)
@Message(id = 8, value = "Use Vertx instance from vertx subsystem")
void useVertxFromSubsystem();

@Message(id = 9, value = "There is no vertx defined from vertx subsystem")
IllegalStateException noVertxDefined();

}
145 changes: 94 additions & 51 deletions subsystem/src/main/java/org/wildfly/extension/vertx/processors/CDIExtension.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@

import jakarta.enterprise.context.spi.CreationalContext;
import jakarta.enterprise.event.Observes;
import jakarta.enterprise.inject.literal.NamedLiteral;
import jakarta.enterprise.inject.spi.AfterBeanDiscovery;
import jakarta.enterprise.inject.spi.AnnotatedType;
import jakarta.enterprise.inject.spi.Bean;
Expand All @@ -27,11 +28,17 @@
import jakarta.enterprise.inject.spi.InjectionPoint;
import jakarta.enterprise.inject.spi.InjectionTarget;
import jakarta.enterprise.inject.spi.InjectionTargetFactory;
import org.wildfly.extension.vertx.VertxProxy;
import org.wildfly.extension.vertx.VertxProxyHolder;
import org.wildfly.extension.vertx.logging.VertxLogger;

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.HashSet;
import java.util.Set;

import static org.wildfly.extension.vertx.VertxConstants.CDI_NAMED_QUALIFIER;

/**
* CDI Extension which adds the ability to inject the Vertx instances by the member name.
*
Expand All @@ -44,87 +51,123 @@ public CDIExtension() {

public void registerVertxBean(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) {
if (VertxProxyHolder.instance().getVertxProxy() != null) {
VertxLogger.VERTX_LOGGER.useVertxFromSubsystem();
final String vpName = CDI_NAMED_QUALIFIER;
AnnotatedType<io.vertx.core.Vertx> rawVertxAnnotatedType = beanManager.createAnnotatedType(io.vertx.core.Vertx.class);
BeanAttributes<io.vertx.core.Vertx> rawVertxBeanAttributes = beanManager.createBeanAttributes(rawVertxAnnotatedType);
BeanAttributes<io.vertx.core.Vertx> rawVertxBeanAttributes =
new BeanAttributesWrapper<>(beanManager.createBeanAttributes(rawVertxAnnotatedType), Set.of(NamedLiteral.of(vpName)));
afterBeanDiscovery.addBean(beanManager.createBean(rawVertxBeanAttributes, io.vertx.core.Vertx.class, new RawVertxProducer()));

AnnotatedType<io.vertx.mutiny.core.Vertx> annotatedType = beanManager.createAnnotatedType(io.vertx.mutiny.core.Vertx.class);
BeanAttributes<io.vertx.mutiny.core.Vertx> beanAttributes = beanManager.createBeanAttributes(annotatedType);
BeanAttributes<io.vertx.mutiny.core.Vertx> beanAttributes =
new BeanAttributesWrapper<>(beanManager.createBeanAttributes(annotatedType), Set.of(NamedLiteral.of(vpName)));
afterBeanDiscovery.addBean(beanManager.createBean(beanAttributes, io.vertx.mutiny.core.Vertx.class, new MunityVertxProducer()));
}
}

private class MunityVertxProducer implements InjectionTargetFactory<io.vertx.mutiny.core.Vertx> {
private static class BeanAttributesWrapper<T> implements BeanAttributes<T> {
private final BeanAttributes<T> delegate;
private final Set<Annotation> qualifiers;

BeanAttributesWrapper(BeanAttributes<T> delegate, Set<Annotation> additionalQualifiers) {
this.delegate = delegate;
this.qualifiers = new HashSet<>(delegate.getQualifiers());
this.qualifiers.addAll(additionalQualifiers);
}

@Override
public InjectionTarget<io.vertx.mutiny.core.Vertx> createInjectionTarget(Bean<io.vertx.mutiny.core.Vertx> bean) {
return new InjectionTarget<>() {
@Override
public void inject(io.vertx.mutiny.core.Vertx instance, CreationalContext<io.vertx.mutiny.core.Vertx> ctx) {
}
public Set<Type> getTypes() {
return delegate.getTypes();
}

@Override
public void postConstruct(io.vertx.mutiny.core.Vertx instance) {
}
@Override
public Set<Annotation> getQualifiers() {
return qualifiers;
}

@Override
public void preDestroy(io.vertx.mutiny.core.Vertx instance) {
}
@Override
public Class<? extends Annotation> getScope() {
return delegate.getScope();
}

@Override
public io.vertx.mutiny.core.Vertx produce(CreationalContext<io.vertx.mutiny.core.Vertx> ctx) {
return mutinyVertx();
}
@Override
public String getName() {
return delegate.getName();
}

@Override
public void dispose(io.vertx.mutiny.core.Vertx instance) {
}
@Override
public Set<Class<? extends Annotation>> getStereotypes() {
return delegate.getStereotypes();
}

@Override
public Set<InjectionPoint> getInjectionPoints() {
return Set.of();
}
};
@Override
public boolean isAlternative() {
return delegate.isAlternative();
}

}
private class RawVertxProducer implements InjectionTargetFactory<io.vertx.core.Vertx> {

private abstract static class AbstractVertxInjectionTarget<T> implements InjectionTarget<T> {
@Override
public InjectionTarget<io.vertx.core.Vertx> createInjectionTarget(Bean<io.vertx.core.Vertx> bean) {
return new InjectionTarget<>() {
@Override
public void inject(io.vertx.core.Vertx instance, CreationalContext<io.vertx.core.Vertx> ctx) {
}
public void inject(T instance, CreationalContext<T> ctx) {
}

@Override
public void postConstruct(io.vertx.core.Vertx instance) {
}
@Override
public void postConstruct(T instance) {
}

@Override
public void preDestroy(io.vertx.core.Vertx instance) {
}
@Override
public void preDestroy(T instance) {
}

@Override
public io.vertx.core.Vertx produce(CreationalContext<io.vertx.core.Vertx> ctx) {
return rawVertx();
}
@Override
public void dispose(T instance) {
}

@Override
public Set<InjectionPoint> getInjectionPoints() {
return Set.of();
}
}

private static class MunityVertxProducer implements InjectionTargetFactory<io.vertx.mutiny.core.Vertx> {
@Override
public InjectionTarget<io.vertx.mutiny.core.Vertx> createInjectionTarget(Bean<io.vertx.mutiny.core.Vertx> bean) {
return new AbstractVertxInjectionTarget<>() {

@Override
public void dispose(io.vertx.core.Vertx instance) {
public io.vertx.mutiny.core.Vertx produce(CreationalContext<io.vertx.mutiny.core.Vertx> ctx) {
return mutinyVertx();
}

};
}
}
private static class RawVertxProducer implements InjectionTargetFactory<io.vertx.core.Vertx> {
@Override
public InjectionTarget<io.vertx.core.Vertx> createInjectionTarget(Bean<io.vertx.core.Vertx> bean) {
return new AbstractVertxInjectionTarget<>() {
@Override
public Set<InjectionPoint> getInjectionPoints() {
return Set.of();
public io.vertx.core.Vertx produce(CreationalContext<io.vertx.core.Vertx> ctx) {
return rawVertx();
}
};
}
}

private io.vertx.mutiny.core.Vertx mutinyVertx() {
return VertxProxyHolder.instance().getVertxProxy().getMutiyVertx();
private static io.vertx.mutiny.core.Vertx mutinyVertx() {
VertxProxy vertxProxy = VertxProxyHolder.instance().getVertxProxy();
if (vertxProxy == null) {
throw VertxLogger.VERTX_LOGGER.noVertxDefined();
}
VertxLogger.VERTX_LOGGER.useVertxFromSubsystem();
return vertxProxy.getMutiyVertx();
}

private io.vertx.core.Vertx rawVertx() {
return VertxProxyHolder.instance().getVertxProxy().getVertx();
private static io.vertx.core.Vertx rawVertx() {
VertxProxy vertxProxy = VertxProxyHolder.instance().getVertxProxy();
if (vertxProxy == null) {
throw VertxLogger.VERTX_LOGGER.noVertxDefined();
}
VertxLogger.VERTX_LOGGER.useVertxFromSubsystem();
return vertxProxy.getVertx();
}
}
Loading