package com.ximple.eofms.jobs;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.nio.ByteBuffer;
|
import java.sql.SQLException;
|
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 org.apache.commons.logging.Log;
|
import org.geotools.data.DataStore;
|
import org.geotools.data.postgis.PostgisDataStoreFactory;
|
import org.geotools.data.jdbc.ConnectionPoolManager;
|
import org.geotools.data.oracle.OracleDataStore;
|
import org.geotools.data.oracle.OracleDataStoreFactory;
|
import org.quartz.Job;
|
import org.quartz.JobDataMap;
|
import org.quartz.JobDetail;
|
import org.quartz.JobExecutionContext;
|
import org.quartz.JobExecutionException;
|
|
import oracle.sql.BLOB;
|
|
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 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";
|
|
protected static OracleDataStoreFactory dataStoreFactory = new OracleDataStoreFactory();
|
|
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 _elementLogging;
|
protected String _createDummy;
|
protected ArrayList<String> _orgSchema = new ArrayList<String>();
|
protected boolean _testMode = false;
|
protected int _testCount = -1;
|
protected OracleDataStore sourceDataStore;
|
private boolean driverFound = true;
|
|
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);
|
_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);
|
|
// 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 filterPath);
|
|
protected static byte[] getBytesFromBLOB(BLOB blob) throws SQLException
|
{
|
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;
|
|
try
|
{
|
while ((len = (is.read(chunk))) != -1)
|
{
|
if (buffer != null)
|
{
|
buffer.limit(buffer.limit() + len);
|
} else
|
{
|
buffer = ByteBuffer.allocate(len);
|
}
|
|
buffer.put(chunk);
|
}
|
|
is.close();
|
|
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();
|
}
|
|
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 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 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("host", _oracleHost);
|
map.put("port", _oraclePort);
|
map.put("instance", _oracleInstance);
|
map.put("user", _username);
|
map.put("passwd", _password);
|
map.put("dbtype", "oracle");
|
map.put("alias", _oracleInstance);
|
map.put("namespace", null);
|
if (!map.containsKey(OracleDataStoreFactory.MAXCONN.key))
|
{
|
map.put(OracleDataStoreFactory.MAXCONN.key, "2");
|
}
|
if (!map.containsKey(OracleDataStoreFactory.MINCONN.key))
|
{
|
map.put(OracleDataStoreFactory.MINCONN.key, "1");
|
}
|
|
if (!dataStoreFactory.canProcess(map))
|
{
|
getLogger().warn("cannot process properties-");
|
throw new JobExecutionException("cannot process properties-");
|
}
|
try
|
{
|
sourceDataStore = (OracleDataStore) 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();
|
}
|
}
|
