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

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

Introduction

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

Prototype

public void createFolder() throws FileSystemException;

Source Link

Document

Creates this folder, if it does not exist.

Usage

From source file:org.objectweb.proactive.extensions.dataspaces.vfs.VFSNodeScratchSpaceImpl.java

private FileObject createEmptyDirectoryRelative(final FileObject parent, final String path)
        throws org.apache.commons.vfs.FileSystemException {

    FileObject f = parent.resolveFile(path);
    f.delete(Selectors.EXCLUDE_SELF);//from  w  ww . j ava 2s. co  m
    f.createFolder();
    return f;
}

From source file:org.openbi.kettle.plugins.avrooutput.AvroOutput.java

private void createParentFolder(String filename) throws Exception {
    // Check for parent folder
    FileObject parentfolder = null;
    try {/*from  w ww .  ja va 2 s.c  om*/
        // Get parent folder
        parentfolder = getFileObject(filename).getParent();
        if (parentfolder.exists()) {
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "AvroOutput.Log.ParentFolderExist",
                        parentfolder.getName()));
            }
        } else {
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "AvroOutput.Log.ParentFolderNotExist",
                        parentfolder.getName()));
            }
            if (meta.getCreateParentFolder()) {
                parentfolder.createFolder();
                if (isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "AvroOutput.Log.ParentFolderCreated",
                            parentfolder.getName()));
                }
            } else {
                throw new KettleException(BaseMessages.getString(PKG,
                        "AvroOutput.Log.ParentFolderNotExistCreateIt", parentfolder.getName(), filename));
            }
        }

    } finally {
        if (parentfolder != null) {
            try {
                parentfolder.close();
            } catch (Exception ex) {
                // Ignore
            }
        }
    }
}

From source file:org.openbi.kettle.plugins.parquetoutput.ParquetOutput.java

private void createParentFolder(String filename) throws Exception {
    // Check for parent folder
    FileObject parentfolder = null;
    FileObject schemaParentFolder = null;
    try {/*from www. j a va 2 s.  com*/
        // Get parent folder
        parentfolder = getFileObject(filename).getParent();
        if (parentfolder.exists()) {
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "AvroOutput.Log.ParentFolderExist",
                        parentfolder.getName()));
            }
        } else {
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "AvroOutput.Log.ParentFolderNotExist",
                        parentfolder.getName()));
            }
            if (meta.isCreateParentFolder()) {
                parentfolder.createFolder();
                if (isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "AvroOutput.Log.ParentFolderCreated",
                            parentfolder.getName()));
                }
            } else {
                throw new KettleException(BaseMessages.getString(PKG,
                        "AvroOutput.Log.ParentFolderNotExistCreateIt", parentfolder.getName(), filename));
            }
        }

    } finally {
        if (parentfolder != null) {
            try {
                parentfolder.close();
            } catch (Exception ex) {
                // Ignore
            }
        }

    }
}

From source file:org.openbi.kettle.plugins.tableauDataExtract.TDEOutput.java

private void createParentFolder(String filename) throws Exception {
    // Check for parent folder
    FileObject parentfolder = null;
    try {//from  ww w  . j a  va 2 s . c om
        // Get parent folder
        parentfolder = KettleVFS.getFileObject(filename).getParent();
        if (parentfolder.exists()) {
            if (isDetailed())
                logDetailed(
                        BaseMessages.getString(PKG, "TDEOutput.Log.ParentFolderExist", parentfolder.getName()));
        } else {
            if (isDetailed())
                logDetailed(BaseMessages.getString(PKG, "TDEOutput.Log.ParentFolderNotExist",
                        parentfolder.getName()));
            if (meta.isCreateParentFolder()) {
                parentfolder.createFolder();
                if (isDetailed())
                    logDetailed(BaseMessages.getString(PKG, "TDEOutput.Log.ParentFolderCreated",
                            parentfolder.getName()));
            } else {
                throw new KettleException(BaseMessages.getString(PKG,
                        "TDEOutput.Log.ParentFolderNotExistCreateIt", parentfolder.getName(), filename));
            }
        }
    } finally {
        if (parentfolder != null) {
            try {
                parentfolder.close();
            } catch (Exception ex) {
            }
            ;
        }
    }
}

