/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.oodt.filemgrcheck;
import org.eclipse.swt.widgets.Shell;
import org.pentaho.di.core.CheckResult;
import org.pentaho.di.core.CheckResultInterface;
import org.pentaho.di.core.annotations.Step;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleStepException;
import org.pentaho.di.core.exception.KettleValueException;
import org.pentaho.di.core.exception.KettleXMLException;
import org.pentaho.di.core.row.RowMetaInterface;
import org.pentaho.di.core.row.ValueMeta;
import org.pentaho.di.core.row.ValueMetaInterface;
import org.pentaho.di.core.variables.VariableSpace;
import org.pentaho.di.core.xml.XMLHandler;
import org.pentaho.di.i18n.BaseMessages;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.Repository;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.*;
import org.pentaho.metastore.api.IMetaStore;
import org.w3c.dom.Node;
import java.util.List;
/**
* This class is part of the demo step plug-in implementation.
* It demonstrates the basics of developing a plug-in step for PDI.
*
* The demo step adds a new string field to the row stream and sets its
* value to "Hello World!". The user may select the name of the new field.
*
* This class is the implementation of StepMetaInterface.
* Classes implementing this interface need to:
*
* - keep track of the step settings
* - serialize step settings both to xml and a repository
* - provide new instances of objects implementing StepDialogInterface, StepInterface and StepDataInterface
* - report on how the step modifies the meta-data of the row-stream (row structure and field types)
* - perform a sanity-check on the settings provided by the user
*
*/
@Step(
id = "FilemgrCheck",
image = "bi/meteorite/filemgrcheck/resources/check/oodt.jpg",
i18nPackageName="bi.meteorite.filemgrcheck",
name="FilemgrCheckStep.Name",
description = "FilemgrCheckStep.TooltipDesc",
categoryDescription="i18n:org.pentaho.di.trans.step:BaseStep.Category.BigData"
)
public class FilemgrCheckStepMeta extends BaseStepMeta implements StepMetaInterface {
/**
* The PKG member is used when looking up internationalized strings.
* The properties file with localized keys is expected to reside in
* {the package of the class specified}/messages/messages_{locale}.properties
*/
private static Class<?> PKG = FilemgrCheckStepMeta.class; // for i18n purposes
/**
* Stores the name of the field added to the row-stream.
*/
private String outputField;
private String filenameField;
private String serverURLField;
private String resultField;
/**
* Constructor should call super() to make sure the base class has a chance to initialize properly.
*/
public FilemgrCheckStepMeta() {
super();
}
/**
* Called by Spoon to get a new instance of the SWT dialog for the step.
* A standard implementation passing the arguments to the constructor of the step dialog is recommended.
*
* @param shell an SWT Shell
* @param meta description of the step
* @param transMeta description of the the transformation
* @param name the name of the step
* @return new instance of a dialog for this step
*/
public StepDialogInterface getDialog(Shell shell, StepMetaInterface meta, TransMeta transMeta, String name) {
return new FilemgrCheckStepDialog(shell, meta, transMeta, name);
}
/**
* Called by PDI to get a new instance of the step implementation.
* A standard implementation passing the arguments to the constructor of the step class is recommended.
*
* @param stepMeta description of the step
* @param stepDataInterface instance of a step data class
* @param cnr copy number
* @param transMeta description of the transformation
* @param disp runtime implementation of the transformation
* @return the new instance of a step implementation
*/
public StepInterface getStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta transMeta, Trans disp) {
return new FilemgrCheckStep(stepMeta, stepDataInterface, cnr, transMeta, disp);
}
/**
* Called by PDI to get a new instance of the step data class.
*/
public StepDataInterface getStepData() {
return new FilemgrCheckStepData();
}
/**
* This method is called every time a new step is created and should allocate/set the step configuration
* to sensible defaults. The values set here will be used by Spoon when a new step is created.
*/
public void setDefault() {
outputField = "demo_field";
filenameField = "fieldname";
serverURLField = "http://localhost:9000";
resultField = "result";
}
/**
* Getter for the name of the field added by this step
* @return the name of the field added
*/
public String getOutputField() {
return outputField;
}
/**
* Setter for the name of the field added by this step
* @param outputField the name of the field added
*/
public void setOutputField(String outputField) {
this.outputField = outputField;
}
public String getFilenameField(){
return filenameField;
}
public void setFilenameField(String filenameField){
this.filenameField = filenameField;
}
/**
* This method is used when a step is duplicated in Spoon. It needs to return a deep copy of this
* step meta object. Be sure to create proper deep copies if the step configuration is stored in
* modifiable objects.
*
* See org.pentaho.di.trans.steps.rowgenerator.RowGeneratorMeta.clone() for an example on creating
* a deep copy.
*
* @return a deep copy of this
*/
public Object clone() {
Object retval = super.clone();
return retval;
}
/**
* This method is called by Spoon when a step needs to serialize its configuration to XML. The expected
* return value is an XML fragment consisting of one or more XML tags.
*
* Please use org.pentaho.di.core.xml.XMLHandler to conveniently generate the XML.
*
* @return a string containing the XML serialization of this step
*/
public String getXML() throws KettleValueException {
// only one field to serialize
String xml = " ";
xml += " " +XMLHandler.addTagValue("outputfield", outputField);
xml += " " +XMLHandler.addTagValue("filenamefield", filenameField);
xml += " " +XMLHandler.addTagValue("serverurlfield", serverURLField);
xml += " " +XMLHandler.addTagValue("resultfield", resultField);
return xml;
}
/**
* This method is called by PDI when a step needs to load its configuration from XML.
*
* Please use org.pentaho.di.core.xml.XMLHandler to conveniently read from the
* XML node passed in.
*
* @param stepnode the XML node containing the configuration
* @param databases the databases available in the transformation
* @param metaStore the metaStore to optionally read from
*/
public void loadXML(Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore) throws KettleXMLException {
try {
setOutputField(XMLHandler.getNodeValue(XMLHandler.getSubNode(stepnode, "outputfield")));
setFilenameField(XMLHandler.getNodeValue(XMLHandler.getSubNode(stepnode, "filenamefield")));
setServerURLField(XMLHandler.getNodeValue(XMLHandler.getSubNode(stepnode, "serverurlfield")));
setResultField(XMLHandler.getNodeValue(XMLHandler.getSubNode(stepnode, "resultfield")));
} catch (Exception e) {
throw new KettleXMLException("Demo plugin unable to read step info from XML node", e);
}
}
/**
* This method is called by Spoon when a step needs to serialize its configuration to a repository.
* The repository implementation provides the necessary methods to save the step attributes.
*
* @param rep the repository to save to
* @param metaStore the metaStore to optionally write to
* @param id_transformation the id to use for the transformation when saving
* @param id_step the id to use for the step when saving
*/
public void saveRep(Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step) throws KettleException
{
try{
rep.saveStepAttribute(id_transformation, id_step, "outputfield", outputField); //$NON-NLS-1$
}
catch(Exception e){
throw new KettleException("Unable to save step into repository: "+id_step, e);
}
}
/**
* This method is called by PDI when a step needs to read its configuration from a repository.
* The repository implementation provides the necessary methods to read the step attributes.
*
* @param rep the repository to read from
* @param metaStore the metaStore to optionally read from
* @param id_step the id of the step being read
* @param databases the databases available in the transformation
* @param counters the counters available in the transformation
*/
public void readRep(Repository rep, IMetaStore metaStore, ObjectId id_step, List<DatabaseMeta> databases) throws KettleException {
try{
outputField = rep.getStepAttributeString(id_step, "outputfield"); //$NON-NLS-1$
}
catch(Exception e){
throw new KettleException("Unable to load step from repository", e);
}
}
/**
* This method is called to determine the changes the step is making to the row-stream.
* To that end a RowMetaInterface object is passed in, containing the row-stream structure as it is when entering
* the step. This method must apply any changes the step makes to the row stream. Usually a step adds fields to the
* row-stream.
*
* @param inputRowMeta the row structure coming in to the step
* @param name the name of the step making the changes
* @param info row structures of any info steps coming in
* @param nextStep the description of a step this step is passing rows to
* @param space the variable space for resolving variables
* @param repository the repository instance optionally read from
* @param metaStore the metaStore to optionally read from
*/
public void getFields(RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore) throws KettleStepException{
/*
* This implementation appends the outputField to the row-stream
*/
// a value meta object contains the meta data for a field
ValueMetaInterface v = new ValueMeta(outputField, ValueMeta.TYPE_STRING);
// setting trim type to "both"
v.setTrimType(ValueMeta.TRIM_TYPE_BOTH);
// the name of the step that adds this field
v.setOrigin(name);
// modify the row structure and add the field this step generates
inputRowMeta.addValueMeta(v);
}
/**
* This method is called when the user selects the "Verify Transformation" option in Spoon.
* A list of remarks is passed in that this method should add to. Each remark is a comment, warning, error, or ok.
* The method should perform as many checks as necessary to catch design-time errors.
*
* Typical checks include:
* - verify that all mandatory configuration is given
* - verify that the step receives any input, unless it's a row generating step
* - verify that the step does not receive any input if it does not take them into account
* - verify that the step finds fields it relies on in the row-stream
*
* @param remarks the list of remarks to append to
* @param transmeta the description of the transformation
* @param stepMeta the description of the step
* @param prev the structure of the incoming row-stream
* @param input names of steps sending input to the step
* @param output names of steps this step is sending output to
* @param info fields coming in from info steps
* @param metaStore metaStore to optionally read from
*/
public void check(List<CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev, String input[], String output[], RowMetaInterface info, VariableSpace space, Repository repository, IMetaStore metaStore) {
CheckResult cr;
// See if there are input streams leading to this step!
if (input.length > 0) {
cr = new CheckResult(CheckResult.TYPE_RESULT_OK, BaseMessages.getString(PKG, "Demo.CheckResult.ReceivingRows.OK"), stepMeta);
remarks.add(cr);
} else {
cr = new CheckResult(CheckResult.TYPE_RESULT_ERROR, BaseMessages.getString(PKG, "Demo.CheckResult.ReceivingRows.ERROR"), stepMeta);
remarks.add(cr);
}
}
public void setServerURLField(String serverURLField) {
this.serverURLField = serverURLField;
}
public String getServerURLField() {
return serverURLField;
}
public void setResultField(String resultField) {
this.resultField = resultField;
}
public String getResultField() {
return resultField;
}
}