/**
* Enforce mutual exclusivity and implicit activation of profiles as described in {@link
* SaganProfiles}.
*/
@Override
protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
super.configureProfiles(environment, args);
boolean stagingActive = environment.acceptsProfiles(STAGING);
boolean productionActive = environment.acceptsProfiles(PRODUCTION);
if (stagingActive && productionActive) {
throw new IllegalStateException(
format(
"Only one of the following profiles may be specified: [%s]",
arrayToCommaDelimitedString(new String[] {STAGING, PRODUCTION})));
}
if (stagingActive || productionActive) {
logger.info(
format(
"Activating '%s' profile because one of '%s' or '%s' profiles have been specified.",
CLOUDFOUNDRY, STAGING, PRODUCTION));
environment.addActiveProfile(CLOUDFOUNDRY);
} else {
logger.info(
"The default 'standalone' profile is active because no other profiles have been specified.");
environment.addActiveProfile(STANDALONE);
}
}
private void applySpringProfiles(
ConfigurableEnvironment environment, ServletContext servletContext) {
if (environment.containsProperty("spring_profiles")) {
String profiles = environment.getProperty("spring_profiles");
servletContext.log("Setting active profiles: " + profiles);
environment.setActiveProfiles(StringUtils.commaDelimitedListToStringArray(profiles));
}
}
private void reorderSources(ConfigurableEnvironment environment) {
ConfigurationPropertySources.finishAndRelocate(environment.getPropertySources());
PropertySource<?> defaultProperties =
environment.getPropertySources().remove(DEFAULT_PROPERTIES);
if (defaultProperties != null) {
environment.getPropertySources().addLast(defaultProperties);
}
}
private void prependProfile(ConfigurableEnvironment environment, String profile) {
Set<String> profiles = new LinkedHashSet<String>();
environment.getActiveProfiles(); // ensure they are initialized
// But this one should go first (last wins in a property key clash)
profiles.add(profile);
profiles.addAll(Arrays.asList(environment.getActiveProfiles()));
environment.setActiveProfiles(profiles.toArray(new String[profiles.size()]));
}
private String getApplicationId(ConfigurableEnvironment environment) {
String name = environment.resolvePlaceholders(this.name);
String index = environment.resolvePlaceholders(INDEX_PATTERN);
String profiles = StringUtils.arrayToCommaDelimitedString(environment.getActiveProfiles());
if (StringUtils.hasText(profiles)) {
name = name + ":" + profiles;
}
if (!"null".equals(index)) {
name = name + ":" + index;
}
return name;
}
/**
* Add config file property sources to the specified environment.
*
* @param environment the environment to add source to
* @see #addPostProcessors(ConfigurableApplicationContext)
*/
protected void addPropertySources(
ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
RandomValuePropertySource.addToEnvironment(environment);
try {
PropertySource<?> defaultProperties =
environment.getPropertySources().remove(DEFAULT_PROPERTIES);
new Loader(environment, resourceLoader).load();
if (defaultProperties != null) {
environment.getPropertySources().addLast(defaultProperties);
}
} catch (IOException ex) {
throw new IllegalStateException("Unable to load configuration files", ex);
}
}
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
String conf = "spring.xml";
AbstractApplicationContext context = new ClassPathXmlApplicationContext(conf);
ConfigurableEnvironment configurableEnvironment = new StandardEnvironment();
boolean testMode = false;
if (args != null && args.length > 0) {
if ("-test".equals(args[0])) {
configurableEnvironment.setActiveProfiles("TEST");
testMode = true;
} else {
configurableEnvironment.setActiveProfiles("PROD");
}
} else {
configurableEnvironment.setActiveProfiles("PROD");
}
context.setEnvironment(configurableEnvironment);
PropertyConfigurator.configure("resources/log4j.properties");
logger.info("Starting launcher...");
int iteration = 0;
Launcher launcher = context.getBean("launcher", Launcher.class);
while (true) {
iteration++;
logger.info("Iteration #" + iteration + " at " + new Date());
logger.info(" Launching zezo automatic routing...");
launcher.runZezoAutoRouting(testMode);
/*
* logger.info(" Launching waypoints..."); launcher.runWaypoints();
*
* logger.info(" Launching speed regulation...");
* launcher.speedRegulation();
*/
Date nextIteration = getNextIteration();
long msToSleep = getSecondRemainingBefore(nextIteration);
logger.info("Waiting for next iteration at " + nextIteration + "\n\n\n");
Thread.sleep(msToSleep);
}
}
/** @param containerAttributes */
private void setConfiguredContainerAttributes(ContainerAttributes containerAttributes) {
Map<String, String> attributes = new HashMap<String, String>();
for (PropertySource<?> propertySource : environment.getPropertySources()) {
if (propertySource instanceof EnumerablePropertySource) {
EnumerablePropertySource<?> ps = (EnumerablePropertySource<?>) propertySource;
for (String key : ps.getPropertyNames()) {
if (key.startsWith(CONTAINER_ATTRIBUTES_PREFIX)) {
String attributeKey = key.replaceAll(CONTAINER_ATTRIBUTES_PREFIX, "");
attributes.put(attributeKey, environment.getProperty(key));
}
}
}
}
containerAttributes.putAll(attributes);
}
protected static void mess() {
// System.setProperty("spring.profiles.active","foo");
// ConfigurableApplicationContext ctx =
// new
// ClassPathXmlApplicationContext("classpath:/com/rooney/spring/spel/Spel-context.xml");
// can we add appcontext.xml to a genericAppCtx and then add property sources, when call
// refresh?
ConfigurableApplicationContext ctx = new GenericApplicationContext();
ConfigurableEnvironment environment = ctx.getEnvironment();
MutablePropertySources sources = environment.getPropertySources();
sources.addFirst(new MyPropertySource());
System.out.println(ctx.getBean("stringBean"));
}
@Override
public void postProcessEnvironment(
ConfigurableEnvironment environment, SpringApplication application) {
String json =
environment.resolvePlaceholders("${spring.application.json:${SPRING_APPLICATION_JSON:}}");
if (StringUtils.hasText(json)) {
processJson(environment, json);
}
}
protected static void configureInfoProperties(ConfigurableEnvironment env) {
SystemInformation systemInformation = new SystemInformation();
Map<String, Object> infoMap = new HashMap<>();
infoMap.put("info.fileTimestamp", systemInformation.getDeploymentDateAsString());
infoMap.put("info.hostname", systemInformation.getHostname());
env.getPropertySources().addFirst(new MapPropertySource("INFO_MAP", infoMap));
}
@Bean
public ContainerAttributes containerAttributes() {
final ContainerAttributes containerAttributes = new ContainerAttributes();
setConfiguredContainerAttributes(containerAttributes);
final String containerIp =
environment.getProperty(CONTAINER_ATTRIBUTES_PREFIX + ContainerAttributes.IP_ADDRESS_KEY);
final String containerHostname =
environment.getProperty(CONTAINER_ATTRIBUTES_PREFIX + ContainerAttributes.HOST_KEY);
containerAttributes.setIp(
StringUtils.hasText(containerIp) ? containerIp : RuntimeUtils.getIpAddress());
containerAttributes.setHost(
StringUtils.hasText(containerHostname) ? containerHostname : RuntimeUtils.getHost());
containerAttributes.setPid(RuntimeUtils.getPid());
return containerAttributes;
}
private void addJsonPropertySource(
ConfigurableEnvironment environment, PropertySource<?> source) {
MutablePropertySources sources = environment.getPropertySources();
String name = findPropertySource(sources);
if (sources.contains(name)) {
sources.addBefore(name, source);
} else {
sources.addFirst(source);
}
}
private void applyLog4jConfiguration(
ConfigurableEnvironment environment, ServletContext servletContext) {
String log4jConfigLocation = "classpath:log4j.properties";
if (environment.containsProperty("logging.file")) {
String location = environment.getProperty("logging.file");
servletContext.log("Setting LOG_FILE: " + location);
System.setProperty("LOG_FILE", location);
} else if (environment.containsProperty("logging.path")) {
String location = environment.getProperty("logging.path");
servletContext.log("Setting LOG_PATH: " + location);
System.setProperty("LOG_PATH", location);
} else if (environment.containsProperty("logging.config")) {
log4jConfigLocation = environment.getProperty("logging.config");
}
try {
servletContext.log("Loading log4j config from location: " + log4jConfigLocation);
Log4jConfigurer.initLogging(log4jConfigLocation);
} catch (FileNotFoundException e) {
servletContext.log("Error loading log4j config from location: " + log4jConfigLocation, e);
}
MDC.put("context", servletContext.getContextPath());
}
@Override
public void postProcessEnvironment(
ConfigurableEnvironment environment, SpringApplication application) {
if (CloudPlatform.CLOUD_FOUNDRY.isActive(environment)) {
Properties properties = new Properties();
addWithPrefix(properties, getPropertiesFromApplication(environment), "vcap.application.");
addWithPrefix(properties, getPropertiesFromServices(environment), "vcap.services.");
MutablePropertySources propertySources = environment.getPropertySources();
if (propertySources.contains(CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME)) {
propertySources.addAfter(
CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME,
new PropertiesPropertySource("vcap", properties));
} else {
propertySources.addFirst(new PropertiesPropertySource("vcap", properties));
}
}
}
@SuppressWarnings("unchecked")
private List<ApplicationListener<ApplicationEvent>> getListeners(ConfigurableEnvironment env) {
String classNames = env.getProperty(PROPERTY_NAME);
List<ApplicationListener<ApplicationEvent>> listeners =
new ArrayList<ApplicationListener<ApplicationEvent>>();
if (StringUtils.hasLength(classNames)) {
for (String className : StringUtils.commaDelimitedListToSet(classNames)) {
try {
Class<?> clazz = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());
Assert.isAssignable(
ApplicationListener.class,
clazz,
"class [" + className + "] must implement ApplicationListener");
listeners.add((ApplicationListener<ApplicationEvent>) BeanUtils.instantiateClass(clazz));
} catch (Exception ex) {
throw new ApplicationContextException(
"Failed to load context listener class [" + className + "]", ex);
}
}
}
AnnotationAwareOrderComparator.sort(listeners);
return listeners;
}
/**
* Bind the environment to the {@link SpringApplication}.
*
* @param environment the environment to bind
* @param application the application to bind to
*/
protected void bindToSpringApplication(
ConfigurableEnvironment environment, SpringApplication application) {
RelaxedDataBinder binder = new RelaxedDataBinder(application, "spring.main");
binder.setConversionService(this.conversionService);
binder.bind(new PropertySourcesPropertyValues(environment.getPropertySources()));
}
@Test
public void noBootstrapProperties() {
assertFalse(environment.getPropertySources().contains("bootstrap"));
}
@Override
public void postProcessEnvironment(
ConfigurableEnvironment environment, SpringApplication application) {
assertThat(environment.getPropertySources().size(), is(equalTo(4)));
}
@Override
public void initialize(ConfigurableWebApplicationContext ctx) {
ConfigurableEnvironment environment = ctx.getEnvironment();
environment.setActiveProfiles("prod");
}
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
ConfigurableEnvironment environment = applicationContext.getEnvironment();
environment.setActiveProfiles("alarms-" + environment.getProperty("httpd.alarms.db.type"));
}