org.infinispan.cdi.InfinispanExtensionRemote Maven / Gradle / Ivy

Go to download
package org.infinispan.cdi;

import org.infinispan.cdi.logging.RemoteLog;
import org.infinispan.cdi.util.BeanBuilder;
import org.infinispan.cdi.util.ContextualLifecycle;
import org.infinispan.cdi.util.Reflections;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.commons.logging.LogFactory;

import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.event.Observes;
import javax.enterprise.inject.Default;
import javax.enterprise.inject.spi.*;
import javax.enterprise.util.AnnotationLiteral;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class InfinispanExtensionRemote implements Extension {

   private static final RemoteLog logger = LogFactory.getLog(InfinispanExtensionRemote.class, RemoteLog.class);

   private final Map> remoteCacheInjectionPoints;

   private Producer> remoteCacheProducer;


   public InfinispanExtensionRemote() {
      new ConfigurationBuilder(); // Attempt to initialize a hotrod client class
      this.remoteCacheInjectionPoints = new HashMap>();
   }

   void processProducers(@Observes ProcessProducer event) {
      AnnotatedMember member = event.getAnnotatedMember();
      if (RemoteCacheProducer.class.equals(member.getDeclaringType().getBaseType())) {
         remoteCacheProducer = (Producer>) event.getProducer();
      }
   }

   // This is a work around for CDI Uber Jar deployment. When Weld scans the classpath it  pick up RemoteCacheManager
   // (this is an implementation, not an interface, so it gets instantiated). As a result we get duplicated classes
   // in CDI BeanManager.
   @SuppressWarnings("unused")
    void removeDuplicatedRemoteCacheManager(@Observes ProcessAnnotatedType bean) {
      if(RemoteCacheManager.class.getCanonicalName().equals(bean.getAnnotatedType().getJavaClass().getCanonicalName())) {
         logger.info("removing duplicated  RemoteCacheManager" + bean.getAnnotatedType());
         bean.veto();
      }
   }

    void saveRemoteInjectionPoints(@Observes ProcessInjectionTarget event, BeanManager beanManager) {
      final InjectionTarget injectionTarget = event.getInjectionTarget();

      for (InjectionPoint injectionPoint : injectionTarget.getInjectionPoints()) {
         final Annotated annotated = injectionPoint.getAnnotated();
         final Type type = annotated.getBaseType();
         final Class rawType = Reflections.getRawType(annotated.getBaseType());
         final Set qualifiers = Reflections.getQualifiers(beanManager, annotated.getAnnotations());

         if (rawType.equals(RemoteCache.class) && qualifiers.isEmpty()) {
            qualifiers.add(new AnnotationLiteral() {});
            addRemoteCacheInjectionPoint(type, qualifiers);

         } else if (!annotated.isAnnotationPresent(Remote.class)
               && Reflections.getMetaAnnotation(annotated, Remote.class) != null
               && rawType.isAssignableFrom(RemoteCache.class)) {

            addRemoteCacheInjectionPoint(type, qualifiers);
         }
      }
   }

   private void addRemoteCacheInjectionPoint(Type type, Set qualifiers) {
      final Set currentQualifiers = remoteCacheInjectionPoints.get(type);

      if (currentQualifiers == null) {
         remoteCacheInjectionPoints.put(type, qualifiers);
      } else {
         currentQualifiers.addAll(qualifiers);
      }
   }

   @SuppressWarnings("unchecked")
   void registerCacheBeans(@Observes AfterBeanDiscovery event, final BeanManager beanManager) {
      for (Map.Entry> entry : remoteCacheInjectionPoints.entrySet()) {

         event.addBean(new BeanBuilder(beanManager)
                             .readFromType(beanManager.createAnnotatedType(Reflections.getRawType(entry.getKey())))
                             .addType(entry.getKey())
                             .addQualifiers(entry.getValue())
                             .beanLifecycle(new ContextualLifecycle>() {
                                @Override
                                public RemoteCache create(Bean> bean, CreationalContext> ctx) {
                                   return remoteCacheProducer.produce(ctx);
                                }

                                @Override
                                public void destroy(Bean> bean, RemoteCache instance, CreationalContext> ctx) {
                                   remoteCacheProducer.dispose(instance);
                                }
                             }).create());
      }
   }
}