Example usage for org.apache.commons.vfs FileObject exists

List of usage examples for org.apache.commons.vfs FileObject exists

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.vfs.*
  5. FileObject
  6. exists

Introduction

In this page you can find the example usage for org.apache.commons.vfs FileObject exists.

Prototype

public boolean exists() throws FileSystemException;

Source Link

Document

Determines if this file exists.

Usage

From source file:org.pentaho.di.job.entries.createfolder.JobEntryCreateFolder.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);//  ww  w  . j av  a  2 s . c  o m

    if (foldername != null) {
        String realFoldername = getRealFoldername();
        FileObject folderObject = null;
        try {
            folderObject = KettleVFS.getFileObject(realFoldername, this);

            if (folderObject.exists()) {
                boolean isFolder = false;

                // Check if it's a folder
                if (folderObject.getType() == FileType.FOLDER) {
                    isFolder = true;
                }

                if (isFailOfFolderExists()) {
                    // Folder exists and fail flag is on.
                    result.setResult(false);
                    if (isFolder) {
                        logError("Folder [" + realFoldername + "] exists, failing.");
                    } else {
                        logError("File [" + realFoldername + "] exists, failing.");
                    }
                } else {
                    // Folder already exists, no reason to try to create it
                    result.setResult(true);
                    if (log.isDetailed()) {
                        logDetailed("Folder [" + realFoldername + "] already exists, not recreating.");
                    }
                }

            } else {
                // No Folder yet, create an empty Folder.
                folderObject.createFolder();
                if (log.isDetailed()) {
                    logDetailed("Folder [" + realFoldername + "] created!");
                }
                result.setResult(true);
            }
        } catch (Exception e) {
            logError("Could not create Folder [" + realFoldername + "]", e);
            result.setResult(false);
            result.setNrErrors(1);
        } finally {
            if (folderObject != null) {
                try {
                    folderObject.close();
                    folderObject = null;
                } catch (IOException ex) { /* Ignore */
                }
            }
        }
    } else {
        logError("No Foldername is defined.");
    }

    return result;
}

From source file:org.pentaho.di.job.entries.deletefile.JobEntryDeleteFile.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);/*w  w  w .j a  va  2s  . com*/

    if (filename != null) {
        String realFilename = getRealFilename();

        FileObject fileObject = null;
        try {
            fileObject = KettleVFS.getFileObject(realFilename, this);

            if (!fileObject.exists()) {
                if (isFailIfFileNotExists()) {
                    // File doesn't exist and fail flag is on.
                    result.setResult(false);
                    logError(BaseMessages.getString(PKG, "JobEntryDeleteFile.ERROR_0004_File_Does_Not_Exist",
                            realFilename));
                } else {
                    // File already deleted, no reason to try to delete it
                    result.setResult(true);
                    if (log.isBasic()) {
                        logBasic(BaseMessages.getString(PKG, "JobEntryDeleteFile.File_Already_Deleted",
                                realFilename));
                    }
                }
            } else {
                boolean deleted = fileObject.delete();
                if (!deleted) {
                    logError(BaseMessages.getString(PKG, "JobEntryDeleteFile.ERROR_0005_Could_Not_Delete_File",
                            realFilename));
                    result.setResult(false);
                    result.setNrErrors(1);
                }
                if (log.isBasic()) {
                    logBasic(BaseMessages.getString(PKG, "JobEntryDeleteFile.File_Deleted", realFilename));
                }
                result.setResult(true);
            }
        } catch (Exception e) {
            logError(BaseMessages.getString(PKG, "JobEntryDeleteFile.ERROR_0006_Exception_Deleting_File",
                    realFilename, e.getMessage()), e);
            result.setResult(false);
            result.setNrErrors(1);
        } finally {
            if (fileObject != null) {
                try {
                    fileObject.close();
                    fileObject = null;
                } catch (IOException ex) { /* Ignore */
                }
            }
        }
    } else {
        logError(BaseMessages.getString(PKG, "JobEntryDeleteFile.ERROR_0007_No_Filename_Is_Defined"));
    }

    return result;
}

