@Override
public void eventAdded(KettleLoggingEvent event) {
try {
Object messageObject = event.getMessage();
if (messageObject instanceof LogMessage) {
boolean logToFile = false;
if (logChannelId == null) {
logToFile = true;
} else {
LogMessage message = (LogMessage) messageObject;
// This should be fast enough cause cached.
List<String> logChannelChildren =
LoggingRegistry.getInstance().getLogChannelChildren(logChannelId);
// This could be non-optimal, consider keeping the list sorted in the logging registry
logToFile = Const.indexOfString(message.getLogChannelId(), logChannelChildren) >= 0;
}
if (logToFile) {
String logText = layout.format(event);
outputStream.write(logText.getBytes());
outputStream.write(Const.CR.getBytes());
}
}
} catch (Exception e) {
exception =
new KettleException("Unable to write to logging event to file '" + filename + "'", e);
}
}
private void getParameters(TransMeta inputTransMeta) {
try {
if (inputTransMeta == null) {
JobEntryTrans jet = new JobEntryTrans();
getInfo(jet);
inputTransMeta = jet.getTransMeta(rep, metaStore, jobMeta);
}
String[] parameters = inputTransMeta.listParameters();
String[] existing = wParameters.getItems(1);
for (int i = 0; i < parameters.length; i++) {
if (Const.indexOfString(parameters[i], existing) < 0) {
TableItem item = new TableItem(wParameters.table, SWT.NONE);
item.setText(1, parameters[i]);
}
}
wParameters.removeEmptyRows();
wParameters.setRowNums();
wParameters.optWidth(true);
} catch (Exception e) {
new ErrorDialog(
shell,
BaseMessages.getString(
PKG, "JobEntryTransDialog.Exception.UnableToLoadTransformation.Title"),
BaseMessages.getString(
PKG, "JobEntryTransDialog.Exception.UnableToLoadTransformation.Message"),
e);
}
}
public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
meta = (DatabaseLookupMeta) smi;
data = (DatabaseLookupData) sdi;
if (super.init(smi, sdi)) {
if (meta.getDatabaseMeta() == null) {
logError(
BaseMessages.getString(PKG, "DatabaseLookup.Init.ConnectionMissing", getStepname()));
return false;
}
data.db = new Database(this, meta.getDatabaseMeta());
data.db.shareVariablesWith(this);
try {
if (getTransMeta().isUsingUniqueConnections()) {
synchronized (getTrans()) {
data.db.connect(getTrans().getTransactionId(), getPartitionID());
}
} else {
data.db.connect(getPartitionID());
}
data.db.setCommit(100); // we never get a commit, but it just turns off auto-commit.
if (log.isDetailed()) {
logDetailed(BaseMessages.getString(PKG, "DatabaseLookup.Log.ConnectedToDatabase"));
}
// See if all the lookup conditions are "equal"
// This might speed up things in the case when we load all data in the cache
//
data.allEquals = true;
data.hasDBCondition = false;
data.conditions = new int[meta.getKeyCondition().length];
for (int i = 0; i < meta.getKeyCondition().length; i++) {
data.conditions[i] =
Const.indexOfString(meta.getKeyCondition()[i], DatabaseLookupMeta.conditionStrings);
if (!("=".equals(meta.getKeyCondition()[i]))) {
data.allEquals = false;
}
if (data.conditions[i] == DatabaseLookupMeta.CONDITION_LIKE) {
data.hasDBCondition = true;
}
}
return true;
} catch (Exception e) {
logError(
BaseMessages.getString(PKG, "DatabaseLookup.ERROR0004.UnexpectedErrorDuringInit")
+ e.toString());
if (data.db != null) {
data.db.disconnect();
}
}
}
return false;
}
// Liste des encodages
private void loadEncodings() {
wEncoding.removeAll();
List<Charset> values = new ArrayList<Charset>(Charset.availableCharsets().values());
for (int i = 0; i < values.size(); i++) {
Charset charSet = (Charset) values.get(i);
wEncoding.add(charSet.displayName());
}
// Celui par défaut en environnement
String defEncoding = Const.getEnvironmentVariable("file.encoding", "UTF-8");
int idx = Const.indexOfString(defEncoding, wEncoding.getItems());
if (idx >= 0) wEncoding.select(idx);
}
private void setEncodings() {
// Encoding of the text file:
if (!gotEncodings) {
gotEncodings = true;
wEncoding.removeAll();
List<Charset> values = new ArrayList<Charset>(Charset.availableCharsets().values());
for (int i = 0; i < values.size(); i++) {
Charset charSet = values.get(i);
wEncoding.add(charSet.displayName());
}
// Now select the default!
String defEncoding = Const.getEnvironmentVariable("file.encoding", "UTF-8");
int idx = Const.indexOfString(defEncoding, wEncoding.getItems());
if (idx >= 0) {
wEncoding.select(idx);
}
}
}
/**
* Verifies on the specified database connection if an index exists on the fields with the
* specified name.
*
* @param database a connected database
* @param schemaName
* @param tableName
* @param idxFields
* @return true if the index exists, false if it doesn't.
* @throws KettleDatabaseException
*/
@Override
public boolean checkIndexExists(
Database database, String schemaName, String tableName, String[] idx_fields)
throws KettleDatabaseException {
String tablename =
database.getDatabaseMeta().getQuotedSchemaTableCombination(schemaName, tableName);
boolean[] exists = new boolean[idx_fields.length];
for (int i = 0; i < exists.length; i++) {
exists[i] = false;
}
try {
//
// Get the info from the data dictionary...
//
StringBuffer sql = new StringBuffer(128);
sql.append("select i.name table_name, c.name column_name ");
sql.append("from sysindexes i, sysindexkeys k, syscolumns c ");
sql.append("where i.name = '" + tablename + "' ");
sql.append("AND i.id = k.id ");
sql.append("AND i.id = c.id ");
sql.append("AND k.colid = c.colid ");
ResultSet res = null;
try {
res = database.openQuery(sql.toString());
if (res != null) {
Object[] row = database.getRow(res);
while (row != null) {
String column = database.getReturnRowMeta().getString(row, "column_name", "");
int idx = Const.indexOfString(column, idx_fields);
if (idx >= 0) {
exists[idx] = true;
}
row = database.getRow(res);
}
} else {
return false;
}
} finally {
if (res != null) {
database.closeQuery(res);
}
}
// See if all the fields are indexed...
boolean all = true;
for (int i = 0; i < exists.length && all; i++) {
if (!exists[i]) {
all = false;
}
}
return all;
} catch (Exception e) {
throw new KettleDatabaseException(
"Unable to determine if indexes exists on table [" + tablename + "]", e);
}
}
public void getFields(
RowMetaInterface row,
String origin,
RowMetaInterface info[],
StepMeta nextStep,
VariableSpace space)
throws KettleStepException {
// First load some interesting data...
// Then see which fields get added to the row.
//
TransMeta mappingTransMeta = null;
try {
mappingTransMeta = loadMappingMeta(this, repository, space);
} catch (KettleException e) {
throw new KettleStepException(
BaseMessages.getString(PKG, "MappingMeta.Exception.UnableToLoadMappingTransformation"),
e);
}
// The field structure may depend on the input parameters as well (think of parameter
// replacements in MDX queries for instance)
if (mappingParameters != null) {
// See if we need to pass all variables from the parent or not...
//
if (mappingParameters.isInheritingAllVariables()) {
mappingTransMeta.copyVariablesFrom(space);
}
// Just set the variables in the transformation statically.
// This just means: set a number of variables or parameter values:
//
List<String> subParams = Arrays.asList(mappingTransMeta.listParameters());
for (int i = 0; i < mappingParameters.getVariable().length; i++) {
String name = mappingParameters.getVariable()[i];
String value = space.environmentSubstitute(mappingParameters.getInputField()[i]);
if (!Const.isEmpty(name) && !Const.isEmpty(value)) {
if (subParams.contains(name)) {
try {
mappingTransMeta.setParameterValue(name, value);
} catch (UnknownParamException e) {
// this is explicitly checked for up front
}
}
mappingTransMeta.setVariable(name, value);
}
}
}
// Keep track of all the fields that need renaming...
//
List<MappingValueRename> inputRenameList = new ArrayList<MappingValueRename>();
/*
* Before we ask the mapping outputs anything, we should teach the mapping
* input steps in the sub-transformation about the data coming in...
*/
for (MappingIODefinition definition : inputMappings) {
RowMetaInterface inputRowMeta;
if (definition.isMainDataPath() || Const.isEmpty(definition.getInputStepname())) {
// The row metadata, what we pass to the mapping input step
// definition.getOutputStep(), is "row"
// However, we do need to re-map some fields...
//
inputRowMeta = row.clone();
if (!inputRowMeta.isEmpty()) {
for (MappingValueRename valueRename : definition.getValueRenames()) {
ValueMetaInterface valueMeta =
inputRowMeta.searchValueMeta(valueRename.getSourceValueName());
if (valueMeta == null) {
throw new KettleStepException(
BaseMessages.getString(
PKG,
"MappingMeta.Exception.UnableToFindField",
valueRename.getSourceValueName()));
}
valueMeta.setName(valueRename.getTargetValueName());
}
}
} else {
// The row metadata that goes to the info mapping input comes from the
// specified step
// In fact, it's one of the info steps that is going to contain this
// information...
//
String[] infoSteps = getInfoSteps();
int infoStepIndex = Const.indexOfString(definition.getInputStepname(), infoSteps);
if (infoStepIndex < 0) {
throw new KettleStepException(
BaseMessages.getString(
PKG,
"MappingMeta.Exception.UnableToFindMetadataInfo",
definition.getInputStepname()));
}
if (info[infoStepIndex] != null) {
inputRowMeta = info[infoStepIndex].clone();
} else {
inputRowMeta = null;
}
}
// What is this mapping input step?
//
StepMeta mappingInputStep =
mappingTransMeta.findMappingInputStep(definition.getOutputStepname());
// We're certain it's a MappingInput step...
//
MappingInputMeta mappingInputMeta =
(MappingInputMeta) mappingInputStep.getStepMetaInterface();
// Inform the mapping input step about what it's going to receive...
//
mappingInputMeta.setInputRowMeta(inputRowMeta);
// What values are we changing names for?
//
mappingInputMeta.setValueRenames(definition.getValueRenames());
// Keep a list of the input rename values that need to be changed back at
// the output
//
if (definition.isRenamingOnOutput())
Mapping.addInputRenames(inputRenameList, definition.getValueRenames());
}
// All the mapping steps now know what they will be receiving.
// That also means that the sub-transformation / mapping has everything it
// needs.
// So that means that the MappingOutput steps know exactly what the output
// is going to be.
// That could basically be anything.
// It also could have absolutely no resemblance to what came in on the
// input.
// The relative old approach is therefore no longer suited.
//
// OK, but what we *can* do is have the MappingOutput step rename the
// appropriate fields.
// The mapping step will tell this step how it's done.
//
// Let's look for the mapping output step that is relevant for this actual
// call...
//
MappingIODefinition mappingOutputDefinition = null;
if (nextStep == null) {
// This is the main step we read from...
// Look up the main step to write to.
// This is the output mapping definition with "main path" enabled.
//
for (MappingIODefinition definition : outputMappings) {
if (definition.isMainDataPath() || Const.isEmpty(definition.getOutputStepname())) {
// This is the definition to use...
//
mappingOutputDefinition = definition;
}
}
} else {
// Is there an output mapping definition for this step?
// If so, we can look up the Mapping output step to see what has changed.
//
for (MappingIODefinition definition : outputMappings) {
if (nextStep.getName().equals(definition.getOutputStepname())
|| definition.isMainDataPath()
|| Const.isEmpty(definition.getOutputStepname())) {
mappingOutputDefinition = definition;
}
}
}
if (mappingOutputDefinition == null) {
throw new KettleStepException(
BaseMessages.getString(PKG, "MappingMeta.Exception.UnableToFindMappingDefinition"));
}
// OK, now find the mapping output step in the mapping...
// This method in TransMeta takes into account a number of things, such as
// the step not specified, etc.
// The method never returns null but throws an exception.
//
StepMeta mappingOutputStep =
mappingTransMeta.findMappingOutputStep(mappingOutputDefinition.getInputStepname());
// We know it's a mapping output step...
MappingOutputMeta mappingOutputMeta =
(MappingOutputMeta) mappingOutputStep.getStepMetaInterface();
// Change a few columns.
mappingOutputMeta.setOutputValueRenames(mappingOutputDefinition.getValueRenames());
// Perhaps we need to change a few input columns back to the original?
//
mappingOutputMeta.setInputValueRenames(inputRenameList);
// Now we know wat's going to come out of there...
// This is going to be the full row, including all the remapping, etc.
//
RowMetaInterface mappingOutputRowMeta = mappingTransMeta.getStepFields(mappingOutputStep);
row.clear();
row.addRowMeta(mappingOutputRowMeta);
}
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
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);
data.schemaTable =
meta.getDatabaseMeta()
.getQuotedSchemaTableCombination(data.realSchemaName, data.realTableName);
determineTechKeyCreation();
// The indexes of the key values...
//
data.keynrs = new int[meta.getKeyField().length];
for (int i = 0; i < meta.getKeyField().length; i++) {
data.keynrs[i] = getInputRowMeta().indexOfValue(meta.getKeyField()[i]);
if (data.keynrs[i] < 0) // couldn't find field!
{
throw new KettleStepException(
BaseMessages.getString(
PKG,
"CombinationLookup.Exception.FieldNotFound",
meta.getKeyField()[i])); // $NON-NLS-1$ //$NON-NLS-2$
}
}
// Determine for each input field if we want it removed or not.
//
data.removeField = new boolean[getInputRowMeta().size()];
// Sort lookup values keys so that we
//
for (int i = 0; i < getInputRowMeta().size(); i++) {
ValueMetaInterface valueMeta = getInputRowMeta().getValueMeta(i);
// Is this one of the keys?
int idx = Const.indexOfString(valueMeta.getName(), meta.getKeyField());
data.removeField[i] = idx >= 0;
}
// Determine the metadata row to calculate hashcodes.
//
data.hashRowMeta = new RowMeta();
for (int i = 0; i < meta.getKeyField().length; i++) {
data.hashRowMeta.addValueMeta(getInputRowMeta().getValueMeta(data.keynrs[i])); // KEYi = ?
}
setCombiLookup(getInputRowMeta());
}
try {
Object[] outputRow =
lookupValues(getInputRowMeta(), r); // add new values to the row in rowset[0].
putRow(data.outputRowMeta, outputRow); // copy row to output rowset(s);
if (checkFeedback(getLinesRead())) {
if (log.isBasic())
logBasic(
BaseMessages.getString(PKG, "CombinationLookup.Log.LineNumber")
+ getLinesRead()); //$NON-NLS-1$
}
} catch (KettleException e) {
if (getStepMeta().isDoingErrorHandling()) {
putError(getInputRowMeta(), r, 1L, Const.getStackTracker(e), null, "CBL001");
} else {
logError(
BaseMessages.getString(PKG, "CombinationLookup.Log.ErrorInStepRunning")
+ e.getMessage()); // $NON-NLS-1$
setErrors(1);
stopAll();
setOutputDone(); // signal end to receiver(s)
return false;
}
}
return true;
}
@Override
public String encode(AbstractMeta meta) throws Exception {
TransMeta transMeta = (TransMeta) meta;
mxGraph graph = new mxGraph();
graph.getModel().beginUpdate();
mxCell parent = (mxCell) graph.getDefaultParent();
Document doc = mxUtils.createDocument();
try {
Element e = super.encodeCommRootAttr(transMeta, doc);
e.setAttribute("trans_version", transMeta.getTransversion());
e.setAttribute("trans_type", transMeta.getTransformationType().getCode());
e.setAttribute("trans_status", String.valueOf(transMeta.getTransstatus()));
// variables
Properties sp = new Properties();
JSONArray jsonArray = new JSONArray();
String[] keys = Variables.getADefaultVariableSpace().listVariables();
for (int i = 0; i < keys.length; i++) {
sp.put(keys[i], Variables.getADefaultVariableSpace().getVariable(keys[i]));
}
List<String> vars = transMeta.getUsedVariables();
for (int i = 0; i < vars.size(); i++) {
String varname = vars.get(i);
if (!varname.startsWith(Const.INTERNAL_VARIABLE_PREFIX)
&& Const.indexOfString(varname, transMeta.listParameters()) < 0) {
JSONObject param = new JSONObject();
param.put("var_name", varname);
param.put("var_value", sp.getProperty(varname, ""));
jsonArray.add(param);
}
}
for (String varname : Const.INTERNAL_JOB_VARIABLES) {
String value = transMeta.getVariable(varname);
if (!Const.isEmpty(value)) {
JSONObject param = new JSONObject();
param.put("var_name", varname);
param.put("var_value", value);
jsonArray.add(param);
}
}
e.setAttribute("variables", jsonArray.toString());
TransLogTable transLogTable = transMeta.getTransLogTable();
JSONObject jsonObject = new JSONObject();
jsonObject.put("connection", transLogTable.getConnectionName());
jsonObject.put("schema", transLogTable.getSchemaName());
jsonObject.put("table", transLogTable.getTableName());
jsonObject.put("size_limit_lines", transLogTable.getLogSizeLimit());
jsonObject.put("interval", transLogTable.getLogInterval());
jsonObject.put("timeout_days", transLogTable.getTimeoutInDays());
JSONArray fields = new JSONArray();
for (LogTableField field : transLogTable.getFields()) {
JSONObject jsonField = new JSONObject();
jsonField.put("id", field.getId());
jsonField.put("enabled", field.isEnabled());
jsonField.put("name", field.getFieldName());
jsonField.put("subjectAllowed", field.isSubjectAllowed());
if (field.isSubjectAllowed()) {
jsonField.put("subject", field.getSubject() == null ? "" : field.getSubject().toString());
} else {
jsonField.put("subject", "-");
}
jsonField.put("description", StringEscapeHelper.encode(field.getDescription()));
fields.add(jsonField);
}
jsonObject.put("fields", fields);
e.setAttribute("transLogTable", jsonObject.toString());
StepLogTable stepLogTable = transMeta.getStepLogTable();
jsonObject = new JSONObject();
jsonObject.put("connection", stepLogTable.getConnectionName());
jsonObject.put("schema", stepLogTable.getSchemaName());
jsonObject.put("table", stepLogTable.getTableName());
jsonObject.put("timeout_days", stepLogTable.getTimeoutInDays());
fields = new JSONArray();
for (LogTableField field : stepLogTable.getFields()) {
JSONObject jsonField = new JSONObject();
jsonField.put("id", field.getId());
jsonField.put("enabled", field.isEnabled());
jsonField.put("name", field.getFieldName());
jsonField.put("description", StringEscapeHelper.encode(field.getDescription()));
fields.add(jsonField);
}
jsonObject.put("fields", fields);
e.setAttribute("stepLogTable", jsonObject.toString());
PerformanceLogTable performanceLogTable = transMeta.getPerformanceLogTable();
jsonObject = new JSONObject();
jsonObject.put("connection", performanceLogTable.getConnectionName());
jsonObject.put("schema", performanceLogTable.getSchemaName());
jsonObject.put("table", performanceLogTable.getTableName());
jsonObject.put("interval", performanceLogTable.getLogInterval());
jsonObject.put("timeout_days", performanceLogTable.getTimeoutInDays());
fields = new JSONArray();
for (LogTableField field : performanceLogTable.getFields()) {
JSONObject jsonField = new JSONObject();
jsonField.put("id", field.getId());
jsonField.put("enabled", field.isEnabled());
jsonField.put("name", field.getFieldName());
jsonField.put("description", StringEscapeHelper.encode(field.getDescription()));
fields.add(jsonField);
}
jsonObject.put("fields", fields);
e.setAttribute("performanceLogTable", jsonObject.toString());
MetricsLogTable metricsLogTable = transMeta.getMetricsLogTable();
jsonObject = new JSONObject();
jsonObject.put("connection", metricsLogTable.getConnectionName());
jsonObject.put("schema", metricsLogTable.getSchemaName());
jsonObject.put("table", metricsLogTable.getTableName());
jsonObject.put("timeout_days", metricsLogTable.getTimeoutInDays());
fields = new JSONArray();
for (LogTableField field : metricsLogTable.getFields()) {
JSONObject jsonField = new JSONObject();
jsonField.put("id", field.getId());
jsonField.put("enabled", field.isEnabled());
jsonField.put("name", field.getFieldName());
jsonField.put("description", StringEscapeHelper.encode(field.getDescription()));
fields.add(jsonField);
}
jsonObject.put("fields", fields);
e.setAttribute("metricsLogTable", jsonObject.toString());
jsonObject = new JSONObject();
jsonObject.put(
"connection",
transMeta.getMaxDateConnection() == null
? ""
: transMeta.getMaxDateConnection().getName());
jsonObject.put("table", transMeta.getMaxDateTable());
jsonObject.put("field", transMeta.getMaxDateField());
jsonObject.put("offset", transMeta.getMaxDateOffset());
jsonObject.put("maxdiff", transMeta.getMaxDateDifference());
e.setAttribute("maxdate", jsonObject.toString());
e.setAttribute("size_rowset", String.valueOf(transMeta.getSizeRowset()));
e.setAttribute("sleep_time_empty", String.valueOf(transMeta.getSleepTimeEmpty()));
e.setAttribute("sleep_time_full", String.valueOf(transMeta.getSleepTimeFull()));
e.setAttribute("unique_connections", transMeta.isUsingUniqueConnections() ? "Y" : "N");
e.setAttribute("feedback_shown", transMeta.isFeedbackShown() ? "Y" : "N");
e.setAttribute("feedback_size", String.valueOf(transMeta.getFeedbackSize()));
e.setAttribute(
"using_thread_priorities", transMeta.isUsingThreadPriorityManagment() ? "Y" : "N");
e.setAttribute(
"capture_step_performance", transMeta.isCapturingStepPerformanceSnapShots() ? "Y" : "N");
e.setAttribute(
"step_performance_capturing_delay",
String.valueOf(transMeta.getStepPerformanceCapturingDelay()));
e.setAttribute(
"step_performance_capturing_size_limit",
transMeta.getStepPerformanceCapturingSizeLimit());
super.encodeSlaveServers(e, transMeta);
encodeClusterSchema(e, transMeta);
encodePartitionSchema(e, transMeta);
try {
if (transMeta.getKey() != null) {
e.setAttribute("key_for_session_key", XMLHandler.encodeBinaryData(transMeta.getKey()));
} else {
e.setAttribute("key_for_session_key", "");
}
} catch (Exception e1) {
e1.printStackTrace();
e.setAttribute("key_for_session_key", "");
}
e.setAttribute("is_key_private", transMeta.isPrivateKey() ? "Y" : "N");
super.encodeNote(doc, graph, transMeta);
super.encodeDatabases(e, transMeta);
parent.setValue(e);
// encode steps and hops
HashMap<StepMeta, Object> cells = new HashMap<StepMeta, Object>();
List<StepMeta> list = transMeta.getSteps();
for (int i = 0; i < list.size(); i++) {
StepMeta step = (StepMeta) list.get(i);
Point p = step.getLocation();
StepEncoder stepEncoder = (StepEncoder) PluginFactory.getBean(step.getStepID());
PluginInterface plugin =
PluginRegistry.getInstance().getPlugin(StepPluginType.class, step.getStepID());
Object cell =
graph.insertVertex(
parent,
null,
stepEncoder.encodeStep(step),
p.x,
p.y,
40,
40,
"icon;image=" + SvgImageUrl.getUrl(plugin));
cells.put(step, cell);
}
for (int i = 0; i < transMeta.nrTransHops(); i++) {
TransHopMeta transHopMeta = transMeta.getTransHop(i);
Object v1 = cells.get(transHopMeta.getFromStep());
Object v2 = cells.get(transHopMeta.getToStep());
graph.insertEdge(parent, null, TransHopMetaCodec.encode(transHopMeta), v1, v2);
}
} finally {
graph.getModel().endUpdate();
}
mxCodec codec = new mxCodec();
return mxUtils.getPrettyXml(codec.encode(graph.getModel()));
}
protected boolean importJob(Node jobnode, RepositoryImportFeedbackInterface feedback)
throws KettleException {
// Load the job from the XML node.
//
JobMeta jobMeta = createJobMetaForNode(jobnode);
feedback.setLabel(
BaseMessages.getString(
PKG,
"RepositoryImporter.ImportJob.Label",
Integer.toString(jobNumber),
jobMeta.getName()));
validateImportedElement(importRules, jobMeta);
// What's the directory path?
String directoryPath =
Const.NVL(XMLHandler.getTagValue(jobnode, "directory"), Const.FILE_SEPARATOR);
if (jobDirOverride != null) {
directoryPath = jobDirOverride;
}
if (directoryPath.startsWith("/")) {
// remove the leading root, we don't need it.
directoryPath = directoryPath.substring(1);
}
// If we have a set of source directories to limit ourselves to, consider this.
//
if (limitDirs.size() > 0 && Const.indexOfString(directoryPath, limitDirs) < 0) {
// Not in the limiting set of source directories, skip the import of this transformation...
//
feedback.addLog(
BaseMessages.getString(
PKG,
"RepositoryImporter.SkippedJobNotPartOfLimitingDirectories.Log",
jobMeta.getName()));
return true;
}
RepositoryDirectoryInterface targetDirectory =
getTargetDirectory(directoryPath, jobDirOverride, feedback);
// OK, we loaded the job from XML and all went well...
// See if the job already exists!
ObjectId existintId = rep.getJobId(jobMeta.getName(), targetDirectory);
if (existintId != null && askOverwrite) {
overwrite = feedback.jobOverwritePrompt(jobMeta);
askOverwrite = feedback.isAskingOverwriteConfirmation();
} else {
updateDisplay();
}
if (existintId == null || overwrite) {
replaceSharedObjects(jobMeta);
jobMeta.setRepositoryDirectory(targetDirectory);
jobMeta.setObjectId(existintId);
patchJobEntries(jobMeta);
try {
saveJobMeta(jobMeta);
if (jobMeta.hasRepositoryReferences()) {
referencingObjects.add(
new RepositoryObject(
jobMeta.getObjectId(),
jobMeta.getName(),
jobMeta.getRepositoryDirectory(),
null,
null,
RepositoryObjectType.JOB,
null,
false));
}
feedback.addLog(
BaseMessages.getString(
PKG,
"RepositoryImporter.JobSaved.Log",
Integer.toString(jobNumber),
jobMeta.getName()));
} catch (Exception e) {
feedback.addLog(
BaseMessages.getString(
PKG,
"RepositoryImporter.ErrorSavingJob.Log",
Integer.toString(jobNumber),
jobMeta.getName(),
Const.getStackTracker(e)));
if (!feedback.askContinueOnErrorQuestion(
BaseMessages.getString(PKG, "RepositoryImporter.DoYouWantToContinue.Title"),
BaseMessages.getString(PKG, "RepositoryImporter.DoYouWantToContinue.Message"))) {
return false;
}
}
} else {
feedback.addLog(
BaseMessages.getString(
PKG, "RepositoryImporter.SkippedExistingJob.Log", jobMeta.getName()));
}
return true;
}
/**
* @param transnode The XML DOM node to read the transformation from
* @return false if the import should be canceled.
* @throws KettleException in case there is an unexpected error
*/
protected boolean importTransformation(Node transnode, RepositoryImportFeedbackInterface feedback)
throws KettleException {
//
// Load transformation from XML into a directory, possibly created!
//
TransMeta transMeta = createTransMetaForNode(transnode); // ignore shared objects
feedback.setLabel(
BaseMessages.getString(
PKG,
"RepositoryImporter.ImportTrans.Label",
Integer.toString(transformationNumber),
transMeta.getName()));
validateImportedElement(importRules, transMeta);
// What's the directory path?
String directoryPath =
Const.NVL(XMLHandler.getTagValue(transnode, "info", "directory"), Const.FILE_SEPARATOR);
if (transDirOverride != null) {
directoryPath = transDirOverride;
}
if (directoryPath.startsWith("/")) {
// remove the leading root, we don't need it.
directoryPath = directoryPath.substring(1);
}
// If we have a set of source directories to limit ourselves to, consider this.
//
if (limitDirs.size() > 0 && Const.indexOfString(directoryPath, limitDirs) < 0) {
// Not in the limiting set of source directories, skip the import of this transformation...
//
feedback.addLog(
BaseMessages.getString(
PKG,
"RepositoryImporter.SkippedTransformationNotPartOfLimitingDirectories.Log",
transMeta.getName()));
return true;
}
RepositoryDirectoryInterface targetDirectory =
getTargetDirectory(directoryPath, transDirOverride, feedback);
// OK, we loaded the transformation from XML and all went well...
// See if the transformation already existed!
ObjectId existingId = rep.getTransformationID(transMeta.getName(), targetDirectory);
if (existingId != null && askOverwrite) {
overwrite = feedback.transOverwritePrompt(transMeta);
askOverwrite = feedback.isAskingOverwriteConfirmation();
} else {
updateDisplay();
}
if (existingId == null || overwrite) {
replaceSharedObjects(transMeta);
transMeta.setObjectId(existingId);
transMeta.setRepositoryDirectory(targetDirectory);
patchMappingSteps(transMeta);
try {
// Keep info on who & when this transformation was created...
if (transMeta.getCreatedUser() == null || transMeta.getCreatedUser().equals("-")) {
transMeta.setCreatedDate(new Date());
if (rep.getUserInfo() != null) {
transMeta.setCreatedUser(rep.getUserInfo().getLogin());
} else {
transMeta.setCreatedUser(null);
}
}
saveTransMeta(transMeta);
feedback.addLog(
BaseMessages.getString(
PKG,
"RepositoryImporter.TransSaved.Log",
Integer.toString(transformationNumber),
transMeta.getName()));
if (transMeta.hasRepositoryReferences()) {
referencingObjects.add(
new RepositoryObject(
transMeta.getObjectId(),
transMeta.getName(),
transMeta.getRepositoryDirectory(),
null,
null,
RepositoryObjectType.TRANSFORMATION,
null,
false));
}
} catch (Exception e) {
feedback.addLog(
BaseMessages.getString(
PKG,
"RepositoryImporter.ErrorSavingTrans.Log",
Integer.toString(transformationNumber),
transMeta.getName(),
Const.getStackTracker(e)));
if (!feedback.askContinueOnErrorQuestion(
BaseMessages.getString(PKG, "RepositoryImporter.DoYouWantToContinue.Title"),
BaseMessages.getString(PKG, "RepositoryImporter.DoYouWantToContinue.Message"))) {
return false;
}
}
} else {
feedback.addLog(
BaseMessages.getString(
PKG, "RepositoryImporter.SkippedExistingTransformation.Log", transMeta.getName()));
}
return true;
}