From source file:org.pentaho.di.job.entries.copyfiles.JobEntryCopyFiles.java

private boolean CreateDestinationFolder(FileObject filefolder) {
    FileObject folder = null;
    try {/*  www .j a  v  a2  s .c o  m*/
        if (destination_is_a_file) {
            folder = filefolder.getParent();
        } else {
            folder = filefolder;
        }

        if (!folder.exists()) {
            if (create_destination_folder) {
                if (isDetailed()) {
                    logDetailed("Folder  " + folder.getName() + " does not exist !");
                }
                folder.createFolder();
                if (isDetailed()) {
                    logDetailed("Folder parent was created.");
                }
            } else {
                logError("Folder  " + folder.getName() + " does not exist !");
                return false;
            }
        }
        return true;
    } catch (Exception e) {
        logError("Couldn't created parent folder " + folder.getName(), e);
    } finally {
        if (folder != null) {
            try {
                folder.close();
                folder = null;
            } catch (Exception ex) { /* Ignore */
            }
        }
    }
    return false;
}

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

private boolean CreateDestinationFolder(String foldername) {
    FileObject folder = null;
    try {/*w w  w .j  a  v a  2 s. c o 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.createfolder.JobEntryCreateFolder.java

public Result execute(Result previousResult, int nr) {
    Result result = previousResult;
    result.setResult(false);//from  w  ww .  j  av  a2 s.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.getpop.JobEntryGetPOP.java

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

    //FileObject fileObject = null;
    MailConnection mailConn = null;
    Date beginDate = null;
    Date endDate = null;

    SimpleDateFormat df = new SimpleDateFormat(DATE_PATTERN);

    try {

        boolean usePOP3 = getProtocol().equals(MailConnectionMeta.PROTOCOL_STRING_POP3);
        boolean moveafter = false;
        int nbrmailtoretrieve = usePOP3 ? getRetrievemails() == 2 ? Const.toInt(getFirstMails(), 0) : 0
                : Const.toInt(getFirstIMAPMails(), 0);

        String realOutputFolder = getRealOutputDirectory();
        String targetAttachmentFolder = null;
        if (getActionType() == MailConnectionMeta.ACTION_TYPE_GET) {
            FileObject fileObject = KettleVFS.getFileObject(realOutputFolder, this);
            // Check if output folder exists
            if (fileObject.exists()) {
                if (fileObject.getType() != FileType.FOLDER) {
                    throw new KettleException(BaseMessages.getString(PKG,
                            "JobGetMailsFromPOP.Error.NotAFolderNot", realOutputFolder));
                }
                if (isDebug()) {
                    logDebug(BaseMessages.getString(PKG, "JobGetMailsFromPOP.Log.OutputFolderExists",
                            realOutputFolder));
                }
            } else {
                if (isCreateLocalFolder()) {
                    if (isDetailed()) {
                        logDetailed(BaseMessages.getString(PKG, "JobGetMailsFromPOP.Log.OutputFolderNotExist",
                                realOutputFolder));
                    }
                    // create folder
                    fileObject.createFolder();
                } else {
                    throw new KettleException(
                            BaseMessages.getString(PKG, "JobGetMailsFromPOP.FolderNotExists1.Label")
                                    + realOutputFolder
                                    + BaseMessages.getString(PKG, "JobGetMailsFromPOP.FolderNotExists2.Label"));
                }
            }

            targetAttachmentFolder = KettleVFS.getFilename(fileObject);
            // check for attachment folder
            boolean useDifferentFolderForAttachment = (isSaveAttachment() && isDifferentFolderForAttachment());

            if (useDifferentFolderForAttachment) {
                String realFolderAttachment = environmentSubstitute(getAttachmentFolder());
                if (Const.isEmpty(realFolderAttachment)) {
                    throw new KettleException(
                            BaseMessages.getString(PKG, "JobGetMailsFromPOP.Error.AttachmentFolderEmpty"));
                }
                //close old file object
                try {
                    fileObject.close();
                } catch (IOException ex) { /* Ignore */
                }
                //reuse old link
                fileObject = KettleVFS.getFileObject(realFolderAttachment, this);

                if (!fileObject.exists()) {
                    throw new KettleException(BaseMessages.getString(PKG,
                            "JobGetMailsFromPOP.Error.AttachmentFolderNotExist", realFolderAttachment));
                }

                if (fileObject.getType() != FileType.FOLDER) {
                    throw new KettleException(BaseMessages.getString(PKG,
                            "JobGetMailsFromPOP.Error.AttachmentFolderNotAFolder", realFolderAttachment));
                }
                targetAttachmentFolder = KettleVFS.getFilename(fileObject);
            }
            // Close fileObject! we don't need it anymore ...
            try {
                fileObject.close();
            } catch (IOException ex) { /* Ignore */
            }
        } // end if get

        // Check destination folder
        String realMoveToIMAPFolder = environmentSubstitute(getMoveToIMAPFolder());
        if (getProtocol().equals(MailConnectionMeta.PROTOCOL_STRING_IMAP)
                && (getActionType() == MailConnectionMeta.ACTION_TYPE_MOVE)
                || (getActionType() == MailConnectionMeta.ACTION_TYPE_GET
                        && getAfterGetIMAP() == MailConnectionMeta.AFTER_GET_IMAP_MOVE)) {
            if (Const.isEmpty(realMoveToIMAPFolder)) {
                throw new KettleException(
                        BaseMessages.getString(PKG, "JobGetMailsFromPOP.Error.MoveToIMAPFolderEmpty"));
            }
            moveafter = true;
        }

        // check search terms
        // Received Date
        switch (getConditionOnReceivedDate()) {
        case MailConnectionMeta.CONDITION_DATE_EQUAL:
        case MailConnectionMeta.CONDITION_DATE_GREATER:
        case MailConnectionMeta.CONDITION_DATE_SMALLER:
            String realBeginDate = environmentSubstitute(getReceivedDate1());
            if (Const.isEmpty(realBeginDate)) {
                throw new KettleException(
                        BaseMessages.getString(PKG, "JobGetMailsFromPOP.Error.ReceivedDateSearchTermEmpty"));
            }
            beginDate = df.parse(realBeginDate);
            break;
        case MailConnectionMeta.CONDITION_DATE_BETWEEN:
            realBeginDate = environmentSubstitute(getReceivedDate1());
            if (Const.isEmpty(realBeginDate)) {
                throw new KettleException(
                        BaseMessages.getString(PKG, "JobGetMailsFromPOP.Error.ReceivedDatesSearchTermEmpty"));
            }
            beginDate = df.parse(realBeginDate);
            String realEndDate = environmentSubstitute(getReceivedDate2());
            if (Const.isEmpty(realEndDate)) {
                throw new KettleException(
                        BaseMessages.getString(PKG, "JobGetMailsFromPOP.Error.ReceivedDatesSearchTermEmpty"));
            }
            endDate = df.parse(realEndDate);
            break;
        default:
            break;
        }

        String realserver = getRealServername();
        String realusername = getRealUsername();
        String realpassword = getRealPassword();
        String realFilenamePattern = getRealFilenamePattern();
        int realport = Const.toInt(environmentSubstitute(sslport), -1);
        String realIMAPFolder = environmentSubstitute(getIMAPFolder());
        String realProxyUsername = getRealProxyUsername();

        initVariables();
        // create a mail connection object
        mailConn = new MailConnection(log,
                MailConnectionMeta.getProtocolFromString(getProtocol(), MailConnectionMeta.PROTOCOL_IMAP),
                realserver, realport, realusername, realpassword, isUseSSL(), isUseProxy(), realProxyUsername);
        // connect
        mailConn.connect();

        if (moveafter) {
            // Set destination folder
            // Check if folder exists
            mailConn.setDestinationFolder(realMoveToIMAPFolder, isCreateMoveToFolder());
        }

        // apply search term?
        String realSearchSender = environmentSubstitute(getSenderSearchTerm());
        if (!Const.isEmpty(realSearchSender)) {
            // apply FROM
            mailConn.setSenderTerm(realSearchSender, isNotTermSenderSearch());
        }
        String realSearchReceipient = environmentSubstitute(getReceipientSearch());
        if (!Const.isEmpty(realSearchReceipient)) {
            // apply TO
            mailConn.setReceipientTerm(realSearchReceipient);
        }
        String realSearchSubject = environmentSubstitute(getSubjectSearch());
        if (!Const.isEmpty(realSearchSubject)) {
            // apply Subject
            mailConn.setSubjectTerm(realSearchSubject, isNotTermSubjectSearch());
        }
        String realSearchBody = environmentSubstitute(getBodySearch());
        if (!Const.isEmpty(realSearchBody)) {
            // apply body
            mailConn.setBodyTerm(realSearchBody, isNotTermBodySearch());
        }
        // Received Date
        switch (getConditionOnReceivedDate()) {
        case MailConnectionMeta.CONDITION_DATE_EQUAL:
            mailConn.setReceivedDateTermEQ(beginDate);
            break;
        case MailConnectionMeta.CONDITION_DATE_GREATER:
            mailConn.setReceivedDateTermGT(beginDate);
            break;
        case MailConnectionMeta.CONDITION_DATE_SMALLER:
            mailConn.setReceivedDateTermLT(beginDate);
            break;
        case MailConnectionMeta.CONDITION_DATE_BETWEEN:
            mailConn.setReceivedDateTermBetween(beginDate, endDate);
            break;
        default:
            break;
        }
        // set FlagTerm?
        if (usePOP3) {
            // retrieve messages
            if (getRetrievemails() == 1) {
                // New messages
                // POP doesn't support the concept of "new" messages!
                mailConn.setFlagTermUnread();
            }
        } else {
            switch (getValueImapList()) {
            case MailConnectionMeta.VALUE_IMAP_LIST_NEW:
                mailConn.setFlagTermNew();
                break;
            case MailConnectionMeta.VALUE_IMAP_LIST_OLD:
                mailConn.setFlagTermOld();
                break;
            case MailConnectionMeta.VALUE_IMAP_LIST_READ:
                mailConn.setFlagTermRead();
                break;
            case MailConnectionMeta.VALUE_IMAP_LIST_UNREAD:
                mailConn.setFlagTermUnread();
                break;
            case MailConnectionMeta.VALUE_IMAP_LIST_FLAGGED:
                mailConn.setFlagTermFlagged();
                break;
            case MailConnectionMeta.VALUE_IMAP_LIST_NOT_FLAGGED:
                mailConn.setFlagTermNotFlagged();
                break;
            case MailConnectionMeta.VALUE_IMAP_LIST_DRAFT:
                mailConn.setFlagTermDraft();
                break;
            case MailConnectionMeta.VALUE_IMAP_LIST_NOT_DRAFT:
                mailConn.setFlagTermNotDraft();
                break;
            default:
                break;
            }
        }
        // open folder and retrieve messages
        fetchOneFolder(mailConn, usePOP3, realIMAPFolder, realOutputFolder, targetAttachmentFolder,
                realMoveToIMAPFolder, realFilenamePattern, nbrmailtoretrieve, df);

        if (isIncludeSubFolders()) {
            // Fetch also sub folders?
            if (isDebug()) {
                logDebug(BaseMessages.getString(PKG, "JobGetPOP.FetchingSubFolders"));
            }
            String[] subfolders = mailConn.returnAllFolders();
            if (subfolders.length == 0) {
                if (isDebug()) {
                    logDebug(BaseMessages.getString(PKG, "JobGetPOP.NoSubFolders"));
                }
            } else {
                for (int i = 0; i < subfolders.length; i++) {
                    fetchOneFolder(mailConn, usePOP3, subfolders[i], realOutputFolder, targetAttachmentFolder,
                            realMoveToIMAPFolder, realFilenamePattern, nbrmailtoretrieve, df);
                }
            }
        }

        result.setResult(true);
        result.setNrFilesRetrieved(mailConn.getSavedAttachedFilesCounter());
        result.setNrLinesWritten(mailConn.getSavedMessagesCounter());
        result.setNrLinesDeleted(mailConn.getDeletedMessagesCounter());
        result.setNrLinesUpdated(mailConn.getMovedMessagesCounter());

        if (isDetailed()) {
            logDetailed("=======================================");
            logDetailed(BaseMessages.getString(PKG, "JobGetPOP.Log.Info.SavedMessages",
                    "" + mailConn.getSavedMessagesCounter()));
            logDetailed(BaseMessages.getString(PKG, "JobGetPOP.Log.Info.DeletedMessages",
                    "" + mailConn.getDeletedMessagesCounter()));
            logDetailed(BaseMessages.getString(PKG, "JobGetPOP.Log.Info.MovedMessages",
                    "" + mailConn.getMovedMessagesCounter()));
            if (getActionType() == MailConnectionMeta.ACTION_TYPE_GET && isSaveAttachment()) {
                logDetailed(BaseMessages.getString(PKG, "JobGetPOP.Log.Info.AttachedMessagesSuccess",
                        "" + mailConn.getSavedAttachedFilesCounter()));
            }
            logDetailed("=======================================");
        }
    } catch (Exception e) {
        result.setNrErrors(1);
        logError("Unexpected error: " + e.getMessage());
        logError(Const.getStackTracker(e));
    } finally {
        try {
            if (mailConn != null) {
                mailConn.disconnect();
                mailConn = null;
            }
        } catch (Exception e) { /* Ignore */
        }
    }

    return result;
}

