Example usage for org.apache.commons.vfs FileType FILE

List of usage examples for org.apache.commons.vfs FileType FILE

Introduction

In this page you can find the example usage for org.apache.commons.vfs FileType FILE.

Prototype

FileType FILE

To view the source code for org.apache.commons.vfs FileType FILE.

Click Source Link

Document

A regular file.

Usage

From source file:com.panet.imeta.trans.steps.getfilenames.GetFileNames.java

public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    if (!meta.isFileField()) {
        if (data.filenr >= data.filessize) {
            setOutputDone();/*from   w ww.  j  a v a  2s .  com*/
            return false;
        }
    } else {
        if (data.filenr >= data.filessize) {
            // Grab one row from previous step ...
            data.readrow = getRow();
        }

        if (data.readrow == null) {
            setOutputDone();
            return false;
        }

        if (first) {
            first = false;

            data.inputRowMeta = getInputRowMeta();
            data.outputRowMeta = data.inputRowMeta.clone();
            meta.getFields(data.outputRowMeta, getStepname(), null, null, this);

            // Get total previous fields
            data.totalpreviousfields = data.inputRowMeta.size();

            // Check is filename field is provided
            if (Const.isEmpty(meta.getDynamicFilenameField())) {
                logError(Messages.getString("GetFileNames.Log.NoField"));
                throw new KettleException(Messages.getString("GetFileNames.Log.NoField"));
            }

            // cache the position of the field         
            if (data.indexOfFilenameField < 0) {
                data.indexOfFilenameField = data.inputRowMeta.indexOfValue(meta.getDynamicFilenameField());
                if (data.indexOfFilenameField < 0) {
                    // The field is unreachable !
                    logError(Messages.getString("GetFileNames.Log.ErrorFindingField", //$NON-NLS-1$
                            meta.getDynamicFilenameField())); //$NON-NLS-2$
                    throw new KettleException(Messages.getString("GetFileNames.Exception.CouldnotFindField", //$NON-NLS-1$
                            meta.getDynamicFilenameField())); //$NON-NLS-2$
                }
            }

            // If wildcard field is specified, Check if field exists
            if (!Const.isEmpty(meta.getDynamicWildcardField())) {
                if (data.indexOfWildcardField < 0) {
                    data.indexOfWildcardField = data.inputRowMeta.indexOfValue(meta.getDynamicWildcardField());
                    if (data.indexOfWildcardField < 0) {
                        // The field is unreachable !
                        logError(Messages.getString("GetFileNames.Log.ErrorFindingField") + "[" //$NON-NLS-1$//$NON-NLS-2$
                                + meta.getDynamicWildcardField() + "]");
                        throw new KettleException(Messages.getString("GetFileNames.Exception.CouldnotFindField", //$NON-NLS-1$
                                meta.getDynamicWildcardField())); //$NON-NLS-2$
                    }
                }
            }

        }
    } // end if first

    try {
        Object[] outputRow = buildEmptyRow();
        int outputIndex = 0;
        Object extraData[] = new Object[data.nrStepFields];
        if (meta.isFileField()) {
            if (data.filenr >= data.filessize) {
                // Get value of dynamic filename field ...
                String filename = getInputRowMeta().getString(data.readrow, data.indexOfFilenameField);
                String wildcard = "";
                if (data.indexOfWildcardField >= 0)
                    wildcard = getInputRowMeta().getString(data.readrow, data.indexOfWildcardField);

                String[] filesname = { filename };
                String[] filesmask = { wildcard };
                String[] filesrequired = { "N" };
                // Get files list
                data.files = meta.getDynamicFileList(getTransMeta(), filesname, filesmask, filesrequired);
                data.filessize = data.files.nrOfFiles();
                data.filenr = 0;
            }

            // Clone current input row
            outputRow = data.readrow.clone();
        }
        if (data.filessize > 0) {
            data.file = data.files.getFile(data.filenr);

            if (meta.isAddResultFile()) {
                // Add this to the result file names...
                ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, data.file,
                        getTransMeta().getName(), getStepname());
                resultFile.setComment(Messages.getString("GetFileNames.Log.FileReadByStep"));
                addResultFile(resultFile);
            }

            // filename
            extraData[outputIndex++] = KettleVFS.getFilename(data.file);

            // short_filename
            extraData[outputIndex++] = data.file.getName().getBaseName();

            try {
                // Path
                extraData[outputIndex++] = KettleVFS.getFilename(data.file.getParent());

                // type
                extraData[outputIndex++] = data.file.getType().toString();

                // exists
                extraData[outputIndex++] = Boolean.valueOf(data.file.exists());

                // ishidden
                extraData[outputIndex++] = Boolean.valueOf(data.file.isHidden());

                // isreadable
                extraData[outputIndex++] = Boolean.valueOf(data.file.isReadable());

                // iswriteable
                extraData[outputIndex++] = Boolean.valueOf(data.file.isWriteable());

                // lastmodifiedtime
                extraData[outputIndex++] = new Date(data.file.getContent().getLastModifiedTime());

                // size
                Long size = null;
                if (data.file.getType().equals(FileType.FILE)) {
                    size = new Long(data.file.getContent().getSize());
                }

                extraData[outputIndex++] = size;

            } catch (IOException e) {
                throw new KettleException(e);
            }

            // extension
            extraData[outputIndex++] = data.file.getName().getExtension();

            // uri   
            extraData[outputIndex++] = data.file.getName().getURI();

            // rooturi   
            extraData[outputIndex++] = data.file.getName().getRootURI();

            // See if we need to add the row number to the row...  
            if (meta.includeRowNumber() && !Const.isEmpty(meta.getRowNumberField())) {
                extraData[outputIndex++] = new Long(data.rownr);
            }

            data.rownr++;
            // Add row data
            outputRow = RowDataUtil.addRowData(outputRow, data.totalpreviousfields, extraData);
            // Send row
            putRow(data.outputRowMeta, outputRow);

            if (meta.getRowLimit() > 0 && data.rownr >= meta.getRowLimit()) // limit has been reached: stop now.
            {
                setOutputDone();
                return false;
            }

        }
    } catch (Exception e) {
        throw new KettleStepException(e);
    }

    data.filenr++;

    if (checkFeedback(getLinesInput())) {
        if (log.isBasic())
            logBasic(Messages.getString("GetFileNames.Log.NrLine", "" + getLinesInput()));
    }

    return true;
}

