embulk 0.7.0-java

data/embulk-core/src/main/java/org/embulk/guice/CloseableInjector.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2015 Sadayuki Furuhashi
+ *
+ * Licensed 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.embulk.guice;
+
+import com.google.inject.Injector;
+
+public interface CloseableInjector
+        extends LifeCycleInjector, AutoCloseable
+{ }

data/embulk-core/src/main/java/org/embulk/guice/InjectorProxy.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2015 Sadayuki Furuhashi
+ *
+ * Licensed 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.embulk.guice;
+
+import com.google.inject.Binding;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.MembersInjector;
+import com.google.inject.Module;
+import com.google.inject.Provider;
+import com.google.inject.Scope;
+import com.google.inject.TypeLiteral;
+import com.google.inject.spi.TypeConverterBinding;
+
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+abstract class InjectorProxy
+        implements Injector
+{
+    protected abstract Injector injector();
+
+    @Override
+    public void injectMembers(Object instance)
+    {
+        injector().injectMembers(instance);
+    }
+
+    @Override
+    public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral)
+    {
+        return injector().getMembersInjector(typeLiteral);
+    }
+
+    @Override
+    public <T> MembersInjector<T> getMembersInjector(Class<T> type)
+    {
+        return injector().getMembersInjector(type);
+    }
+
+    @Override
+    public Map<Key<?>, Binding<?>> getBindings()
+    {
+        return injector().getBindings();
+    }
+
+    @Override
+    public Map<Key<?>, Binding<?>> getAllBindings()
+    {
+        return injector().getAllBindings();
+    }
+
+    @Override
+    public <T> Binding<T> getBinding(Key<T> key)
+    {
+        return injector().getBinding(key);
+    }
+
+    @Override
+    public <T> Binding<T> getBinding(Class<T> type)
+    {
+        return injector().getBinding(type);
+    }
+
+    @Override
+    public <T> Binding<T> getExistingBinding(Key<T> key)
+    {
+        return injector().getExistingBinding(key);
+    }
+
+    @Override
+    public <T> List<Binding<T>> findBindingsByType(TypeLiteral<T> type)
+    {
+        return injector().findBindingsByType(type);
+    }
+
+    @Override
+    public <T> Provider<T> getProvider(Key<T> key)
+    {
+        return injector().getProvider(key);
+    }
+
+    @Override
+    public <T> Provider<T> getProvider(Class<T> type)
+    {
+        return injector().getProvider(type);
+    }
+
+    @Override
+    public <T> T getInstance(Key<T> key)
+    {
+        return injector().getInstance(key);
+    }
+
+    @Override
+    public <T> T getInstance(Class<T> type)
+    {
+        return injector().getInstance(type);
+    }
+
+    @Override
+    public Injector getParent()
+    {
+        return injector().getParent();
+    }
+
+    @Override
+    public Injector createChildInjector(Iterable<? extends Module> modules)
+    {
+        return injector().createChildInjector(modules);
+    }
+
+    @Override
+    public Injector createChildInjector(Module... modules)
+    {
+        return injector().createChildInjector(modules);
+    }
+
+    @Override
+    public Map<Class<? extends Annotation>, Scope> getScopeBindings()
+    {
+        return injector().getScopeBindings();
+    }
+
+    @Override
+    public Set<TypeConverterBinding> getTypeConverterBindings()
+    {
+        return injector().getTypeConverterBindings();
+    }
+}

data/embulk-core/src/main/java/org/embulk/guice/LifeCycleInjector.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2015 Sadayuki Furuhashi
+ *
+ * Licensed 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.embulk.guice;
+
+import com.google.inject.Injector;
+
+public interface LifeCycleInjector
+        extends Injector
+{
+    boolean isDestroyed();
+
+    void destroy() throws Exception;
+}