From source file:org.pentaho.di.job.entries.hadooptransjobexecutor.DistributedCacheUtil.java

/**
 * Extract a zip archive to a directory.
 *
 * @param archive Zip archive to extract
 * @param dest    Destination directory. This must not exist!
 * @return Directory the zip was extracted into
 * @throws IllegalArgumentException when the archive file does not exist or the destination directory already exists
 * @throws IOException//www .j a v  a  2s  .  co  m
 * @throws KettleFileException
 */
public FileObject extract(FileObject archive, FileObject dest) throws IOException, KettleFileException {
    if (!archive.exists()) {
        throw new IllegalArgumentException("archive does not exist: " + archive.getURL().getPath());
    }

    if (dest.exists()) {
        throw new IllegalArgumentException("destination already exists");
    }
    dest.createFolder();

    try {
        byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
        int len = 0;
        ZipInputStream zis = new ZipInputStream(archive.getContent().getInputStream());
        try {
            ZipEntry ze;
            while ((ze = zis.getNextEntry()) != null) {
                FileObject entry = KettleVFS.getFileObject(dest + Const.FILE_SEPARATOR + ze.getName());

                if (ze.isDirectory()) {
                    entry.createFolder();
                    continue;
                }

                OutputStream os = KettleVFS.getOutputStream(entry, false);
                try {
                    while ((len = zis.read(buffer)) > 0) {
                        os.write(buffer, 0, len);
                    }
                } finally {
                    if (os != null) {
                        os.close();
                    }
                }
            }
        } finally {
            if (zis != null) {
                zis.close();
            }
        }
    } catch (Exception ex) {
        // Try to clean up the temp directory and all files
        if (!deleteDirectory(dest)) {
            throw new KettleFileException("Could not clean up temp dir after error extracting", ex);
        }
        throw new KettleFileException("error extracting archive", ex);
    }

    return dest;
}

From source file:org.pentaho.di.job.entries.hadooptransjobexecutor.DistributedCacheUtilTest.java

private FileObject createTestFolderWithContent(String rootFolderName) throws Exception {
    String rootName = "bin/test/" + rootFolderName;
    FileObject root = KettleVFS.getFileObject(rootName);
    FileObject jar1 = KettleVFS.getFileObject(rootName + Const.FILE_SEPARATOR + "jar1.jar");
    FileObject jar2 = KettleVFS.getFileObject(rootName + Const.FILE_SEPARATOR + "jar2.jar");
    FileObject folder = KettleVFS.getFileObject(rootName + Const.FILE_SEPARATOR + "folder");
    FileObject file = KettleVFS/*from   ww  w .  j  a va  2 s. c o m*/
            .getFileObject(rootName + Const.FILE_SEPARATOR + "folder" + Const.FILE_SEPARATOR + "file.txt");

    root.createFolder();
    folder.createFolder();
    jar1.createFile();
    jar2.createFile();
    file.createFile();

    return root;
}