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

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

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

Introduction

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

Prototype

public String toString()

Source Link

Document

Returns a string representation of the object.

Usage

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 {/*ww  w .ja  va  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.deleteresultfilenames.JobEntryDeleteResultFilenames.java

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

    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 convert(FileObject file, boolean toUnix) {
    boolean retval = false;
    // CR = CR/*w ww.java  2  s.c  o m*/
    // LF = LF
    try {
        String localfilename = KettleVFS.getFilename(file);
        File source = new File(localfilename);
        if (isDetailed()) {
            if (toUnix) {
                logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.ConvertingFileToUnix",
                        source.getAbsolutePath()));
            } else {
                logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.ConvertingFileToDos",
                        source.getAbsolutePath()));
            }
        }
        File tempFile = new File(tempFolder, source.getName() + ".tmp");

        if (isDebug()) {
            logDebug(BaseMessages.getString(PKG, "JobDosToUnix.Log.CreatingTempFile",
                    tempFile.getAbsolutePath()));
        }
        FileOutputStream out = new FileOutputStream(tempFile);
        FileInputStream in = new FileInputStream(localfilename);

        if (toUnix) {
            // Dos to Unix
            while (in.available() > 0) {
                int b1 = in.read();
                if (b1 == CR) {
                    int b2 = in.read();
                    if (b2 == LF) {
                        out.write(LF);
                    } else {
                        out.write(b1);
                        out.write(b2);
                    }
                } else {
                    out.write(b1);
                }
            }
        } else {
            // Unix to Dos
            while (in.available() > 0) {
                int b1 = in.read();
                if (b1 == LF) {
                    out.write(CR);
                    out.write(LF);
                } else {
                    out.write(b1);
                }
            }
        }

        in.close();
        out.close();

        if (isDebug()) {
            logDebug(BaseMessages.getString(PKG, "JobDosToUnix.Log.DeletingSourceFile", localfilename));
        }
        file.delete();
        if (isDebug()) {
            logDebug(BaseMessages.getString(PKG, "JobDosToUnix.Log.RenamingTempFile",
                    tempFile.getAbsolutePath(), source.getAbsolutePath()));
        }
        tempFile.renameTo(source);

        retval = true;

    } catch (Exception e) {
        logError(BaseMessages.getString(PKG, "JobDosToUnix.Log.ErrorConvertingFile", file.toString(),
                e.getMessage()));
    }

    return retval;
}

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

private boolean processFileFolder(String sourcefilefoldername, String wildcard, int convertion, Job parentJob,
        Result result) {/*w  w w.  j  a v a2 s.  c om*/
    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.dostounix.JobEntryDosToUnix.java

private boolean convertOneFile(FileObject file, int convertion, Result result, Job parentJob)
        throws KettleException {
    boolean retval = false;
    try {/*from   w w w.  j a v a 2  s. co  m*/
        // We deal with a file..

        boolean convertToUnix = true;

        if (convertion == CONVERTION_TYPE_GUESS) {
            // Get file Type
            int fileType = getFileType(file);
            if (fileType == TYPE_DOS_FILE) {
                // File type is DOS
                // We need to convert it to UNIX
                convertToUnix = true;
            } else {
                // File type is not DOS
                // so let's convert it to DOS
                convertToUnix = false;
            }
        } else if (convertion == CONVERTION_TYPE_DOS_TO_UNIX) {
            convertToUnix = true;
        } else {
            convertToUnix = false;
        }

        retval = convert(file, convertToUnix);

        if (!retval) {
            logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.FileNotConverted", file.toString()));
            // Update Bad files number
            updateBadFormed();
            if (resultfilenames.equals(ADD_ALL_FILENAMES) || resultfilenames.equals(ADD_ERROR_FILES_ONLY)) {
                addFileToResultFilenames(file, result, parentJob);
            }
        } else {
            if (isDetailed()) {
                logDetailed("---------------------------");
                logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Error.FileConverted", file,
                        convertToUnix ? "UNIX" : "DOS"));
            }
            // Update processed files number
            updateProcessedFormed();
            if (resultfilenames.equals(ADD_ALL_FILENAMES) || resultfilenames.equals(ADD_PROCESSED_FILES_ONLY)) {
                addFileToResultFilenames(file, result, parentJob);
            }
        }

    } catch (Exception e) {
        throw new KettleException("Unable to convert file '" + file.toString() + "'", e);
    }
    return retval;
}

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

