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

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

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.vfs.*
  5. FileObject
  6. exists

Introduction

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

Prototype

public boolean exists() throws FileSystemException;

Source Link

Document

Determines if this file exists.

Usage

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

public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
    meta = (SQLFileOutputMeta) smi;//from  w  w w . jav  a 2  s .c o m
    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.sqlfileoutput.SQLFileOutputMeta.java

/**
 * Since the exported transformation that runs this will reside in a ZIP file, we can't reference files relatively. So
 * what this does is turn the name of files into absolute paths OR it simply includes the resource in the ZIP file.
 * For now, we'll simply turn it into an absolute path and pray that the file is on a shared drive or something like
 * that./*from w w w  .j  a  v a 2 s.  c  o m*/
 *
 * @param space
 *          the variable space to use
 * @param definitions
 * @param resourceNamingInterface
 * @param repository
 *          The repository to optionally load other resources from (to be converted to XML)
 * @param metaStore
 *          the metaStore in which non-kettle metadata could reside.
 *
 * @return the filename of the exported resource
 */
public String exportResources(VariableSpace space, Map<String, ResourceDefinition> definitions,
        ResourceNamingInterface resourceNamingInterface, Repository repository, IMetaStore metaStore)
        throws KettleException {
    try {
        // The object that we're modifying here is a copy of the original!
        // So let's change the filename from relative to absolute by grabbing the file object...
        //
        // From : ${Internal.Transformation.Filename.Directory}/../foo/bar.data
        // To : /home/matt/test/files/foo/bar.data
        //
        FileObject fileObject = KettleVFS.getFileObject(space.environmentSubstitute(fileName), space);

        // If the file doesn't exist, forget about this effort too!
        //
        if (fileObject.exists()) {
            // Convert to an absolute path...
            //
            fileName = resourceNamingInterface.nameResource(fileObject, space, true);

            return fileName;
        }
        return null;
    } catch (Exception e) {
        throw new KettleException(e);
    }
}

From source file:org.pentaho.di.trans.steps.symmetriccrypto.symmetricalgorithm.SymmetricCrypto.java