From source file:com.vobject.appengine.java.io.File.java

public boolean isFile() {
    boolean isFile = false;

    try {//from   w  w w. ja v a 2 s.  c  o m
        isFile = (file.getType() == FileType.FILE);
    } catch (FileSystemException e) {
        e.printStackTrace();
    }

    return isFile;
}

From source file:com.panet.imeta.job.entries.filecompare.JobEntryFileCompare.java

public Result execute(Result previousResult, int nr, Repository rep, Job parentJob) {
    LogWriter log = LogWriter.getInstance();
    Result result = previousResult;
    result.setResult(false);/*w  ww. j ava  2 s. c o  m*/

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

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

            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(Messages.getString("JobWaitForFile.FilenameAdded"));
                    result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
                    resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, file2, parentJob.getJobname(),
                            toString());
                    resultFile.setComment(Messages.getString("JobWaitForFile.FilenameAdded"));
                    result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
                }
            } else {
                if (!file1.exists())
                    log.logError(toString(), Messages
                            .getString("JobEntryFileCompare.ERROR_0004_File1_Does_Not_Exist", realFilename1)); //$NON-NLS-1$
                if (!file2.exists())
                    log.logError(toString(), Messages
                            .getString("JobEntryFileCompare.ERROR_0005_File2_Does_Not_Exist", realFilename2)); //$NON-NLS-1$
                result.setResult(false);
                result.setNrErrors(1);
            }
        } else {
            log.logError(toString(), Messages.getString("JobEntryFileCompare.ERROR_0006_Need_Two_Filenames")); //$NON-NLS-1$
        }
    } catch (Exception e) {
        result.setResult(false);
        result.setNrErrors(1);
        log.logError(toString(), Messages.getString("JobEntryFileCompare.ERROR_0007_Comparing_Files", //$NON-NLS-1$
                realFilename2, realFilename2, e.getMessage()));
    } finally {
        try {
            if (file1 != null)
                file1.close();

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

    return result;
}

From source file:net.sf.jvifm.ui.ZipLister.java

private void sortFiles(FileObject[] children) {
    Arrays.sort(children, new Comparator() {
        public int compare(Object o1, Object o2) {

            try {
                FileType fileType1 = ((FileObject) o1).getType();
                FileType fileType2 = ((FileObject) o2).getType();
                String filename1 = ((FileObject) o1).getName().getBaseName();
                String filename2 = ((FileObject) o2).getName().getBaseName();
                if (fileType1.equals(FileType.FILE) && fileType2.equals(FileType.FOLDER)) {
                    return 1;
                }/*  w ww . jav  a  2 s  . c  o m*/
                if (fileType2.equals(FileType.FILE) && fileType1.equals(FileType.FOLDER)) {
                    return -1;
                }
                return filename1.compareTo(filename2);
            } catch (Exception e) {
                return 1;
            }
        }

    });

}

From source file:com.github.stephenc.javaisotools.iso9660.impl.CreateISOTest.java

@Test
public void canCreateAnIsoWithLoadsOfFiles() throws Exception {
    final int numFiles = entropy.nextInt(50) + 50;
    // Output file
    File outfile = new File(workDir, "big.iso");
    File rootDir = new File(workDir, "big");
    assertThat(rootDir.isDirectory() || rootDir.mkdirs(), is(true));

    // Directory hierarchy, starting from the root
    ISO9660RootDirectory.MOVED_DIRECTORIES_STORE_NAME = "rr_moved";
    ISO9660RootDirectory root = new ISO9660RootDirectory();
    for (int i = 0; i < numFiles; i++) {
        File content = new File(rootDir, Integer.toString(i) + ".bin");
        int length = entropy.nextInt(1024 * 10 + 1);
        byte[] contents = new byte[length];
        entropy.nextBytes(contents);//  ww  w  .j  av a2  s.c  o  m
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(content);
            fos.write(contents);
        } finally {
            IOUtil.close(fos);
        }
        root.addFile(content);
    }

    StreamHandler streamHandler = new ISOImageFileHandler(outfile);
    CreateISO iso = new CreateISO(streamHandler, root);
    ISO9660Config iso9660Config = new ISO9660Config();
    iso9660Config.allowASCII(false);
    iso9660Config.setInterchangeLevel(2);
    iso9660Config.restrictDirDepthTo8(true);
    iso9660Config.setVolumeID("ISO Test");
    iso9660Config.forceDotDelimiter(true);
    RockRidgeConfig rrConfig = new RockRidgeConfig();
    rrConfig.setMkisofsCompatibility(true);
    rrConfig.hideMovedDirectoriesStore(true);
    rrConfig.forcePortableFilenameCharacterSet(true);

    JolietConfig jolietConfig = new JolietConfig();
    jolietConfig.setVolumeID("Joliet Test");
    jolietConfig.forceDotDelimiter(true);

    iso.process(iso9660Config, rrConfig, jolietConfig, null);

    assertThat(outfile.isFile(), is(true));
    assertThat(outfile.length(), not(is(0L)));

    FileSystemManager fsManager = VFS.getManager();
    for (int i = 0; i < numFiles; i++) {
        File content = new File(rootDir, Integer.toString(i) + ".bin");
        FileObject t = fsManager.resolveFile("iso:" + outfile.getPath() + "!/" + Integer.toString(i) + ".bin");
        assertThat(t, CoreMatchers.<Object>notNullValue());
        assertThat(t.getType(), is(FileType.FILE));
        assertThat(t.getContent().getSize(), is(content.length()));
        assertThat(IOUtil.toByteArray(t.getContent().getInputStream()),
                is(IOUtil.toByteArray(new FileInputStream(content))));
    }
}

