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

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

Introduction

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

Prototype

public FileContent getContent() throws FileSystemException;

Source Link

Document

Returns this file's content.

Usage

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);// w  ww. j a  va 2 s  .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.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);/*from  ww  w. 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:org.apache.commons.vfs.example.ChangeLastModificationTime.java

public static void main(String[] args) throws Exception {
    if (args.length == 0) {
        System.err.println("Please pass the name of a file as parameter.");
        return;// w  ww .j av  a2 s. c o  m
    }

    FileObject fo = VFS.getManager().resolveFile(args[0]);
    long setTo = System.currentTimeMillis();
    System.err.println("set to: " + setTo);
    fo.getContent().setLastModifiedTime(setTo);
    System.err.println("after set: " + fo.getContent().getLastModifiedTime());
}

From source file:org.apache.commons.vfs.example.Shell.java

/**
 * Does an 'ls' command./*from   w w  w .ja  va  2  s.c o m*/
 */
private void ls(final String[] cmd) throws FileSystemException {
    int pos = 1;
    final boolean recursive;
    if (cmd.length > pos && cmd[pos].equals("-R")) {
        recursive = true;
        pos++;
    } else {
        recursive = false;
    }

    final FileObject file;
    if (cmd.length > pos) {
        file = mgr.resolveFile(cwd, cmd[pos]);
    } else {
        file = cwd;
    }

    if (file.getType() == FileType.FOLDER) {
        // List the contents
        System.out.println("Contents of " + file.getName());
        listChildren(file, recursive, "");
    } else {
        // Stat the file
        System.out.println(file.getName());
        final FileContent content = file.getContent();
        System.out.println("Size: " + content.getSize() + " bytes.");
        final DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
        final String lastMod = dateFormat.format(new Date(content.getLastModifiedTime()));
        System.out.println("Last modified: " + lastMod);
    }
}

From source file:org.apache.commons.vfs.example.Shell.java

/**
 * Does a 'touch' command.//from  ww w  .  j a v  a 2  s .c o m
 */
private void touch(final String[] cmd) throws Exception {
    if (cmd.length < 2) {
        throw new Exception("USAGE: touch <path>");
    }
    final FileObject file = mgr.resolveFile(cwd, cmd[1]);
    if (!file.exists()) {
        file.createFile();
    }
    file.getContent().setLastModifiedTime(System.currentTimeMillis());
}

From source file:org.apache.commons.vfs.example.ShowProperties.java

public static void main(String[] args) {
    if (args.length == 0) {
        System.err.println("Please pass the name of a file as parameter.");
        System.err.println("e.g. java org.apache.commons.vfs.example.ShowProperties LICENSE.txt");
        return;/* w w w  .  ja  v  a  2s  . c  om*/
    }
    for (int i = 0; i < args.length; i++) {
        try {
            FileSystemManager mgr = VFS.getManager();
            System.out.println();
            System.out.println("Parsing: " + args[i]);
            FileObject file = mgr.resolveFile(args[i]);
            System.out.println("URL: " + file.getURL());
            System.out.println("getName(): " + file.getName());
            System.out.println("BaseName: " + file.getName().getBaseName());
            System.out.println("Extension: " + file.getName().getExtension());
            System.out.println("Path: " + file.getName().getPath());
            System.out.println("Scheme: " + file.getName().getScheme());
            System.out.println("URI: " + file.getName().getURI());
            System.out.println("Root URI: " + file.getName().getRootURI());
            System.out.println("Parent: " + file.getName().getParent());
            System.out.println("Type: " + file.getType());
            System.out.println("Exists: " + file.exists());
            System.out.println("Readable: " + file.isReadable());
            System.out.println("Writeable: " + file.isWriteable());
            System.out.println("Root path: " + file.getFileSystem().getRoot().getName().getPath());
            if (file.exists()) {
                if (file.getType().equals(FileType.FILE)) {
                    System.out.println("Size: " + file.getContent().getSize() + " bytes");
                } else if (file.getType().equals(FileType.FOLDER) && file.isReadable()) {
                    FileObject[] children = file.getChildren();
                    System.out.println("Directory with " + children.length + " files");
                    for (int iterChildren = 0; iterChildren < children.length; iterChildren++) {
                        System.out.println("#" + iterChildren + ": " + children[iterChildren].getName());
                        if (iterChildren > 5) {
                            break;
                        }
                    }
                }
                System.out.println("Last modified: "
                        + DateFormat.getInstance().format(new Date(file.getContent().getLastModifiedTime())));
            } else {
                System.out.println("The file does not exist");
            }
            file.close();
        } catch (FileSystemException ex) {
            ex.printStackTrace();
        }
    }
}