public void setSecretKeyFromFile(String filename) throws CryptoKeyException {
    FileObject file = null;
    try {//from  www .j ava 2s  . co m
        file = KettleVFS.getFileObject(filename);
        if (!file.exists()) {
            throw new CryptoException(
                    BaseMessages.getString(PKG, "SymmetricCrypto.CanNotFindFile", file.getName()));
        }
        byte[] KeyBytes = new byte[(int) file.getContent().getSize()];

        setSecretKey(KeyBytes);

    } catch (Exception e) {
        throw new CryptoKeyException(e);
    } finally {
        if (file != null) {
            try {
                file.close();
            } catch (Exception e) { /* Ignore */
            }
        }
    }
}

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 {//  ww w  . ja v  a2s.c  om
        // 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.xbaseinput.XBaseInputMeta.java

/**
 * Since the exported transformation that runs this will reside in a ZIP file, we can't reference files relatively. So
 * what this does is turn the name of files into absolute paths OR it simply includes the resource in the ZIP file.
 * For now, we'll simply turn it into an absolute path and pray that the file is on a shared drive or something like
 * that.//  w  ww.  j  a  va2 s.  co m
 *
 * @param space
 *          the variable space to use
 * @param definitions
 * @param resourceNamingInterface
 * @param repository
 *          The repository to optionally load other resources from (to be converted to XML)
 * @param metaStore
 *          the metaStore in which non-kettle metadata could reside.
 *
 * @return the filename of the exported resource
 */
public String exportResources(VariableSpace space, Map<String, ResourceDefinition> definitions,
        ResourceNamingInterface resourceNamingInterface, Repository repository, IMetaStore metaStore)
        throws KettleException {
    try {
        // The object that we're modifying here is a copy of the original!
        // So let's change the filename from relative to absolute by grabbing the file object...
        // In case the name of the file comes from previous steps, forget about this!
        //
        if (!acceptingFilenames) {
            // From : ${Internal.Transformation.Filename.Directory}/../foo/bar.dbf
            // To : /home/matt/test/files/foo/bar.dbf
            //
            FileObject fileObject = KettleVFS.getFileObject(space.environmentSubstitute(dbfFileName), space);

            // If the file doesn't exist, forget about this effort too!
            //
            if (fileObject.exists()) {
                // Convert to an absolute path...
                //
                dbfFileName = resourceNamingInterface.nameResource(fileObject, space, true);

                return dbfFileName;
            }
        }
        return null;
    } catch (Exception e) {
        throw new KettleException(e);
    }
}

From source file:org.pentaho.di.trans.steps.xsdvalidator.XsdValidator.java

public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    meta = (XsdValidatorMeta) smi;//from   w w w  .  j  a va  2s .  com
    data = (XsdValidatorData) sdi;

    Object[] row = getRow();

    if (row == 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, repository, metaStore);

        // Check if XML stream is given
        if (meta.getXMLStream() != null) {
            // Try to get XML Field index
            data.xmlindex = getInputRowMeta().indexOfValue(meta.getXMLStream());
            // Let's check the Field
            if (data.xmlindex < 0) {
                // The field is unreachable !
                logError(BaseMessages.getString(PKG, "XsdValidator.Log.ErrorFindingField") + "["
                        + meta.getXMLStream() + "]");
                throw new KettleStepException(BaseMessages.getString(PKG,
                        "XsdValidator.Exception.CouldnotFindField", meta.getXMLStream()));
            }

            // Let's check that Result Field is given
            if (meta.getResultfieldname() == null) {
                // Result field is missing !
                logError(BaseMessages.getString(PKG, "XsdValidator.Log.ErrorResultFieldMissing"));
                throw new KettleStepException(
                        BaseMessages.getString(PKG, "XsdValidator.Exception.ErrorResultFieldMissing"));
            }

            // Is XSD file is provided?
            if (meta.getXSDSource().equals(meta.SPECIFY_FILENAME)) {
                if (meta.getXSDFilename() == null) {
                    logError(BaseMessages.getString(PKG, "XsdValidator.Log.ErrorXSDFileMissing"));
                    throw new KettleStepException(
                            BaseMessages.getString(PKG, "XsdValidator.Exception.ErrorXSDFileMissing"));
                } else {
                    // Is XSD file exists ?
                    FileObject xsdfile = null;
                    try {
                        xsdfile = KettleVFS.getFileObject(environmentSubstitute(meta.getXSDFilename()),
                                getTransMeta());
                        if (!xsdfile.exists()) {
                            logError(BaseMessages.getString(PKG, "XsdValidator.Log.Error.XSDFileNotExists"));
                            throw new KettleStepException(
                                    BaseMessages.getString(PKG, "XsdValidator.Exception.XSDFileNotExists"));
                        }

                    } catch (Exception e) {
                        logError(BaseMessages.getString(PKG, "XsdValidator.Log.Error.GettingXSDFile"));
                        throw new KettleStepException(
                                BaseMessages.getString(PKG, "XsdValidator.Exception.GettingXSDFile"));
                    } finally {
                        try {
                            if (xsdfile != null) {
                                xsdfile.close();
                            }
                        } catch (IOException e) {
                            // Ignore errors
                        }
                    }
                }
            }

            // Is XSD field is provided?
            if (meta.getXSDSource().equals(meta.SPECIFY_FIELDNAME)) {
                if (meta.getXSDDefinedField() == null) {
                    logError(BaseMessages.getString(PKG, "XsdValidator.Log.Error.XSDFieldMissing"));
                    throw new KettleStepException(
                            BaseMessages.getString(PKG, "XsdValidator.Exception.XSDFieldMissing"));
                } else {
                    // Let's check if the XSD field exist
                    // Try to get XML Field index
                    data.xsdindex = getInputRowMeta().indexOfValue(meta.getXSDDefinedField());

                    if (data.xsdindex < 0) {
                        // The field is unreachable !
                        logError(BaseMessages.getString(PKG, "XsdValidator.Log.ErrorFindingXSDField",
                                meta.getXSDDefinedField()));
                        throw new KettleStepException(BaseMessages.getString(PKG,
                                "XsdValidator.Exception.ErrorFindingXSDField", meta.getXSDDefinedField()));
                    }
                }
            }

        } else {
            // XML stream field is missing !
            logError(BaseMessages.getString(PKG, "XsdValidator.Log.Error.XmlStreamFieldMissing"));
            throw new KettleStepException(
                    BaseMessages.getString(PKG, "XsdValidator.Exception.XmlStreamFieldMissing"));
        }
    }

    try {

        // Get the XML field value
        String XMLFieldvalue = getInputRowMeta().getString(row, data.xmlindex);

        boolean isvalid = false;

        // XSD filename
        String xsdfilename = null;

        if (meta.getXSDSource().equals(meta.SPECIFY_FILENAME)) {
            xsdfilename = environmentSubstitute(meta.getXSDFilename());
        } else if (meta.getXSDSource().equals(meta.SPECIFY_FIELDNAME)) {
            // Get the XSD field value
            xsdfilename = getInputRowMeta().getString(row, data.xsdindex);
        }

        // Get XSD filename
        FileObject xsdfile = null;
        String validationmsg = null;
        try {

            SchemaFactory factoryXSDValidator = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

            xsdfile = KettleVFS.getFileObject(xsdfilename, getTransMeta());

            // Get XML stream
            Source sourceXML = new StreamSource(new StringReader(XMLFieldvalue));

            if (meta.getXMLSourceFile()) {

                // We deal with XML file
                // Get XML File
                File xmlfileValidator = new File(XMLFieldvalue);
                if (!xmlfileValidator.exists()) {
                    logError(BaseMessages.getString(PKG, "XsdValidator.Log.Error.XMLfileMissing",
                            XMLFieldvalue));
                    throw new KettleStepException(BaseMessages.getString(PKG,
                            "XsdValidator.Exception.XMLfileMissing", XMLFieldvalue));
                }
                sourceXML = new StreamSource(xmlfileValidator);
            }

            // create the schema
            Schema SchematXSD = null;
            if (xsdfile instanceof LocalFile) {
                SchematXSD = factoryXSDValidator.newSchema(new File(KettleVFS.getFilename(xsdfile)));
            } else if (xsdfile instanceof HttpFileObject) {
                SchematXSD = factoryXSDValidator.newSchema(new URL(KettleVFS.getFilename(xsdfile)));
            } else {
                // we should not get here as anything entered in that does not look like
                // a url should be made a FileObject.
                throw new KettleStepException(BaseMessages.getString(PKG,
                        "XsdValidator.Exception.CannotCreateSchema", xsdfile.getClass().getName()));
            }

            if (meta.getXSDSource().equals(meta.NO_NEED)) {
                // ---Some documents specify the schema they expect to be validated against,
                // ---typically using xsi:noNamespaceSchemaLocation and/or xsi:schemaLocation attributes
                // ---Schema SchematXSD = factoryXSDValidator.newSchema();
                SchematXSD = factoryXSDValidator.newSchema();
            }

            // Create XSDValidator
            Validator XSDValidator = SchematXSD.newValidator();
            // Validate XML / XSD
            XSDValidator.validate(sourceXML);

            isvalid = true;

        } catch (SAXException ex) {
            validationmsg = ex.getMessage();
        } catch (IOException ex) {
            validationmsg = ex.getMessage();
        } finally {
            try {
                if (xsdfile != null) {
                    xsdfile.close();
                }
            } catch (IOException e) {
                // Ignore errors
            }
        }

        Object[] outputRowData = null;
        Object[] outputRowData2 = null;

        if (meta.getOutputStringField()) {
            // Output type=String
            if (isvalid) {
                outputRowData = RowDataUtil.addValueData(row, getInputRowMeta().size(),
                        environmentSubstitute(meta.getIfXmlValid()));
            } else {
                outputRowData = RowDataUtil.addValueData(row, getInputRowMeta().size(),
                        environmentSubstitute(meta.getIfXmlInvalid()));
            }
        } else {
            outputRowData = RowDataUtil.addValueData(row, getInputRowMeta().size(), isvalid);
        }

        if (meta.useAddValidationMessage()) {
            outputRowData2 = RowDataUtil.addValueData(outputRowData, getInputRowMeta().size() + 1,
                    validationmsg);
        } else {
            outputRowData2 = outputRowData;
        }

        if (log.isRowLevel()) {
            logRowlevel(BaseMessages.getString(PKG, "XsdValidator.Log.ReadRow") + " "
                    + getInputRowMeta().getString(row));
        }

        // add new values to the row.
        putRow(data.outputRowMeta, outputRowData2); // copy row to output rowset(s);
    } catch (KettleException e) {
        boolean sendToErrorRow = false;
        String errorMessage = null;

        if (getStepMeta().isDoingErrorHandling()) {
            sendToErrorRow = true;
            errorMessage = e.toString();
        }

        if (sendToErrorRow) {
            // Simply add this row to the error row
            putError(getInputRowMeta(), row, 1, errorMessage, null, "XSD001");
        } else {
            logError(BaseMessages.getString(PKG, "XsdValidator.ErrorProcesing" + " : " + e.getMessage()));
            throw new KettleStepException(BaseMessages.getString(PKG, "XsdValidator.ErrorProcesing"), e);
        }
    }

    return true;

}

