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

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

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.vfs.*
  5. FileObject
  6. 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.pentaho.di.trans.steps.jsonoutput.JsonOutput.java

private void createParentFolder(String filename) throws KettleStepException {
    if (!meta.isCreateParentFolder()) {
        return;/*from w ww  .  j a  v a2  s. c  o m*/
    }
    // Check for parent folder
    FileObject parentfolder = null;
    try {
        // Get parent folder
        parentfolder = KettleVFS.getFileObject(filename, getTransMeta()).getParent();
        if (!parentfolder.exists()) {
            if (log.isDebug()) {
                logDebug(BaseMessages.getString(PKG, "JsonOutput.Error.ParentFolderNotExist",
                        parentfolder.getName()));
            }
            parentfolder.createFolder();
            if (log.isDebug()) {
                logDebug(BaseMessages.getString(PKG, "JsonOutput.Log.ParentFolderCreated"));
            }
        }
    } catch (Exception e) {
        throw new KettleStepException(BaseMessages.getString(PKG, "JsonOutput.Error.ErrorCreatingParentFolder",
                parentfolder.getName()));
    } finally {
        if (parentfolder != null) {
            try {
                parentfolder.close();
            } catch (Exception ex) { /* Ignore */
            }
        }
    }
}

From source file:org.pentaho.di.trans.steps.luciddbbulkloader.LucidDBBulkLoader.java

public boolean execute(LucidDBBulkLoaderMeta meta, boolean wait) throws KettleException {
    Runtime rt = Runtime.getRuntime();

    try {/*from  w w w.ja  v a 2 s.  c o m*/
        String tableName = environmentSubstitute(meta.getTableName());

        // 1) Set up the FIFO folder, create the directory and path to it...
        //
        String fifoVfsDirectory = environmentSubstitute(meta.getFifoDirectory());
        FileObject directory = KettleVFS.getFileObject(fifoVfsDirectory, getTransMeta());
        directory.createFolder();
        String fifoDirectory = KettleVFS.getFilename(directory);

        // 2) Create the FIFO file using the "mkfifo" command...
        // Make sure to log all the possible output, also from STDERR
        //
        data.fifoFilename = KettleVFS.getFilename(directory) + Const.FILE_SEPARATOR + tableName + ".csv";
        data.bcpFilename = KettleVFS.getFilename(directory) + Const.FILE_SEPARATOR + tableName + ".bcp";

        File fifoFile = new File(data.fifoFilename);
        if (!fifoFile.exists()) {
            String mkFifoCmd = "mkfifo " + data.fifoFilename + "";
            logBasic("Creating FIFO file using this command : " + mkFifoCmd);
            Process mkFifoProcess = rt.exec(mkFifoCmd);
            StreamLogger errorLogger = new StreamLogger(log, mkFifoProcess.getErrorStream(), "mkFifoError");
            StreamLogger outputLogger = new StreamLogger(log, mkFifoProcess.getInputStream(), "mkFifoOuptut");
            new Thread(errorLogger).start();
            new Thread(outputLogger).start();
            int result = mkFifoProcess.waitFor();
            if (result != 0) {
                throw new Exception("Return code " + result + " received from statement : " + mkFifoCmd);
            }
        }

        // 3) Make a connection to LucidDB for sending SQL commands
        // (Also, we need a clear cache for getting up-to-date target metadata)
        DBCache.getInstance().clear(meta.getDatabaseMeta().getName());
        if (meta.getDatabaseMeta() == null) {
            logError(BaseMessages.getString(PKG, "LuciDBBulkLoader.Init.ConnectionMissing", getStepname()));
            return false;
        }
        data.db = new Database(this, meta.getDatabaseMeta());
        data.db.shareVariablesWith(this);
        // Connect to the database
        if (getTransMeta().isUsingUniqueConnections()) {
            synchronized (getTrans()) {
                data.db.connect(getTrans().getTransactionId(), getPartitionID());
            }
        } else {
            data.db.connect(getPartitionID());
        }

        logBasic("Connected to LucidDB");

        // 4) Now we are ready to create the LucidDB FIFO server that will handle the actual bulk loading.
        //
        String fifoServerStatement = "";
        fifoServerStatement += "create or replace server " + meta.getFifoServerName() + Const.CR;
        fifoServerStatement += "foreign data wrapper sys_file_wrapper" + Const.CR;
        fifoServerStatement += "options (" + Const.CR;
        fifoServerStatement += "directory '" + fifoDirectory + "'," + Const.CR;
        fifoServerStatement += "file_extension 'csv'," + Const.CR;
        fifoServerStatement += "with_header 'no'," + Const.CR;
        fifoServerStatement += "num_rows_scan '0'," + Const.CR;
        fifoServerStatement += "lenient 'no');" + Const.CR;

        logBasic("Creating LucidDB fifo_server with the following command: " + fifoServerStatement);
        data.db.execStatements(fifoServerStatement);

        // 5) Set the error limit in the LucidDB session
        // REVIEW jvs 13-Dec-2008: is this guaranteed to retain the same
        // connection?
        String errorMaxStatement = "";
        errorMaxStatement += "alter session set \"errorMax\" = " + meta.getMaxErrors() + ";" + Const.CR;
        logBasic("Setting error limit in LucidDB session with the following command: " + errorMaxStatement);
        data.db.execStatements(errorMaxStatement);

        // 6) Now we also need to create a bulk loader file .bcp
        //
        createBulkLoadConfigFile(data.bcpFilename);

        // 7) execute the actual load command!
        // This will actually block until the load is done in the
        // separate execution thread; see notes in executeLoadCommand
        // on why it's important for this to occur BEFORE
        // opening our end of the FIFO.
        //
        executeLoadCommand(tableName);

        // 8) We have to write rows to the FIFO file later on.
        data.fifoStream = new BufferedOutputStream(new FileOutputStream(fifoFile));
    } catch (Exception ex) {
        throw new KettleException(ex);
    }

    return true;
}