From source file:org.pentaho.di.job.entries.deletefiles.JobEntryDeleteFiles.java

private boolean ProcessFile(String filename, String wildcard, Job parentJob) {
    boolean rcode = false;
    FileObject filefolder = null;
    String realFilefoldername = environmentSubstitute(filename);
    String realwildcard = environmentSubstitute(wildcard);

    try {/*from   w  w w  . j av a  2 s.  com*/
        filefolder = KettleVFS.getFileObject(realFilefoldername, this);

        if (filefolder.exists()) {
            // the file or folder exists
            if (filefolder.getType() == FileType.FOLDER) {
                // It's a folder
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobEntryDeleteFiles.ProcessingFolder",
                            realFilefoldername));
                    // Delete Files
                }

                int Nr = filefolder
                        .delete(new TextFileSelector(filefolder.toString(), realwildcard, parentJob));

                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobEntryDeleteFiles.TotalDeleted",
                            String.valueOf(Nr)));
                }
                rcode = true;
            } else {
                // It's a file
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobEntryDeleteFiles.ProcessingFile",
                            realFilefoldername));
                }
                boolean deleted = filefolder.delete();
                if (!deleted) {
                    logError(BaseMessages.getString(PKG, "JobEntryDeleteFiles.CouldNotDeleteFile",
                            realFilefoldername));
                } else {
                    if (log.isBasic()) {
                        logBasic(BaseMessages.getString(PKG, "JobEntryDeleteFiles.FileDeleted", filename));
                    }
                    rcode = true;
                }
            }
        } else {
            // File already deleted, no reason to try to delete it
            if (log.isBasic()) {
                logBasic(BaseMessages.getString(PKG, "JobEntryDeleteFiles.FileAlreadyDeleted",
                        realFilefoldername));
            }
            rcode = true;
        }
    } catch (Exception e) {
        logError(BaseMessages.getString(PKG, "JobEntryDeleteFiles.CouldNotProcess", realFilefoldername,
                e.getMessage()), e);
    } finally {
        if (filefolder != null) {
            try {
                filefolder.close();
                filefolder = null;
            } catch (IOException ex) {
                // Ignore
            }
        }
    }

    return rcode;
}

From source file:org.pentaho.di.job.entries.deletefolders.JobEntryDeleteFolders.java

private boolean deleteFolder(String foldername) {
    boolean rcode = false;
    FileObject filefolder = null;

    try {/*ww  w .j a  v  a2  s. c  om*/
        filefolder = KettleVFS.getFileObject(foldername, this);

        if (filefolder.exists()) {
            // the file or folder exists
            if (filefolder.getType() == FileType.FOLDER) {
                // It's a folder
                if (log.isDetailed()) {
                    logDetailed(
                            BaseMessages.getString(PKG, "JobEntryDeleteFolders.ProcessingFolder", foldername));
                }
                // Delete Files
                int Nr = filefolder.delete(new TextFileSelector());

                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobEntryDeleteFolders.TotalDeleted", foldername,
                            String.valueOf(Nr)));
                }
                rcode = true;
            } else {
                // Error...This file is not a folder!
                logError(BaseMessages.getString(PKG, "JobEntryDeleteFolders.Error.NotFolder"));
            }
        } else {
            // File already deleted, no reason to try to delete it
            if (log.isBasic()) {
                logBasic(BaseMessages.getString(PKG, "JobEntryDeleteFolders.FolderAlreadyDeleted", foldername));
            }
            rcode = true;
        }
    } catch (Exception e) {
        logError(
                BaseMessages.getString(PKG, "JobEntryDeleteFolders.CouldNotDelete", foldername, e.getMessage()),
                e);
    } finally {
        if (filefolder != null) {
            try {
                filefolder.close();
                filefolder = null;
            } catch (IOException ex) {
                // Ignore
            }
        }
    }

    return rcode;
}

