/*
* Copyright 2011-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.integration.util;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
import java.sql.Driver;
import java.util.Properties;
import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import com.mongodb.MongoClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.jdbc.datasource.SimpleDriverDataSource;
import org.springframework.util.ClassUtils;
/**
* Extracts the host and port information for the XD Instances.
* Assumes that the host that runs the RabbitMQ broker is the same host that runs the admin server.
*
* @author Glenn Renfro
*/
public class XdEnvironment implements BeanClassLoaderAware {
private static final Logger LOGGER = LoggerFactory.getLogger(XdEnvironment.class);
private volatile ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
// Environment Keys
public static final String XD_ADMIN_HOST = "xd_admin_host";
public static final String XD_HTTP_PORT = "xd_http_port";
public static final String XD_JMX_PORT = "xd_jmx_port";
// Result Environment Variables
public static final String RESULT_LOCATION = "/tmp/xd/output";
public static final String HTTP_PREFIX = "http://";
@Value("${xd_admin_host:}")
private String adminHost;
private URL adminServerUrl;
@Value("${xd_jmx_port}")
private int jmxPort;
@Value("${xd_container_log_dir}")
private String containerLogLocation;
@Value("${xd_base_dir}")
private String baseXdDir;
@Value("${xd_http_port}")
private int httpPort;
@Value("${xd_pvt_keyfile:}")
private String privateKeyFileName;
private String privateKey;
@Value("${xd_run_on_ec2:true}")
private boolean isOnEc2;
// JDBC Attributes
@Value("${jdbc_url}")
private String jdbcUrl;
@Value("${jdbc_username}")
private String jdbcUsername;
@Value("${jdbc_password}")
private String jdbcPassword;
@Value("${jdbc_database}")
private String jdbcDatabase;
@Value("${jdbc_driver}")
private String jdbcDriver;
// JMS Attributes
@Value("${jms_host}")
private String jmsHost;
@Value("${jms_port}")
private int jmsPort;
// Twitter Search Attributes
// Twitter Keys
@Value("${twitterConsumerKey}")
private String twitterConsumerKey;
@Value("${twitterConsumerSecretKey}")
private String twitterConsumerSecretKey;
@Value("${twitterAccessToken}")
private String twitterAccessToken;
@Value("${twitterAccessTokenSecret}")
private String twitterAccessTokenSecret;
@Value("${spring.mongo.host}")
private String mongoHost;
@Value("${spring.mongo.port}")
private String mongoPort;
private SimpleDriverDataSource dataSource;
MongoDbFactory mongoDbFactory;
private CachingConnectionFactory rabbitConnectionFactory;
@Value("${spring.hadoop.fsUri}")
private String nameNode;
@Value("${dfs.datanode.http.port:50075}")
private String dataNodePort;
@Value("${gemfire.host}")
private String gemfireHost;
@Value("${gemfire.port}")
private int gemfirePort;
private Properties artifactProperties;
/**
* If not running tests on a local XD Instance it will retrieve the information from the artifact and setup the
* environment to test against a remote XD. Als initializes the dataSource for JDBC Tests.
*
* @throws MalformedURLException
*/
@PostConstruct()
public void initalizeEc2Environment() throws MalformedURLException {
if (isOnEc2()) {
artifactProperties = ConfigUtil.getPropertiesFromArtifact();
adminServerUrl = new URL(artifactProperties.getProperty(XD_ADMIN_HOST));
jmxPort = Integer.parseInt(artifactProperties.getProperty(XD_JMX_PORT));
httpPort = Integer.parseInt(artifactProperties.getProperty(XD_HTTP_PORT));
}
else {
adminServerUrl = new URL(adminHost);
}
if (jdbcUrl == null) {
return;
}
dataSource = new SimpleDriverDataSource();
rabbitConnectionFactory = new CachingConnectionFactory(adminServerUrl.getHost());
try {
@SuppressWarnings("unchecked") Class<? extends Driver> classz =
(Class<? extends Driver>) ClassUtils.forName(jdbcDriver, beanClassLoader);
dataSource.setDriverClass(classz);
}
catch (ClassNotFoundException e) {
throw new IllegalStateException("failed to load class: " + jdbcDriver, e);
}
String resolvedJdbcUrl = String.format(jdbcUrl, jdbcDatabase);
dataSource.setUrl(resolvedJdbcUrl);
if (jdbcUsername != null) {
dataSource.setUsername(jdbcUsername);
}
if (jdbcPassword != null) {
dataSource.setPassword(jdbcPassword);
}
try {
mongoDbFactory = new SimpleMongoDbFactory(new MongoClient(mongoHost + ":" + mongoPort), "xd");
}
catch (UnknownHostException unknownHostException) {
throw new IllegalStateException(unknownHostException.getMessage(), unknownHostException);
}
}
@Override
public void setBeanClassLoader(ClassLoader beanClassLoader) {
this.beanClassLoader = beanClassLoader;
}
public URL getAdminServerUrl() {
return adminServerUrl;
}
public int getJmxPort() {
return jmxPort;
}
public int getHttpPort() {
return httpPort;
}
public String getPrivateKey() {
// Initialize private key if not already set.
if (isOnEc2 && privateKey == null) {
privateKey = ConfigUtil.getPrivateKey(privateKeyFileName);
}
return privateKey;
}
public boolean isOnEc2() {
return isOnEc2;
}
public String getContainerLogLocation() {
return containerLogLocation;
}
public String getBaseDir() {
return baseXdDir;
}
public DataSource getDataSource() {
return dataSource;
}
public CachingConnectionFactory getRabbitConnectionFactory() {
return rabbitConnectionFactory;
}
public String getJmsHost() {
return jmsHost;
}
public int getJmsPort() {
return jmsPort;
}
/**
* Default value is the same as the admin server host.
*
* @return the host where the rabbitmq broker is running.
*/
public String getRabbitMQHost() {
return getAdminServerUrl().getHost();
}
/**
* The twitter consumer key
*
* @return consumer key
*/
public String getTwitterConsumerKey() {
return twitterConsumerKey;
}
/**
* The twitter consumer secret key
*
* @return consumer secret key
*/
public String getTwitterConsumerSecretKey() {
return twitterConsumerSecretKey;
}
/**
* The Twitter Access Token
*
* @return twitter access token
*/
public String getTwitterAccessToken() {
return twitterAccessToken;
}
/**
* The Twitter Access Token Secret
*
* @return twitter access token secret
*/
public String getTwitterAccessTokenSecret() {
return twitterAccessTokenSecret;
}
/**
* The hadoop name node that is available for this environment.
*
* @return the hadoop name node.
*/
public String getNameNode() {
return nameNode;
}
/**
* The hadoop data node port that is available for this environment.
*
* @return the data node port.
*/
public String getDataNodePort() {
return dataNodePort;
}
/**
* The mongo db factory to be used for the tests.
*
* @return The current mongoDbFactory instance.
*/
public MongoDbFactory getMongoDbFactory() {
return mongoDbFactory;
}
/**
* Retrieves the host where the mongo server is running.
*
* @return the mongo host
*/
public String getMongoHost() {
return mongoHost;
}
/**
* Retrieves the port that the mongo server is monitoring.
*
* @return the mongo server port.
*/
public String getMongoPort() {
return mongoPort;
}
/**
* Retrieves the Gemfire host.
*
* @return the host
*/
public String getGemfireHost() {
return gemfireHost;
}
/**
* Retrieves the Gemfire port.
*
* @return the port
*/
public int getGemfirePort() {
return gemfirePort;
}
}