From source file:com.panet.imeta.job.entries.waitforfile.JobEntryWaitForFile.java

public Result execute(Result previousResult, int nr, Repository rep, Job parentJob) {
    LogWriter log = LogWriter.getInstance();
    Result result = previousResult;
    result.setResult(false);//from   w  w  w. j  a v a2s .c om

    // starttime (in seconds)
    long timeStart = System.currentTimeMillis() / 1000;

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

            long iMaximumTimeout = Const.toInt(getRealMaximumTimeout(),
                    Const.toInt(DEFAULT_MAXIMUM_TIMEOUT, 0));
            long iCycleTime = Const.toInt(getRealCheckCycleTime(), Const.toInt(DEFAULT_CHECK_CYCLE_TIME, 0));

            //
            // Sanity check on some values, and complain on insanity
            //
            if (iMaximumTimeout < 0) {
                iMaximumTimeout = Const.toInt(DEFAULT_MAXIMUM_TIMEOUT, 0);
                if (log.isBasic())
                    log.logBasic(toString(), "Maximum timeout invalid, reset to " + iMaximumTimeout);
            }

            if (iCycleTime < 1) {
                // If lower than 1 set to the default
                iCycleTime = Const.toInt(DEFAULT_CHECK_CYCLE_TIME, 1);
                if (log.isBasic())
                    log.logBasic(toString(), "Check cycle time invalid, reset to " + iCycleTime);
            }

            if (iMaximumTimeout == 0) {
                if (log.isBasic())
                    log.logBasic(toString(), "Waiting indefinitely for file [" + realFilename + "]");
            } else {
                if (log.isBasic())
                    log.logBasic(toString(),
                            "Waiting " + iMaximumTimeout + " seconds for file [" + realFilename + "]");
            }

            boolean continueLoop = true;
            while (continueLoop && !parentJob.isStopped()) {
                fileObject = KettleVFS.getFileObject(realFilename);

                if (fileObject.exists()) {
                    // file exists, we're happy to exit
                    if (log.isBasic())
                        log.logBasic(toString(), "Detected file [" + realFilename + "] within timeout");
                    result.setResult(true);
                    continueLoop = false;

                    // add filename to result filenames
                    if (addFilenameToResult && fileObject.getType() == FileType.FILE) {
                        ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, fileObject,
                                parentJob.getJobname(), toString());
                        resultFile.setComment(Messages.getString("JobWaitForFile.FilenameAdded"));
                        result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
                    }
                } else {
                    long now = System.currentTimeMillis() / 1000;

                    if ((iMaximumTimeout > 0) && (now > (timeStart + iMaximumTimeout))) {
                        continueLoop = false;

                        // file doesn't exist after timeout, either true or
                        // false
                        if (isSuccessOnTimeout()) {
                            if (log.isBasic())
                                log.logBasic(toString(),
                                        "Didn't detect file [" + realFilename + "] before timeout, success");
                            result.setResult(true);
                        } else {
                            if (log.isBasic())
                                log.logBasic(toString(),
                                        "Didn't detect file [" + realFilename + "] before timeout, failure");
                            result.setResult(false);
                        }
                    }

                    // sleep algorithm
                    long sleepTime = 0;

                    if (iMaximumTimeout == 0) {
                        sleepTime = iCycleTime;
                    } else {
                        if ((now + iCycleTime) < (timeStart + iMaximumTimeout)) {
                            sleepTime = iCycleTime;
                        } else {
                            sleepTime = iCycleTime - ((now + iCycleTime) - (timeStart + iMaximumTimeout));
                        }
                    }

                    try {
                        if (sleepTime > 0) {
                            if (log.isDetailed()) {
                                log.logDetailed(toString(), "Sleeping " + sleepTime
                                        + " seconds before next check for file [" + realFilename + "]");
                            }
                            Thread.sleep(sleepTime * 1000);
                        }
                    } catch (InterruptedException e) {
                        // something strange happened
                        result.setResult(false);
                        continueLoop = false;
                    }
                }
            }

            if (!parentJob.isStopped() && fileObject.exists() && isFileSizeCheck()) {
                long oldSize = -1;
                long newSize = fileObject.getContent().getSize();

                if (log.isDetailed())
                    log.logDetailed(toString(), "File [" + realFilename + "] is " + newSize + " bytes long");
                if (log.isBasic())
                    log.logBasic(toString(), "Waiting until file [" + realFilename + "] stops growing for "
                            + iCycleTime + " seconds");
                while (oldSize != newSize && !parentJob.isStopped()) {
                    try {
                        if (log.isDetailed()) {
                            log.logDetailed(toString(), "Sleeping " + iCycleTime
                                    + " seconds, waiting for file [" + realFilename + "] to stop growing");
                        }
                        Thread.sleep(iCycleTime * 1000);
                    } catch (InterruptedException e) {
                        // something strange happened
                        result.setResult(false);
                        continueLoop = false;
                    }
                    oldSize = newSize;
                    newSize = fileObject.getContent().getSize();
                    if (log.isDetailed()) {
                        log.logDetailed(toString(),
                                "File [" + realFilename + "] is " + newSize + " bytes long");
                    }
                }
                if (log.isBasic())
                    log.logBasic(toString(), "Stopped waiting for file [" + realFilename + "] to stop growing");
            }

            if (parentJob.isStopped()) {
                result.setResult(false);
            }
        } catch (IOException e) {
            log.logBasic(toString(), "Exception while waiting for file [" + realFilename + "] to stop growing: "
                    + e.getMessage());
        } finally {
            if (fileObject != null) {
                try {
                    fileObject.close();
                } catch (Exception e) {
                }
            }
        }
    } else {
        log.logError(toString(), "No filename is defined.");
    }

    return result;
}

