use of org.pentaho.di.job.JobExecutionConfiguration in project pentaho-kettle by pentaho.
the class JobResource method addJob.
@PUT
@Path("/add")
@Produces({ MediaType.APPLICATION_JSON })
public JobStatus addJob(String xml) {
// Parse the XML, create a job configuration
//
// System.out.println(xml);
//
JobConfiguration jobConfiguration;
try {
jobConfiguration = JobConfiguration.fromXML(xml.toString());
JobMeta jobMeta = jobConfiguration.getJobMeta();
JobExecutionConfiguration jobExecutionConfiguration = jobConfiguration.getJobExecutionConfiguration();
jobMeta.setLogLevel(jobExecutionConfiguration.getLogLevel());
jobMeta.injectVariables(jobExecutionConfiguration.getVariables());
// If there was a repository, we know about it at this point in time.
//
final Repository repository = jobConfiguration.getJobExecutionConfiguration().getRepository();
String carteObjectId = UUID.randomUUID().toString();
SimpleLoggingObject servletLoggingObject = new SimpleLoggingObject(getClass().getName(), LoggingObjectType.CARTE, null);
servletLoggingObject.setContainerObjectId(carteObjectId);
servletLoggingObject.setLogLevel(jobExecutionConfiguration.getLogLevel());
// Create the transformation and store in the list...
//
final Job job = new Job(repository, jobMeta, servletLoggingObject);
// Setting variables
//
job.initializeVariablesFrom(null);
job.getJobMeta().setInternalKettleVariables(job);
job.injectVariables(jobConfiguration.getJobExecutionConfiguration().getVariables());
job.setArguments(jobExecutionConfiguration.getArgumentStrings());
// Also copy the parameters over...
//
job.copyParametersFrom(jobMeta);
job.clearParameters();
String[] parameterNames = job.listParameters();
for (int idx = 0; idx < parameterNames.length; idx++) {
// Grab the parameter value set in the job entry
//
String thisValue = jobExecutionConfiguration.getParams().get(parameterNames[idx]);
if (!Utils.isEmpty(thisValue)) {
// Set the value as specified by the user in the job entry
//
jobMeta.setParameterValue(parameterNames[idx], thisValue);
}
}
jobMeta.activateParameters();
job.setSocketRepository(CarteSingleton.getInstance().getSocketRepository());
CarteSingleton.getInstance().getJobMap().addJob(job.getJobname(), carteObjectId, job, jobConfiguration);
//
if (repository != null) {
job.addJobListener(new JobAdapter() {
public void jobFinished(Job job) {
repository.disconnect();
}
});
}
return getJobStatus(carteObjectId);
} catch (KettleException e) {
e.printStackTrace();
}
return null;
}
use of org.pentaho.di.job.JobExecutionConfiguration in project pentaho-kettle by pentaho.
the class JobExecutor method executeJob.
private void executeJob() throws KettleException {
//
if (data.groupBuffer.isEmpty()) {
return;
}
data.groupTimeStart = System.currentTimeMillis();
if (first) {
discardLogLines(data);
}
data.executorJob = createJob(meta.getRepository(), data.executorJobMeta, this);
data.executorJob.shareVariablesWith(data.executorJobMeta);
data.executorJob.setParentTrans(getTrans());
data.executorJob.setLogLevel(getLogLevel());
data.executorJob.setInternalKettleVariables(this);
data.executorJob.copyParametersFrom(data.executorJobMeta);
data.executorJob.setArguments(getTrans().getArguments());
// data.executorJob.setInteractive(); TODO: pass interactivity through the transformation too for drill-down.
// TODO
/*
* if (data.executorJob.isInteractive()) {
* data.executorJob.getJobEntryListeners().addAll(parentJob.getJobEntryListeners()); }
*/
// Pass the accumulated rows
//
data.executorJob.setSourceRows(data.groupBuffer);
// Pass parameter values
//
passParametersToJob();
// keep track for drill down in Spoon...
//
getTrans().getActiveSubjobs().put(getStepname(), data.executorJob);
ExtensionPointHandler.callExtensionPoint(log, KettleExtensionPoint.JobStart.id, data.executorJob);
data.executorJob.beginProcessing();
Result result = new Result();
//
for (DelegationListener delegationListener : getTrans().getDelegationListeners()) {
// TODO: copy some settings in the job execution configuration, not strictly needed
// but the execution configuration information is useful in case of a job re-start on Carte
//
delegationListener.jobDelegationStarted(data.executorJob, new JobExecutionConfiguration());
}
//
try {
result = data.executorJob.execute(0, result);
} catch (KettleException e) {
log.logError("An error occurred executing the job: ", e);
result.setResult(false);
result.setNrErrors(1);
} finally {
try {
ExtensionPointHandler.callExtensionPoint(log, KettleExtensionPoint.JobFinish.id, data.executorJob);
data.executorJob.fireJobFinishListeners();
} catch (KettleException e) {
result.setNrErrors(1);
result.setResult(false);
log.logError(BaseMessages.getString(PKG, "JobExecutor.Log.ErrorExecJob", e.getMessage()), e);
}
}
//
if (meta.getExecutionResultTargetStepMeta() != null) {
Object[] outputRow = RowDataUtil.allocateRowData(data.executionResultsOutputRowMeta.size());
int idx = 0;
if (!Utils.isEmpty(meta.getExecutionTimeField())) {
outputRow[idx++] = Long.valueOf(System.currentTimeMillis() - data.groupTimeStart);
}
if (!Utils.isEmpty(meta.getExecutionResultField())) {
outputRow[idx++] = Boolean.valueOf(result.getResult());
}
if (!Utils.isEmpty(meta.getExecutionNrErrorsField())) {
outputRow[idx++] = Long.valueOf(result.getNrErrors());
}
if (!Utils.isEmpty(meta.getExecutionLinesReadField())) {
outputRow[idx++] = Long.valueOf(result.getNrLinesRead());
}
if (!Utils.isEmpty(meta.getExecutionLinesWrittenField())) {
outputRow[idx++] = Long.valueOf(result.getNrLinesWritten());
}
if (!Utils.isEmpty(meta.getExecutionLinesInputField())) {
outputRow[idx++] = Long.valueOf(result.getNrLinesInput());
}
if (!Utils.isEmpty(meta.getExecutionLinesOutputField())) {
outputRow[idx++] = Long.valueOf(result.getNrLinesOutput());
}
if (!Utils.isEmpty(meta.getExecutionLinesRejectedField())) {
outputRow[idx++] = Long.valueOf(result.getNrLinesRejected());
}
if (!Utils.isEmpty(meta.getExecutionLinesUpdatedField())) {
outputRow[idx++] = Long.valueOf(result.getNrLinesUpdated());
}
if (!Utils.isEmpty(meta.getExecutionLinesDeletedField())) {
outputRow[idx++] = Long.valueOf(result.getNrLinesDeleted());
}
if (!Utils.isEmpty(meta.getExecutionFilesRetrievedField())) {
outputRow[idx++] = Long.valueOf(result.getNrFilesRetrieved());
}
if (!Utils.isEmpty(meta.getExecutionExitStatusField())) {
outputRow[idx++] = Long.valueOf(result.getExitStatus());
}
if (!Utils.isEmpty(meta.getExecutionLogTextField())) {
String channelId = data.executorJob.getLogChannelId();
String logText = KettleLogStore.getAppender().getBuffer(channelId, false).toString();
outputRow[idx++] = logText;
}
if (!Utils.isEmpty(meta.getExecutionLogChannelIdField())) {
outputRow[idx++] = data.executorJob.getLogChannelId();
}
putRowTo(data.executionResultsOutputRowMeta, outputRow, data.executionResultRowSet);
}
//
if (meta.getResultRowsTargetStepMeta() != null && result.getRows() != null) {
for (RowMetaAndData row : result.getRows()) {
Object[] targetRow = RowDataUtil.allocateRowData(data.resultRowsOutputRowMeta.size());
for (int i = 0; i < meta.getResultRowsField().length; i++) {
ValueMetaInterface valueMeta = row.getRowMeta().getValueMeta(i);
if (valueMeta.getType() != meta.getResultRowsType()[i]) {
throw new KettleException(BaseMessages.getString(PKG, "JobExecutor.IncorrectDataTypePassed", valueMeta.getTypeDesc(), ValueMetaFactory.getValueMetaName(meta.getResultRowsType()[i])));
}
targetRow[i] = row.getData()[i];
}
putRowTo(data.resultRowsOutputRowMeta, targetRow, data.resultRowsRowSet);
}
}
if (meta.getResultFilesTargetStepMeta() != null && result.getResultFilesList() != null) {
for (ResultFile resultFile : result.getResultFilesList()) {
Object[] targetRow = RowDataUtil.allocateRowData(data.resultFilesOutputRowMeta.size());
int idx = 0;
targetRow[idx++] = resultFile.getFile().getName().toString();
// TODO: time, origin, ...
putRowTo(data.resultFilesOutputRowMeta, targetRow, data.resultFilesRowSet);
}
}
data.groupBuffer.clear();
}
use of org.pentaho.di.job.JobExecutionConfiguration in project pentaho-kettle by pentaho.
the class JobEntryJob method execute.
@Override
public Result execute(Result result, int nr) throws KettleException {
result.setEntryNr(nr);
LogChannelFileWriter logChannelFileWriter = null;
LogLevel jobLogLevel = parentJob.getLogLevel();
// Set Embedded NamedCluter MetatStore Provider Key so that it can be passed to VFS
if (parentJobMeta.getNamedClusterEmbedManager() != null) {
parentJobMeta.getNamedClusterEmbedManager().passEmbeddedMetastoreKey(this, parentJobMeta.getEmbeddedMetastoreProviderKey());
}
if (setLogfile) {
String realLogFilename = environmentSubstitute(getLogFilename());
// if we do not have one, we must fail
if (Utils.isEmpty(realLogFilename)) {
logError(BaseMessages.getString(PKG, "JobJob.Exception.LogFilenameMissing"));
result.setNrErrors(1);
result.setResult(false);
return result;
}
// create parent folder?
if (!createParentFolder(realLogFilename)) {
result.setNrErrors(1);
result.setResult(false);
return result;
}
try {
logChannelFileWriter = new LogChannelFileWriter(this.getLogChannelId(), KettleVFS.getFileObject(realLogFilename), setAppendLogfile);
logChannelFileWriter.startLogging();
} catch (KettleException e) {
logError("Unable to open file appender for file [" + getLogFilename() + "] : " + e.toString());
logError(Const.getStackTracker(e));
result.setNrErrors(1);
result.setResult(false);
return result;
}
jobLogLevel = logFileLevel;
}
try {
// First load the job, outside of the loop...
if (parentJob.getJobMeta() != null) {
// reset the internal variables again.
// Maybe we should split up the variables even more like in UNIX shells.
// The internal variables need to be reset to be able use them properly
// in 2 sequential sub jobs.
parentJob.getJobMeta().setInternalKettleVariables();
}
//
switch(specificationMethod) {
case REPOSITORY_BY_NAME:
if (log.isDetailed()) {
logDetailed("Loading job from repository : [" + directory + " : " + environmentSubstitute(jobname) + "]");
}
break;
case FILENAME:
if (log.isDetailed()) {
logDetailed("Loading job from XML file : [" + environmentSubstitute(filename) + "]");
}
break;
case REPOSITORY_BY_REFERENCE:
if (log.isDetailed()) {
logDetailed("Loading job from repository by reference : [" + jobObjectId + "]");
}
break;
default:
break;
}
JobMeta jobMeta = getJobMeta(rep, this);
//
if (jobMeta == null) {
throw new KettleException("Unable to load the job: please specify the name and repository directory OR a filename");
}
verifyRecursiveExecution(parentJob, jobMeta);
int iteration = 0;
String[] args1 = arguments;
// no arguments? Check the parent jobs arguments
if (args1 == null || args1.length == 0) {
args1 = parentJob.getArguments();
}
copyVariablesFrom(parentJob);
setParentVariableSpace(parentJob);
//
// For the moment only do variable translation at the start of a job, not
// for every input row (if that would be switched on)
//
String[] args = null;
if (args1 != null) {
args = new String[args1.length];
for (int idx = 0; idx < args1.length; idx++) {
args[idx] = environmentSubstitute(args1[idx]);
}
}
RowMetaAndData resultRow = null;
boolean first = true;
List<RowMetaAndData> rows = new ArrayList<RowMetaAndData>(result.getRows());
while ((first && !execPerRow) || (execPerRow && rows != null && iteration < rows.size() && result.getNrErrors() == 0)) {
first = false;
//
if (execPerRow) {
result.getRows().clear();
}
if (rows != null && execPerRow) {
resultRow = rows.get(iteration);
} else {
resultRow = null;
}
NamedParams namedParam = new NamedParamsDefault();
//
if (paramsFromPrevious) {
String[] parentParameters = parentJob.listParameters();
for (int idx = 0; idx < parentParameters.length; idx++) {
String par = parentParameters[idx];
String def = parentJob.getParameterDefault(par);
String val = parentJob.getParameterValue(par);
String des = parentJob.getParameterDescription(par);
namedParam.addParameterDefinition(par, def, des);
namedParam.setParameterValue(par, val);
}
}
//
if (parameters != null) {
for (int idx = 0; idx < parameters.length; idx++) {
if (!Utils.isEmpty(parameters[idx])) {
//
if (Const.indexOfString(parameters[idx], namedParam.listParameters()) < 0) {
// We have a parameter
try {
namedParam.addParameterDefinition(parameters[idx], "", "Job entry runtime");
} catch (DuplicateParamException e) {
// Should never happen
//
logError("Duplicate parameter definition for " + parameters[idx]);
}
}
if (Utils.isEmpty(Const.trim(parameterFieldNames[idx]))) {
namedParam.setParameterValue(parameters[idx], Const.NVL(environmentSubstitute(parameterValues[idx]), ""));
} else {
// something filled in, in the field column...
//
String value = "";
if (resultRow != null) {
value = resultRow.getString(parameterFieldNames[idx], "");
}
namedParam.setParameterValue(parameters[idx], value);
}
}
}
}
Result oneResult = new Result();
List<RowMetaAndData> sourceRows = null;
if (execPerRow) {
if (argFromPrevious) {
// Copy the input row to the (command line) arguments
args = null;
if (resultRow != null) {
args = new String[resultRow.size()];
for (int i = 0; i < resultRow.size(); i++) {
args[i] = resultRow.getString(i, null);
}
}
} else {
// Just pass a single row
List<RowMetaAndData> newList = new ArrayList<RowMetaAndData>();
newList.add(resultRow);
sourceRows = newList;
}
if (paramsFromPrevious) {
if (parameters != null) {
for (int idx = 0; idx < parameters.length; idx++) {
if (!Utils.isEmpty(parameters[idx])) {
// We have a parameter
if (Utils.isEmpty(Const.trim(parameterFieldNames[idx]))) {
namedParam.setParameterValue(parameters[idx], Const.NVL(environmentSubstitute(parameterValues[idx]), ""));
} else {
String fieldValue = "";
if (resultRow != null) {
fieldValue = resultRow.getString(parameterFieldNames[idx], "");
}
// Get the value from the input stream
namedParam.setParameterValue(parameters[idx], Const.NVL(fieldValue, ""));
}
}
}
}
}
} else {
if (argFromPrevious) {
// Only put the first Row on the arguments
args = null;
if (resultRow != null) {
args = new String[resultRow.size()];
for (int i = 0; i < resultRow.size(); i++) {
args[i] = resultRow.getString(i, null);
}
}
} else {
// Keep it as it was...
sourceRows = result.getRows();
}
if (paramsFromPrevious) {
if (parameters != null) {
for (int idx = 0; idx < parameters.length; idx++) {
if (!Utils.isEmpty(parameters[idx])) {
// We have a parameter
if (Utils.isEmpty(Const.trim(parameterFieldNames[idx]))) {
namedParam.setParameterValue(parameters[idx], Const.NVL(environmentSubstitute(parameterValues[idx]), ""));
} else {
String fieldValue = "";
if (resultRow != null) {
fieldValue = resultRow.getString(parameterFieldNames[idx], "");
}
// Get the value from the input stream
namedParam.setParameterValue(parameters[idx], Const.NVL(fieldValue, ""));
}
}
}
}
}
}
boolean doFallback = true;
SlaveServer remoteSlaveServer = null;
JobExecutionConfiguration executionConfiguration = new JobExecutionConfiguration();
if (!Utils.isEmpty(runConfiguration)) {
log.logBasic(BaseMessages.getString(PKG, "JobJob.RunConfig.Message"), runConfiguration);
runConfiguration = environmentSubstitute(runConfiguration);
executionConfiguration.setRunConfiguration(runConfiguration);
try {
ExtensionPointHandler.callExtensionPoint(log, KettleExtensionPoint.SpoonTransBeforeStart.id, new Object[] { executionConfiguration, parentJob.getJobMeta(), jobMeta, rep });
if (!executionConfiguration.isExecutingLocally() && !executionConfiguration.isExecutingRemotely()) {
result.setResult(true);
return result;
}
remoteSlaveServer = executionConfiguration.getRemoteServer();
doFallback = false;
} catch (KettleException e) {
log.logError(e.getMessage(), getName());
result.setNrErrors(1);
result.setResult(false);
return result;
}
}
if (doFallback) {
//
if (!Utils.isEmpty(remoteSlaveServerName)) {
String realRemoteSlaveServerName = environmentSubstitute(remoteSlaveServerName);
remoteSlaveServer = parentJob.getJobMeta().findSlaveServer(realRemoteSlaveServerName);
if (remoteSlaveServer == null) {
throw new KettleException(BaseMessages.getString(PKG, "JobTrans.Exception.UnableToFindRemoteSlaveServer", realRemoteSlaveServerName));
}
}
}
if (remoteSlaveServer == null) {
// Local execution...
//
// Create a new job
//
job = new Job(rep, jobMeta, this);
job.setParentJob(parentJob);
job.setLogLevel(jobLogLevel);
job.shareVariablesWith(this);
job.setInternalKettleVariables(this);
job.copyParametersFrom(jobMeta);
job.setInteractive(parentJob.isInteractive());
if (job.isInteractive()) {
job.getJobEntryListeners().addAll(parentJob.getJobEntryListeners());
}
// Pass the socket repository all around.
//
job.setSocketRepository(parentJob.getSocketRepository());
// Set the parameters calculated above on this instance.
//
job.clearParameters();
String[] parameterNames = job.listParameters();
for (int idx = 0; idx < parameterNames.length; idx++) {
// Grab the parameter value set in the job entry
//
String thisValue = namedParam.getParameterValue(parameterNames[idx]);
if (!Utils.isEmpty(thisValue)) {
// Set the value as specified by the user in the job entry
//
job.setParameterValue(parameterNames[idx], thisValue);
} else {
//
if (isPassingAllParameters()) {
String parentValue = parentJob.getParameterValue(parameterNames[idx]);
if (!Utils.isEmpty(parentValue)) {
job.setParameterValue(parameterNames[idx], parentValue);
}
}
}
}
job.activateParameters();
// Set the source rows we calculated above...
//
job.setSourceRows(sourceRows);
// Don't forget the logging...
job.beginProcessing();
// Link the job with the sub-job
parentJob.getJobTracker().addJobTracker(job.getJobTracker());
// Link both ways!
job.getJobTracker().setParentJobTracker(parentJob.getJobTracker());
if (parentJob.getJobMeta().isBatchIdPassed()) {
job.setPassedBatchId(parentJob.getBatchId());
}
job.setArguments(args);
//
for (DelegationListener delegationListener : parentJob.getDelegationListeners()) {
// TODO: copy some settings in the job execution configuration, not strictly needed
// but the execution configuration information is useful in case of a job re-start
//
delegationListener.jobDelegationStarted(job, new JobExecutionConfiguration());
}
JobEntryJobRunner runner = new JobEntryJobRunner(job, result, nr, log);
Thread jobRunnerThread = new Thread(runner);
// PDI-6518
// added UUID to thread name, otherwise threads do share names if jobs entries are executed in parallel in a
// parent job
// if that happens, contained transformations start closing each other's connections
jobRunnerThread.setName(Const.NVL(job.getJobMeta().getName(), job.getJobMeta().getFilename()) + " UUID: " + UUID.randomUUID().toString());
jobRunnerThread.start();
//
while (!runner.isFinished() && !parentJob.isStopped()) {
try {
Thread.sleep(0, 1);
} catch (InterruptedException e) {
// Ignore
}
}
// if the parent-job was stopped, stop the sub-job too...
if (parentJob.isStopped()) {
job.stopAll();
// Wait until finished!
runner.waitUntilFinished();
}
oneResult = runner.getResult();
} else {
// Make sure we can parameterize the slave server connection
//
remoteSlaveServer.shareVariablesWith(this);
// Remote execution...
//
JobExecutionConfiguration jobExecutionConfiguration = new JobExecutionConfiguration();
// lightClone() because rows are
jobExecutionConfiguration.setPreviousResult(result.lightClone());
// overwritten in next line.
jobExecutionConfiguration.getPreviousResult().setRows(sourceRows);
jobExecutionConfiguration.setArgumentStrings(args);
jobExecutionConfiguration.setVariables(this);
jobExecutionConfiguration.setRemoteServer(remoteSlaveServer);
jobExecutionConfiguration.setRepository(rep);
jobExecutionConfiguration.setLogLevel(jobLogLevel);
jobExecutionConfiguration.setPassingExport(passingExport);
jobExecutionConfiguration.setExpandingRemoteJob(expandingRemoteJob);
for (String param : namedParam.listParameters()) {
String defValue = namedParam.getParameterDefault(param);
String value = namedParam.getParameterValue(param);
jobExecutionConfiguration.getParams().put(param, Const.NVL(value, defValue));
}
if (parentJob.getJobMeta().isBatchIdPassed()) {
jobExecutionConfiguration.setPassedBatchId(parentJob.getBatchId());
}
// Send the XML over to the slave server
// Also start the job over there...
//
String carteObjectId = null;
try {
carteObjectId = Job.sendToSlaveServer(jobMeta, jobExecutionConfiguration, rep, metaStore);
} catch (KettleException e) {
// Perhaps the job exists on the remote server, carte is down, etc.
// This is an abort situation, stop the parent job...
// We want this in case we are running in parallel. The other job
// entries can stop running now.
//
parentJob.stopAll();
//
throw e;
}
// Now start the monitoring...
//
SlaveServerJobStatus jobStatus = null;
while (!parentJob.isStopped() && waitingToFinish) {
try {
jobStatus = remoteSlaveServer.getJobStatus(jobMeta.getName(), carteObjectId, 0);
if (jobStatus.getResult() != null) {
// The job is finished, get the result...
//
oneResult = jobStatus.getResult();
break;
}
} catch (Exception e1) {
logError("Unable to contact slave server [" + remoteSlaveServer + "] to verify the status of job [" + jobMeta.getName() + "]", e1);
oneResult.setNrErrors(1L);
// Stop looking too, chances are too low the server will
break;
// come back on-line
}
// sleep for 1 second
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// Ignore
}
}
// Write log from carte to file
if (setLogfile && jobStatus != null) {
String logFromCarte = jobStatus.getLoggingString();
if (!Utils.isEmpty(logFromCarte)) {
FileObject logfile = logChannelFileWriter.getLogFile();
OutputStream logFileOutputStream = null;
try {
logFileOutputStream = KettleVFS.getOutputStream(logfile, setAppendLogfile);
logFileOutputStream.write(logFromCarte.getBytes());
logFileOutputStream.flush();
} catch (Exception e) {
logError("There was an error logging to file '" + logfile + "'", e);
} finally {
try {
if (logFileOutputStream != null) {
logFileOutputStream.close();
logFileOutputStream = null;
}
} catch (Exception e) {
logError("There was an error closing log file file '" + logfile + "'", e);
}
}
}
}
if (!waitingToFinish) {
// Since the job was posted successfully, the result is true...
//
oneResult = new Result();
oneResult.setResult(true);
}
if (parentJob.isStopped()) {
try {
//
if (jobStatus == null || jobStatus.isRunning()) {
// Try a remote abort ...
//
remoteSlaveServer.stopJob(jobMeta.getName(), carteObjectId);
}
} catch (Exception e1) {
logError("Unable to contact slave server [" + remoteSlaveServer + "] to stop job [" + jobMeta.getName() + "]", e1);
oneResult.setNrErrors(1L);
// Stop looking too, chances are too low the server will
break;
// come back on-line
}
}
}
// clear only the numbers, NOT the files or rows.
result.clear();
result.add(oneResult);
// Set the result rows too, if any ...
if (!Utils.isEmpty(oneResult.getRows())) {
result.setRows(new ArrayList<RowMetaAndData>(oneResult.getRows()));
}
//
if (oneResult.getResult() == false) {
result.setNrErrors(result.getNrErrors() + 1);
}
iteration++;
}
} catch (KettleException ke) {
logError("Error running job entry 'job' : ", ke);
result.setResult(false);
result.setNrErrors(1L);
}
if (setLogfile) {
if (logChannelFileWriter != null) {
logChannelFileWriter.stopLogging();
ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_LOG, logChannelFileWriter.getLogFile(), parentJob.getJobname(), getName());
result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
//
if (logChannelFileWriter.getException() != null) {
logError("Unable to open log file [" + getLogFilename() + "] : ");
logError(Const.getStackTracker(logChannelFileWriter.getException()));
result.setNrErrors(1);
result.setResult(false);
return result;
}
}
}
if (result.getNrErrors() > 0) {
result.setResult(false);
} else {
result.setResult(true);
}
return result;
}
use of org.pentaho.di.job.JobExecutionConfiguration in project pentaho-kettle by pentaho.
the class SpoonJobDelegateTest method testSetParamsIntoMetaInExecuteJob.
@Test
@SuppressWarnings("ResultOfMethodCallIgnored")
public void testSetParamsIntoMetaInExecuteJob() throws KettleException {
doCallRealMethod().when(delegate).executeJob(jobMeta, true, false, null, false, null, 0);
JobExecutionConfiguration jobExecutionConfiguration = mock(JobExecutionConfiguration.class);
RowMetaInterface rowMeta = mock(RowMetaInterface.class);
Shell shell = mock(Shell.class);
JobExecutionConfigurationDialog jobExecutionConfigurationDialog = mock(JobExecutionConfigurationDialog.class);
JobGraph activeJobGraph = mock(JobGraph.class);
activeJobGraph.jobLogDelegate = mock(JobLogDelegate.class);
doReturn(jobExecutionConfiguration).when(spoon).getJobExecutionConfiguration();
doReturn(rowMeta).when(spoon.variables).getRowMeta();
doReturn(EMPTY_STRING_ARRAY).when(rowMeta).getFieldNames();
doReturn(shell).when(spoon).getShell();
doReturn(jobExecutionConfigurationDialog).when(delegate).newJobExecutionConfigurationDialog(jobExecutionConfiguration, jobMeta);
doReturn(activeJobGraph).when(spoon).getActiveJobGraph();
doReturn(MAP_WITH_TEST_VARIABLE).when(jobExecutionConfiguration).getVariables();
doReturn(MAP_WITH_TEST_PARAM).when(jobExecutionConfiguration).getParams();
doReturn(TEST_LOG_LEVEL).when(jobExecutionConfiguration).getLogLevel();
doReturn(TEST_START_COPY_NAME).when(jobExecutionConfiguration).getStartCopyName();
doReturn(TEST_BOOLEAN_PARAM).when(jobExecutionConfiguration).isClearingLog();
doReturn(TEST_BOOLEAN_PARAM).when(jobExecutionConfiguration).isSafeModeEnabled();
doReturn(TEST_BOOLEAN_PARAM).when(jobExecutionConfiguration).isExpandingRemoteJob();
delegate.executeJob(jobMeta, true, false, null, false, null, 0);
verify(jobMeta).setVariable(TEST_VARIABLE_KEY, TEST_VARIABLE_VALUE);
verify(jobMeta).setParameterValue(TEST_PARAM_KEY, TEST_PARAM_VALUE);
verify(jobMeta).activateParameters();
verify(jobMeta).setLogLevel(TEST_LOG_LEVEL);
verify(jobMeta).setStartCopyName(TEST_START_COPY_NAME);
verify(jobMeta).setClearingLog(TEST_BOOLEAN_PARAM);
verify(jobMeta).setSafeModeEnabled(TEST_BOOLEAN_PARAM);
verify(jobMeta).setExpandingRemoteJob(TEST_BOOLEAN_PARAM);
}
use of org.pentaho.di.job.JobExecutionConfiguration in project pentaho-kettle by pentaho.
the class DefaultRunConfigurationExecutorTest method testExecuteRemoteJob.
@Test
public void testExecuteRemoteJob() throws Exception {
DefaultRunConfiguration defaultRunConfiguration = new DefaultRunConfiguration();
defaultRunConfiguration.setName("Default Configuration");
defaultRunConfiguration.setLocal(false);
defaultRunConfiguration.setRemote(true);
defaultRunConfiguration.setServer("Test Server");
JobExecutionConfiguration jobExecutionConfiguration = new JobExecutionConfiguration();
doReturn(slaveServer).when(abstractMeta).findSlaveServer("Test Server");
defaultRunConfigurationExecutor.execute(defaultRunConfiguration, jobExecutionConfiguration, abstractMeta, variableSpace, null);
assertFalse(jobExecutionConfiguration.isExecutingLocally());
assertTrue(jobExecutionConfiguration.isExecutingRemotely());
assertEquals(jobExecutionConfiguration.getRemoteServer(), slaveServer);
}
Aggregations