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

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

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

Introduction

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

Prototype

public void close() throws FileSystemException;

Source Link

Document

Closes this file, and its content.

Usage

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 {/*  ww  w .  jav a2s  .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);//  w w w.j ava2 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  ava 2s.c om
        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.filecompare.JobEntryFileCompare.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);/*  w  w  w  .ja  va  2 s  .c  om*/

    String realFilename1 = getRealFilename1();
    String realFilename2 = getRealFilename2();

    FileObject file1 = null;
    FileObject file2 = null;
    try {
        if (filename1 != null && filename2 != null) {
            file1 = KettleVFS.getFileObject(realFilename1, this);
            file2 = KettleVFS.getFileObject(realFilename2, this);

            if (file1.exists() && file2.exists()) {
                if (equalFileContents(file1, file2)) {
                    result.setResult(true);
                } else {
                    result.setResult(false);
                }

                // add filename to result filenames
                if (addFilenameToResult && file1.getType() == FileType.FILE
                        && file2.getType() == FileType.FILE) {
                    ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, file1,
                            parentJob.getJobname(), toString());
                    resultFile.setComment(BaseMessages.getString(PKG, "JobWaitForFile.FilenameAdded"));
                    result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
                    resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, file2, parentJob.getJobname(),
                            toString());
                    resultFile.setComment(BaseMessages.getString(PKG, "JobWaitForFile.FilenameAdded"));
                    result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
                }
            } else {
                if (!file1.exists()) {
                    logError(BaseMessages.getString(PKG, "JobEntryFileCompare.ERROR_0004_File1_Does_Not_Exist",
                            realFilename1));
                }
                if (!file2.exists()) {
                    logError(BaseMessages.getString(PKG, "JobEntryFileCompare.ERROR_0005_File2_Does_Not_Exist",
                            realFilename2));
                }
                result.setResult(false);
                result.setNrErrors(1);
            }
        } else {
            logError(BaseMessages.getString(PKG, "JobEntryFileCompare.ERROR_0006_Need_Two_Filenames"));
        }
    } catch (Exception e) {
        result.setResult(false);
        result.setNrErrors(1);
        logError(BaseMessages.getString(PKG, "JobEntryFileCompare.ERROR_0007_Comparing_Files", realFilename2,
                realFilename2, e.getMessage()));
    } finally {
        try {
            if (file1 != null) {
                file1.close();
                file1 = null;
            }

            if (file2 != null) {
                file2.close();
                file2 = null;
            }
        } catch (IOException e) {
            // Ignore errors
        }
    }

    return result;
}

From source file:org.pentaho.di.job.entries.filesexist.JobEntryFilesExist.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);//from   w  ww . j a  v a2 s.co  m
    result.setNrErrors(0);
    int missingfiles = 0;
    int nrErrors = 0;

    // see PDI-10270 for details
    boolean oldBehavior = "Y"
            .equalsIgnoreCase(getVariable(Const.KETTLE_COMPATIBILITY_SET_ERROR_ON_SPECIFIC_JOB_ENTRIES, "N"));

    if (arguments != null) {
        for (int i = 0; i < arguments.length && !parentJob.isStopped(); i++) {
            FileObject file = null;

            try {
                String realFilefoldername = environmentSubstitute(arguments[i]);
                file = KettleVFS.getFileObject(realFilefoldername, this);

                if (file.exists() && file.isReadable()) // TODO: is it needed to check file for readability?
                {
                    if (log.isDetailed()) {
                        logDetailed(BaseMessages.getString(PKG, "JobEntryFilesExist.File_Exists",
                                realFilefoldername));
                    }
                } else {
                    missingfiles++;
                    if (log.isDetailed()) {
                        logDetailed(BaseMessages.getString(PKG, "JobEntryFilesExist.File_Does_Not_Exist",
                                realFilefoldername));
                    }
                }

            } catch (Exception e) {
                nrErrors++;
                missingfiles++;
                logError(
                        BaseMessages.getString(PKG, "JobEntryFilesExist.ERROR_0004_IO_Exception", e.toString()),
                        e);
            } finally {
                if (file != null) {
                    try {
                        file.close();
                        file = null;
                    } catch (IOException ex) { /* Ignore */
                    }
                }
            }
        }

    }

    result.setNrErrors(nrErrors);

    if (oldBehavior) {
        result.setNrErrors(missingfiles);
    }

    if (missingfiles == 0) {
        result.setResult(true);
    }

    return result;
}

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  ava 2s.  c  o  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;
}

