protected void startThreads( Trans trans ) throws KettleException { trans.startThreads(); }
/** * Executes the transformation. This method will prepare the transformation for execution and then start all the * threads associated with the transformation and its steps. * * @param arguments the arguments * @throws KettleException if the transformation could not be prepared (initialized) */ public void execute( String[] arguments ) throws KettleException { prepareExecution( arguments ); startThreads(); }
protected void executeTrans( Trans trans ) throws KettleException { trans.prepareExecution( null ); trans.startThreads(); trans.waitUntilFinished(); }
public Optional<Result> execute( List<RowMetaAndData> rows ) throws KettleException { if ( rows.isEmpty() || stopped ) { return Optional.empty(); } Trans subtrans = this.createSubtrans(); running.add( subtrans ); parentTrans.addActiveSubTransformation( subTransName, subtrans ); // Pass parameter values passParametersToTrans( subtrans, rows.get( 0 ) ); Result result = new Result(); result.setRows( rows ); subtrans.setPreviousResult( result ); subtrans.prepareExecution( this.parentTrans.getArguments() ); List<RowMetaAndData> rowMetaAndData = new ArrayList<>(); subtrans.getSteps().stream() .filter( c -> c.step.getStepname().equalsIgnoreCase( subStep ) ) .findFirst() .ifPresent( c -> c.step.addRowListener( new RowAdapter() { @Override public void rowWrittenEvent( RowMetaInterface rowMeta, Object[] row ) { rowMetaAndData.add( new RowMetaAndData( rowMeta, row ) ); } } ) ); subtrans.startThreads(); subtrans.waitUntilFinished(); updateStatuses( subtrans ); running.remove( subtrans ); Result subtransResult = subtrans.getResult(); subtransResult.setRows( rowMetaAndData ); return Optional.of( subtransResult ); }
@Before public void setUp() throws Exception { executor = StepMockUtil.getStep( TransExecutor.class, TransExecutorMeta.class, "TransExecutorUnitTest" ); executor = spy( executor ); TransMeta internalTransMeta = mock( TransMeta.class ); doReturn( internalTransMeta ).when( executor ).loadExecutorTransMeta(); internalTrans = spy( new Trans() ); internalTrans.setLog( mock( LogChannelInterface.class ) ); doNothing().when( internalTrans ).prepareExecution( any( String[].class ) ); doNothing().when( internalTrans ).startThreads(); doNothing().when( internalTrans ).waitUntilFinished(); doNothing().when( executor ).discardLogLines( any( TransExecutorData.class ) ); doReturn( internalTrans ).when( executor ).createInternalTrans(); internalResult = new Result(); doReturn( internalResult ).when( internalTrans ).getResult(); meta = new TransExecutorMeta(); data = new TransExecutorData(); }
trans.startThreads(); } catch ( final KettleException e ) { shell.getDisplay().asyncExec( new Runnable() {
/** * PDI-14948 - Execution of trans with no steps never ends */ @Test ( timeout = 1000 ) public void transWithNoStepsIsNotEndless() throws Exception { Trans transWithNoSteps = new Trans( new TransMeta() ); transWithNoSteps = spy( transWithNoSteps ); transWithNoSteps.prepareExecution( new String[] {} ); transWithNoSteps.startThreads(); // check trans lifecycle is not corrupted verify( transWithNoSteps ).fireTransStartedListeners(); verify( transWithNoSteps ).fireTransFinishedListeners(); }
@Before public void beforeTest() throws KettleException { meta = new TransMeta(); trans = new Trans( meta ); trans.setLog( Mockito.mock( LogChannelInterface.class ) ); trans.prepareExecution( null ); trans.startThreads(); }
trans.startThreads(); startRedrawTimer();
@Test public void doesNotWriteRowOnTimeWhenStopped() throws KettleException, InterruptedException { TransMeta transMeta = new TransMeta( getClass().getResource( "safe-stop.ktr" ).getPath() ); Trans trans = new Trans( transMeta ); trans.prepareExecution( new String[] {} ); trans.getSteps().get( 1 ).step.addRowListener( new RowAdapter() { @Override public void rowWrittenEvent( RowMetaInterface rowMeta, Object[] row ) throws KettleStepException { trans.safeStop(); } } ); trans.startThreads(); trans.waitUntilFinished(); assertEquals( 1, trans.getSteps().get( 0 ).step.getLinesWritten() ); assertEquals( 1, trans.getSteps().get( 1 ).step.getLinesRead() ); } }
trans.startThreads(); trans.waitUntilFinished(); if ( trans.getErrors() > 0 ) {
private JoinRows getJoinRows() throws Exception { StepMeta stepMeta = new StepMeta(); TransMeta transMeta = new TransMeta(); Trans trans = new Trans( transMeta ); transMeta.clear(); transMeta.addStep( stepMeta ); transMeta.setStep( 0, stepMeta ); stepMeta.setName( "test" ); trans.setLog( mock( LogChannelInterface.class ) ); trans.prepareExecution( null ); trans.startThreads(); return new JoinRows( stepMeta, null, 0, transMeta, trans ); }
injectTrans.startThreads();
executorTrans.startThreads();
getData().getMappingTrans().startThreads();
simpleMappingData.mappingTrans.startThreads();
singleThreaderData.mappingTrans.startThreads();