From source file:org.bibalex.gallery.storage.BAGStorage.java

public static URL cacheFileLocally(String cacheLocalPath, String fileUrlStr) throws BAGException {
    try {// w  w w.  ja v a  2s .  c om
        // String extension = "";
        //
        // int lastDotIx = fileUrlStr.lastIndexOf('.');
        // if (lastDotIx > fileUrlStr.lastIndexOf('/')) {
        // extension = fileUrlStr.substring(lastDotIx);
        // }
        // String cacheFileName = "cached" + fileUrlStr.hashCode() + extension;

        int lastSlashIx = fileUrlStr.lastIndexOf('/');

        String cacheFileName = fileUrlStr.substring(lastSlashIx + 1);

        String cacheFilePath = URLPathStrUtils.appendParts(cacheLocalPath, cacheFileName);

        FileSystemManager fsMgr = VFS.getManager();

        final FileObject cacheFileFO = fsMgr.resolveFile(cacheFilePath);
        final FileObject cacheDirFO = fsMgr.resolveFile(cacheLocalPath);

        if (!cacheFileFO.exists()) {
            synchronized (BAGStorage.class) {

                if (!cacheDirFO.exists()) {
                    cacheDirFO.createFolder();
                }

                cacheFileFO.createFile();

                OutputStream cacheFileOut = cacheFileFO.getContent().getOutputStream();
                try {
                    readRemoteFile(fileUrlStr, cacheFileOut);
                } finally {
                    cacheFileOut.close();
                }

            }
        }

        return cacheFileFO.getURL();

    } catch (FileSystemException e) {
        throw new BAGException(e);
    } catch (IOException e) {
        throw new BAGException(e);
    }
}

From source file:org.bibalex.gallery.storage.BAGStorage.java

public static InputStream openFileForInput(String fileUrlStr) throws BAGException {
    try {/*from  w  w w  . java  2s .c  o  m*/
        FileObject FO = VFS.getManager().resolveFile(fileUrlStr);
        return FO.getContent().getInputStream();
    } catch (FileSystemException e) {
        throw new BAGException(e);
    }

}

From source file:org.bibalex.gallery.storage.BAGStorage.java

public static OutputStream openFileForOutput(String fileUrlStr, boolean bAppend) throws BAGException {
    try {/*from   ww  w .  j  a va2  s.co  m*/
        FileSystemManager mgr = VFS.getManager();

        FileObject fileFO = mgr.resolveFile(fileUrlStr);

        return fileFO.getContent().getOutputStream(bAppend);

    } catch (FileSystemException e) {
        throw new BAGException(e);
    }
}

From source file:org.bibalex.gallery.storage.BAGStorage.java

public static void readRemoteFile(String fileUrlStr, OutputStream localOut) throws BAGException {
    try {/*  ww w  .jav  a 2  s  .c o m*/
        try {
            FileObject imageFO;

            imageFO = VFS.getManager().resolveFile(fileUrlStr);

            InputStream imageIS = imageFO.getContent().getInputStream();

            byte buffer[] = new byte[10240];
            int bytesRead = 0;
            do {
                bytesRead = imageIS.read(buffer);

                if (bytesRead > 0) {
                    localOut.write(buffer, 0, bytesRead);
                } else {
                    break;
                }
            } while (true);

        } finally {
            localOut.flush();
        }

    } catch (FileSystemException e) {
        throw new BAGException(e);
    } catch (IOException e) {
        throw new BAGException(e);

    }
}