/*
* Copyright 2013-2014 the original author or authors.
*
* 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.springframework.xd.module.core;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration;
import org.springframework.boot.builder.ParentContextCloserApplicationListener;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.ContextIdApplicationContextInitializer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.Ordered;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.EnumerablePropertySource;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.validation.BindException;
import org.springframework.xd.module.ModuleDefinition;
import org.springframework.xd.module.ModuleDeploymentProperties;
import org.springframework.xd.module.ModuleDescriptor;
import org.springframework.xd.module.SimpleModuleDefinition;
import org.springframework.xd.module.options.ModuleOptions;
import org.springframework.xd.module.options.PassthruModuleOptionsMetadata;
/**
* A {@link Module} implementation backed by a Spring {@link ApplicationContext}.
*
* @author Mark Fisher
* @author David Turanski
* @author Gary Russell
* @author Dave Syer
* @author Ilayaperumal Gopinathan
* @author Eric Bottard
*/
public abstract class SimpleModule extends AbstractModule {
private final Log logger = LogFactory.getLog(this.getClass());
private ConfigurableApplicationContext context;
private final SpringApplicationBuilder application;
private final AtomicInteger propertiesCounter = new AtomicInteger();
private final Properties properties = new Properties();
private final MutablePropertySources propertySources = new MutablePropertySources();
private ConfigurableApplicationContext parent;
private final List<ApplicationListener<?>> listeners = new ArrayList<ApplicationListener<?>>();
private ModuleOptions moduleOptions;
private final ClassLoader classLoader;
public SimpleModule(ModuleDescriptor descriptor, ModuleDeploymentProperties deploymentProperties) {
this(descriptor, deploymentProperties, null, defaultModuleOptions());
}
public SimpleModule(ModuleDescriptor descriptor, ModuleDeploymentProperties deploymentProperties,
ClassLoader classLoader,
ModuleOptions moduleOptions) {
super(descriptor, deploymentProperties);
this.moduleOptions = moduleOptions;
application = new SpringApplicationBuilder().sources(PropertyPlaceholderAutoConfiguration.class)
.web(false).showBanner(false);
this.classLoader = classLoader;
if (classLoader != null) {
application.resourceLoader(new PathMatchingResourcePatternResolver(classLoader));
}
// Also add options as properties for now, b/c other parts of the system
// (eg type conversion plugin) expects it
this.properties.putAll(moduleOptionsToProperties(moduleOptions));
application.profiles(moduleOptions.profilesToActivate());
this.configureModuleApplicationContext((SimpleModuleDefinition) this.getDescriptor().getModuleDefinition());
}
/**
* Subclasses implement this method to configure the application context from sources contained in the
* {@link org.springframework.xd.module.ModuleDefinition}
*/
protected abstract void configureModuleApplicationContext(SimpleModuleDefinition moduleDefinition);
private Map<Object, Object> moduleOptionsToProperties(ModuleOptions moduleOptions) {
Map<Object, Object> result = new HashMap<Object, Object>();
EnumerablePropertySource<?> ps = moduleOptions.asPropertySource();
for (String propname : ps.getPropertyNames()) {
Object value = ps.getProperty(propname);
if (value != null) {
result.put(propname, value.toString());
}
}
return result;
}
@Override
public void setParentContext(ApplicationContext parent) {
this.parent = (ConfigurableApplicationContext) parent;
}
@Override
public void addSource(Object source) {
application.sources(source);
}
@Override
public void addProperties(Properties properties) {
this.registerPropertySource(properties);
this.properties.putAll(properties);
}
@Override
public void addListener(ApplicationListener<?> listener) {
this.listeners.add(listener);
}
@Override
public Properties getProperties() {
return this.properties;
}
public ConfigurableApplicationContext getApplicationContext() {
return this.context;
}
@Override
public <T> T getComponent(Class<T> requiredType) {
return (this.context.isActive()) ? this.context.getBean(requiredType) : null;
}
public ClassLoader getClassLoader() {
return classLoader;
}
@Override
public <T> T getComponent(String componentName, Class<T> requiredType) {
if (this.context.isActive() && this.context.containsBean(componentName)) {
return context.getBean(componentName, requiredType);
}
return null;
}
private void registerPropertySource(Properties properties) {
int propertiesIndex = this.propertiesCounter.getAndIncrement();
String propertySourceName = "properties-" + propertiesIndex;
PropertySource<?> propertySource = new PropertiesPropertySource(propertySourceName, properties);
this.propertySources.addLast(propertySource);
}
/**
* Initialize this module by creating its application context, and provide it with a special
* {@link org.springframework.core.env.Environment} that knows how to resolve module options placeholders.
*/
@Override
public void initialize() {
this.application.initializers(new ContextIdApplicationContextInitializer(this.toString()));
ConfigurableEnvironment parentEnvironment = parent == null ? null
: parent.getEnvironment();
ModuleEnvironment environment = new ModuleEnvironment(moduleOptions.asPropertySource(), parentEnvironment);
for (PropertySource<?> source : propertySources) {
environment.getPropertySources().addFirst(source);
}
this.application.parent(parent);
this.application.environment(environment);
if (this.listeners.size() > 0) {
application.listeners(this.listeners.toArray(new ApplicationListener<?>[this.listeners.size()]));
}
this.application.listeners(new ModuleParentContextCloserApplicationListener(getDescriptor().getIndex()));
if (this.classLoader != null) {
final ClassLoader defaultClassLoader = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(this.classLoader);
this.context = this.application.run();
}
finally {
Thread.currentThread().setContextClassLoader(defaultClassLoader);
}
}
else {
this.context = this.application.run();
}
if (logger.isInfoEnabled()) {
logger.info("initialized module: " + this.toString());
}
}
@Override
public void start() {
try {
context.start();
}
catch (BeansException be) {
// Make sure the context is destroyed; this will allow possible destruction of life-cycle beans registered
// (example: MBeans)
destroy();
throw be;
}
}
@Override
public void stop() {
if (context.isActive()) {
context.stop(); // Shouldn't need to close() as well?
}
}
@Override
public boolean isRunning() {
return context.isRunning();
}
@Override
public void destroy() {
if (context instanceof DisposableBean) {
try {
((DisposableBean) context).destroy();
}
catch (RuntimeException e) {
throw e;
}
catch (Exception e) {
throw new IllegalStateException(e);
}
}
}
private static ModuleOptions defaultModuleOptions() {
try {
return new PassthruModuleOptionsMetadata().interpolate(Collections.<String, String> emptyMap());
}
catch (BindException e) {
throw new IllegalStateException(e);
}
}
/**
* Dedicated sublcass of {@link ParentContextCloserApplicationListener} used to create its own version of
* ContextCloserListener that is aware of module order. Special care is taken so that no strong references to the
* module context are retained (this is a *static* inner class).
*
* @author Eric Bottard
*/
private static final class ModuleParentContextCloserApplicationListener extends
ParentContextCloserApplicationListener {
private final int index;
public ModuleParentContextCloserApplicationListener(int index) {
this.index = index;
}
@Override
protected ContextCloserListener createContextCloserListener(ConfigurableApplicationContext child) {
return new ModuleContextCloserListener(child, index);
}
/**
* Module context closer listener that sets the order based on the module deployment index.
*/
final static class ModuleContextCloserListener extends ContextCloserListener implements Ordered {
private int index;
public ModuleContextCloserListener(ConfigurableApplicationContext moduleContext, int index) {
super(moduleContext);
this.index = index;
}
@Override
public int getOrder() {
// Make sure producer modules get closed before the consumer modules (sink/processor)
// by setting them the highest precedence. Smaller values come first.
return index;
}
}
}
}