From source file:org.pentaho.di.trans.steps.processfiles.ProcessFiles.java

public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    meta = (ProcessFilesMeta) smi;//from  www .  j  av  a  2  s .  co m
    data = (ProcessFilesData) sdi;

    Object[] r = getRow(); // Get row from input rowset & set row busy!
    if (r == null) { // no more input to be expected...

        setOutputDone();
        return false;
    }
    if (first) {
        first = false;
        // Check is source filename field is provided
        if (Const.isEmpty(meta.getDynamicSourceFileNameField())) {
            throw new KettleException(
                    BaseMessages.getString(PKG, "ProcessFiles.Error.SourceFilenameFieldMissing"));
        }
        // Check is target filename field is provided
        if (meta.getOperationType() != ProcessFilesMeta.OPERATION_TYPE_DELETE
                && Const.isEmpty(meta.getDynamicTargetFileNameField())) {
            throw new KettleException(
                    BaseMessages.getString(PKG, "ProcessFiles.Error.TargetFilenameFieldMissing"));
        }

        // cache the position of the source filename field
        if (data.indexOfSourceFilename < 0) {
            data.indexOfSourceFilename = getInputRowMeta().indexOfValue(meta.getDynamicSourceFileNameField());
            if (data.indexOfSourceFilename < 0) {
                // The field is unreachable !
                throw new KettleException(BaseMessages.getString(PKG,
                        "ProcessFiles.Exception.CouldnotFindField", meta.getDynamicSourceFileNameField()));
            }
        }
        // cache the position of the source filename field
        if (meta.getOperationType() != ProcessFilesMeta.OPERATION_TYPE_DELETE
                && data.indexOfTargetFilename < 0) {
            data.indexOfTargetFilename = getInputRowMeta().indexOfValue(meta.getDynamicTargetFileNameField());
            if (data.indexOfTargetFilename < 0) {
                // The field is unreachable !
                throw new KettleException(BaseMessages.getString(PKG,
                        "ProcessFiles.Exception.CouldnotFindField", meta.getDynamicTargetFileNameField()));
            }
        }

        if (meta.simulate) {
            if (log.isBasic()) {
                logBasic(BaseMessages.getString(PKG, "ProcessFiles.Log.SimulationModeON"));
            }
        }
    } // End If first
    try {
        // get source filename
        String sourceFilename = getInputRowMeta().getString(r, data.indexOfSourceFilename);

        if (Const.isEmpty(sourceFilename)) {
            logError(BaseMessages.getString(PKG, "ProcessFiles.Error.SourceFileEmpty"));
            throw new KettleException(BaseMessages.getString(PKG, "ProcessFiles.Error.SourceFileEmpty"));
        }
        data.sourceFile = KettleVFS.getFileObject(sourceFilename, getTransMeta());

        if (!data.sourceFile.exists()) {
            logError(BaseMessages.getString(PKG, "ProcessFiles.Error.SourceFileNotExist", sourceFilename));
            throw new KettleException(
                    BaseMessages.getString(PKG, "ProcessFiles.Error.SourceFileNotExist", sourceFilename));
        }
        if (data.sourceFile.getType() != FileType.FILE) {
            logError(BaseMessages.getString(PKG, "ProcessFiles.Error.SourceFileNotFile", sourceFilename));
            throw new KettleException(
                    BaseMessages.getString(PKG, "ProcessFiles.Error.SourceFileNotFile", sourceFilename));
        }
        String targetFilename = null;
        if (meta.getOperationType() != ProcessFilesMeta.OPERATION_TYPE_DELETE) {
            // get value for target filename
            targetFilename = getInputRowMeta().getString(r, data.indexOfTargetFilename);

            if (Const.isEmpty(targetFilename)) {
                logError(BaseMessages.getString(PKG, "ProcessFiles.Error.TargetFileEmpty"));
                throw new KettleException(BaseMessages.getString(PKG, "ProcessFiles.Error.TargetFileEmpty"));
            }
            data.targetFile = KettleVFS.getFileObject(targetFilename, getTransMeta());
            if (data.targetFile.exists()) {
                if (log.isDetailed()) {
                    logDetailed(
                            BaseMessages.getString(PKG, "ProcessFiles.Log.TargetFileExists", targetFilename));
                }
                // check if target is really a file otherwise it could overwrite a complete folder by copy or move operations
                if (data.targetFile.getType() != FileType.FILE) {
                    logError(BaseMessages.getString(PKG, "ProcessFiles.Error.TargetFileNotFile",
                            targetFilename));
                    throw new KettleException(BaseMessages.getString(PKG,
                            "ProcessFiles.Error.TargetFileNotFile", targetFilename));
                }

            } else {
                // let's check parent folder
                FileObject parentFolder = data.targetFile.getParent();
                if (!parentFolder.exists()) {
                    if (!meta.isCreateParentFolder()) {
                        throw new KettleException(BaseMessages.getString(PKG,
                                "ProcessFiles.Error.TargetParentFolderNotExists", parentFolder.toString()));
                    } else {
                        parentFolder.createFolder();
                    }
                }
                if (parentFolder != null) {
                    parentFolder.close();
                }
            }
        }

        switch (meta.getOperationType()) {
        case ProcessFilesMeta.OPERATION_TYPE_COPY:
            if (((meta.isOverwriteTargetFile() && data.targetFile.exists()) || !data.targetFile.exists())
                    && !meta.simulate) {
                data.targetFile.copyFrom(data.sourceFile, new TextOneToOneFileSelector());
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "ProcessFiles.Log.SourceFileCopied", sourceFilename,
                            targetFilename));
                }
            } else {
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "ProcessFiles.Log.TargetNotOverwritten",
                            sourceFilename, targetFilename));
                }
            }
            break;
        case ProcessFilesMeta.OPERATION_TYPE_MOVE:
            if (((meta.isOverwriteTargetFile() && data.targetFile.exists()) || !data.targetFile.exists())
                    && !meta.simulate) {
                data.sourceFile.moveTo(KettleVFS.getFileObject(targetFilename, getTransMeta()));
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "ProcessFiles.Log.SourceFileMoved", sourceFilename,
                            targetFilename));
                }
            } else {
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "ProcessFiles.Log.TargetNotOverwritten",
                            sourceFilename, targetFilename));
                }
            }
            break;
        case ProcessFilesMeta.OPERATION_TYPE_DELETE:
            if (!meta.simulate) {
                if (!data.sourceFile.delete()) {
                    throw new KettleException(BaseMessages.getString(PKG, "ProcessFiles.Error.CanNotDeleteFile",
                            data.sourceFile.toString()));
                }
            }
            if (log.isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "ProcessFiles.Log.SourceFileDeleted", sourceFilename));
            }
            break;
        default:

            break;
        }

        // add filename to result filenames?
        if (meta.isaddTargetFileNametoResult()
                && meta.getOperationType() != ProcessFilesMeta.OPERATION_TYPE_DELETE
                && data.sourceFile.getType() == FileType.FILE) {
            // Add this to the result file names...
            ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, data.targetFile,
                    getTransMeta().getName(), getStepname());
            resultFile.setComment(BaseMessages.getString(PKG, "ProcessFiles.Log.FileAddedResult"));
            addResultFile(resultFile);

            if (log.isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "ProcessFiles.Log.FilenameAddResult",
                        data.sourceFile.toString()));
            }
        }

        putRow(getInputRowMeta(), r); // copy row to possible alternate rowset(s).

        if (checkFeedback(getLinesRead())) {
            if (log.isBasic()) {
                logBasic(BaseMessages.getString(PKG, "ProcessFiles.LineNumber") + getLinesRead());
            }
        }
    } catch (Exception e) {
        boolean sendToErrorRow = false;
        String errorMessage = null;

        if (getStepMeta().isDoingErrorHandling()) {
            sendToErrorRow = true;
            errorMessage = e.toString();
        } else {
            logError(BaseMessages.getString(PKG, "ProcessFiles.ErrorInStepRunning") + e.getMessage());
            setErrors(1);
            stopAll();
            setOutputDone(); // signal end to receiver(s)
            return false;
        }
        if (sendToErrorRow) {
            // Simply add this row to the error row
            putError(getInputRowMeta(), r, 1, errorMessage, null, "ProcessFiles001");
        }
    }

    return true;
}