From source file:com.naryx.tagfusion.cfm.file.vfs.cfVFSData.java

public void populateInfo() {
    setData("name", new cfStringData(getFileName()));
    setData("path", new cfStringData(getFullName()));
    setData("filepath", new cfStringData(getFullName()));
    setData("parent", new cfStringData(getParent()));

    if (fileObject != null) {
        try {//from ww w.jav  a 2 s .co  m
            setData("size", new cfNumberData(fileObject.getContent().getSize()));
        } catch (Exception e) {
            setData("size", new cfNumberData(0));
        }

        try {
            setData("lastmodified", new cfDateData(fileObject.getContent().getLastModifiedTime()));
        } catch (Exception e) {
            setData("lastmodified", cfStringData.EMPTY_STRING);
        }

        try {
            setData("canread", cfBooleanData.getcfBooleanData(fileObject.isReadable()));
        } catch (Exception e) {
            setData("canread", cfBooleanData.FALSE);
        }

        try {
            setData("canwrite", cfBooleanData.getcfBooleanData(fileObject.isWriteable()));
        } catch (Exception e) {
            setData("canwrite", cfBooleanData.FALSE);
        }

        try {
            setData("ishidden", cfBooleanData.getcfBooleanData(fileObject.isHidden()));
        } catch (Exception e) {
            setData("ishidden", cfBooleanData.FALSE);
        }

        try {
            setData("type", fileObject.getType() == FileType.FILE ? new cfStringData("file")
                    : new cfStringData("directory"));
        } catch (Exception e) {
            setData("type", new cfStringData("unknown"));
        }

    } else {
        setData("size", new cfNumberData(file.length()));
        setData("lastmodified", new cfDateData(file.lastModified()));
        setData("canread", cfBooleanData.getcfBooleanData(file.canRead()));
        setData("canwrite", cfBooleanData.getcfBooleanData(file.canWrite()));
        setData("canexecute", cfBooleanData.getcfBooleanData(file.canExecute()));
        setData("ishidden", cfBooleanData.getcfBooleanData(file.isHidden()));
        setData("type", file.isDirectory() ? new cfStringData("directory") : new cfStringData("file"));
    }

}