From source file:org.pentaho.di.job.entries.deleteresultfilenames.JobEntryDeleteResultFilenames.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);/*from www.  ja v a2s .  c o m*/

    if (previousResult != null) {
        try {
            int size = previousResult.getResultFiles().size();
            if (log.isBasic()) {
                logBasic(
                        BaseMessages.getString(PKG, "JobEntryDeleteResultFilenames.log.FilesFound", "" + size));
            }
            if (!specifywildcard) {
                // Delete all files
                previousResult.getResultFiles().clear();
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobEntryDeleteResultFilenames.log.DeletedFiles",
                            "" + size));
                }
            } else {

                List<ResultFile> resultFiles = result.getResultFilesList();
                if (resultFiles != null && resultFiles.size() > 0) {
                    for (Iterator<ResultFile> it = resultFiles.iterator(); it.hasNext()
                            && !parentJob.isStopped();) {
                        ResultFile resultFile = it.next();
                        FileObject file = resultFile.getFile();
                        if (file != null && file.exists()) {
                            if (CheckFileWildcard(file.getName().getBaseName(), environmentSubstitute(wildcard),
                                    true)
                                    && !CheckFileWildcard(file.getName().getBaseName(),
                                            environmentSubstitute(wildcardexclude), false)) {
                                // Remove file from result files list
                                result.getResultFiles().remove(resultFile.getFile().toString());

                                if (log.isDetailed()) {
                                    logDetailed(BaseMessages.getString(PKG,
                                            "JobEntryDeleteResultFilenames.log.DeletedFile", file.toString()));
                                }
                            }

                        }
                    }
                }
            }
            result.setResult(true);
        } catch (Exception e) {
            logError(BaseMessages.getString(PKG, "JobEntryDeleteResultFilenames.Error", e.toString()));
        }
    }
    return result;
}

From source file:org.pentaho.di.job.entries.dostounix.JobEntryDosToUnix.java

private boolean processFileFolder(String sourcefilefoldername, String wildcard, int convertion, Job parentJob,
        Result result) {/*from   w ww  . j a va2 s.  com*/
    boolean entrystatus = false;
    FileObject sourcefilefolder = null;
    FileObject CurrentFile = null;

    // Get real source file and wilcard
    String realSourceFilefoldername = environmentSubstitute(sourcefilefoldername);
    if (Const.isEmpty(realSourceFilefoldername)) {
        logError(BaseMessages.getString(PKG, "JobDosToUnix.log.FileFolderEmpty", sourcefilefoldername));
        // Update Errors
        updateErrors();

        return entrystatus;
    }
    String realWildcard = environmentSubstitute(wildcard);

    try {
        sourcefilefolder = KettleVFS.getFileObject(realSourceFilefoldername);

        if (sourcefilefolder.exists()) {
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.FileExists",
                        sourcefilefolder.toString()));
            }
            if (sourcefilefolder.getType() == FileType.FILE) {
                entrystatus = convertOneFile(sourcefilefolder, convertion, result, parentJob);

            } else if (sourcefilefolder.getType() == FileType.FOLDER) {
                FileObject[] fileObjects = sourcefilefolder.findFiles(new AllFileSelector() {
                    public boolean traverseDescendents(FileSelectInfo info) {
                        return info.getDepth() == 0 || include_subfolders;
                    }

                    public boolean includeFile(FileSelectInfo info) {

                        FileObject fileObject = info.getFile();
                        try {
                            if (fileObject == null) {
                                return false;
                            }
                            if (fileObject.getType() != FileType.FILE) {
                                return false;
                            }
                        } catch (Exception ex) {
                            // Upon error don't process the file.
                            return false;
                        } finally {
                            if (fileObject != null) {
                                try {
                                    fileObject.close();
                                } catch (IOException ex) { /* Ignore */
                                }
                            }

                        }
                        return true;
                    }
                });

                if (fileObjects != null) {
                    for (int j = 0; j < fileObjects.length && !parentJob.isStopped(); j++) {
                        if (successConditionBroken) {
                            if (!successConditionBrokenExit) {
                                logError(BaseMessages.getString(PKG,
                                        "JobDosToUnix.Error.SuccessConditionbroken", "" + nrAllErrors));
                                successConditionBrokenExit = true;
                            }
                            return false;
                        }
                        // Fetch files in list one after one ...
                        CurrentFile = fileObjects[j];

                        if (!CurrentFile.getParent().toString().equals(sourcefilefolder.toString())) {
                            // Not in the Base Folder..Only if include sub folders
                            if (include_subfolders) {
                                if (GetFileWildcard(CurrentFile.toString(), realWildcard)) {
                                    convertOneFile(CurrentFile, convertion, result, parentJob);
                                }
                            }

                        } else {
                            // In the base folder
                            if (GetFileWildcard(CurrentFile.toString(), realWildcard)) {
                                convertOneFile(CurrentFile, convertion, result, parentJob);
                            }
                        }
                    }
                }
            } else {
                logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.UnknowFileFormat",
                        sourcefilefolder.toString()));
                // Update Errors
                updateErrors();
            }
        } else {
            logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.SourceFileNotExists",
                    realSourceFilefoldername));
            // Update Errors
            updateErrors();
        }
    } catch (Exception e) {
        logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.Exception.Processing",
                realSourceFilefoldername.toString(), e.getMessage()));
        // Update Errors
        updateErrors();
    } finally {
        if (sourcefilefolder != null) {
            try {
                sourcefilefolder.close();
            } catch (IOException ex) {
                /* Ignore */
            }

        }
        if (CurrentFile != null) {
            try {
                CurrentFile.close();
            } catch (IOException ex) { /* Ignore */
            }
        }
    }
    return entrystatus;
}

