embulk 0.7.11-java → 0.8.0-java

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

@@ -1,26 +0,0 @@
-/*
- * 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

@@ -1,61 +0,0 @@
-/*
- * 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

@@ -1,187 +0,0 @@
-/*
- * 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

@@ -1,89 +0,0 @@
-/*
- * 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);
-            }
-        }
-    }
-}

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

@@ -1,38 +0,0 @@
-/*
- * 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.Maps;
-
-import java.util.Map;
-
-class LifeCycleMethodsMap
-{
-    private final Map<Class<?>, LifeCycleMethods> map = Maps.newHashMap();
-
-    synchronized LifeCycleMethods get(Class<?> clazz)
-    {
-        LifeCycleMethods methods = map.get(clazz);
-        if (methods == null) {
-            methods = new LifeCycleMethods(clazz);
-            map.put(clazz, methods);
-        }
-        return methods;
-    }
-}

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

@@ -1,97 +0,0 @@
-/*
- * 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 com.google.inject.Binder;
-import com.google.inject.Module;
-import com.google.inject.Provides;
-import com.google.inject.Singleton;
-import com.google.inject.TypeLiteral;
-import com.google.inject.spi.InjectionListener;
-import com.google.inject.spi.TypeEncounter;
-import com.google.inject.spi.TypeListener;
-
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static com.google.inject.matcher.Matchers.any;
-
-/**
- * Guice module for binding the LifeCycle manager
- */
-public class LifeCycleModule implements Module
-{
-    private final List<Object> injectedInstances = Lists.newArrayList();
-    private final LifeCycleMethodsMap lifeCycleMethodsMap = new LifeCycleMethodsMap();
-    private final AtomicReference<LifeCycleManager> lifeCycleManagerRef = new AtomicReference<LifeCycleManager>(null);
-
-    @Override
-    public void configure(Binder binder)
-    {
-        binder.disableCircularProxies();
-
-        binder.bindListener(any(), new TypeListener()
-        {
-            @Override
-            public <T> void hear(TypeLiteral<T> type, TypeEncounter<T> encounter)
-            {
-                encounter.register(new InjectionListener<T>()
-                {
-                    @Override
-                    public void afterInjection(T obj)
-                    {
-                        if (isLifeCycleClass(obj.getClass())) {
-                            LifeCycleManager lifeCycleManager = lifeCycleManagerRef.get();
-                            if (lifeCycleManager != null) {
-                                try {
-                                    lifeCycleManager.addInstance(obj);
-                                }
-                                catch (Exception e) {
-                                    throw new Error(e);
-                                }
-                            }
-                            else {
-                                injectedInstances.add(obj);
-                            }
-                        }
-                    }
-                });
-            }
-        });
-    }
-
-    @Provides
-    @Singleton
-    public LifeCycleManager getServerManager()
-            throws Exception
-    {
-        LifeCycleManager lifeCycleManager = new LifeCycleManager(injectedInstances, lifeCycleMethodsMap);
-        lifeCycleManagerRef.set(lifeCycleManager);
-        return lifeCycleManager;
-    }
-
-    private boolean isLifeCycleClass(Class<?> clazz)
-    {
-        LifeCycleMethods methods = lifeCycleMethodsMap.get(clazz);
-        return methods.hasFor(PostConstruct.class) || methods.hasFor(PreDestroy.class);
-    }
-}