From source file:org.pentaho.di.job.entries.folderscompare.JobEntryFoldersCompare.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);//from   w  ww .jav a2s  . c om
    boolean ok = true;

    String realFilename1 = getRealFilename1();
    String realFilename2 = getRealFilename2();

    FileObject folder1 = null;
    FileObject folder2 = null;
    FileObject filefolder1 = null;
    FileObject filefolder2 = null;

    try {
        if (filename1 != null && filename2 != null) {
            // Get Folders/Files to compare
            folder1 = KettleVFS.getFileObject(realFilename1, this);
            folder2 = KettleVFS.getFileObject(realFilename2, this);

            if (folder1.exists() && folder2.exists()) {
                if (!folder1.getType().equals(folder2.getType())) {
                    // pb...we try to compare file with folder !!!
                    logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.CanNotCompareFilesFolders"));

                    if (folder1.getType() == FileType.FILE) {
                        logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.IsAFile", realFilename1));
                    } else if (folder1.getType() == FileType.FOLDER) {
                        logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.IsAFolder", realFilename1));
                    } else {
                        logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.IsUnknownFileType",
                                realFilename1));
                    }

                    if (folder2.getType() == FileType.FILE) {
                        logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.IsAFile", realFilename2));
                    } else if (folder2.getType() == FileType.FOLDER) {
                        logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.IsAFolder", realFilename2));
                    } else {
                        logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.IsUnknownFileType",
                                realFilename2));
                    }

                } else {
                    if (folder1.getType() == FileType.FILE) {
                        // simply compare 2 files ..
                        if (equalFileContents(folder1, folder2)) {
                            result.setResult(true);
                        } else {
                            result.setResult(false);
                        }
                    } else if (folder1.getType() == FileType.FOLDER) {
                        // We compare 2 folders ...

                        FileObject[] list1 = folder1.findFiles(new TextFileSelector(folder1.toString()));
                        FileObject[] list2 = folder2.findFiles(new TextFileSelector(folder2.toString()));

                        int lenList1 = list1.length;
                        int lenList2 = list2.length;

                        if (log.isDetailed()) {
                            logDetailed(BaseMessages.getString(PKG, "JobFoldersCompare.Log.FolderContains",
                                    realFilename1, "" + lenList1));
                            logDetailed(BaseMessages.getString(PKG, "JobFoldersCompare.Log.FolderContains",
                                    realFilename2, "" + lenList2));
                        }
                        if (lenList1 == lenList2) {

                            HashMap<String, String> collection1 = new HashMap<String, String>();
                            HashMap<String, String> collection2 = new HashMap<String, String>();

                            for (int i = 0; i < list1.length; i++) {
                                // Put files list1 in TreeMap collection1
                                collection1.put(list1[i].getName().getBaseName(), list1[i].toString());
                            }

                            for (int i = 0; i < list2.length; i++) {
                                // Put files list2 in TreeMap collection2
                                collection2.put(list2[i].getName().getBaseName(), list2[i].toString());
                            }

                            // Let's now fetch Folder1
                            // and for each entry, we will search it in Folder2
                            // if the entry exists..we will compare file entry (file or folder?)
                            // if the 2 entry are file (not folder), we will compare content
                            Set<Map.Entry<String, String>> entrees = collection1.entrySet();
                            Iterator<Map.Entry<String, String>> iterateur = entrees.iterator();

                            while (iterateur.hasNext()) {
                                Map.Entry<String, String> entree = iterateur.next();
                                if (!collection2.containsKey(entree.getKey())) {
                                    ok = false;
                                    if (log.isDetailed()) {
                                        logDetailed(BaseMessages.getString(PKG,
                                                "JobFoldersCompare.Log.FileCanNotBeFoundIn",
                                                entree.getKey().toString(), realFilename2));
                                    }
                                } else {
                                    if (log.isDebug()) {
                                        logDebug(BaseMessages.getString(PKG,
                                                "JobFoldersCompare.Log.FileIsFoundIn",
                                                entree.getKey().toString(), realFilename2));
                                    }

                                    filefolder1 = KettleVFS.getFileObject(entree.getValue().toString(), this);
                                    filefolder2 = KettleVFS
                                            .getFileObject(collection2.get(entree.getKey()).toString(), this);

                                    if (!filefolder2.getType().equals(filefolder1.getType())) {
                                        // The file1 exist in the folder2..but they don't have the same type
                                        ok = false;
                                        if (log.isDetailed()) {
                                            logDetailed(BaseMessages.getString(PKG,
                                                    "JobFoldersCompare.Log.FilesNotSameType",
                                                    filefolder1.toString(), filefolder2.toString()));
                                        }

                                        if (filefolder1.getType() == FileType.FILE) {
                                            logError(BaseMessages.getString(PKG,
                                                    "JobFoldersCompare.Log.IsAFile", filefolder1.toString()));
                                        } else if (filefolder1.getType() == FileType.FOLDER) {
                                            logError(BaseMessages.getString(PKG,
                                                    "JobFoldersCompare.Log.IsAFolder", filefolder1.toString()));
                                        } else {
                                            logError(BaseMessages.getString(PKG,
                                                    "JobFoldersCompare.Log.IsUnknownFileType",
                                                    filefolder1.toString()));
                                        }

                                        if (filefolder2.getType() == FileType.FILE) {
                                            logError(BaseMessages.getString(PKG,
                                                    "JobFoldersCompare.Log.IsAFile", filefolder2.toString()));
                                        } else if (filefolder2.getType() == FileType.FOLDER) {
                                            logError(BaseMessages.getString(PKG,
                                                    "JobFoldersCompare.Log.IsAFolder", filefolder2.toString()));
                                        } else {
                                            logError(BaseMessages.getString(PKG,
                                                    "JobFoldersCompare.Log.IsUnknownFileType",
                                                    filefolder2.toString()));
                                        }

                                    } else {
                                        // Files are the same type ...
                                        if (filefolder2.getType() == FileType.FILE) {
                                            // Let's compare file size
                                            if (comparefilesize) {
                                                long filefolder1_size = filefolder1.getContent().getSize();
                                                long filefolder2_size = filefolder2.getContent().getSize();
                                                if (filefolder1_size != filefolder2_size) {
                                                    ok = false;
                                                    if (log.isDetailed()) {
                                                        logDetailed(BaseMessages.getString(PKG,
                                                                "JobFoldersCompare.Log.FilesNotSameSize",
                                                                filefolder1.toString(),
                                                                filefolder2.toString()));
                                                        logDetailed(BaseMessages.getString(PKG,
                                                                "JobFoldersCompare.Log.SizeFileIs",
                                                                filefolder1.toString(), "" + filefolder1_size));
                                                        logDetailed(BaseMessages.getString(PKG,
                                                                "JobFoldersCompare.Log.SizeFileIs",
                                                                filefolder2.toString(), "" + filefolder2_size));
                                                    }
                                                }
                                            }

                                            if (ok) {
                                                // Let's compare files content..
                                                if (comparefilecontent) {
                                                    if (!equalFileContents(filefolder1, filefolder2)) {
                                                        ok = false;
                                                        if (log.isDetailed()) {
                                                            logDetailed(BaseMessages.getString(PKG,
                                                                    "JobFoldersCompare.Log.FilesNotSameContent",
                                                                    filefolder1.toString(),
                                                                    filefolder2.toString()));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }

                                }
                                // logBasic(entree.getKey() + " - " + entree.getValue());
                            }

                            result.setResult(ok);
                        } else {
                            // The 2 folders don't have the same files number
                            if (log.isDetailed()) {
                                logDetailed(BaseMessages.getString(PKG,
                                        "JobFoldersCompare.Log.FoldersDifferentFiles", realFilename1.toString(),
                                        realFilename2.toString()));
                            }
                        }

                    }
                    // else: File type unknown !!
                }

            } else {
                if (!folder1.exists()) {
                    logError(BaseMessages.getString(PKG, "JobFileCompare.Log.FileNotExist", realFilename1));
                }
                if (!folder2.exists()) {
                    logError(BaseMessages.getString(PKG, "JobFileCompare.Log.FileNotExist", realFilename2));
                }
                result.setResult(false);
                result.setNrErrors(1);
            }
        } else {
            logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.Need2Files"));
        }
    } catch (Exception e) {
        result.setResult(false);
        result.setNrErrors(1);
        logError(BaseMessages.getString(PKG, "JobFoldersCompare.Log.ErrorComparing", realFilename2,
                realFilename2, e.getMessage()));
    } finally {
        try {
            if (folder1 != null) {
                folder1.close();
                folder1 = null;
            }
            if (folder2 != null) {
                folder2.close();
                folder2 = null;
            }
            if (filefolder1 != null) {
                filefolder1.close();
                filefolder1 = null;
            }
            if (filefolder2 != null) {
                filefolder2.close();
                filefolder2 = null;
            }
        } catch (IOException e) {
            // Ignore errors
        }
    }

    return result;
}

From source file:org.pentaho.di.job.entries.ftp.JobEntryFTP.java

private void addFilenameToResultFilenames(Result result, Job parentJob, String filename)
        throws KettleException {
    if (isaddresult) {
        FileObject targetFile = null;
        try {//from ww  w  . ja  v  a2  s  . c  o  m
            targetFile = KettleVFS.getFileObject(filename, this);

            // Add to the result files...
            ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, targetFile,
                    parentJob.getJobname(), toString());
            resultFile.setComment(BaseMessages.getString(PKG, "JobEntryFTP.Downloaded", serverName));
            result.getResultFiles().put(resultFile.getFile().toString(), resultFile);

            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobEntryFTP.FileAddedToResult", filename));
            }
        } catch (Exception e) {
            throw new KettleException(e);
        } finally {
            try {
                targetFile.close();
                targetFile = null;
            } catch (Exception e) {
                // Ignore close errors
            }
        }
    }
}

