package com.ximple.eofms.jobs;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.nio.BufferOverflowException;
|
import java.nio.ByteBuffer;
|
import java.sql.Connection;
|
import java.sql.ResultSet;
|
import java.sql.SQLException;
|
import java.sql.Statement;
|
import java.util.ArrayList;
|
import java.util.Map;
|
import java.util.StringTokenizer;
|
import java.util.TreeMap;
|
|
import com.vividsolutions.jts.util.Assert;
|
import com.ximple.eofms.jobs.context.AbstractOracleJobContext;
|
import com.ximple.eofms.util.FeatureTypeBuilderUtil;
|
import oracle.sql.BLOB;
|
import org.apache.commons.logging.Log;
|
import org.geotools.data.DataStore;
|
import org.geotools.data.oracle.OracleNGDataStoreFactory;
|
import org.geotools.jdbc.JDBCDataStore;
|
import org.quartz.Job;
|
import org.quartz.JobDataMap;
|
import org.quartz.JobDetail;
|
import org.quartz.JobExecutionContext;
|
import org.quartz.JobExecutionException;
|
|
public abstract class AbstractOracleDatabaseJob implements Job {
|
/**
|
* The Oracle driver class name
|
*/
|
private static final String JDBC_DRIVER = "oracle.jdbc.driver.OracleDriver";
|
|
private static final String ORACLE_URL = "jdbc:oracle:thin:@";
|
private static final String PROPUsrKey = "user";
|
private static final String PROPPassKey = "password";
|
|
private static final String JOBDATA_DIR = "JOBDATA_DIR";
|
private static final String CONFELMSFILTER = "ELMSFILTER_CONF";
|
private static final String SPATAILSCHEMA = "ORGSCHEMA";
|
private static final String CONVERTDB = "CONVERTDB";
|
private static final String CONVERTFILE = "CONVERTFILE";
|
private static final String CONVERTELEMIN = "CONVERTELEMIN";
|
private static final String CONVERTPWTHEMES = "CONVERTPWTHEMES";
|
private static final String CREATEDUMMY = "CREATEDUMMY";
|
private static final String ELEMLOG = "ELEMLOG";
|
private static final String ORAHOST = "ORAHOST";
|
private static final String ORAINST = "ORAINST";
|
private static final String ORAPORT = "ORAPORT";
|
private static final String ORAUSER = "ORAUSER";
|
private static final String ORAPASS = "ORAPASS";
|
private static final String TESTMODE = "TESTMODE";
|
private static final String TESTCOUNT = "TESTCOUNT";
|
private static final String COPYCONNECTIVITYMODE = "COPYCONNECTIVITYMODE";
|
private static final String PROFILEMODE = "PROFILEMODE";
|
private static final String USEZONE121 = "USEZONE121";
|
private static final String IGNORE_DBETL = "IGNORE_DBETL";
|
|
protected static OracleNGDataStoreFactory dataStoreFactory = new OracleNGDataStoreFactory();
|
|
protected String _dataPath;
|
protected String _filterPath;
|
protected String _oracleHost;
|
protected String _oracleInstance;
|
protected String _oraclePort;
|
protected String _username;
|
protected String _password;
|
protected String _convertDB;
|
protected String _convertFile;
|
protected String _convertElementIn;
|
protected String _convertPWThemes;
|
protected String _elementLogging;
|
protected String _createDummy;
|
protected ArrayList<String> _orgSchema = new ArrayList<String>();
|
protected boolean _testMode = false;
|
protected boolean _copyConnectivityMode = false;
|
protected boolean _profileMode = false;
|
protected boolean _useZone121 = true;
|
protected boolean _useTransform = true;
|
protected boolean _ignoreDBETL = false;
|
|
protected int _testCount = -1;
|
protected JDBCDataStore sourceDataStore;
|
private boolean driverFound = true;
|
|
private long _processTime;
|
private long _updateTime;
|
private long _processTimeStart;
|
private long _updateTimeStart;
|
|
protected AbstractOracleDatabaseJob() {
|
try {
|
Class.forName(JDBC_DRIVER);
|
} catch (Throwable t) {
|
// must be running off dummy jar!
|
driverFound = false;
|
}
|
}
|
|
public abstract void execute(JobExecutionContext context) throws JobExecutionException;
|
|
public abstract Log getLogger();
|
|
protected void extractJobConfiguration(JobDetail jobDetail) throws JobExecutionException {
|
// The directory to scan is stored in the job map
|
JobDataMap dataMap = jobDetail.getJobDataMap();
|
_dataPath = dataMap.getString(JOBDATA_DIR);
|
_filterPath = dataMap.getString(CONFELMSFILTER);
|
_oracleHost = dataMap.getString(ORAHOST);
|
_oracleInstance = dataMap.getString(ORAINST);
|
_oraclePort = dataMap.getString(ORAPORT);
|
_username = dataMap.getString(ORAUSER);
|
_password = dataMap.getString(ORAPASS);
|
_convertDB = dataMap.getString(CONVERTDB);
|
_convertFile = dataMap.getString(CONVERTFILE);
|
_convertElementIn = dataMap.getString(CONVERTELEMIN);
|
_convertPWThemes = dataMap.getString(CONVERTPWTHEMES);
|
_elementLogging = dataMap.getString(ELEMLOG);
|
_createDummy = dataMap.getString(CREATEDUMMY);
|
|
Log logger = getLogger();
|
/*
|
logger.info("JOBDATA_DIR=" + _dataPath);
|
logger.info("CONFELMSFILTER=" + _filterPath);
|
logger.info("ORAHOST=" + _oracleHost);
|
logger.info("ORAINST=" + _oracleInstance);
|
logger.info("ORAPORT=" + _oraclePort);
|
logger.info("ORAUSER=" + _username);
|
logger.info("ORAPASS=" + _password);
|
logger.info("CONVERTDB=" + _convertDB);
|
logger.info("CONVERTFILE=" + _convertFile);
|
logger.info("CONVERTELEMIN=" + _convertElementIn);
|
logger.info("ELEMLOG=" + _elementLogging);
|
*/
|
|
String strSchema = dataMap.getString(SPATAILSCHEMA);
|
StringTokenizer st = new StringTokenizer(strSchema, ",");
|
while (st.hasMoreTokens()) {
|
String aSchema = st.nextToken().trim();
|
_orgSchema.add(aSchema);
|
}
|
_testMode = dataMap.getBooleanFromString(TESTMODE);
|
_testCount = dataMap.getIntFromString(TESTCOUNT);
|
_copyConnectivityMode = dataMap.getBooleanFromString(COPYCONNECTIVITYMODE);
|
_profileMode = dataMap.getBooleanFromString(PROFILEMODE);
|
_useZone121 = dataMap.getBooleanFromString(USEZONE121);
|
_ignoreDBETL = dataMap.getBooleanFromString(IGNORE_DBETL);
|
|
if (_useZone121) {
|
FeatureTypeBuilderUtil.setDefaultFeatureSRID(3826);
|
} else {
|
FeatureTypeBuilderUtil.setDefaultFeatureSRID(3825);
|
}
|
|
// Validate the required input
|
if (_dataPath == null) {
|
if (logger != null) {
|
logger.warn("Cannot found data directory in configarion.");
|
}
|
throw new JobExecutionException("Directory not configured");
|
}
|
|
// Make sure the directory exists
|
File dir = new File(_dataPath);
|
if (!dir.exists()) {
|
logger = getLogger();
|
if (logger != null) {
|
logger.warn("Cannot found data directory in file system.[" + _dataPath + "]");
|
}
|
throw new JobExecutionException("Invalid Dir " + _dataPath);
|
}
|
|
if (_oracleHost == null) {
|
logger.warn("OracleHOST is null");
|
throw new JobExecutionException("Unknown Oracle Host.");
|
}
|
if (_oracleInstance == null) {
|
logger.warn("OracleINSTANCE is null");
|
throw new JobExecutionException("Unknown Oracle Instance.");
|
}
|
if (_username == null) {
|
logger.warn("OracleUSER is null");
|
throw new JobExecutionException("Unknown Oracle Username.");
|
}
|
if (_password == null) {
|
logger.warn("OraclePASS is null");
|
throw new JobExecutionException("Unknown Oracle Password.");
|
}
|
if (_orgSchema == null) {
|
logger.warn("OracleSchema is null");
|
throw new JobExecutionException("Unknown Spatial Database Schema.");
|
}
|
}
|
|
protected abstract AbstractOracleJobContext prepareJobContext(String targetSchemaName, String filterPath,
|
boolean profileMode, boolean useTransform);
|
|
protected byte[] getBytesFromBLOB(BLOB blob) throws SQLException, BufferOverflowException {
|
byte[] raw = null;
|
|
// BLOB blob = (BLOB) rs.getBlob(1);
|
int optimalSize = blob.getChunkSize();
|
byte[] chunk = new byte[optimalSize];
|
InputStream is = blob.getBinaryStream(0);
|
ByteBuffer buffer = null; // ByteBuffer.allocate(optimalSize);
|
int len = 0;
|
|
try {
|
while ((len = (is.read(chunk))) != -1) {
|
if (buffer != null) {
|
buffer.limit(buffer.limit() + len);
|
} else {
|
buffer = ByteBuffer.allocate(len);
|
}
|
|
buffer.put(chunk, 0, len);
|
}
|
|
assert buffer != null;
|
buffer.position(0);
|
raw = buffer.array();
|
} catch (IOException e) {
|
e.printStackTrace(); // To change body of catch statement use File | Settings | File Templates.
|
Assert.shouldNeverReachHere();
|
} catch (BufferOverflowException e) {
|
getLogger().warn("BufferOverflowException:: len = " + len + "buffer.limit=" + buffer.limit());
|
} finally {
|
try {
|
is.close();
|
} catch (IOException e) {
|
getLogger().warn("InputStream cannot close", e);
|
}
|
;
|
}
|
|
return raw;
|
}
|
|
public boolean isDriverFound() {
|
return driverFound;
|
}
|
|
public String getDataPath() {
|
return _dataPath;
|
}
|
|
public String getFilterPath() {
|
return _filterPath;
|
}
|
|
public String getOracleHost() {
|
return _oracleHost;
|
}
|
|
public String getOracleInstance() {
|
return _oracleInstance;
|
}
|
|
public String getOraclePort() {
|
return _oraclePort;
|
}
|
|
public String getUsername() {
|
return _username;
|
}
|
|
public String getPassword() {
|
return _password;
|
}
|
|
public ArrayList<String> getOriginSchema() {
|
return _orgSchema;
|
}
|
|
public boolean isTestMode() {
|
return _testMode;
|
}
|
|
public int getTestCount() {
|
return _testCount;
|
}
|
|
public String getConvertDB() {
|
return _convertDB;
|
}
|
|
public void setConvertDB(String convertDB) {
|
_convertDB = convertDB;
|
}
|
|
public String getConvertFile() {
|
return _convertFile;
|
}
|
|
public void setConvertFile(String convertFile) {
|
_convertFile = convertFile;
|
}
|
|
public String getConvertElementIn() {
|
return _convertElementIn;
|
}
|
|
public void setConvertElementIn(String convertElementIn) {
|
_convertElementIn = convertElementIn;
|
}
|
|
public boolean checkConvertDB() {
|
return _convertDB != null && !_convertDB.equalsIgnoreCase("false") &&
|
!_convertDB.equalsIgnoreCase("no") && !_convertDB.equalsIgnoreCase("0");
|
}
|
|
public boolean checkConvertFile() {
|
return _convertFile != null && !_convertFile.equalsIgnoreCase("false") &&
|
!_convertFile.equalsIgnoreCase("no") && !_convertFile.equalsIgnoreCase("0");
|
}
|
|
public boolean checkConvertElementIn() {
|
return _convertElementIn != null && !_convertElementIn.equalsIgnoreCase("false") &&
|
!_convertElementIn.equalsIgnoreCase("no") && !_convertElementIn.equalsIgnoreCase("0");
|
}
|
|
public boolean checkConvertPWThemes() {
|
return _convertPWThemes != null && !_convertPWThemes.equalsIgnoreCase("false") &&
|
!_convertPWThemes.equalsIgnoreCase("no") && !_convertPWThemes.equalsIgnoreCase("0");
|
}
|
|
public String getElementLogging() {
|
return _elementLogging;
|
}
|
|
public void setElementLogging(String elementLogging) {
|
this._elementLogging = elementLogging;
|
}
|
|
public boolean checkElementLogging() {
|
return _elementLogging != null && !_elementLogging.equalsIgnoreCase("false") &&
|
!_elementLogging.equalsIgnoreCase("no") && !_elementLogging.equalsIgnoreCase("0");
|
}
|
|
public boolean checkCreateDummy() {
|
return _createDummy != null && !_createDummy.equalsIgnoreCase("false") &&
|
!_createDummy.equalsIgnoreCase("no") && !_createDummy.equalsIgnoreCase("0");
|
}
|
|
public boolean isCopyConnectivityMode() {
|
return _copyConnectivityMode;
|
}
|
|
public boolean isProfileMode() {
|
return _profileMode;
|
}
|
|
public boolean isTransformed() {
|
return _useTransform;
|
}
|
|
public boolean isZone121() {
|
return _useZone121;
|
}
|
|
public boolean isIgnoreDBETL() {
|
return _ignoreDBETL;
|
}
|
|
public void set_ignoreDBETL(boolean _ignoreDBETL) {
|
this._ignoreDBETL = _ignoreDBETL;
|
}
|
|
public DataStore getSourceDataStore() {
|
return sourceDataStore;
|
}
|
|
protected void createSourceDataStore() throws JobExecutionException {
|
if (sourceDataStore != null) {
|
sourceDataStore.dispose();
|
sourceDataStore = null;
|
}
|
|
if (!isDriverFound()) {
|
throw new JobExecutionException("Oracle JDBC Driver not found.-" + JDBC_DRIVER);
|
}
|
Map<String, String> map = new TreeMap<String, String>();
|
map.put(OracleNGDataStoreFactory.HOST.key, _oracleHost);
|
map.put(OracleNGDataStoreFactory.PORT.key, _oraclePort);
|
map.put(OracleNGDataStoreFactory.DATABASE.key, _oracleInstance);
|
map.put(OracleNGDataStoreFactory.USER.key, _username);
|
map.put(OracleNGDataStoreFactory.PASSWD.key, _password);
|
map.put(OracleNGDataStoreFactory.DBTYPE.key, "oracle");
|
map.put(OracleNGDataStoreFactory.NAMESPACE.key, null);
|
|
if (!map.containsKey(OracleNGDataStoreFactory.MAXCONN.key)) {
|
map.put(OracleNGDataStoreFactory.MAXCONN.key, "5");
|
}
|
if (!map.containsKey(OracleNGDataStoreFactory.MINCONN.key)) {
|
map.put(OracleNGDataStoreFactory.MINCONN.key, "1");
|
}
|
|
if (!dataStoreFactory.canProcess(map)) {
|
getLogger().warn("cannot process properties-");
|
throw new JobExecutionException("cannot process properties-");
|
}
|
try {
|
sourceDataStore = dataStoreFactory.createDataStore(map);
|
} catch (IOException e) {
|
getLogger().warn(e.getMessage(), e);
|
throw new JobExecutionException(e.getMessage(), e);
|
}
|
}
|
|
protected void disconnect() {
|
// ConnectionPoolManager manager = ConnectionPoolManager.getInstance();
|
// manager.closeAll();
|
if (sourceDataStore != null) {
|
sourceDataStore.dispose();
|
sourceDataStore = null;
|
}
|
}
|
|
public final void accumulateProcessTime() {
|
_processTime += System.currentTimeMillis() - _processTimeStart;
|
}
|
|
public final void accumulateUpdateTime() {
|
_updateTime += System.currentTimeMillis() - _updateTimeStart;
|
}
|
|
public long getProcessTime() {
|
return _processTime;
|
}
|
|
public long getUpdateTime() {
|
return _updateTime;
|
}
|
|
public final void markProcessTime() {
|
_processTimeStart = System.currentTimeMillis();
|
}
|
|
public final void markUpdateTime() {
|
_updateTimeStart = System.currentTimeMillis();
|
}
|
|
public final void resetProcessTime() {
|
_processTime = 0;
|
}
|
|
public final void resetUpdateTime() {
|
_updateTime = 0;
|
}
|
|
/**
|
* Connectivity (Connectivity)
|
*
|
* @param jobContext job context
|
* @throws java.sql.SQLException sql exception
|
*/
|
protected void copyConnectivity(AbstractOracleJobContext jobContext) throws SQLException {
|
Connection connection = jobContext.getOracleConnection();
|
ResultSet rsMeta = connection.getMetaData().getTables(null, "BASEDB",
|
AbstractOracleJobContext.CONNECTIVITY_WEBCHECK_NAME + "%",
|
new String[]{"TABLE"});
|
|
boolean found = false;
|
try {
|
while (rsMeta.next()) {
|
String tablename = rsMeta.getString(3);
|
if (AbstractOracleJobContext.CONNECTIVITY_WEBCHECK_NAME.equalsIgnoreCase(tablename)) {
|
found = true;
|
break;
|
}
|
}
|
// } catch (SQLException e)
|
} finally {
|
if (rsMeta != null) {
|
rsMeta.close();
|
rsMeta = null;
|
}
|
}
|
Statement stmt = connection.createStatement();
|
if (found) {
|
stmt.execute(AbstractOracleJobContext.TRUNCATE_CONNECTIVITY_WEBCHECK);
|
} else {
|
getLogger().info("Create CONNECTIVITY_WEBCHECK table.");
|
stmt.execute(AbstractOracleJobContext.CREATE_CONNECTIVITY_WEBCHECK);
|
stmt.execute(AbstractOracleJobContext.CREATE_CONNECTIVITY_WEBCHECK_INDEX_1);
|
stmt.execute(AbstractOracleJobContext.CREATE_CONNECTIVITY_WEBCHECK_INDEX_2);
|
stmt.execute(AbstractOracleJobContext.CREATE_CONNECTIVITY_WEBCHECK_INDEX_3);
|
stmt.execute(AbstractOracleJobContext.CREATE_CONNECTIVITY_WEBCHECK_INDEX_4);
|
stmt.execute(AbstractOracleJobContext.CREATE_CONNECTIVITY_WEBCHECK_INDEX_5);
|
stmt.execute(AbstractOracleJobContext.CREATE_CONNECTIVITY_WEBCHECK_INDEX_6);
|
stmt.execute(AbstractOracleJobContext.ALTER_CONNECTIVITY_WEBCHECK_1);
|
stmt.execute(AbstractOracleJobContext.ALTER_CONNECTIVITY_WEBCHECK_2);
|
}
|
|
stmt.execute(AbstractOracleJobContext.COPY_CONNECTIVITY_TO_WEBCHECK);
|
stmt.close();
|
}
|
|
protected void fetchTPData(AbstractOracleJobContext jobContext) {
|
Connection connection = jobContext.getOracleConnection();
|
|
try {
|
Statement stmt = connection.createStatement();
|
ResultSet rs = stmt.executeQuery(AbstractOracleJobContext.FETCH_TPDATA);
|
if (rs.next()) {
|
short disId = rs.getShort(1);
|
jobContext.setDistId(disId);
|
|
String distName = rs.getString(2);
|
jobContext.setDistName(distName);
|
}
|
rs.close();
|
stmt.close();
|
} catch (SQLException e) {
|
getLogger().warn("Fetch TPDATA Error.", e);
|
}
|
}
|
|
protected void createHibernateSequence(AbstractOracleJobContext jobContext) throws SQLException {
|
Connection connection = jobContext.getOracleConnection();
|
|
try {
|
Statement stmt = connection.createStatement();
|
stmt.execute(AbstractOracleJobContext.CREATE_HIBERNATE_SEQUENCE);
|
stmt.close();
|
} catch (SQLException e) {
|
getLogger().warn("HIBERNATE_SEQUENCE is already exist.");
|
}
|
}
|
}
|
