org.jclouds.lifecycle.config.LifeCycleModule Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jclouds-core Show documentation
Core components to access jclouds services
The newest version!
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jclouds.lifecycle.config;

import static com.google.common.base.Throwables.propagate;
import static com.google.common.collect.Iterables.filter;
import static com.google.common.util.concurrent.MoreExecutors.sameThreadExecutor;
import static com.google.inject.matcher.Matchers.any;
import static org.jclouds.Constants.PROPERTY_IO_WORKER_THREADS;
import static org.jclouds.Constants.PROPERTY_SCHEDULER_THREADS;
import static org.jclouds.Constants.PROPERTY_USER_THREADS;
import static org.jclouds.reflect.Reflection2.methods;

import java.io.Closeable;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Collection;
import java.util.concurrent.ScheduledExecutorService;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Named;

import org.jclouds.lifecycle.Closer;

import com.google.common.base.Predicate;
import com.google.common.reflect.Invokable;
import com.google.common.util.concurrent.ExecutionList;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.inject.AbstractModule;
import com.google.inject.Inject;
import com.google.inject.TypeLiteral;
import com.google.inject.spi.InjectionListener;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;

/**
 * This associates java lifecycle annotations with guice hooks. For example, we invoke {@link PostConstruct} after
 * injection, and Associate {@link PreDestroy} with a global {@link Closer} object.
 * 
 * Important Make sure you create your injector with {@link Stage#PRODUCTION} and execute the bound
 * {@link ExecutionList} prior to using any other objects.
 * 
 * 
 * Ex.
 * 
 * 
 * 
 * 
 * 
 * @author Adrian Cole
 */
public class LifeCycleModule extends AbstractModule {

   protected void configure() {

      Closeable executorCloser = new Closeable() {
         @Inject
         @Named(PROPERTY_USER_THREADS)
         ListeningExecutorService userExecutor;
         @Inject
         @Named(PROPERTY_IO_WORKER_THREADS)
         ListeningExecutorService ioExecutor;
         // ScheduledExecutor is defined in an optional module
         @Inject(optional = true)
         @Named(PROPERTY_SCHEDULER_THREADS)
         ScheduledExecutorService scheduledExecutor;

         public void close() throws IOException {
            assert userExecutor != null;
            userExecutor.shutdownNow();
            assert ioExecutor != null;
            ioExecutor.shutdownNow();
            // ScheduledExecutor is defined in an optional module
            if (scheduledExecutor != null)
               scheduledExecutor.shutdownNow();
         }
      };

      binder().requestInjection(executorCloser);
      Closer closer = new Closer();
      closer.addToClose(executorCloser);
      bind(Closer.class).toInstance(closer);

      ExecutionList list = new ExecutionList();
      bindPostInjectionInvoke(closer, list);
      bind(ExecutionList.class).toInstance(list);
   }

   private static final Predicate> isPreDestroy = new Predicate>() {
      public boolean apply(Invokable in) {
         return in.isAnnotationPresent(PreDestroy.class);
      }
   };

   private static final Predicate> isPostConstruct = new Predicate>() {
      public boolean apply(Invokable in) {
         return in.isAnnotationPresent(PostConstruct.class);
      }
   };

   protected void bindPostInjectionInvoke(final Closer closer, final ExecutionList list) {
      bindListener(any(), new TypeListener() {
         public  void hear(TypeLiteral injectableType, TypeEncounter encounter) {
            Collection> methods = methods(injectableType.getRawType());
            for (final Invokable method : filter(methods, isPostConstruct)) {
               encounter.register(new InjectionListener() {
                  public void afterInjection(final I injectee) {
                     list.add(new Runnable() {
                        public void run() {
                           invokeOnInjectee(method, injectee);
                        }

                     }, sameThreadExecutor());
                  }
               });
            }
            for (final Invokable method : filter(methods, isPreDestroy)) {
               encounter.register(new InjectionListener() {
                  public void afterInjection(final I injectee) {
                     closer.addToClose(new Closeable() {
                        public void close() throws IOException {
                           invokeOnInjectee(method, injectee);
                        }
                     });
                  }
               });
            }
         }

      });
   }

   private static  void invokeOnInjectee(Invokable method, I injectee) {
      try {
         method.invoke(injectee);
      } catch (InvocationTargetException ie) {
         throw propagate(ie.getTargetException());
      } catch (IllegalAccessException e) {
         throw propagate(e);
      }
   }
}