From source file:org.pentaho.di.job.entries.ftpsget.FTPSConnection.java

/**
 *
 * this method is used to upload a file to a remote host
 *
 * @param localFileName/*from  w  w w.  j  a v  a  2 s .  c  o m*/
 *          Local full filename
 * @param shortFileName
 *          Filename in remote host
 * @throws KettleException
 */
public void uploadFile(String localFileName, String shortFileName) throws KettleException {
    FileObject file = null;

    try {
        file = KettleVFS.getFileObject(localFileName);
        this.connection.uploadStream(file.getContent().getInputStream(), new FTPFile(new File(shortFileName)));
    } catch (Exception e) {
        throw new KettleException(BaseMessages.getString(PKG, "JobFTPS.Error.UuploadingFile", localFileName),
                e);
    } finally {
        if (file != null) {
            try {
                file.close();
            } catch (Exception e) {
                // Ignore close errors
            }
        }
    }
}

From source file:org.pentaho.di.job.entries.ftpsget.JobEntryFTPSGet.java

private void addFilenameToResultFilenames(Result result, String filename) throws KettleException {
    if (isaddresult) {
        FileObject targetFile = null;
        try {//  w ww .  j a va  2 s .c  o m
            targetFile = KettleVFS.getFileObject(filename);

            // Add to the result files...
            ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, targetFile,
                    parentJob.getJobname(), toString());
            resultFile.setComment(BaseMessages.getString(PKG, "JobEntryFTPS.Downloaded", serverName));
            result.getResultFiles().put(resultFile.getFile().toString(), resultFile);

            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobEntryFTPS.FileAddedToResult", filename));
            }
        } catch (Exception e) {
            throw new KettleException(e);
        } finally {
            try {
                targetFile.close();
                targetFile = null;
            } catch (Exception e) {
                // Ignore errors
            }
        }
    }
}