From source file:org.pentaho.di.job.entries.dtdvalidator.DTDValidator.java

public boolean validate() {

    boolean retval = false;

    FileObject xmlfile = null;
    FileObject DTDfile = null;//from  w ww  .  j av a2 s  .c o m

    ByteArrayInputStream ba = null;
    try {
        if (xmlfilename != null && ((getDTDFilename() != null && !isInternDTD()) || (isInternDTD()))) {
            xmlfile = KettleVFS.getFileObject(getXMLFilename());

            if (xmlfile.exists()) {

                URL xmlFile = new File(KettleVFS.getFilename(xmlfile)).toURI().toURL();
                StringBuffer xmlStringbuffer = new StringBuffer("");

                BufferedReader xmlBufferedReader = null;
                InputStreamReader is = null;
                try {
                    // open XML File
                    is = new InputStreamReader(xmlFile.openStream());
                    xmlBufferedReader = new BufferedReader(is);

                    char[] buffertXML = new char[1024];
                    int LenXML = -1;
                    while ((LenXML = xmlBufferedReader.read(buffertXML)) != -1) {
                        xmlStringbuffer.append(buffertXML, 0, LenXML);
                    }
                } finally {
                    if (is != null) {
                        is.close();
                    }
                    if (xmlBufferedReader != null) {
                        xmlBufferedReader.close();
                    }
                }

                // Prepare parsing ...
                DocumentBuilderFactory DocBuilderFactory = DocumentBuilderFactory.newInstance();
                DocumentBuilder DocBuilder = DocBuilderFactory.newDocumentBuilder();

                // Let's try to get XML document encoding

                DocBuilderFactory.setValidating(false);
                ba = new ByteArrayInputStream(xmlStringbuffer.toString().getBytes("UTF-8"));
                Document xmlDocDTD = DocBuilder.parse(ba);
                if (ba != null) {
                    ba.close();
                }

                String encoding = null;
                if (xmlDocDTD.getXmlEncoding() == null) {
                    encoding = "UTF-8";
                } else {
                    encoding = xmlDocDTD.getXmlEncoding();
                }

                int xmlStartDTD = xmlStringbuffer.indexOf("<!DOCTYPE");

                if (isInternDTD()) {
                    // DTD find in the XML document
                    if (xmlStartDTD != -1) {
                        log.logBasic(BaseMessages.getString(PKG, "JobEntryDTDValidator.ERRORDTDFound.Label",
                                getXMLFilename()));
                    } else {
                        setErrorMessage(BaseMessages.getString(PKG,
                                "JobEntryDTDValidator.ERRORDTDNotFound.Label", getXMLFilename()));
                    }

                } else {
                    // DTD in external document
                    // If we find an intern declaration, we remove it
                    DTDfile = KettleVFS.getFileObject(getDTDFilename());

                    if (DTDfile.exists()) {
                        if (xmlStartDTD != -1) {
                            int EndDTD = xmlStringbuffer.indexOf(">", xmlStartDTD);
                            // String DocTypeDTD = xmlStringbuffer.substring(xmlStartDTD, EndDTD + 1);
                            xmlStringbuffer.replace(xmlStartDTD, EndDTD + 1, "");
                        }

                        String xmlRootnodeDTD = xmlDocDTD.getDocumentElement().getNodeName();

                        String RefDTD = "<?xml version='" + xmlDocDTD.getXmlVersion() + "' encoding='"
                                + encoding + "'?>\n<!DOCTYPE " + xmlRootnodeDTD + " SYSTEM '"
                                + KettleVFS.getFilename(DTDfile) + "'>\n";

                        int xmloffsetDTD = xmlStringbuffer.indexOf("<" + xmlRootnodeDTD);
                        xmlStringbuffer.replace(0, xmloffsetDTD, RefDTD);
                    } else {
                        log.logError(
                                BaseMessages.getString(PKG,
                                        "JobEntryDTDValidator.ERRORDTDFileNotExists.Subject"),
                                BaseMessages.getString(PKG, "JobEntryDTDValidator.ERRORDTDFileNotExists.Msg",
                                        getDTDFilename()));
                    }
                }

                if (!(isInternDTD() && xmlStartDTD == -1 || (!isInternDTD() && !DTDfile.exists()))) {

                    // Let's parse now ...
                    MyErrorHandler error = new MyErrorHandler();
                    DocBuilderFactory.setValidating(true);
                    DocBuilder = DocBuilderFactory.newDocumentBuilder();
                    DocBuilder.setErrorHandler(error);

                    ba = new ByteArrayInputStream(xmlStringbuffer.toString().getBytes(encoding));
                    xmlDocDTD = DocBuilder.parse(ba);

                    if (error.errorMessage == null) {
                        log.logBasic(BaseMessages.getString(PKG, "JobEntryDTDValidator.DTDValidatorOK.Subject"),
                                BaseMessages.getString(PKG, "JobEntryDTDValidator.DTDValidatorOK.Label",
                                        getXMLFilename()));

                        // Everything is OK
                        retval = true;
                    } else {
                        // Invalid DTD
                        setNrErrors(error.nrErrors);
                        setErrorMessage(BaseMessages.getString(PKG, "JobEntryDTDValidator.DTDValidatorKO",
                                getXMLFilename(), error.nrErrors, error.errorMessage));
                    }
                }

            } else {
                if (!xmlfile.exists()) {
                    setErrorMessage(BaseMessages.getString(PKG, "JobEntryDTDValidator.FileDoesNotExist.Label",
                            getXMLFilename()));
                }
            }
        } else {
            setErrorMessage(BaseMessages.getString(PKG, "JobEntryDTDValidator.AllFilesNotNull.Label"));
        }
    } catch (Exception e) {
        setErrorMessage(BaseMessages.getString(PKG, "JobEntryDTDValidator.ErrorDTDValidator.Label",
                getXMLFilename(), getDTDFilename(), e.getMessage()));
    } finally {
        try {
            if (xmlfile != null) {
                xmlfile.close();
            }
            if (DTDfile != null) {
                DTDfile.close();
            }
            if (ba != null) {
                ba.close();
            }
        } catch (IOException e) {
            // Ignore close errors
        }
    }
    return retval;
}