From source file:org.pentaho.di.trans.steps.propertyoutput.PropertyOutput.java

private void createParentFolder() throws KettleException {
    if (meta.isCreateParentFolder()) {
        FileObject parentfolder = null;
        try {/*from   w  w  w . j a v  a  2 s. c  o  m*/
            // Do we need to create parent folder ?

            // Check for parent folder
            // Get parent folder
            parentfolder = data.file.getParent();
            if (!parentfolder.exists()) {
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "PropertyOutput.Log.ParentFolderExists",
                            parentfolder.getName().toString()));
                }
                parentfolder.createFolder();
                if (log.isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "PropertyOutput.Log.CanNotCreateParentFolder",
                            parentfolder.getName().toString()));
                }
            }
        } catch (Exception e) {
            logError(BaseMessages.getString(PKG, "PropertyOutput.Log.CanNotCreateParentFolder",
                    parentfolder.getName().toString()));
            throw new KettleException(BaseMessages.getString(PKG, "PropertyOutput.Log.CanNotCreateParentFolder",
                    parentfolder.getName().toString()));

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

From source file:org.pentaho.di.trans.steps.rssoutput.RssOutput.java

public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    meta = (RssOutputMeta) smi;/*from   www .j  a va 2 s.c  o m*/
    data = (RssOutputData) sdi;

    Object[] r = getRow(); // this also waits for a previous step to be finished.

    if (r == null) { // no more input to be expected...

        if (!first) {
            if (!meta.isCustomRss()) {
                // No more input..so write and close the file.
                WriteToFile(data.channeltitlevalue, data.channellinkvalue, data.channeldescriptionvalue,
                        data.channelpubdatevalue, data.channelcopyrightvalue, data.channelimagelinkvalue,
                        data.channelimagedescriptionvalue, data.channelimagelinkvalue,
                        data.channelimageurlvalue, data.channellanguagevalue, data.channelauthorvalue);
            } else {

                // Write to document
                OutputFormat format = org.dom4j.io.OutputFormat.createPrettyPrint();
                // Set encoding ...
                if (Const.isEmpty(meta.getEncoding())) {
                    format.setEncoding("iso-8859-1");
                } else {
                    format.setEncoding(meta.getEncoding());
                }

                try {
                    XMLWriter writer = new XMLWriter(new FileWriter(new File(data.filename)), format);
                    writer.write(data.document);
                    writer.close();
                } catch (Exception e) {
                    // Ignore errors
                } finally {
                    data.document = null;
                }

            }
        }
        setOutputDone();
        return false;
    }

    if (first) {
        first = false;
        data.inputRowMeta = getInputRowMeta();
        data.outputRowMeta = data.inputRowMeta.clone();
        meta.getFields(data.outputRowMeta, getStepname(), null, null, this, repository, metaStore);
        // Let's check for filename...

        if (meta.isFilenameInField()) {
            if (Const.isEmpty(meta.getFileNameField())) {
                logError(BaseMessages.getString(PKG, "RssOutput.Log.FilenameFieldMissing"));
                setErrors(1);
                stopAll();
                return false;
            }

            // get filename field index
            data.indexOfFieldfilename = data.inputRowMeta.indexOfValue(meta.getFileNameField());
            if (data.indexOfFieldfilename < 0) {
                // The field is unreachable !
                logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                        meta.getFileNameField()));
                throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                        meta.getFileNameField()));
            }

        } else {
            data.filename = buildFilename();
        }

        // Check if filename is empty..
        if (Const.isEmpty(data.filename)) {
            logError(BaseMessages.getString(PKG, "RssOutput.Log.FilenameEmpty"));
            throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.FilenameEmpty"));
        }

        // Do we need to create parent folder ?
        if (meta.isCreateParentFolder()) {
            // Check for parent folder
            FileObject parentfolder = null;
            try {
                // Get parent folder
                parentfolder = KettleVFS.getFileObject(data.filename, getTransMeta()).getParent();
                if (!parentfolder.exists()) {
                    if (log.isDetailed()) {
                        logDetailed(BaseMessages.getString(PKG, "RssOutput.Log.ParentFolderExists",
                                parentfolder.getName().toString()));
                    }
                    parentfolder.createFolder();
                    if (log.isDetailed()) {
                        logDetailed(BaseMessages.getString(PKG, "RssOutput.Log.CanNotCreateParentFolder",
                                parentfolder.getName().toString()));
                    }
                }
            } catch (Exception e) {
                // The field is unreachable !
                logError(BaseMessages.getString(PKG, "RssOutput.Log.CanNotCreateParentFolder",
                        parentfolder.getName().toString()));
                throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.CanNotCreateParentFolder",
                        parentfolder.getName().toString()));

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

        if (!meta.isCustomRss()) {
            // Let's check for mandatory fields ...
            if (Const.isEmpty(meta.getChannelTitle())) {
                logError(BaseMessages.getString(PKG, "RssOutput.Log.ChannelTitleMissing"));
                setErrors(1);
                stopAll();
                return false;
            }
            if (Const.isEmpty(meta.getChannelDescription())) {
                logError(BaseMessages.getString(PKG, "RssOutput.Log.ChannelDescription"));
                setErrors(1);
                stopAll();
                return false;
            }
            if (Const.isEmpty(meta.getChannelLink())) {
                logError(BaseMessages.getString(PKG, "RssOutput.Log.ChannelLink"));
                setErrors(1);
                stopAll();
                return false;
            }

            // Let's take the index of channel title field ...
            data.indexOfFieldchanneltitle = data.inputRowMeta.indexOfValue(meta.getChannelTitle());
            if (data.indexOfFieldchanneltitle < 0) {
                // The field is unreachable !
                logError(
                        BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField", meta.getChannelTitle()));
                throw new KettleException(
                        BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField", meta.getChannelTitle()));
            }
            data.channeltitlevalue = data.inputRowMeta.getString(r, data.indexOfFieldchanneltitle);

            // Let's take the index of channel description field ...
            data.indexOfFieldchanneldescription = data.inputRowMeta.indexOfValue(meta.getChannelDescription());
            if (data.indexOfFieldchanneldescription < 0) {
                // The field is unreachable !
                logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                        meta.getChannelDescription()));
                throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                        meta.getChannelDescription()));
            }

            data.channeldescriptionvalue = data.inputRowMeta.getString(r, data.indexOfFieldchanneldescription);

            // Let's take the index of channel link field ...
            data.indexOfFieldchannellink = data.inputRowMeta.indexOfValue(meta.getChannelLink());
            if (data.indexOfFieldchannellink < 0) {
                // The field is unreachable !
                logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField", meta.getChannelLink()));
                throw new KettleException(
                        BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField", meta.getChannelLink()));
            }

            data.channellinkvalue = data.inputRowMeta.getString(r, data.indexOfFieldchannellink);

            if (!Const.isEmpty(meta.getItemTitle())) {
                // Let's take the index of item title field ...
                data.indexOfFielditemtitle = data.inputRowMeta.indexOfValue(meta.getItemTitle());
                if (data.indexOfFielditemtitle < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemTitle()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemTitle()));
                }
            }

            if (!Const.isEmpty(meta.getItemDescription())) {
                // Let's take the index of item description field ...
                data.indexOfFielditemdescription = data.inputRowMeta.indexOfValue(meta.getItemDescription());
                if (data.indexOfFielditemdescription < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemDescription()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemDescription()));
                }
            }
            if (meta.AddGeoRSS()) {
                if (Const.isEmpty(meta.getGeoPointLong())) {
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.GeoPointLatEmpty"));
                }
                if (Const.isEmpty(meta.getGeoPointLong())) {
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.GeoPointLongEmpty"));
                }

                // Let's take the index of item geopointX field ...
                data.indexOfFielditempointx = data.inputRowMeta.indexOfValue(meta.getGeoPointLat());
                if (data.indexOfFielditempointx < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getGeoPointLat()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getGeoPointLat()));
                }
                // Let's take the index of item geopointY field ...
                data.indexOfFielditempointy = data.inputRowMeta.indexOfValue(meta.getGeoPointLong());
                if (data.indexOfFielditempointy < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getGeoPointLong()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getGeoPointLong()));
                }
            }

            // It's time to check non empty fields !
            // Channel PubDate field ...
            if (!Const.isEmpty(meta.getChannelPubDate())) {
                data.indexOfFieldchannelpubdate = data.inputRowMeta.indexOfValue(meta.getChannelPubDate());
                if (data.indexOfFieldchannelpubdate < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelPubDate()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelPubDate()));
                }

                data.channelpubdatevalue = data.inputRowMeta.getDate(r, data.indexOfFieldchannelpubdate);
            }
            // Channel Language field ...
            if (!Const.isEmpty(meta.getChannelLanguage())) {
                data.indexOfFieldchannellanguage = data.inputRowMeta.indexOfValue(meta.getChannelLanguage());
                if (data.indexOfFieldchannellanguage < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelLanguage()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelLanguage()));
                }

                data.channellanguagevalue = data.inputRowMeta.getString(r, data.indexOfFieldchannellanguage);
            }

            // Channel Copyright field ...
            if (!Const.isEmpty(meta.getChannelCopyright())) {
                data.indexOfFieldchannelcopyright = data.inputRowMeta.indexOfValue(meta.getChannelCopyright());
                if (data.indexOfFieldchannelcopyright < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelCopyright()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelCopyright()));
                }

                data.channelcopyrightvalue = data.inputRowMeta.getString(r, data.indexOfFieldchannelcopyright);
            }

            // Channel Author field ...
            if (!Const.isEmpty(meta.getChannelAuthor())) {
                data.indexOfFieldchannelauthor = data.inputRowMeta.indexOfValue(meta.getChannelAuthor());
                if (data.indexOfFieldchannelauthor < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelAuthor()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getChannelAuthor()));
                }

                data.channelauthorvalue = data.inputRowMeta.getString(r, data.indexOfFieldchannelauthor);
            }

            // Channel Image field ...
            if (meta.AddImage()) {
                // Channel image title
                if (!Const.isEmpty(meta.getChannelImageTitle())) {
                    data.indexOfFieldchannelimagetitle = data.inputRowMeta
                            .indexOfValue(meta.getChannelImageTitle());
                    if (data.indexOfFieldchannelimagetitle < 0) {
                        // The field is unreachable !
                        logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageTitle()));
                        throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageTitle()));
                    }

                    data.channelimagetitlevalue = data.inputRowMeta.getString(r,
                            data.indexOfFieldchannelimagetitle);
                }

                // Channel link title
                if (!Const.isEmpty(meta.getChannelImageLink())) {
                    data.indexOfFieldchannelimagelink = data.inputRowMeta
                            .indexOfValue(meta.getChannelImageLink());
                    if (data.indexOfFieldchannelimagelink < 0) {
                        // The field is unreachable !
                        logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageLink()));
                        throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageLink()));
                    }

                    data.channelimagelinkvalue = data.inputRowMeta.getString(r,
                            data.indexOfFieldchannelimagelink);
                }

                // Channel url title
                if (!Const.isEmpty(meta.getChannelImageUrl())) {
                    data.indexOfFieldchannelimageurl = data.inputRowMeta
                            .indexOfValue(meta.getChannelImageUrl());
                    if (data.indexOfFieldchannelimageurl < 0) {
                        // The field is unreachable !
                        logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageUrl()));
                        throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageUrl()));
                    }

                    data.channelimageurlvalue = data.inputRowMeta.getString(r,
                            data.indexOfFieldchannelimageurl);
                }

                // Channel description title
                if (!Const.isEmpty(meta.getChannelImageDescription())) {
                    data.indexOfFieldchannelimagedescription = data.inputRowMeta
                            .indexOfValue(meta.getChannelImageDescription());
                    if (data.indexOfFieldchannelimagedescription < 0) {
                        // The field is unreachable !
                        logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageDescription()));
                        throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                                meta.getChannelImageDescription()));
                    }

                    data.channelimagedescriptionvalue = data.inputRowMeta.getString(r,
                            data.indexOfFieldchannelimagedescription);
                }

            }

            // Item link field ...
            if (!Const.isEmpty(meta.getItemLink())) {
                data.indexOfFielditemlink = data.inputRowMeta.indexOfValue(meta.getItemLink());
                if (data.indexOfFielditemlink < 0) {
                    // The field is unreachable !
                    logError(
                            BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField", meta.getItemLink()));
                    throw new KettleException(
                            BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField", meta.getItemLink()));
                }

            }

            // Item pubdate field ...
            if (!Const.isEmpty(meta.getItemPubDate())) {
                data.indexOfFielditempubdate = data.inputRowMeta.indexOfValue(meta.getItemPubDate());
                if (data.indexOfFielditempubdate < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemPubDate()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemPubDate()));
                }
            }

            // Item author field ...
            if (!Const.isEmpty(meta.getItemAuthor())) {
                data.indexOfFielditemauthor = data.inputRowMeta.indexOfValue(meta.getItemAuthor());
                if (data.indexOfFielditemauthor < 0) {
                    // The field is unreachable !
                    logError(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemAuthor()));
                    throw new KettleException(BaseMessages.getString(PKG, "RssOutput.Log.ErrorFindingField",
                            meta.getItemAuthor()));
                }
            }
        } else {
            // Custom RSS
            // Check Custom channel fields
            data.customchannels = new int[meta.getChannelCustomFields().length];
            for (int i = 0; i < meta.getChannelCustomFields().length; i++) {
                data.customchannels[i] = data.inputRowMeta.indexOfValue(meta.getChannelCustomFields()[i]);
                if (data.customchannels[i] < 0) { // couldn't find field!

                    throw new KettleStepException(BaseMessages.getString(PKG,
                            "RssOutput.Exception.FieldRequired", meta.getChannelCustomFields()[i]));
                }
            }
            // Check Custom channel fields
            data.customitems = new int[meta.getItemCustomFields().length];
            for (int i = 0; i < meta.getItemCustomFields().length; i++) {
                data.customitems[i] = data.inputRowMeta.indexOfValue(meta.getItemCustomFields()[i]);
                if (data.customitems[i] < 0) { // couldn't find field!

                    throw new KettleStepException(BaseMessages.getString(PKG,
                            "RssOutput.Exception.FieldRequired", meta.getItemCustomFields()[i]));
                }
            }
            // Prepare Output RSS Custom document
            data.document = DocumentHelper.createDocument();
            data.rssElement = data.document.addElement("rss");
            data.rssElement.addAttribute("version", "2.0");
            // add namespaces here ...
            for (int i = 0; i < meta.getNameSpaces().length; i++) {
                data.rssElement.addNamespace(environmentSubstitute(meta.getNameSpacesTitle()[i]),
                        environmentSubstitute(meta.getNameSpaces()[i]));
            }

            // Add channel
            data.channel = data.rssElement.addElement("channel");

            // Set channel Only the first time ...
            for (int i = 0; i < data.customchannels.length; i++) {
                String channelname = environmentSubstitute(meta.getChannelCustomTags()[i]);
                String channelvalue = data.inputRowMeta.getString(r, data.customchannels[i]);

                if (log.isDetailed()) {
                    logDetailed("outputting channel value <" + channelname + ">" + channelvalue + "<"
                            + channelname + "/>");
                }

                // add Channel
                Element channeltag = data.channel.addElement(channelname);
                channeltag.setText(channelvalue);

            }
        }
    } // end test first time

    // Let's get value for each item...
    if (!meta.isCustomRss()) {
        String itemtitlevalue = null;
        String itemauthorvalue = null;
        String itemlinkvalue = null;
        Date itemdatevalue = null;
        String itemdescvalue = null;
        String itemgeopointx = null;
        String itemgeopointy = null;

        if (data.indexOfFielditemtitle > -1) {
            itemtitlevalue = data.inputRowMeta.getString(r, data.indexOfFielditemtitle);
        }
        if (data.indexOfFielditemauthor > -1) {
            itemauthorvalue = data.inputRowMeta.getString(r, data.indexOfFielditemauthor);
        }
        if (data.indexOfFielditemlink > -1) {
            itemlinkvalue = data.inputRowMeta.getString(r, data.indexOfFielditemlink);
        }
        if (data.indexOfFielditempubdate > -1) {
            itemdatevalue = data.inputRowMeta.getDate(r, data.indexOfFielditempubdate);
        }
        if (data.indexOfFielditemdescription > -1) {
            itemdescvalue = data.inputRowMeta.getString(r, data.indexOfFielditemdescription);
        }
        if (data.indexOfFielditempointx > -1) {
            itemgeopointx = data.inputRowMeta.getString(r, data.indexOfFielditempointx);
        }
        if (data.indexOfFielditempointy > -1) {
            itemgeopointy = data.inputRowMeta.getString(r, data.indexOfFielditempointy);
        }

        // Now add entry ..
        if (!createEntry(itemauthorvalue, itemtitlevalue, itemlinkvalue, itemdatevalue, itemdescvalue,
                itemgeopointx, itemgeopointy)) {
            throw new KettleException("Error adding item to feed");
        }
    } else {

        // Set item tag at each row received
        if (meta.isDisplayItem()) {
            data.itemtag = data.channel.addElement("item");
        }
        for (int i = 0; i < data.customitems.length; i++) {
            // get item value and name
            String itemname = environmentSubstitute(meta.getItemCustomTags()[i]);
            String itemvalue = data.inputRowMeta.getString(r, data.customitems[i]);

            if (log.isDetailed()) {
                logDetailed("outputting item value <" + itemname + ">" + itemvalue + "<" + itemname + "/>");
            }

            // add Item
            if (meta.isDisplayItem()) {
                Element itemtagsub = data.itemtag.addElement(itemname);
                itemtagsub.setText(itemvalue);
            } else {
                // display item at channel level
                Element temp = data.channel.addElement(itemname);
                temp.setText(itemvalue);
            }
        }
    }

    try {
        putRow(data.outputRowMeta, r); // in case we want it to go further...
        incrementLinesOutput();

        if (checkFeedback(getLinesOutput())) {
            if (log.isDebug()) {
                logDebug(BaseMessages.getString(PKG, "RssOutput.Log.Linenr", "" + getLinesOutput()));
            }
        }

    } catch (KettleStepException e) {
        logError(BaseMessages.getString(PKG, "RssOutputMeta.Log.ErrorInStep") + e.getMessage());
        setErrors(1);
        stopAll();
        setOutputDone(); // signal end to receiver(s)
        return false;
    }

    return true;
}