From source file:org.pentaho.di.trans.steps.xslt.Xslt.java

public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    meta = (XsltMeta) smi;//from w  ww.j  a  v  a 2  s .  com
    data = (XsltData) sdi;

    Object[] row = getRow();

    if (row == 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, repository, metaStore);

        // Check if The result field is given
        if (Const.isEmpty(meta.getResultfieldname())) {
            // Result Field is missing !
            logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorResultFieldMissing"));
            throw new KettleStepException(
                    BaseMessages.getString(PKG, "Xslt.Exception.ErrorResultFieldMissing"));
        }

        // Check if The XML field is given
        if (Const.isEmpty(meta.getFieldname())) {
            // Result Field is missing !
            logError(BaseMessages.getString(PKG, "Xslt.Exception.ErrorXMLFieldMissing"));
            throw new KettleStepException(BaseMessages.getString(PKG, "Xslt.Exception.ErrorXMLFieldMissing"));
        }

        // Try to get XML Field index
        data.fieldposition = getInputRowMeta().indexOfValue(meta.getFieldname());
        // Let's check the Field
        if (data.fieldposition < 0) {
            // The field is unreachable !
            logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorFindingField") + "[" + meta.getFieldname()
                    + "]");
            throw new KettleStepException(
                    BaseMessages.getString(PKG, "Xslt.Exception.CouldnotFindField", meta.getFieldname()));
        }

        // Check if the XSL Filename is contained in a column
        if (meta.useXSLField()) {
            if (Const.isEmpty(meta.getXSLFileField())) {
                // The field is missing
                // Result field is missing !
                logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFileFieldMissing"));
                throw new KettleStepException(
                        BaseMessages.getString(PKG, "Xslt.Exception.ErrorXSLFileFieldMissing"));
            }

            // Try to get Field index
            data.fielxslfiledposition = getInputRowMeta().indexOfValue(meta.getXSLFileField());

            // Let's check the Field
            if (data.fielxslfiledposition < 0) {
                // The field is unreachable !
                logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFileFieldFinding") + "["
                        + meta.getXSLFileField() + "]");
                throw new KettleStepException(BaseMessages.getString(PKG,
                        "Xslt.Exception.ErrorXSLFileFieldFinding", meta.getXSLFileField()));
            }

        } else {
            if (Const.isEmpty(meta.getXslFilename())) {
                logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFile"));
                throw new KettleStepException(BaseMessages.getString(PKG, "Xslt.Exception.ErrorXSLFile"));
            }

            // Check if XSL File exists!
            data.xslfilename = environmentSubstitute(meta.getXslFilename());
            FileObject file = null;
            try {
                file = KettleVFS.getFileObject(data.xslfilename);
                if (!file.exists()) {
                    logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLFileNotExists", data.xslfilename));
                    throw new KettleStepException(BaseMessages.getString(PKG,
                            "Xslt.Exception.ErrorXSLFileNotExists", data.xslfilename));
                }
                if (file.getType() != FileType.FILE) {
                    logError(BaseMessages.getString(PKG, "Xslt.Log.ErrorXSLNotAFile", data.xslfilename));
                    throw new KettleStepException(
                            BaseMessages.getString(PKG, "Xslt.Exception.ErrorXSLNotAFile", data.xslfilename));
                }
            } catch (Exception e) {
                throw new KettleStepException(e);
            } finally {
                try {
                    if (file != null) {
                        file.close();
                    }
                } catch (Exception e) { /* Ignore */
                }
            }
        }

        // Check output parameters
        int nrOutputProps = meta.getOutputPropertyName() == null ? 0 : meta.getOutputPropertyName().length;
        if (nrOutputProps > 0) {
            data.outputProperties = new Properties();
            for (int i = 0; i < nrOutputProps; i++) {
                data.outputProperties.put(meta.getOutputPropertyName()[i],
                        environmentSubstitute(meta.getOutputPropertyValue()[i]));
            }
            data.setOutputProperties = true;
        }

        // Check parameters
        data.nrParams = meta.getParameterField() == null ? 0 : meta.getParameterField().length;
        if (data.nrParams > 0) {
            data.indexOfParams = new int[data.nrParams];
            data.nameOfParams = new String[data.nrParams];
            for (int i = 0; i < data.nrParams; i++) {
                String name = environmentSubstitute(meta.getParameterName()[i]);
                String field = environmentSubstitute(meta.getParameterField()[i]);
                if (Const.isEmpty(field)) {
                    throw new KettleStepException(
                            BaseMessages.getString(PKG, "Xslt.Exception.ParameterFieldMissing", name, i));
                }
                data.indexOfParams[i] = getInputRowMeta().indexOfValue(field);
                if (data.indexOfParams[i] < 0) {
                    throw new KettleStepException(
                            BaseMessages.getString(PKG, "Xslt.Exception.ParameterFieldNotFound", name));
                }
                data.nameOfParams[i] = name;
            }
            data.useParameters = true;
        }

        data.factory = TransformerFactory.newInstance();

        if (meta.getXSLFactory().equals("SAXON")) {
            // Set the TransformerFactory to the SAXON implementation.
            data.factory = new net.sf.saxon.TransformerFactoryImpl();
        }
    } // end if first

    // Get the field value
    String xmlValue = getInputRowMeta().getString(row, data.fieldposition);

    if (meta.useXSLField()) {
        // Get the value
        data.xslfilename = getInputRowMeta().getString(row, data.fielxslfiledposition);
        if (log.isDetailed()) {
            logDetailed(BaseMessages.getString(PKG, "Xslt.Log.XslfileNameFromFied", data.xslfilename,
                    meta.getXSLFileField()));
        }
    }

    try {

        if (log.isDetailed()) {
            if (meta.isXSLFieldIsAFile()) {
                logDetailed(BaseMessages.getString(PKG, "Xslt.Log.Filexsl") + data.xslfilename);
            } else {
                logDetailed(BaseMessages.getString(PKG, "Xslt.Log.XslStream", data.xslfilename));
            }
        }

        // Get the template from the cache
        Transformer transformer = data.getTemplate(data.xslfilename, data.xslIsAfile);

        // Do we need to set output properties?
        if (data.setOutputProperties) {
            transformer.setOutputProperties(data.outputProperties);
        }

        // Do we need to pass parameters?
        if (data.useParameters) {
            for (int i = 0; i < data.nrParams; i++) {
                transformer.setParameter(data.nameOfParams[i], row[data.indexOfParams[i]]);
            }
        }

        Source source = new StreamSource(new StringReader(xmlValue));
        // Prepare output stream
        StreamResult result = new StreamResult(new StringWriter());
        // transform xml source
        transformer.transform(source, result);

        String xmlString = result.getWriter().toString();
        if (log.isDetailed()) {
            logDetailed(BaseMessages.getString(PKG, "Xslt.Log.FileResult"));
            logDetailed(xmlString);
        }
        Object[] outputRowData = RowDataUtil.addValueData(row, getInputRowMeta().size(), xmlString);

        if (log.isRowLevel()) {
            logRowlevel(
                    BaseMessages.getString(PKG, "Xslt.Log.ReadRow") + " " + getInputRowMeta().getString(row));
        }

        // add new values to the row.
        putRow(data.outputRowMeta, outputRowData); // copy row to output rowset(s);

    } catch (Exception e) {
        String errorMessage = e.getMessage();
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        DefaultErrorHandler.printLocation(pw, e);
        pw.close();
        errorMessage = sw.toString() + "\n" + errorMessage;

        if (getStepMeta().isDoingErrorHandling()) {
            // Simply add this row to the error row
            putError(getInputRowMeta(), row, 1, errorMessage, meta.getResultfieldname(), "XSLT01");
        } else {
            logError(BaseMessages.getString(PKG, "Xslt.ErrorProcesing" + " : " + errorMessage));
            throw new KettleStepException(BaseMessages.getString(PKG, "Xslt.ErrorProcesing"), e);
        }
    }

    return true;
}

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