From source file:org.pentaho.di.job.entries.essbase.JobEntryMAXL.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;

    if (databaseMeta != null) {
        final EssbaseHelper helper = new EssbaseHelper(databaseMeta);
        FileObject MAXLfile = null;
        try {//from   w w w  .  j  a  v  a  2 s .c o  m
            String myMAXL = null;
            helper.connect();
            helper.openMaxlSession(this.getObjectName());

            if (maxlfromfile) {
                if (maxlfilename == null)
                    throw new KettleDatabaseException(
                            BaseMessages.getString(PKG, "JobMAXL.NoMAXLFileSpecified"));

                try {
                    String realfilename = environmentSubstitute(maxlfilename);
                    MAXLfile = KettleVFS.getFileObject(realfilename, this);
                    if (!MAXLfile.exists()) {
                        logError(BaseMessages.getString(PKG, "JobMAXL.MAXLFileNotExist", realfilename));
                        throw new KettleDatabaseException(
                                BaseMessages.getString(PKG, "JobMAXL.MAXLFileNotExist", realfilename));
                    }
                    if (isDetailed())
                        logDetailed(BaseMessages.getString(PKG, "JobMAXL.MAXLFileExists", realfilename));

                    InputStream IS = KettleVFS.getInputStream(MAXLfile);
                    try {
                        InputStreamReader BIS = new InputStreamReader(new BufferedInputStream(IS, 500));
                        StringBuffer lineStringBuffer = new StringBuffer(256);
                        lineStringBuffer.setLength(0);

                        BufferedReader buff = new BufferedReader(BIS);
                        String sLine = null;
                        myMAXL = Const.CR;
                        ;

                        while ((sLine = buff.readLine()) != null) {
                            if (Const.isEmpty(sLine)) {
                                myMAXL = myMAXL + Const.CR;
                            } else {
                                myMAXL = myMAXL + Const.CR + sLine;
                            }
                        }
                    } finally {
                        IS.close();
                    }
                } catch (Exception e) {
                    throw new KettleDatabaseException(
                            BaseMessages.getString(PKG, "JobMAXL.ErrorRunningMAXLfromFile"), e);
                }

            } else {
                myMAXL = maxl;
            }
            if (!Const.isEmpty(myMAXL)) {
                // let it run
                if (useVariableSubstitution)
                    myMAXL = environmentSubstitute(myMAXL);
                if (isDetailed())
                    logDetailed(BaseMessages.getString(PKG, "JobMAXL.Log.MAXLStatement", myMAXL));
                if (sendOneStatement)
                    helper.execStatement(myMAXL);
                else
                    helper.execStatements(myMAXL);
            }
        } catch (Exception e) {
            result.setNrErrors(1);
            logError(BaseMessages.getString(PKG, "JobMAXL.ErrorRunJobEntry", e.getMessage()));
        } finally {
            helper.disconnect();
            if (MAXLfile != null) {
                try {
                    MAXLfile.close();
                } catch (Exception e) {
                }
            }
        }
    } else {
        result.setNrErrors(1);
        logError(BaseMessages.getString(PKG, "JobMAXL.NoDatabaseConnection"));
    }

    if (result.getNrErrors() == 0) {
        result.setResult(true);
    } else {
        result.setResult(false);
    }

    return result;
}