From source file:org.pentaho.di.trans.steps.script.ScriptAddedFunctions.java

public static void createFolder(ScriptEngine actualContext, Bindings actualObject, Object[] ArgList,
        Object FunctionContext) {

    try {/*from ww  w.  j a  v a 2  s . c o m*/
        if (ArgList.length == 1 && !isNull(ArgList[0]) && !isUndefined(ArgList[0])) {
            FileObject fileObject = null;

            try {
                fileObject = KettleVFS.getFileObject((String) ArgList[0]);
                if (!fileObject.exists()) {
                    fileObject.createFolder();
                } else {
                    new RuntimeException("folder [" + (String) ArgList[0] + "] already exist!");
                }
            } catch (IOException e) {
                throw new RuntimeException("The function call createFolder is not valid.");
            } finally {
                if (fileObject != null) {
                    try {
                        fileObject.close();
                    } catch (Exception e) {
                        // Ignore errors
                    }
                }
            }

        } else {
            throw new RuntimeException("The function call createFolder is not valid.");
        }
    } catch (Exception e) {
        throw new RuntimeException(e.toString());
    }
}

From source file:org.pentaho.di.trans.steps.scriptvalues_mod.ScriptValuesAddedFunctions.java

public static void createFolder(Context actualContext, Scriptable actualObject, Object[] ArgList,
        Function FunctionContext) {

    try {//from  w  ww . j  a v a2s  .c om
        if (ArgList.length == 1 && !isNull(ArgList[0]) && !isUndefined(ArgList[0])) {
            FileObject fileObject = null;

            try {
                fileObject = KettleVFS.getFileObject(Context.toString(ArgList[0]));
                if (!fileObject.exists()) {
                    fileObject.createFolder();
                } else {
                    Context.reportRuntimeError("folder [" + Context.toString(ArgList[0]) + "] already exist!");
                }
            } catch (IOException e) {
                throw Context.reportRuntimeError("The function call createFolder is not valid.");
            } finally {
                if (fileObject != null) {
                    try {
                        fileObject.close();
                    } catch (Exception e) {
                        // Ignore errors
                    }
                }
            }

        } else {
            throw Context.reportRuntimeError("The function call createFolder is not valid.");
        }
    } catch (Exception e) {
        throw Context.reportRuntimeError(e.toString());
    }
}