From source file:com.panet.imeta.job.entries.folderscompare.JobEntryFoldersCompare.java

public Result execute(Result previousResult, int nr, Repository rep, Job parentJob) {
    LogWriter log = LogWriter.getInstance();
    Result result = previousResult;
    result.setResult(false);/*  w  ww  . j  a v a  2s .c o  m*/
    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);
            folder2 = KettleVFS.getFileObject(realFilename2);

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

                    if (folder1.getType() == FileType.FILE)
                        log.logError(toString(),
                                Messages.getString("JobFoldersCompare.Log.IsAFile", realFilename1));
                    else if (folder1.getType() == FileType.FOLDER)
                        log.logError(toString(),
                                Messages.getString("JobFoldersCompare.Log.IsAFolder", realFilename1));
                    else
                        log.logError(toString(),
                                Messages.getString("JobFoldersCompare.Log.IsUnknownFileType", realFilename1));

                    if (folder2.getType() == FileType.FILE)
                        log.logError(toString(),
                                Messages.getString("JobFoldersCompare.Log.IsAFile", realFilename2));
                    else if (folder2.getType() == FileType.FOLDER)
                        log.logError(toString(),
                                Messages.getString("JobFoldersCompare.Log.IsAFolder", realFilename2));
                    else
                        log.logError(toString(),
                                Messages.getString("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()) {
                            log.logDetailed(toString(), Messages.getString(
                                    "JobFoldersCompare.Log.FolderContains", realFilename1, "" + lenList1));
                            log.logDetailed(toString(), Messages.getString(
                                    "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())
                                        log.logDetailed(toString(),
                                                Messages.getString("JobFoldersCompare.Log.FileCanNotBeFoundIn",
                                                        entree.getKey().toString(), realFilename2));
                                } else {
                                    if (log.isDebug())
                                        log.logDebug(toString(),
                                                Messages.getString("JobFoldersCompare.Log.FileIsFoundIn",
                                                        entree.getKey().toString(), realFilename2));

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

                                    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())
                                            log.logDetailed(toString(),
                                                    Messages.getString("JobFoldersCompare.Log.FilesNotSameType",
                                                            filefolder1.toString(), filefolder2.toString()));

                                        if (filefolder1.getType() == FileType.FILE)
                                            log.logError(toString(), Messages.getString(
                                                    "JobFoldersCompare.Log.IsAFile", filefolder1.toString()));
                                        else if (filefolder1.getType() == FileType.FOLDER)
                                            log.logError(toString(), Messages.getString(
                                                    "JobFoldersCompare.Log.IsAFolder", filefolder1.toString()));
                                        else
                                            log.logError(toString(),
                                                    Messages.getString(
                                                            "JobFoldersCompare.Log.IsUnknownFileType",
                                                            filefolder1.toString()));

                                        if (filefolder2.getType() == FileType.FILE)
                                            log.logError(toString(), Messages.getString(
                                                    "JobFoldersCompare.Log.IsAFile", filefolder2.toString()));
                                        else if (filefolder2.getType() == FileType.FOLDER)
                                            log.logError(toString(), Messages.getString(
                                                    "JobFoldersCompare.Log.IsAFolder", filefolder2.toString()));
                                        else
                                            log.logError(toString(),
                                                    Messages.getString(
                                                            "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()) {
                                                        log.logDetailed(toString(), Messages.getString(
                                                                "JobFoldersCompare.Log.FilesNotSameSize",
                                                                filefolder1.toString(),
                                                                filefolder2.toString()));
                                                        log.logDetailed(toString(), Messages.getString(
                                                                "JobFoldersCompare.Log.SizeFileIs",
                                                                filefolder1.toString(), "" + filefolder1_size));
                                                        log.logDetailed(toString(), Messages.getString(
                                                                "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())
                                                            log.logDetailed(toString(), Messages.getString(
                                                                    "JobFoldersCompare.Log.FilesNotSameContent",
                                                                    filefolder1.toString(),
                                                                    filefolder2.toString()));
                                                    }
                                                }
                                            }
                                        }
                                    }

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

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

                    } else {
                        // File type unknown !!
                    }
                }

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

    return result;
}