data/embulk-core/src/main/java/org/embulk/guice/LifeCycleInjectorProxy.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2015 Sadayuki Furuhashi
+ *
+ * Licensed 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.embulk.guice;
+
+import com.google.inject.Injector;
+
+class LifeCycleInjectorProxy
+        extends InjectorProxy
+        implements LifeCycleInjector, CloseableInjector
+{
+    private final Injector injector;
+    private final LifeCycleManager lifeCycleManager;
+
+    public LifeCycleInjectorProxy(Injector injector, LifeCycleManager lifeCycleManager)
+    {
+        this.injector = injector;
+        this.lifeCycleManager = lifeCycleManager;
+    }
+
+    @Override
+    protected synchronized Injector injector()
+    {
+        if (isDestroyed()) {
+            throw new IllegalStateException("Injector already destroyed");
+        }
+        return injector;
+    }
+
+    @Override
+    public synchronized boolean isDestroyed()
+    {
+        return lifeCycleManager.isDestroyed();
+    }
+
+    @Override
+    public synchronized void destroy()
+            throws Exception
+    {
+        lifeCycleManager.destroy();  // reentrant
+    }
+
+    @Override
+    public void close()
+            throws Exception
+    {
+        destroy();
+    }
+}

data/embulk-core/src/main/java/org/embulk/guice/LifeCycleManager.java

@@ -0,0 +1,187 @@
+/*
+ * Copyright 2010 Proofpoint, Inc.
+ *
+ * Licensed 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.
+ */
+/*
+ * Copyright 2015 Sadayuki Furuhashi
+ */
+package org.embulk.guice;
+
+import com.google.common.collect.Lists;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Manages PostConstruct and PreDestroy life cycles
+ */
+public final class LifeCycleManager
+{
+    private final AtomicReference<State> state = new AtomicReference<State>(State.LATENT);
+    private final Queue<Object> managedInstances = new ConcurrentLinkedQueue<Object>();
+    private final LifeCycleMethodsMap methodsMap;
+
+    private enum State
+    {
+        LATENT,
+        STARTING,
+        STARTED,
+        STOPPING,
+        STOPPED
+    }
+
+    /**
+     * @param managedInstances list of objects that have life cycle annotations
+     * @param methodsMap existing or new methods map
+     * @throws Exception exceptions starting instances (depending on mode)
+     */
+    public LifeCycleManager(List<Object> managedInstances, LifeCycleMethodsMap methodsMap)
+            throws Exception
+    {
+        this.methodsMap = (methodsMap != null) ? methodsMap : new LifeCycleMethodsMap();
+        for (Object instance : managedInstances) {
+            addInstance(instance);
+        }
+    }
+
+    /**
+     * Returns the number of managed instances
+     *
+     * @return qty
+     */
+    public int size()
+    {
+        return managedInstances.size();
+    }
+
+    /**
+     * Start the life cycle - all instances will have their {@link javax.annotation.PostConstruct} method(s) called
+     */
+    public void start()
+    {
+        if (!state.compareAndSet(State.LATENT, State.STARTING)) {
+            throw new IllegalStateException("System already starting");
+        }
+        //log.info("Life cycle starting...");
+
+        for (Object obj : managedInstances) {
+            LifeCycleMethods methods = methodsMap.get(obj.getClass());
+            if (!methods.hasFor(PreDestroy.class)) {
+                managedInstances.remove(obj);   // remove reference to instances that aren't needed anymore
+            }
+        }
+
+        state.set(State.STARTED);
+        //log.info("Life cycle startup complete. System ready.");
+    }
+
+    /**
+     * Add a shutdown hook that calls {@link destroy} method
+     */
+    public void destroyOnShutdownHook()
+    {
+        Runtime.getRuntime().addShutdownHook(new Thread()
+        {
+            @Override
+            public void run()
+            {
+                try {
+                    LifeCycleManager.this.destroy();
+                }
+                catch (Exception e) {
+                    //log.error(e, "Trying to shut down");
+                }
+            }
+        });
+    }
+
+    /**
+     * Stop the life cycle - all instances will have their {@link javax.annotation.PreDestroy} method(s) called
+     *
+     * @throws Exception errors
+     */
+    public void destroy()
+            throws Exception
+    {
+        if (!state.compareAndSet(State.STARTED, State.STOPPING)) {
+            return;
+        }
+
+        //log.info("Life cycle stopping...");
+
+        List<Object> reversedInstances = Lists.newArrayList(managedInstances);
+        Collections.reverse(reversedInstances);
+
+        for (Object obj : reversedInstances) {
+            //log.debug("Stopping %s", obj.getClass().getName());
+            LifeCycleMethods methods = methodsMap.get(obj.getClass());
+            for (Method preDestroy : methods.methodsFor(PreDestroy.class)) {
+                //log.debug("\t%s()", preDestroy.getName());
+                preDestroy.invoke(obj);
+            }
+        }
+
+        state.set(State.STOPPED);
+        //log.info("Life cycle stopped.");
+    }
+
+    /**
+     * Return true if {@link destroy} is called
+     *
+     * @return true if already destroyed
+     */
+    public boolean isDestroyed()
+    {
+        State currentState = state.get();
+        return currentState == State.STOPPING || currentState == State.STOPPED;
+    }
+
+    /**
+     * Add an additional managed instance
+     *
+     * @param instance instance to add
+     * @throws Exception errors
+     */
+    public void addInstance(Object instance)
+            throws Exception
+    {
+        if (isDestroyed()) {
+            throw new IllegalStateException("System already stopped");
+        }
+        else {
+            startInstance(instance);
+            if (methodsMap.get(instance.getClass()).hasFor(PreDestroy.class)) {
+                managedInstances.add(instance);
+            }
+        }
+    }
+
+    private void startInstance(Object obj)
+            throws IllegalAccessException, InvocationTargetException
+    {
+        //log.debug("Starting %s", obj.getClass().getName());
+        LifeCycleMethods methods = methodsMap.get(obj.getClass());
+        for (Method postConstruct : methods.methodsFor(PostConstruct.class)) {
+            //log.debug("\t%s()", postConstruct.getName());
+            postConstruct.invoke(obj);
+        }
+    }
+}

