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.copymoveresultfilenames.JobEntryCopyMoveResultFilenames.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setNrErrors(1);/*from w w w  . j a v a2s. c o  m*/
    result.setResult(false);

    boolean deleteFile = getAction().equals("delete");

    String realdestinationFolder = null;
    if (!deleteFile) {
        realdestinationFolder = environmentSubstitute(getDestinationFolder());

        if (!CreateDestinationFolder(realdestinationFolder)) {
            return result;
        }
    }
    if (!Const.isEmpty(wildcard)) {
        wildcardPattern = Pattern.compile(environmentSubstitute(wildcard));
    }
    if (!Const.isEmpty(wildcardexclude)) {
        wildcardExcludePattern = Pattern.compile(environmentSubstitute(wildcardexclude));
    }

    if (previousResult != null) {
        NrErrors = 0;
        limitFiles = Const.toInt(environmentSubstitute(getNrErrorsLessThan()), 10);
        NrErrors = 0;
        NrSuccess = 0;
        successConditionBroken = false;
        successConditionBrokenExit = false;

        FileObject file = null;

        try {
            int size = result.getResultFiles().size();
            if (log.isBasic()) {
                logBasic(BaseMessages.getString(PKG, "JobEntryCopyMoveResultFilenames.log.FilesFound",
                        "" + size));
            }

            List<ResultFile> resultFiles = result.getResultFilesList();
            if (resultFiles != null && resultFiles.size() > 0) {
                for (Iterator<ResultFile> it = resultFiles.iterator(); it.hasNext()
                        && !parentJob.isStopped();) {
                    if (successConditionBroken) {
                        logError(BaseMessages.getString(PKG,
                                "JobEntryCopyMoveResultFilenames.Error.SuccessConditionbroken", "" + NrErrors));
                        throw new Exception(BaseMessages.getString(PKG,
                                "JobEntryCopyMoveResultFilenames.Error.SuccessConditionbroken", "" + NrErrors));
                    }

                    ResultFile resultFile = it.next();
                    file = resultFile.getFile();
                    if (file != null && file.exists()) {
                        if (!specifywildcard
                                || (CheckFileWildcard(file.getName().getBaseName(), wildcardPattern, true)
                                        && !CheckFileWildcard(file.getName().getBaseName(),
                                                wildcardExcludePattern, false)
                                        && specifywildcard)) {
                            // Copy or Move file
                            if (!processFile(file, realdestinationFolder, result, parentJob, deleteFile)) {
                                // Update Errors
                                updateErrors();
                            }
                        }

                    } else {
                        logError(BaseMessages.getString(PKG,
                                "JobEntryCopyMoveResultFilenames.log.ErrorCanNotFindFile", file.toString()));
                        // Update Errors
                        updateErrors();
                    }
                } // end for
            }
        } catch (Exception e) {
            logError(BaseMessages.getString(PKG, "JobEntryCopyMoveResultFilenames.Error", e.toString()));
        } finally {
            if (file != null) {
                try {
                    file.close();
                    file = null;
                } catch (Exception ex) { /* Ignore */
                }
            }
        }
    }
    // Success Condition
    result.setNrErrors(NrErrors);
    result.setNrLinesWritten(NrSuccess);
    if (getSuccessStatus()) {
        result.setResult(true);
    }

    return result;
}

From source file:org.pentaho.di.job.entries.copymoveresultfilenames.JobEntryCopyMoveResultFilenames.java

private boolean CreateDestinationFolder(String foldername) {
    FileObject folder = null;
    try {//from  w  ww. jav a2 s  .  co m
        folder = KettleVFS.getFileObject(foldername, this);

        if (!folder.exists()) {
            logError(BaseMessages.getString(PKG, "JobEntryCopyMoveResultFilenames.Log.FolderNotExists",
                    foldername));
            if (isCreateDestinationFolder()) {
                folder.createFolder();
            } else {
                return false;
            }
            if (log.isBasic()) {
                logBasic(BaseMessages.getString(PKG, "JobEntryCopyMoveResultFilenames.Log.FolderCreated",
                        foldername));
            }
        } else {
            if (log.isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobEntryCopyMoveResultFilenames.Log.FolderExists",
                        foldername));
            }
        }
        return true;
    } catch (Exception e) {
        logError(BaseMessages.getString(PKG, "JobEntryCopyMoveResultFilenames.Log.CanNotCreatedFolder",
                foldername, e.toString()));

    } finally {
        if (folder != null) {
            try {
                folder.close();
                folder = null;
            } catch (Exception ex) { /* Ignore */
            }
        }
    }
    return false;
}

From source file:org.pentaho.di.job.entries.createfile.JobEntryCreateFile.java

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

    if (filename != null) {
        String realFilename = getRealFilename();
        FileObject fileObject = null;
        try {
            fileObject = KettleVFS.getFileObject(realFilename, this);

            if (fileObject.exists()) {
                if (isFailIfFileExists()) {
                    // File exists and fail flag is on.
                    result.setResult(false);
                    logError("File [" + realFilename + "] exists, failing.");
                } else {
                    // File already exists, no reason to try to create it
                    result.setResult(true);
                    logBasic("File [" + realFilename + "] already exists, not recreating.");
                }
                // add filename to result filenames if needed
                if (isAddFilenameToResult()) {
                    addFilenameToResult(realFilename, result, parentJob);
                }
            } else {
                // No file yet, create an empty file.
                fileObject.createFile();
                logBasic("File [" + realFilename + "] created!");
                // add filename to result filenames if needed
                if (isAddFilenameToResult()) {
                    addFilenameToResult(realFilename, result, parentJob);
                }
                result.setResult(true);
            }
        } catch (IOException e) {
            logError("Could not create file [" + realFilename + "], exception: " + e.getMessage());
            result.setResult(false);
            result.setNrErrors(1);
        } finally {
            if (fileObject != null) {
                try {
                    fileObject.close();
                    fileObject = null;
                } catch (IOException ex) {
                    // Ignore
                }
            }
        }
    } else {
        logError("No filename is defined.");
    }

    return result;
}

From source file:org.pentaho.di.job.entries.createfile.JobEntryCreateFile.java

private void addFilenameToResult(String targetFilename, Result result, Job parentJob) throws KettleException {
    FileObject targetFile = null;
    try {//from  w w  w . j av  a  2s .  co m
        targetFile = KettleVFS.getFileObject(targetFilename, this);

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

        if (log.isDetailed()) {
            logDetailed(BaseMessages.getString(PKG, "JobEntryCreateFile.FileAddedToResult", targetFilename));
        }
    } 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.createfolder.JobEntryCreateFolder.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);/*w w w .  j a v a2s.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);/*from w  ww .  j a v  a2s .  c o m*/

    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 ww.  jav  a  2 s.c  o  m*/
        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 {//w w w  . j  a va 2s  .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.dostounix.JobEntryDosToUnix.java

private boolean processFileFolder(String sourcefilefoldername, String wildcard, int convertion, Job parentJob,
        Result result) {//from   ww w  . j  a v  a  2  s .co m
    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 ww w. j a  v  a2s. co  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;
}