org.infinispan.cdi.embedded.DelegatingDistributedTaskLifecycle Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of infinispan-embedded
Infinispan Embedded All-in-One module
There is a newer version: 9.1.7.Final
package org.infinispan.cdi.embedded;

import java.util.Collection;
import java.util.concurrent.Callable;

import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.InjectionTarget;

import org.infinispan.Cache;
import org.infinispan.cdi.common.util.CDIHelper;
import org.infinispan.distexec.RunnableAdapter;
import org.infinispan.distexec.spi.DistributedTaskLifecycle;

public class DelegatingDistributedTaskLifecycle implements DistributedTaskLifecycle {
   private final DistributedTaskLifecycle delegate;

   public DelegatingDistributedTaskLifecycle() {
      delegate = CDIHelper.isCDIAvailable() ? new CDIDistributedTaskLifecycle() : new NoCDIDistributedTaskLifecycle();
   }

   @Override
   public  void onPreExecute(Callable task, Cache inputDataCache, Collection inputKeys) {
      delegate.onPreExecute(task, inputDataCache, inputKeys);
   }

   @Override
   public  void onPostExecute(Callable task) {
      delegate.onPostExecute(task);
   }

   static class NoCDIDistributedTaskLifecycle implements DistributedTaskLifecycle {

      @Override
      public  void onPreExecute(Callable task, Cache inputDataCache, Collection inputKeys) {
      }

      @Override
      public  void onPostExecute(Callable task) {
      }
   }

   static class CDIDistributedTaskLifecycle implements DistributedTaskLifecycle {

      @Override
      public  void onPreExecute(Callable task, Cache inputDataCache, Collection inputKeys) {
         BeanManager bm = CDIHelper.getBeanManager();
         if (bm == null)
            return;
         ContextInputCache.set(inputDataCache);
         ContextInputCache.setKeys(inputKeys);
         preInject(bm, task);
         if (task instanceof RunnableAdapter) {
            preInject(bm, ((RunnableAdapter) task).getTask());
         }
      }

      @Override
      public  void onPostExecute(Callable task) {
         try {
            BeanManager bm = CDIHelper.getBeanManager();
            if (bm == null)
               return;
            postInject(bm, task);
            if (task instanceof RunnableAdapter) {
               postInject(bm, ((RunnableAdapter) task).getTask());
            }
         } finally {
            ContextInputCache.clean();
         }
      }

      private  void preInject(BeanManager bm, T task) {
         Class clazz = (Class) task.getClass();
         AnnotatedType type = bm.createAnnotatedType(clazz);
         InjectionTarget it = bm.createInjectionTarget(type);
         CreationalContext ctx = bm.createCreationalContext(null);
         it.inject(task, ctx);
         it.postConstruct(task);
      }

      private  void postInject(BeanManager bm, T task) {
         Class clazz = (Class) task.getClass();
         AnnotatedType type = bm.createAnnotatedType(clazz);
         InjectionTarget it = bm.createInjectionTarget(type);
         it.preDestroy(task);
         it.dispose(task);
      }
   }
}