data/embulk-core/src/main/java/org/embulk/guice/LifeCycleMethods.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2010 Proofpoint, Inc.
+ *
+ * Licensed 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.
+ */
+/*
+ * Copyright 2015 Sadayuki Furuhashi
+ */
+package org.embulk.guice;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+class LifeCycleMethods
+{
+    private final Multimap<Class<? extends Annotation>, Method> methodMap = ArrayListMultimap.create();
+
+    LifeCycleMethods(Class<?> clazz)
+    {
+        addLifeCycleMethods(clazz, new HashSet<String>(), new HashSet<String>());
+    }
+
+    boolean hasFor(Class<? extends Annotation> annotation)
+    {
+        Collection<Method> methods = methodMap.get(annotation);
+        return (methods != null) && (methods.size() > 0);
+    }
+
+    Collection<Method> methodsFor(Class<? extends Annotation> annotation)
+    {
+        Collection<Method> methods = methodMap.get(annotation);
+        return (methods != null) ? methods : Lists.<Method>newArrayList();
+    }
+
+    private void addLifeCycleMethods(Class<?> clazz, Set<String> usedConstructNames, Set<String> usedDestroyNames)
+    {
+        if (clazz == null) {
+            return;
+        }
+
+        for (Method method : clazz.getDeclaredMethods()) {
+            if (method.isSynthetic() || method.isBridge()) {
+                continue;
+            }
+
+            processMethod(method, PostConstruct.class, usedConstructNames);
+            processMethod(method, PreDestroy.class, usedDestroyNames);
+        }
+
+        addLifeCycleMethods(clazz.getSuperclass(), usedConstructNames, usedDestroyNames);
+        for (Class<?> face : clazz.getInterfaces()) {
+            addLifeCycleMethods(face, usedConstructNames, usedDestroyNames);
+        }
+    }
+
+    private void processMethod(Method method, Class<? extends Annotation> annotationClass, Set<String> usedSet)
+    {
+        if (method.isAnnotationPresent(annotationClass)) {
+            if (!usedSet.contains(method.getName())) {
+                if (method.getParameterTypes().length != 0) {
+                    throw new UnsupportedOperationException(String.format("@PostConstruct/@PreDestroy methods cannot have arguments: %s", method.getDeclaringClass().getName() + "." + method.getName() + "(...)"));
+                }
+
+                method.setAccessible(true);
+                usedSet.add(method.getName());
+                methodMap.put(annotationClass, method);
+            }
+        }
+    }
+}