public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    meta = (ZipFileMeta) smi;/*from w  w  w . j  a  v a2  s .co 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;
}

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

private void processFile(String folder) throws Exception {

    switch (meta.getOperationType()) {
    case ZipFileMeta.OPERATION_TYPE_MOVE:
        FileObject file = null;//from   w  w  w .jav  a  2s . c o  m
        FileObject moveToFolder = null;
        try {
            // Move to folder
            moveToFolder = KettleVFS.getFileObject(folder);

            if (moveToFolder.exists()) {
                if (moveToFolder.getType() != FileType.FOLDER) {
                    throw new KettleException(BaseMessages.getString(PKG, "ZipFile.Error.NotAFolder", folder));
                }
            } else {
                moveToFolder.createFolder();
            }

            // get target filename
            String targetfilename = KettleVFS.getFilename(moveToFolder) + Const.FILE_SEPARATOR
                    + data.sourceFile.getName().getBaseName();
            file = KettleVFS.getFileObject(targetfilename);

            // Move file
            data.sourceFile.moveTo(file);

        } finally {
            if (file != null) {
                try {
                    file.close();
                } catch (Exception e) { /* Ignore */
                }
            }
            if (moveToFolder != null) {
                try {
                    moveToFolder.close();
                } catch (Exception e) { /* Ignore */
                }
            }
        }
        break;
    case ZipFileMeta.OPERATION_TYPE_DELETE:
        data.sourceFile.delete();
        break;
    default:
        break;
    }
}