From source file:com.panet.imeta.job.entries.addresultfilenames.JobEntryAddResultFilenames.java

private boolean ProcessFile(String filename, String wildcard, Job parentJob, Result result) {
    LogWriter log = LogWriter.getInstance();

    boolean rcode = false;
    FileObject filefolder = null;
    String realFilefoldername = environmentSubstitute(filename);
    String realwildcard = environmentSubstitute(wildcard);

    try {//from   ww w  .  ja  va 2 s  . c o m
        filefolder = KettleVFS.getFileObject(realFilefoldername);

        // Here gc() is explicitly called if e.g. createfile is used in the
        // same
        // job for the same file. The problem is that after creating the
        // file the
        // file object is not properly garbaged collected and thus the file
        // cannot
        // be deleted anymore. This is a known problem in the JVM.

        System.gc();

        if (filefolder.exists()) {
            // the file or folder exists

            if (filefolder.getType() == FileType.FILE) {
                // Add filename to Resultfilenames ...
                if (log.isDetailed())
                    log.logDetailed(toString(), Messages
                            .getString("JobEntryAddResultFilenames.AddingFileToResult", filefolder.toString()));
                ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL,
                        KettleVFS.getFileObject(filefolder.toString()), parentJob.getJobname(), toString());
                result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
            } else {
                FileObject list[] = filefolder
                        .findFiles(new TextFileSelector(filefolder.toString(), realwildcard));

                for (int i = 0; i < list.length && !parentJob.isStopped(); i++) {
                    // Add filename to Resultfilenames ...
                    if (log.isDetailed())
                        log.logDetailed(toString(), Messages.getString(
                                "JobEntryAddResultFilenames.AddingFileToResult", list[i].toString()));
                    ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL,
                            KettleVFS.getFileObject(list[i].toString()), parentJob.getJobname(), toString());
                    result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
                }
            }

        } else {
            // File can not be found
            if (log.isBasic())
                log.logBasic(toString(),
                        Messages.getString("JobEntryAddResultFilenames.FileCanNotbeFound", realFilefoldername)); //$NON-NLS-1$
            rcode = true;
        }
    } catch (IOException e) {
        log.logError(toString(), Messages.getString("JobEntryAddResultFilenames.CouldNotProcess", //$NON-NLS-1$
                realFilefoldername, e.getMessage()));
    } finally {
        if (filefolder != null) {
            try {
                filefolder.close();
            } catch (IOException ex) {
            }
            ;
        }
    }

    return rcode;
}