From source file:org.pentaho.di.job.entries.evalfilesmetrics.JobEntryEvalFilesMetrics.java

public Result execute(Result previousResult, int nr) throws KettleException {
    Result result = previousResult;
    result.setNrErrors(1);/*from   ww w.ja v  a  2  s  .  c om*/
    result.setResult(false);

    List<RowMetaAndData> rows = result.getRows();
    RowMetaAndData resultRow = null;

    try {
        initMetrics();
    } catch (Exception e) {
        logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.Init", e.toString()));
        return result;
    }

    // Get source and destination files, also wildcard
    String[] vsourcefilefolder = source_filefolder;
    String[] vwildcard = wildcard;
    String[] vincludeSubFolders = includeSubFolders;

    switch (getSourceFiles()) {
    case SOURCE_FILES_PREVIOUS_RESULT:
        // Filenames are retrieved from previous result rows

        String realResultFieldFile = environmentSubstitute(getResultFieldFile());
        String realResultFieldWildcard = environmentSubstitute(getResultFieldWildcard());
        String realResultFieldIncluseSubfolders = environmentSubstitute(getResultFieldIncludeSubfolders());

        int indexOfResultFieldFile = -1;
        if (Const.isEmpty(realResultFieldFile)) {
            logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.ResultFieldsFileMissing"));
            return result;
        }

        int indexOfResultFieldWildcard = -1;
        int indexOfResultFieldIncludeSubfolders = -1;

        // as such we must get rows
        if (log.isDetailed()) {
            logDetailed(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.ArgFromPrevious.Found",
                    (rows != null ? rows.size() : 0) + ""));
        }

        if (rows != null && rows.size() > 0) {
            // We get rows
            RowMetaAndData firstRow = rows.get(0);
            indexOfResultFieldFile = firstRow.getRowMeta().indexOfValue(realResultFieldFile);
            if (indexOfResultFieldFile == -1) {
                logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.CanNotFindField",
                        realResultFieldFile));
                return result;
            }
            if (!Const.isEmpty(realResultFieldWildcard)) {
                indexOfResultFieldWildcard = firstRow.getRowMeta().indexOfValue(realResultFieldWildcard);
                if (indexOfResultFieldWildcard == -1) {
                    logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.CanNotFindField",
                            realResultFieldWildcard));
                    return result;
                }
            }
            if (!Const.isEmpty(realResultFieldIncluseSubfolders)) {
                indexOfResultFieldIncludeSubfolders = firstRow.getRowMeta()
                        .indexOfValue(realResultFieldIncluseSubfolders);
                if (indexOfResultFieldIncludeSubfolders == -1) {
                    logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.CanNotFindField",
                            realResultFieldIncluseSubfolders));
                    return result;
                }
            }

            for (int iteration = 0; iteration < rows.size() && !parentJob.isStopped(); iteration++) {

                resultRow = rows.get(iteration);

                // Get source and destination file names, also wildcard
                String vsourcefilefolder_previous = resultRow.getString(indexOfResultFieldFile, null);
                String vwildcard_previous = null;
                if (indexOfResultFieldWildcard > -1) {
                    vwildcard_previous = resultRow.getString(indexOfResultFieldWildcard, null);
                }
                String vincludeSubFolders_previous = NO;
                if (indexOfResultFieldIncludeSubfolders > -1) {
                    vincludeSubFolders_previous = resultRow.getString(indexOfResultFieldIncludeSubfolders, NO);
                }

                if (isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.ProcessingRow",
                            vsourcefilefolder_previous, vwildcard_previous));
                }

                ProcessFileFolder(vsourcefilefolder_previous, vwildcard_previous, vincludeSubFolders_previous,
                        parentJob, result);
            }
        }

        break;
    case SOURCE_FILES_FILENAMES_RESULT:
        List<ResultFile> resultFiles = result.getResultFilesList();
        if (log.isDetailed()) {
            logDetailed(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.ResultFilenames.Found",
                    (resultFiles != null ? resultFiles.size() : 0) + ""));
        }

        if (resultFiles != null && resultFiles.size() > 0) {
            // Let's check wildcard
            Pattern pattern = null;
            String realPattern = environmentSubstitute(getResultFilenamesWildcard());
            if (!Const.isEmpty(realPattern)) {
                pattern = Pattern.compile(realPattern);
            }

            for (Iterator<ResultFile> it = resultFiles.iterator(); it.hasNext() && !parentJob.isStopped();) {
                ResultFile resultFile = it.next();
                FileObject file = resultFile.getFile();
                try {
                    if (file != null && file.exists()) {
                        boolean getIt = true;
                        if (pattern != null) {
                            Matcher matcher = pattern.matcher(file.getName().getBaseName());
                            getIt = matcher.matches();
                        }
                        if (getIt) {
                            getFileSize(file, result, parentJob);
                        }
                    }
                } catch (Exception e) {
                    incrementErrors();
                    logError(BaseMessages.getString(PKG,
                            "JobEvalFilesMetrics.Error.GettingFileFromResultFilenames", file.toString(),
                            e.toString()));
                } finally {
                    if (file != null) {
                        try {
                            file.close();
                        } catch (Exception e) { /* Ignore */
                        }
                    }
                }
            }
        }
        break;
    default:
        // static files/folders
        // from grid entered by user
        if (vsourcefilefolder != null && vsourcefilefolder.length > 0) {
            for (int i = 0; i < vsourcefilefolder.length && !parentJob.isStopped(); i++) {

                if (isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.ProcessingRow",
                            vsourcefilefolder[i], vwildcard[i]));
                }

                ProcessFileFolder(vsourcefilefolder[i], vwildcard[i], vincludeSubFolders[i], parentJob, result);
            }
        } else {
            logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.FilesGridEmpty"));
            return result;
        }
        break;
    }

    result.setResult(isSuccess());
    result.setNrErrors(getNrError());
    displayResults();

    return result;
}