From source file:org.pentaho.di.trans.steps.sqlfileoutput.SQLFileOutput.java

public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
    meta = (SQLFileOutputMeta) smi;/*from  ww w .  j  av  a 2 s.  c om*/
    data = (SQLFileOutputData) sdi;

    if (super.init(smi, sdi)) {
        try {
            if (meta.getDatabaseMeta() == null) {
                throw new KettleStepException("The connection is not defined (empty)");
            }
            if (meta.getDatabaseMeta() == null) {
                logError(BaseMessages.getString(PKG, "SQLFileOutput.Init.ConnectionMissing", getStepname()));
                return false;
            }
            data.db = new Database(this, meta.getDatabaseMeta());
            data.db.shareVariablesWith(this);

            logBasic("Connected to database [" + meta.getDatabaseMeta() + "]");

            if (meta.isCreateParentFolder()) {
                // Check for parent folder
                FileObject parentfolder = null;
                try {
                    // Get parent folder
                    String filename = environmentSubstitute(meta.getFileName());
                    parentfolder = KettleVFS.getFileObject(filename, getTransMeta()).getParent();
                    if (!parentfolder.exists()) {
                        log.logBasic("Folder parent",
                                "Folder parent " + parentfolder.getName() + " does not exist !");
                        parentfolder.createFolder();
                        log.logBasic("Folder parent", "Folder parent was created.");
                    }
                } catch (Exception e) {
                    logError("Couldn't created parent folder " + parentfolder.getName());
                    setErrors(1L);
                    stopAll();
                } finally {
                    if (parentfolder != null) {
                        try {
                            parentfolder.close();
                        } catch (Exception ex) { /* Ignore */
                        }
                    }
                }
            }

            if (!meta.isDoNotOpenNewFileInit()) {
                if (!openNewFile()) {
                    logError("Couldn't open file [" + buildFilename() + "]");
                    setErrors(1L);
                    stopAll();
                }
            }

            tableName = environmentSubstitute(meta.getTablename());
            schemaName = environmentSubstitute(meta.getSchemaName());

            if (Const.isEmpty(tableName)) {
                throw new KettleStepException("The tablename is not defined (empty)");
            }

            schemaTable = data.db.getDatabaseMeta().getQuotedSchemaTableCombination(schemaName, tableName);

        } catch (Exception e) {
            logError("An error occurred intialising this step: " + e.getMessage());
            stopAll();
            setErrors(1);
        }

        return true;
    }
    return false;
}

