private boolean deleteOrMoveFiles(FileObject file, String destinationFolder)
throws KettleException {
try {
boolean retval = false;
// Delete the file if this is needed!
//
if (afterFtpPut.equals("delete_file")) {
file.delete();
retval = true;
if (log.isDetailed()) {
logDetailed(BaseMessages.getString(PKG, "JobSSH2PUT.Log.DeletedFile", file.toString()));
}
} else if (afterFtpPut.equals("move_file")) {
// Move File
FileObject destination = null;
FileObject source = null;
try {
destination =
KettleVFS.getFileObject(
destinationFolder + Const.FILE_SEPARATOR + file.getName().getBaseName(), this);
file.moveTo(destination);
retval = true;
} catch (Exception e) {
logError(
BaseMessages.getString(
PKG,
"JobSSH2PUT.Cant_Move_File.Label",
file.toString(),
destinationFolder,
e.getMessage()));
} finally {
if (destination != null) {
try {
destination.close();
} catch (Exception ex) {
/* Ignore */
}
}
if (source != null) {
try {
source.close();
} catch (Exception ex) {
/* Ignore */
}
}
}
if (log.isDetailed()) {
logDetailed(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.MovedFile", file.toString(), ftpDirectory));
}
}
return retval;
} catch (Exception e) {
throw new KettleException(e);
}
}
private boolean CreateFolder(String filefolder) {
FileObject folder = null;
try {
folder = KettleVFS.getFileObject(filefolder, this);
if (!folder.exists()) {
if (createtargetfolder) {
folder.createFolder();
if (log.isDetailed()) {
logDetailed(
BaseMessages.getString(PKG, "JobSSH2GET.Log.FolderCreated", folder.toString()));
}
} else {
return false;
}
}
return true;
} catch (Exception e) {
logError(
BaseMessages.getString(PKG, "JobSSH2GET.Log.CanNotCreateFolder", folder.toString()), e);
} finally {
if (folder != null) {
try {
folder.close();
} catch (Exception ex) {
/* Ignore */
}
}
}
return false;
}
public void dispose() {
super.dispose();
if (currentFileObject != null) {
try {
currentFileObject.close();
} catch (Exception e) {
}
}
}
public void dispose(StepMetaInterface smi, StepDataInterface sdi) {
meta = (GPLoadMeta) smi;
data = (GPLoadData) sdi;
super.dispose(smi, sdi);
if (!preview && meta.isEraseFiles()) {
// Erase the created cfg/dat files if requested. We don't erase
// the rest of the files because it would be "stupid" to erase them
// right after creation. If you don't want them, don't fill them in.
FileObject fileObject = null;
String method = meta.getLoadMethod();
if ( // GPLoadMeta.METHOD_AUTO_CONCURRENT.equals(method) ||
GPLoadMeta.METHOD_AUTO_END.equals(method)) {
/*
if ( meta.getControlFile() != null )
{
try
{
fileObject = KettleVFS.getFileObject(environmentSubstitute(meta.getControlFile()), getTransMeta());
fileObject.delete();
fileObject.close();
}
catch ( Exception ex )
{
logError("Error deleting control file \'" + KettleVFS.getFilename(fileObject) + "\': " + ex.getMessage());
}
}*/
}
if (GPLoadMeta.METHOD_AUTO_END.equals(method)) {
// In concurrent mode the data is written to the control file.
if (meta.getDataFile() != null) {
try {
fileObject =
KettleVFS.getFileObject(environmentSubstitute(meta.getDataFile()), getTransMeta());
fileObject.delete();
fileObject.close();
} catch (Exception ex) {
logError(
"Error deleting data file \'"
+ KettleVFS.getFilename(fileObject)
+ "\': "
+ ex.getMessage(),
ex);
}
}
}
if (GPLoadMeta.METHOD_MANUAL.equals(method)) {
logBasic("Deletion of files is not compatible with \'manual load method\'");
}
}
}
@Test
public void testLocalFileProvider() throws Exception {
FileObject fo = null;
try {
fo = manager.resolveFile(testFile.getCanonicalPath());
assertTrue(fo.exists());
final InputStream ios = fo.getContent().getInputStream();
final BufferedReader reader = new BufferedReader(new InputStreamReader(ios));
assertEquals("test", reader.readLine());
} finally {
if (fo != null) fo.close();
}
}
/**
* Save the contained Package as a Zip file in the file system
*
* @param docxFile A destination FileObject
* @return true if successful; false, otherwise.
* @throws Docx4JException if there is an error
*/
public boolean save(FileObject docxFile) throws Docx4JException {
log.info("Saving to" + docxFile);
boolean success = false;
try {
OutputStream docxOut = docxFile.getContent().getOutputStream();
success = _saveToZipFile.save(docxOut);
} catch (FileSystemException exc) {
exc.printStackTrace();
throw new Docx4JException("Failed to save package", exc);
}
try {
docxFile.close();
} catch (FileSystemException exc) {; // ignore
}
return success;
}
private boolean openNextFile() {
try {
if (meta.getIsInFields()) {
data.readrow = getRow(); // Grab another row ...
if (data.readrow == null) // finished processing!
{
if (isDetailed())
logDetailed(BaseMessages.getString(PKG, "LoadFileInput.Log.FinishedProcessing"));
return false;
}
if (first) {
first = false;
data.inputRowMeta = getInputRowMeta();
data.outputRowMeta = data.inputRowMeta.clone();
meta.getFields(data.outputRowMeta, getStepname(), null, null, this);
// Create convert meta-data objects that will contain Date & Number formatters
//
data.convertRowMeta = data.outputRowMeta.cloneToType(ValueMetaInterface.TYPE_STRING);
if (meta.getIsInFields()) {
// Check is filename field is provided
if (Const.isEmpty(meta.getDynamicFilenameField())) {
logError(BaseMessages.getString(PKG, "LoadFileInput.Log.NoField"));
throw new KettleException(BaseMessages.getString(PKG, "LoadFileInput.Log.NoField"));
}
// cache the position of the field
if (data.indexOfFilenameField < 0) {
data.indexOfFilenameField =
data.inputRowMeta.indexOfValue(meta.getDynamicFilenameField());
if (data.indexOfFilenameField < 0) {
// The field is unreachable !
logError(
BaseMessages.getString(PKG, "LoadFileInput.Log.ErrorFindingField")
+ "["
+ meta.getDynamicFilenameField()
+ "]"); //$NON-NLS-1$ //$NON-NLS-2$
throw new KettleException(
BaseMessages.getString(
PKG,
"LoadFileInput.Exception.CouldnotFindField",
meta.getDynamicFilenameField())); // $NON-NLS-1$ //$NON-NLS-2$
}
}
// Get the number of previous fields
data.totalpreviousfields = data.inputRowMeta.size();
}
} // end if first
// get field value
String Fieldvalue = data.inputRowMeta.getString(data.readrow, data.indexOfFilenameField);
if (isDetailed())
logDetailed(
BaseMessages.getString(
PKG, "LoadFileInput.Log.Stream", meta.getDynamicFilenameField(), Fieldvalue));
FileObject file = null;
try {
// Source is a file.
data.file = KettleVFS.getFileObject(Fieldvalue);
} catch (Exception e) {
throw new KettleException(e);
} finally {
try {
if (file != null) file.close();
} catch (Exception e) {
}
}
} else {
if (data.filenr >= data.files.nrOfFiles()) // finished processing!
{
if (isDetailed())
logDetailed(BaseMessages.getString(PKG, "LoadFileInput.Log.FinishedProcessing"));
return false;
}
// Is this the last file?
data.last_file = (data.filenr == data.files.nrOfFiles() - 1);
data.file = (FileObject) data.files.getFile(data.filenr);
}
// Check if file is empty
data.fileSize = data.file.getContent().getSize();
// Move file pointer ahead!
data.filenr++;
if (meta.isIgnoreEmptyFile() && data.fileSize == 0) {
logError(
BaseMessages.getString(
PKG, "LoadFileInput.Error.FileSizeZero", "" + data.file.getName()));
openNextFile();
} else {
if (isDetailed())
logDetailed(
BaseMessages.getString(PKG, "LoadFileInput.Log.OpeningFile", data.file.toString()));
data.filename = KettleVFS.getFilename(data.file);
// Add additional fields?
if (meta.getShortFileNameField() != null && meta.getShortFileNameField().length() > 0) {
data.shortFilename = data.file.getName().getBaseName();
}
if (meta.getPathField() != null && meta.getPathField().length() > 0) {
data.path = KettleVFS.getFilename(data.file.getParent());
}
if (meta.isHiddenField() != null && meta.isHiddenField().length() > 0) {
data.hidden = data.file.isHidden();
}
if (meta.getExtensionField() != null && meta.getExtensionField().length() > 0) {
data.extension = data.file.getName().getExtension();
}
if (meta.getLastModificationDateField() != null
&& meta.getLastModificationDateField().length() > 0) {
data.lastModificationDateTime = new Date(data.file.getContent().getLastModifiedTime());
}
if (meta.getUriField() != null && meta.getUriField().length() > 0) {
data.uriName = data.file.getName().getURI();
}
if (meta.getRootUriField() != null && meta.getRootUriField().length() > 0) {
data.rootUriName = data.file.getName().getRootURI();
}
// get File content
getFileContent();
addFileToResultFilesname(data.file);
if (isDetailed()) {
logDetailed(
BaseMessages.getString(PKG, "LoadFileInput.Log.FileOpened", data.file.toString()));
}
}
} catch (Exception e) {
logError(
BaseMessages.getString(
PKG,
"LoadFileInput.Log.UnableToOpenFile",
"" + data.filenr,
data.file.toString(),
e.toString()));
stopAll();
setErrors(1);
return false;
}
return true;
}
public Result execute(Result previousResult, int nr) {
Result result = previousResult;
result.setResult(false);
try {
// Get real variable value
String realServerName = environmentSubstitute(serverName);
int realServerPort = Const.toInt(environmentSubstitute(serverPort), 22);
String realUserName = environmentSubstitute(userName);
String realServerPassword =
Encr.decryptPasswordOptionallyEncrypted(environmentSubstitute(password));
// Proxy Host
String realProxyHost = environmentSubstitute(httpproxyhost);
int realProxyPort = Const.toInt(environmentSubstitute(httpproxyport), 22);
String realproxyUserName = environmentSubstitute(httpproxyusername);
String realProxyPassword =
Encr.decryptPasswordOptionallyEncrypted(environmentSubstitute(httpProxyPassword));
// Key file
String realKeyFilename = environmentSubstitute(keyFilename);
String relKeyFilepass = environmentSubstitute(keyFilePass);
// Source files
String realLocalDirectory = environmentSubstitute(localDirectory);
String realwildcard = environmentSubstitute(wildcard);
// Remote destination
String realftpDirectory = environmentSubstitute(ftpDirectory);
// Destination folder (Move to)
String realDestinationFolder = environmentSubstitute(destinationfolder);
try {
// Remote source
realftpDirectory = FTPUtils.normalizePath(realftpDirectory);
// Destination folder (Move to)
realDestinationFolder = FTPUtils.normalizePath(realDestinationFolder);
} catch (Exception e) {
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.CanNotNormalizePath", e.getMessage()));
result.setNrErrors(1);
return result;
}
// Check for mandatory fields
boolean mandatoryok = true;
if (Const.isEmpty(realServerName)) {
mandatoryok = false;
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.ServernameMissing"));
}
if (usehttpproxy) {
if (Const.isEmpty(realProxyHost)) {
mandatoryok = false;
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.HttpProxyhostMissing"));
}
}
if (publicpublickey) {
if (Const.isEmpty(realKeyFilename)) {
mandatoryok = false;
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.KeyFileMissing"));
} else {
// Let's check if folder exists...
if (!KettleVFS.fileExists(realKeyFilename, this)) {
mandatoryok = false;
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.KeyFileNotExist"));
}
}
}
if (Const.isEmpty(realLocalDirectory)) {
mandatoryok = false;
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.LocalFolderMissing"));
}
if (afterFtpPut.equals("move_file")) {
if (Const.isEmpty(realDestinationFolder)) {
mandatoryok = false;
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.DestinatFolderMissing"));
} else {
FileObject folder = null;
try {
folder = KettleVFS.getFileObject(realDestinationFolder, this);
// Let's check if folder exists...
if (!folder.exists()) {
// Do we need to create it?
if (createDestinationFolder) {
folder.createFolder();
} else {
logError(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.DestinatFolderNotExist", realDestinationFolder));
}
}
} catch (Exception e) {
throw new KettleException(e);
} finally {
if (folder != null) {
try {
folder.close();
folder = null;
} catch (Exception e) {
/* Ignore */
}
}
}
}
}
if (mandatoryok) {
Connection conn = null;
SFTPv3Client client = null;
boolean good = true;
int nbfilestoput = 0;
int nbput = 0;
int nbrerror = 0;
try {
// Create a connection instance
conn =
getConnection(
realServerName,
realServerPort,
realProxyHost,
realProxyPort,
realproxyUserName,
realProxyPassword);
if (timeout > 0) {
// Use timeout
// Cache Host Key
if (cachehostkey) {
conn.connect(new SimpleVerifier(database), 0, timeout * 1000);
} else {
conn.connect(null, 0, timeout * 1000);
}
} else {
// Cache Host Key
if (cachehostkey) {
conn.connect(new SimpleVerifier(database));
} else {
conn.connect();
}
}
// Authenticate
boolean isAuthenticated = false;
if (publicpublickey) {
String keyContent =
KettleVFS.getTextFileContent(realKeyFilename, this, Const.XML_ENCODING);
isAuthenticated =
conn.authenticateWithPublicKey(
realUserName, keyContent.toCharArray(), relKeyFilepass);
} else {
isAuthenticated = conn.authenticateWithPassword(realUserName, realServerPassword);
}
// LET'S CHECK AUTHENTICATION ...
if (isAuthenticated == false) {
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.AuthenticationFailed"));
} else {
if (log.isBasic()) {
logBasic(
BaseMessages.getString(PKG, "JobSSH2PUT.Log.Connected", serverName, userName));
}
client = new SFTPv3Client(conn);
if (log.isDetailed()) {
logDetailed(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.ProtocolVersion", "" + client.getProtocolVersion()));
}
// Check if remote directory exists
if (!Const.isEmpty(realftpDirectory)) {
if (!sshDirectoryExists(client, realftpDirectory)) {
good = false;
if (createRemoteFolder) {
good = CreateRemoteFolder(client, realftpDirectory);
if (good) {
logBasic(BaseMessages.getString(PKG, "JobSSH2PUT.Log.RemoteDirectoryCreated"));
}
} else {
logError(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.RemoteDirectoryNotExist", realftpDirectory));
}
} else if (log.isDetailed()) {
logDetailed(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.RemoteDirectoryExist", realftpDirectory));
}
}
if (good) {
// Get files list from local folder (source)
List<FileObject> myFileList = getFiles(realLocalDirectory);
// Prepare Pattern for wildcard
Pattern pattern = null;
if (!Const.isEmpty(realwildcard)) {
pattern = Pattern.compile(realwildcard);
}
// Let's put files now ...
// Get the files in the list
for (int i = 0; i < myFileList.size() && !parentJob.isStopped(); i++) {
FileObject myFile = myFileList.get(i);
String localFilename = myFile.toString();
String remoteFilename = myFile.getName().getBaseName();
boolean getIt = true;
// First see if the file matches the regular expression!
if (pattern != null) {
Matcher matcher = pattern.matcher(remoteFilename);
getIt = matcher.matches();
}
// do we have a target directory?
if (!Const.isEmpty(realftpDirectory)) {
remoteFilename = realftpDirectory + FTPUtils.FILE_SEPARATOR + remoteFilename;
}
if (onlyGettingNewFiles) {
// We get only new files
// ie not exist on the remote server
getIt = !sshFileExists(client, remoteFilename);
}
if (getIt) {
nbfilestoput++;
boolean putok = putFile(myFile, remoteFilename, client);
if (!putok) {
nbrerror++;
logError(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.Error.CanNotPutFile", localFilename));
} else {
nbput++;
}
if (putok && !afterFtpPut.equals("do_nothing")) {
deleteOrMoveFiles(myFile, realDestinationFolder);
}
}
}
/** ****************************** RESULT ******************* */
if (log.isDetailed()) {
logDetailed(BaseMessages.getString(PKG, "JobSSH2PUT.Log.Result.JobEntryEnd1"));
logDetailed(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.Result.TotalFiles", "" + nbfilestoput));
logDetailed(
BaseMessages.getString(PKG, "JobSSH2PUT.Log.Result.TotalFilesPut", "" + nbput));
logDetailed(
BaseMessages.getString(
PKG, "JobSSH2PUT.Log.Result.TotalFilesError", "" + nbrerror));
logDetailed(BaseMessages.getString(PKG, "JobSSH2PUT.Log.Result.JobEntryEnd2"));
}
if (nbrerror == 0) {
result.setResult(true);
/** ****************************** RESULT ******************* */
}
}
}
} catch (Exception e) {
result.setNrErrors(nbrerror);
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.Error.ErrorFTP", e.getMessage()));
} finally {
if (conn != null) {
conn.close();
}
if (client != null) {
client.close();
}
}
}
} catch (Exception e) {
result.setResult(false);
result.setNrErrors(1L);
logError(BaseMessages.getString(PKG, "JobSSH2PUT.Log.Error.UnexpectedError"), e);
}
return result;
}
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
meta = (XsltMeta) smi;
data = (XsltData) sdi;
Object[] row = getRow();
if (row == null) { // no more input to be expected...
setOutputDone();
return false;
}
if (first) {
first = false;
data.outputRowMeta = getInputRowMeta().clone();
meta.getFields(data.outputRowMeta, getStepname(), null, null, this, repository, metaStore);
// Check if The result field is given
if (Const.isEmpty(meta.getResultfieldname())) {
// Result Field is missing !
logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorResultFieldMissing"));
throw new KettleStepException(
BaseMessages.getString(PKG, "Xslt.Exception.ErrorResultFieldMissing"));
}
// Check if The XML field is given
if (Const.isEmpty(meta.getFieldname())) {
// Result Field is missing !
logError(BaseMessages.getString(PKG, "Xslt.Exception.ErrorXMLFieldMissing"));
throw new KettleStepException(
BaseMessages.getString(PKG, "Xslt.Exception.ErrorXMLFieldMissing"));
}
// Try to get XML Field index
data.fieldposition = getInputRowMeta().indexOfValue(meta.getFieldname());
// Let's check the Field
if (data.fieldposition < 0) {
// The field is unreachable !
logError(
BaseMessages.getString(PKG, "Xslt.Log.ErrorFindingField")
+ "["
+ meta.getFieldname()
+ "]");
throw new KettleStepException(
BaseMessages.getString(PKG, "Xslt.Exception.CouldnotFindField", meta.getFieldname()));
}
// Check if the XSL Filename is contained in a column
if (meta.useXSLField()) {
if (Const.isEmpty(meta.getXSLFileField())) {
// The field is missing
// Result field is missing !
logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFileFieldMissing"));
throw new KettleStepException(
BaseMessages.getString(PKG, "Xslt.Exception.ErrorXSLFileFieldMissing"));
}
// Try to get Field index
data.fielxslfiledposition = getInputRowMeta().indexOfValue(meta.getXSLFileField());
// Let's check the Field
if (data.fielxslfiledposition < 0) {
// The field is unreachable !
logError(
BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFileFieldFinding")
+ "["
+ meta.getXSLFileField()
+ "]");
throw new KettleStepException(
BaseMessages.getString(
PKG, "Xslt.Exception.ErrorXSLFileFieldFinding", meta.getXSLFileField()));
}
} else {
if (Const.isEmpty(meta.getXslFilename())) {
logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFile"));
throw new KettleStepException(BaseMessages.getString(PKG, "Xslt.Exception.ErrorXSLFile"));
}
// Check if XSL File exists!
data.xslfilename = environmentSubstitute(meta.getXslFilename());
FileObject file = null;
try {
file = KettleVFS.getFileObject(data.xslfilename);
if (!file.exists()) {
logError(
BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFileNotExists", data.xslfilename));
throw new KettleStepException(
BaseMessages.getString(
PKG, "Xslt.Exception.ErrorXSLFileNotExists", data.xslfilename));
}
if (file.getType() != FileType.FILE) {
logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLNotAFile", data.xslfilename));
throw new KettleStepException(
BaseMessages.getString(PKG, "Xslt.Exception.ErrorXSLNotAFile", data.xslfilename));
}
} catch (Exception e) {
throw new KettleStepException(e);
} finally {
try {
if (file != null) {
file.close();
}
} catch (Exception e) {
/* Ignore */
}
}
}
// Check output parameters
int nrOutputProps =
meta.getOutputPropertyName() == null ? 0 : meta.getOutputPropertyName().length;
if (nrOutputProps > 0) {
data.outputProperties = new Properties();
for (int i = 0; i < nrOutputProps; i++) {
data.outputProperties.put(
meta.getOutputPropertyName()[i],
environmentSubstitute(meta.getOutputPropertyValue()[i]));
}
data.setOutputProperties = true;
}
// Check parameters
data.nrParams = meta.getParameterField() == null ? 0 : meta.getParameterField().length;
if (data.nrParams > 0) {
data.indexOfParams = new int[data.nrParams];
data.nameOfParams = new String[data.nrParams];
for (int i = 0; i < data.nrParams; i++) {
String name = environmentSubstitute(meta.getParameterName()[i]);
String field = environmentSubstitute(meta.getParameterField()[i]);
if (Const.isEmpty(field)) {
throw new KettleStepException(
BaseMessages.getString(PKG, "Xslt.Exception.ParameterFieldMissing", name, i));
}
data.indexOfParams[i] = getInputRowMeta().indexOfValue(field);
if (data.indexOfParams[i] < 0) {
throw new KettleStepException(
BaseMessages.getString(PKG, "Xslt.Exception.ParameterFieldNotFound", name));
}
data.nameOfParams[i] = name;
}
data.useParameters = true;
}
data.factory = TransformerFactory.newInstance();
if (meta.getXSLFactory().equals("SAXON")) {
// Set the TransformerFactory to the SAXON implementation.
data.factory = new net.sf.saxon.TransformerFactoryImpl();
}
} // end if first
// Get the field value
String xmlValue = getInputRowMeta().getString(row, data.fieldposition);
if (meta.useXSLField()) {
// Get the value
data.xslfilename = getInputRowMeta().getString(row, data.fielxslfiledposition);
if (log.isDetailed()) {
logDetailed(
BaseMessages.getString(
PKG, "Xslt.Log.XslfileNameFromFied", data.xslfilename, meta.getXSLFileField()));
}
}
try {
if (log.isDetailed()) {
if (meta.isXSLFieldIsAFile()) {
logDetailed(BaseMessages.getString(PKG, "Xslt.Log.Filexsl") + data.xslfilename);
} else {
logDetailed(BaseMessages.getString(PKG, "Xslt.Log.XslStream", data.xslfilename));
}
}
// Get the template from the cache
Transformer transformer = data.getTemplate(data.xslfilename, data.xslIsAfile);
// Do we need to set output properties?
if (data.setOutputProperties) {
transformer.setOutputProperties(data.outputProperties);
}
// Do we need to pass parameters?
if (data.useParameters) {
for (int i = 0; i < data.nrParams; i++) {
transformer.setParameter(data.nameOfParams[i], row[data.indexOfParams[i]]);
}
}
Source source = new StreamSource(new StringReader(xmlValue));
// Prepare output stream
StreamResult result = new StreamResult(new StringWriter());
// transform xml source
transformer.transform(source, result);
String xmlString = result.getWriter().toString();
if (log.isDetailed()) {
logDetailed(BaseMessages.getString(PKG, "Xslt.Log.FileResult"));
logDetailed(xmlString);
}
Object[] outputRowData = RowDataUtil.addValueData(row, getInputRowMeta().size(), xmlString);
if (log.isRowLevel()) {
logRowlevel(
BaseMessages.getString(PKG, "Xslt.Log.ReadRow")
+ " "
+ getInputRowMeta().getString(row));
}
// add new values to the row.
putRow(data.outputRowMeta, outputRowData); // copy row to output rowset(s);
} catch (Exception e) {
String errorMessage = e.getMessage();
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
DefaultErrorHandler.printLocation(pw, e);
pw.close();
errorMessage = sw.toString() + "\n" + errorMessage;
if (getStepMeta().isDoingErrorHandling()) {
// Simply add this row to the error row
putError(getInputRowMeta(), row, 1, errorMessage, meta.getResultfieldname(), "XSLT01");
} else {
logError(BaseMessages.getString(PKG, "Xslt.ErrorProcesing" + " : " + errorMessage));
throw new KettleStepException(BaseMessages.getString(PKG, "Xslt.ErrorProcesing"), e);
}
}
return true;
}
public Result execute(Result previousResult, int nr) {
Result result = previousResult;
result.setResult(false);
// starttime (in seconds)
long timeStart = System.currentTimeMillis() / 1000;
if (filename != null) {
FileObject fileObject = null;
String realFilename = getRealFilename();
try {
fileObject = KettleVFS.getFileObject(realFilename, this);
long iMaximumTimeout =
Const.toInt(getRealMaximumTimeout(), Const.toInt(DEFAULT_MAXIMUM_TIMEOUT, 0));
long iCycleTime =
Const.toInt(getRealCheckCycleTime(), Const.toInt(DEFAULT_CHECK_CYCLE_TIME, 0));
//
// Sanity check on some values, and complain on insanity
//
if (iMaximumTimeout < 0) {
iMaximumTimeout = Const.toInt(DEFAULT_MAXIMUM_TIMEOUT, 0);
if (log.isBasic()) logBasic("Maximum timeout invalid, reset to " + iMaximumTimeout);
}
if (iCycleTime < 1) {
// If lower than 1 set to the default
iCycleTime = Const.toInt(DEFAULT_CHECK_CYCLE_TIME, 1);
if (log.isBasic()) logBasic("Check cycle time invalid, reset to " + iCycleTime);
}
if (iMaximumTimeout == 0) {
if (log.isBasic()) logBasic("Waiting indefinitely for file [" + realFilename + "]");
} else {
if (log.isBasic())
logBasic("Waiting " + iMaximumTimeout + " seconds for file [" + realFilename + "]");
}
boolean continueLoop = true;
while (continueLoop && !parentJob.isStopped()) {
fileObject = KettleVFS.getFileObject(realFilename, this);
if (fileObject.exists()) {
// file exists, we're happy to exit
if (log.isBasic()) logBasic("Detected file [" + realFilename + "] within timeout");
result.setResult(true);
continueLoop = false;
// add filename to result filenames
if (addFilenameToResult && fileObject.getType() == FileType.FILE) {
ResultFile resultFile =
new ResultFile(
ResultFile.FILE_TYPE_GENERAL, fileObject, parentJob.getJobname(), toString());
resultFile.setComment(BaseMessages.getString(PKG, "JobWaitForFile.FilenameAdded"));
result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
}
} else {
long now = System.currentTimeMillis() / 1000;
if ((iMaximumTimeout > 0) && (now > (timeStart + iMaximumTimeout))) {
continueLoop = false;
// file doesn't exist after timeout, either true or false
if (isSuccessOnTimeout()) {
if (log.isBasic())
logBasic("Didn't detect file [" + realFilename + "] before timeout, success");
result.setResult(true);
} else {
if (log.isBasic())
logBasic("Didn't detect file [" + realFilename + "] before timeout, failure");
result.setResult(false);
}
}
// sleep algorithm
long sleepTime = 0;
if (iMaximumTimeout == 0) {
sleepTime = iCycleTime;
} else {
if ((now + iCycleTime) < (timeStart + iMaximumTimeout)) {
sleepTime = iCycleTime;
} else {
sleepTime = iCycleTime - ((now + iCycleTime) - (timeStart + iMaximumTimeout));
}
}
try {
if (sleepTime > 0) {
if (log.isDetailed()) {
logDetailed(
"Sleeping "
+ sleepTime
+ " seconds before next check for file ["
+ realFilename
+ "]");
}
Thread.sleep(sleepTime * 1000);
}
} catch (InterruptedException e) {
// something strange happened
result.setResult(false);
continueLoop = false;
}
}
}
if (!parentJob.isStopped() && fileObject.exists() && isFileSizeCheck()) {
long oldSize = -1;
long newSize = fileObject.getContent().getSize();
if (log.isDetailed())
logDetailed("File [" + realFilename + "] is " + newSize + " bytes long");
if (log.isBasic())
logBasic(
"Waiting until file ["
+ realFilename
+ "] stops growing for "
+ iCycleTime
+ " seconds");
while (oldSize != newSize && !parentJob.isStopped()) {
try {
if (log.isDetailed()) {
logDetailed(
"Sleeping "
+ iCycleTime
+ " seconds, waiting for file ["
+ realFilename
+ "] to stop growing");
}
Thread.sleep(iCycleTime * 1000);
} catch (InterruptedException e) {
// something strange happened
result.setResult(false);
continueLoop = false;
}
oldSize = newSize;
newSize = fileObject.getContent().getSize();
if (log.isDetailed()) {
logDetailed("File [" + realFilename + "] is " + newSize + " bytes long");
}
}
if (log.isBasic())
logBasic("Stopped waiting for file [" + realFilename + "] to stop growing");
}
if (parentJob.isStopped()) {
result.setResult(false);
}
} catch (Exception e) {
logBasic("Exception while waiting for file [" + realFilename + "] to stop growing", e);
} finally {
if (fileObject != null) {
try {
fileObject.close();
} catch (Exception e) {
}
}
}
} else {
logError("No filename is defined.");
}
return result;
}