From source file:org.pentaho.di.job.entries.evalfilesmetrics.JobEntryEvalFilesMetrics.java

private void ProcessFileFolder(String sourcefilefoldername, String wildcard, String includeSubfolders,
        Job parentJob, Result result) {

    FileObject sourcefilefolder = null;
    FileObject CurrentFile = null;

    // Get real source file and wildcard
    String realSourceFilefoldername = environmentSubstitute(sourcefilefoldername);
    if (Const.isEmpty(realSourceFilefoldername)) {
        // Filename is empty!
        logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.log.FileFolderEmpty"));
        incrementErrors();//from w  w  w  .  j  a  v a 2  s .  co  m
        return;
    }
    String realWildcard = environmentSubstitute(wildcard);
    final boolean include_subfolders = YES.equalsIgnoreCase(includeSubfolders);

    try {
        sourcefilefolder = KettleVFS.getFileObject(realSourceFilefoldername);

        if (sourcefilefolder.exists()) {
            // File exists
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.FileExists",
                        sourcefilefolder.toString()));
            }

            if (sourcefilefolder.getType() == FileType.FILE) {
                // We deals here with a file
                // let's get file size
                getFileSize(sourcefilefolder, result, parentJob);

            } else if (sourcefilefolder.getType() == FileType.FOLDER) {
                // We have a folder
                // we will fetch and extract files
                FileObject[] fileObjects = sourcefilefolder.findFiles(new AllFileSelector() {
                    public boolean traverseDescendents(FileSelectInfo info) {
                        return info.getDepth() == 0 || include_subfolders;
                    }

                    public boolean includeFile(FileSelectInfo info) {
                        FileObject fileObject = info.getFile();
                        try {
                            if (fileObject == null) {
                                return false;
                            }
                            if (fileObject.getType() != FileType.FILE) {
                                return false;
                            }
                        } catch (Exception ex) {
                            // Upon error don't process the file.
                            return false;
                        } finally {
                            if (fileObject != null) {
                                try {
                                    fileObject.close();
                                } catch (IOException ex) { /* Ignore */
                                }
                            }
                        }
                        return true;
                    }
                });

                if (fileObjects != null) {
                    for (int j = 0; j < fileObjects.length && !parentJob.isStopped(); j++) {
                        // Fetch files in list one after one ...
                        CurrentFile = fileObjects[j];

                        if (!CurrentFile.getParent().toString().equals(sourcefilefolder.toString())) {
                            // Not in the Base Folder..Only if include sub folders
                            if (include_subfolders) {
                                if (GetFileWildcard(CurrentFile.getName().getBaseName(), realWildcard)) {
                                    getFileSize(CurrentFile, result, parentJob);
                                }
                            }
                        } else {
                            // In the base folder
                            if (GetFileWildcard(CurrentFile.getName().getBaseName(), realWildcard)) {
                                getFileSize(CurrentFile, result, parentJob);
                            }
                        }
                    }
                }
            } else {
                incrementErrors();
                logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.UnknowFileFormat",
                        sourcefilefolder.toString()));
            }
        } else {
            incrementErrors();
            logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.SourceFileNotExists",
                    realSourceFilefoldername));
        }
    } catch (Exception e) {
        incrementErrors();
        logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.Exception.Processing",
                realSourceFilefoldername.toString(), e.getMessage()));

    } finally {
        if (sourcefilefolder != null) {
            try {
                sourcefilefolder.close();
            } catch (IOException ex) { /* Ignore */
            }

        }
        if (CurrentFile != null) {
            try {
                CurrentFile.close();
            } catch (IOException ex) { /* Ignore */
            }
        }
    }
}