From source file:org.pentaho.di.trans.steps.textfileoutput.TextFileOutput.java

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

From source file:org.pentaho.di.trans.steps.zipfile.ZipFile.java

public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    meta = (ZipFileMeta) smi;/*www  .j  a v  a2s .c o m*/
    data = (ZipFileData) sdi;

    Object[] r = getRow(); // Get row from input rowset & set row busy!
    if (r == null) { // no more input to be expected...

        setOutputDone();
        return false;
    }

    if (first) {
        first = false;

        data.outputRowMeta = getInputRowMeta().clone();
        meta.getFields(data.outputRowMeta, getStepname(), null, null, this, getTrans().getRepository(),
                getTrans().getMetaStore());

        // Check is source filename field is provided
        if (Const.isEmpty(meta.getDynamicSourceFileNameField())) {
            throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Error.SourceFilenameFieldMissing"));
        }
        // Check is target filename field is provided
        if (Const.isEmpty(meta.getDynamicTargetFileNameField())) {
            throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Error.TargetFilenameFieldMissing"));
        }

        // cache the position of the source filename field
        if (data.indexOfSourceFilename < 0) {
            data.indexOfSourceFilename = getInputRowMeta().indexOfValue(meta.getDynamicSourceFileNameField());
            if (data.indexOfSourceFilename < 0) {
                // The field is unreachable !
                throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Exception.CouldnotFindField",
                        meta.getDynamicSourceFileNameField()));
            }
        }

        data.indexOfZipFilename = getInputRowMeta().indexOfValue(meta.getDynamicTargetFileNameField());
        if (data.indexOfZipFilename < 0) {
            // The field is unreachable !
            throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Exception.CouldnotFindField",
                    meta.getDynamicTargetFileNameField()));
        }

        if (meta.isKeepSouceFolder()) {
            if (!Const.isEmpty(meta.getBaseFolderField())) {
                // cache the position of the source filename field
                data.indexOfBaseFolder = getInputRowMeta().indexOfValue(meta.getBaseFolderField());
                if (data.indexOfBaseFolder < 0) {
                    // The field is unreachable !
                    throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Exception.CouldnotFindField",
                            meta.getBaseFolderField()));
                }
            }
        }

        // Move to folder
        if (meta.getOperationType() == ZipFileMeta.OPERATION_TYPE_MOVE) {
            if (Const.isEmpty(meta.getMoveToFolderField())) {
                throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Exception.EmptyMovetoFolder"));
            }
            data.indexOfMoveToFolder = getInputRowMeta().indexOfValue(meta.getMoveToFolderField());
            if (data.indexOfMoveToFolder < 0) {
                // The field is unreachable !
                throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Exception.CouldnotFindField",
                        meta.getMoveToFolderField()));
            }
        }

    } // End If first

    boolean sendToErrorRow = false;
    String errorMessage = null;

    try {
        // get source filename
        String sourceFilename = getInputRowMeta().getString(r, data.indexOfSourceFilename);

        if (Const.isEmpty(sourceFilename)) {
            log.logError(toString(), BaseMessages.getString(PKG, "ZipFile.Error.SourceFileEmpty"));
            throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Error.SourceFileEmpty"));
        }
        data.sourceFile = KettleVFS.getFileObject(sourceFilename);

        // Check sourcefile
        boolean skip = false;
        if (!data.sourceFile.exists()) {
            log.logError(toString(),
                    BaseMessages.getString(PKG, "ZipFile.Error.SourceFileNotExist", sourceFilename));
            throw new KettleException(
                    BaseMessages.getString(PKG, "ZipFile.Error.SourceFileNotExist", sourceFilename));
        } else {
            if (data.sourceFile.getType() != FileType.FILE) {
                log.logError(toString(),
                        BaseMessages.getString(PKG, "ZipFile.Error.SourceFileNotFile", sourceFilename));
                throw new KettleException(
                        BaseMessages.getString(PKG, "ZipFile.Error.SourceFileNotFile", sourceFilename));
            }
        }

        // get basefolder
        if (data.indexOfBaseFolder > -1) {
            data.baseFolder = getInputRowMeta().getString(r, data.indexOfBaseFolder);
        }

        // get destination folder
        String moveToFolder = null;
        if (data.indexOfMoveToFolder > -1) {
            moveToFolder = getInputRowMeta().getString(r, data.indexOfMoveToFolder);
            if (Const.isEmpty(moveToFolder)) {
                throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Error.EmptyMoveToFolder"));
            }
        }

        if (!skip) {
            // get value for target filename
            String targetFilename = getInputRowMeta().getString(r, data.indexOfZipFilename);

            if (Const.isEmpty(targetFilename)) {
                log.logError(toString(), BaseMessages.getString(PKG, "ZipFile.Error.TargetFileEmpty"));
                throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Error.TargetFileEmpty"));
            }
            data.zipFile = KettleVFS.getFileObject(targetFilename);
            if (data.zipFile.exists()) {
                if (log.isDetailed()) {
                    log.logDetailed(toString(),
                            BaseMessages.getString(PKG, "ZipFile.Log.TargetFileExists", targetFilename));
                }
            } else {
                // let's check parent folder
                FileObject parentFolder = data.zipFile.getParent();
                if (!parentFolder.exists()) {
                    if (!meta.isCreateParentFolder()) {
                        // Parent folder not exist
                        // So we will fail
                        throw new KettleException(BaseMessages.getString(PKG,
                                "ZipFile.Error.TargetParentFolderNotExists", parentFolder.toString()));
                    } else {
                        // Create parent folder
                        parentFolder.createFolder();
                    }
                }
                if (parentFolder != null) {
                    parentFolder.close();
                }
            }

            // Let's zip
            zipFile();

            // file was zipped, let's see if we need to move or delete it
            processFile(moveToFolder);

            // add filename to result filenames?
            addFilenameToResult();
        }

        getLinesInput();
        putRow(data.outputRowMeta, r); // copy row to output rowset(s);

        if (checkFeedback(getLinesRead())) {
            if (log.isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "ZipFile.LineNumber", "" + getLinesRead()));
            }
        }
    } catch (Exception e) {
        if (getStepMeta().isDoingErrorHandling()) {
            sendToErrorRow = true;
            errorMessage = e.toString();
        } else {
            logError(BaseMessages.getString(PKG, "ZipFile.ErrorInStepRunning") + e.getMessage());
            setErrors(1);
            stopAll();
            setOutputDone(); // signal end to receiver(s)
            return false;
        }
        if (sendToErrorRow) {
            // Simply add this row to the error row
            putError(getInputRowMeta(), r, 1, errorMessage, null, "ZipFile001");
        }
    } finally {
        try {
            if (data.sourceFile != null) {
                data.sourceFile.close();
            }
            if (data.zipFile != null) {
                data.zipFile.close();
            }
        } catch (Exception e) { /* Ignore */
        }
    }

    return true;
}