From source file:org.pentaho.di.ui.i18n.editor.Translator2.java

public void loadConfiguration(String configFile, String sourceFolder) throws Exception {
    // What are the locale to handle?
    ////from w  ww.  jav a 2  s. co  m
    localeList = new ArrayList<String>();
    rootDirectories = new ArrayList<String>();
    filesToAvoid = new ArrayList<String>();
    xmlFolders = new ArrayList<SourceCrawlerXMLFolder>();

    FileObject file = KettleVFS.getFileObject(configFile);
    if (file.exists()) {

        try {
            Document doc = XMLHandler.loadXMLFile(file);
            Node configNode = XMLHandler.getSubNode(doc, "translator-config");

            referenceLocale = XMLHandler.getTagValue(configNode, "reference-locale");

            singleMessagesFile = XMLHandler.getTagValue(configNode, "single-messages-file");

            Node localeListNode = XMLHandler.getSubNode(configNode, "locale-list");
            int nrLocale = XMLHandler.countNodes(localeListNode, "locale");
            if (nrLocale > 0) {
                localeList.clear();
            }
            for (int i = 0; i < nrLocale; i++) {
                Node localeNode = XMLHandler.getSubNodeByNr(localeListNode, "locale", i);
                String locale = XMLHandler.getTagValue(localeNode, "code");
                localeList.add(locale);
            }

            Node phrasesNode = XMLHandler.getSubNode(configNode, "scan-phrases");
            int nrPhrases = XMLHandler.countNodes(phrasesNode, "scan-phrase");
            scanPhrases = new String[nrPhrases];
            for (int i = 0; i < nrPhrases; i++) {
                Node phraseNode = XMLHandler.getSubNodeByNr(phrasesNode, "scan-phrase", i);
                scanPhrases[i] = XMLHandler.getNodeValue(phraseNode);
            }

            Node rootsNode = XMLHandler.getSubNode(configNode, "source-directories");
            int nrRoots = XMLHandler.countNodes(rootsNode, "root");
            if (nrRoots > 0) {
                rootDirectories.clear();
            }
            for (int i = 0; i < nrRoots; i++) {
                Node rootNode = XMLHandler.getSubNodeByNr(rootsNode, "root", i);
                String directory = XMLHandler.getNodeValue(rootNode);
                directory = sourceFolder + File.separator + directory;
                rootDirectories.add(directory);
            }

            Node filesNode = XMLHandler.getSubNode(configNode, "files-to-avoid");
            int nrFiles = XMLHandler.countNodes(filesNode, "filename");
            if (nrFiles > 0) {
                filesToAvoid.clear();
            }
            for (int i = 0; i < nrFiles; i++) {
                Node fileNode = XMLHandler.getSubNodeByNr(filesNode, "filename", i);
                String filename = XMLHandler.getNodeValue(fileNode);
                filesToAvoid.add(filename);
            }

            Node foldersToScanNode = XMLHandler.getSubNode(configNode, "xml-folders-to-scan");
            int nrFolders = XMLHandler.countNodes(foldersToScanNode, "xml-folder-to-scan");
            if (nrFolders > 0) {
                xmlFolders.clear();
            }
            for (int i = 0; i < nrFolders; i++) {
                Node folderToScanNode = XMLHandler.getSubNodeByNr(foldersToScanNode, "xml-folder-to-scan", i);
                String folderName = sourceFolder + File.separator
                        + XMLHandler.getTagValue(folderToScanNode, "folder");
                String wildcard = XMLHandler.getTagValue(folderToScanNode, "wildcard");
                String keyPrefix = XMLHandler.getTagValue(folderToScanNode, "key-prefix");
                SourceCrawlerXMLFolder xmlFolder = new SourceCrawlerXMLFolder(folderName, wildcard, keyPrefix);

                Node elementsNode = XMLHandler.getSubNode(folderToScanNode, "elements-to-scan");
                int nrElements = XMLHandler.countNodes(elementsNode, "element-to-scan");
                for (int j = 0; j < nrElements; j++) {
                    Node elementNode = XMLHandler.getSubNodeByNr(elementsNode, "element-to-scan", j);
                    String element = XMLHandler.getTagValue(elementNode, "element");
                    String tag = XMLHandler.getTagValue(elementNode, "tag");
                    String attribute = XMLHandler.getTagValue(elementNode, "attribute");
                    xmlFolder.getElements().add(new SourceCrawlerXMLElement(element, tag, attribute));
                }

                String defaultPackage = XMLHandler.getTagValue(folderToScanNode, "package-default");
                xmlFolder.setDefaultPackage(defaultPackage);
                String defaultSourceFolder = XMLHandler.getTagValue(folderToScanNode, "package-source-folder");
                xmlFolder.setDefaultSourceFolder(sourceFolder + File.separator + defaultSourceFolder);

                Node packageExceptionsNode = XMLHandler.getSubNode(folderToScanNode, "package-exceptions");
                int nrExceptions = XMLHandler.countNodes(packageExceptionsNode, "package-exception");
                for (int j = 0; j < nrExceptions; j++) {
                    Node packageExceptionNode = XMLHandler.getSubNodeByNr(packageExceptionsNode,
                            "package-exception", j);
                    String startsWith = XMLHandler.getTagValue(packageExceptionNode, "starts-with");
                    String packageName = XMLHandler.getTagValue(packageExceptionNode, "package");
                    xmlFolder.getPackageExceptions()
                            .add(new SourceCrawlerPackageException(startsWith, packageName));
                }

                xmlFolders.add(xmlFolder);
            }

            System.out.println(BaseMessages.getString(PKG, "i18n.Log.XMLFoldersToScan", xmlFolders.size()));
            for (SourceCrawlerXMLFolder xmlFolder : xmlFolders) {
                System.out.println(BaseMessages.getString(PKG, "i18n.Log.Folder", xmlFolder.getFolder(),
                        xmlFolder.getWildcard(), xmlFolder.getElements().size()));
            }
        } catch (Exception e) {
            log.logError("Translator", "Error reading translator.xml", e);
        }
    }
}