From source file:com.panet.imeta.job.entries.sftpput.JobEntrySFTPPUT.java

public Result execute(Result previousResult, int nr, Repository rep, Job parentJob) throws KettleException {
    LogWriter log = LogWriter.getInstance();

    Result result = previousResult;
    List<RowMetaAndData> rows = result.getRows();
    result.setResult(false);/*from   www  .ja va  2  s .  c  o m*/

    if (log.isDetailed())
        log.logDetailed(toString(), Messages.getString("JobSFTPPUT.Log.StartJobEntry"));
    ArrayList<FileObject> myFileList = new ArrayList<FileObject>();

    if (copyprevious) {
        if (rows.size() == 0) {
            if (log.isDetailed())
                log.logDetailed(toString(), Messages.getString("JobSFTPPUT.ArgsFromPreviousNothing"));
            result.setResult(true);
            return result;
        }

        try {
            RowMetaAndData resultRow = null;
            // Copy the input row to the (command line) arguments
            for (int iteration = 0; iteration < rows.size(); iteration++) {
                resultRow = rows.get(iteration);

                // Get file names
                String file_previous = resultRow.getString(0, null);
                if (!Const.isEmpty(file_previous)) {
                    FileObject file = KettleVFS.getFileObject(file_previous);
                    if (!file.exists())
                        log.logError(toString(),
                                Messages.getString("JobSFTPPUT.Log.FilefromPreviousNotFound", file_previous));
                    else {
                        myFileList.add(file);
                        if (log.isDebug())
                            log.logDebug(toString(),
                                    Messages.getString("JobSFTPPUT.Log.FilenameFromResult", file_previous));
                    }
                }
            }
        } catch (Exception e) {
            log.logError(toString(), Messages.getString("JobSFTPPUT.Error.ArgFromPrevious"));
            result.setNrErrors(1);
            return result;
        }

    }
    SFTPClient sftpclient = null;

    // String substitution..
    String realServerName = environmentSubstitute(serverName);
    String realServerPort = environmentSubstitute(serverPort);
    String realUsername = environmentSubstitute(userName);
    String realPassword = environmentSubstitute(password);
    String realSftpDirString = environmentSubstitute(sftpDirectory);
    String realWildcard = environmentSubstitute(wildcard);
    String realLocalDirectory = environmentSubstitute(localDirectory);

    try {
        // Create sftp client to host ...
        sftpclient = new SFTPClient(InetAddress.getByName(realServerName), Const.toInt(realServerPort, 22),
                realUsername);
        if (log.isDetailed())
            log.logDetailed(toString(), Messages.getString("JobSFTPPUT.Log.OpenedConnection", realServerName,
                    "" + realServerPort, realUsername));

        // login to ftp host ...
        sftpclient.login(realPassword);
        // Don't show the password in the logs, it's not good for security
        // audits
        // log.logDetailed(toString(), "logged in using password
        // "+realPassword); // Logging this seems a bad idea! Oh well.

        // move to spool dir ...
        if (!Const.isEmpty(realSftpDirString)) {
            sftpclient.chdir(realSftpDirString);
            if (log.isDetailed())
                log.logDetailed(toString(),
                        Messages.getString("JobSFTPPUT.Log.ChangedDirectory", realSftpDirString));
        } // end if

        if (!copyprevious) {
            // Get all the files in the local directory...
            myFileList = new ArrayList<FileObject>();

            FileObject localFiles = KettleVFS.getFileObject(realLocalDirectory);
            FileObject[] children = localFiles.getChildren();
            if (children != null) {
                for (int i = 0; i < children.length; i++) {
                    // Get filename of file or directory
                    if (children[i].getType().equals(FileType.FILE)) {
                        // myFileList.add(children[i].getAbsolutePath());
                        myFileList.add(children[i]);
                    }
                } // end for
            }
        }

        if (myFileList == null || myFileList.size() == 0) {
            log.logError(toString(), Messages.getString("JobSFTPPUT.Error.NoFileToSend"));
            result.setNrErrors(1);
            return result;
        }

        if (log.isDetailed())
            log.logDetailed(toString(),
                    Messages.getString("JobSFTPPUT.Log.RowsFromPreviousResult", "" + myFileList.size()));

        Pattern pattern = null;
        if (!copyprevious) {
            if (!Const.isEmpty(realWildcard)) {
                pattern = Pattern.compile(realWildcard);
            }
        }

        // Get the files in the list and execute sftp.put() for each file
        for (int i = 0; i < myFileList.size() && !parentJob.isStopped(); i++) {
            FileObject myFile = myFileList.get(i);
            String localFilename = myFile.toString();
            String destinationFilename = myFile.getName().getBaseName();
            boolean getIt = true;

            // First see if the file matches the regular expression!
            if (pattern != null) {
                Matcher matcher = pattern.matcher(destinationFilename);
                getIt = matcher.matches();
            }

            if (getIt) {
                if (log.isDebug())
                    log.logDebug(toString(),
                            Messages.getString("JobSFTPPUT.Log.PuttingFile", localFilename, realSftpDirString));

                sftpclient.put(myFile, destinationFilename);

                if (log.isDetailed())
                    log.logDetailed(toString(),
                            Messages.getString("JobSFTPPUT.Log.TransferedFile", localFilename));

                // Delete the file if this is needed!
                if (remove) {
                    myFile.delete();
                    if (log.isDetailed())
                        log.logDetailed(toString(),
                                Messages.getString("JobSFTPPUT.Log.DeletedFile", localFilename));
                } else {
                    if (addFilenameResut) {
                        // Add to the result files...
                        ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, myFile,
                                parentJob.getJobname(), toString());
                        result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
                        if (log.isDetailed())
                            log.logDetailed(toString(), Messages
                                    .getString("JobSFTPPUT.Log.FilenameAddedToResultFilenames", localFilename));
                    }
                }
            }
        } // end for

        result.setResult(true);
        // JKU: no idea if this is needed...!
        // result.setNrFilesRetrieved(filesRetrieved);
    } // end try
    catch (Exception e) {
        result.setNrErrors(1);
        log.logError(toString(), Messages.getString("JobSFTPPUT.Exception", e.getMessage()));
        log.logError(toString(), Const.getStackTracker(e));
    } finally {
        // close connection, if possible
        try {
            if (sftpclient != null)
                sftpclient.disconnect();
        } catch (Exception e) {
            // just ignore this, makes no big difference
        } // end catch
    } // end finallly

    return result;
}