private void addFileToResultFilenames(FileObject fileaddentry, Result result, Job parentJob) {
    try {/*from   www.ja  v a  2 s  . c  o m*/
        ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, fileaddentry,
                parentJob.getJobname(), toString());
        result.getResultFiles().put(resultFile.getFile().toString(), resultFile);

        if (isDetailed()) {
            logDetailed(
                    BaseMessages.getString(PKG, "JobDosToUnix.Log.FileAddedToResultFilesName", fileaddentry));
        }

    } catch (Exception e) {
        logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.AddingToFilenameResult",
                fileaddentry.toString(), e.getMessage()));
    }
}

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  w ww .  j a v a 2s . co m
    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   ww w. j  a v  a2  s  .  c  o  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 */
            }
        }
    }
}

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

private void getFileSize(FileObject file, Result result, Job parentJob) {
    try {// w w  w  .j  a  v  a2 s. c  o m

        incrementFilesCount();
        if (isDetailed()) {
            logDetailed(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.GetFile", file.toString(),
                    String.valueOf(getFilesCount())));
        }
        switch (evaluationType) {
        case EVALUATE_TYPE_SIZE:
            BigDecimal fileSize = BigDecimal.valueOf(file.getContent().getSize());
            evaluationValue = evaluationValue.add(fileSize);
            if (isDebug()) {
                logDebug(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Log.AddedFileSize",
                        String.valueOf(fileSize), file.toString()));
            }
            break;
        default:
            evaluationValue = evaluationValue.add(ONE);
            break;
        }
    } catch (Exception e) {
        incrementErrors();
        logError(BaseMessages.getString(PKG, "JobEvalFilesMetrics.Error.GettingFileSize", file.toString(),
                e.toString()));
    }
}

From source file:org.pentaho.di.job.entries.folderisempty.JobEntryFolderIsEmpty.java

public Result execute(Result previousResult, int nr) {
    // see PDI-10270 for details
    boolean oldBehavior = "Y"
            .equalsIgnoreCase(getVariable(Const.KETTLE_COMPATIBILITY_SET_ERROR_ON_SPECIFIC_JOB_ENTRIES, "N"));

    Result result = previousResult;
    result.setResult(false);//from w w  w.  j av a2s .  co m
    result.setNrErrors(oldBehavior ? 1 : 0);

    filescount = 0;
    folderscount = 0;
    pattern = null;

    if (!Const.isEmpty(getWildcard())) {
        pattern = Pattern.compile(getRealWildcard());
    }

    if (foldername != null) {
        String realFoldername = getRealFoldername();
        FileObject folderObject = null;
        try {
            folderObject = KettleVFS.getFileObject(realFoldername, this);
            if (folderObject.exists()) {
                // Check if it's a folder
                if (folderObject.getType() == FileType.FOLDER) {
                    // File provided is a folder, so we can process ...
                    try {
                        folderObject.findFiles(new TextFileSelector(folderObject.toString()));
                    } catch (Exception ex) {
                        if (!(ex.getCause() instanceof ExpectedException)) {
                            throw ex;
                        }
                    }
                    if (log.isBasic()) {
                        log.logBasic("Total files", "We found : " + filescount + " file(s)");
                    }
                    if (filescount == 0) {
                        result.setResult(true);
                        result.setNrLinesInput(folderscount);
                    }
                } else {
                    // Not a folder, fail
                    log.logError("[" + realFoldername + "] is not a folder, failing.");
                    result.setNrErrors(1);
                }
            } else {
                // No Folder found
                if (log.isBasic()) {
                    logBasic("we can not find [" + realFoldername + "] !");
                }
                result.setNrErrors(1);
            }
        } catch (Exception e) {
            logError("Error checking 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.");
        result.setNrErrors(1);
    }

    return result;
}