@Override public String getIdentifier() { return METRICS_HANDLER_ID + operation.getId(); } } );
@Override public String getIdentifier() { return OPERATION_STATUS_HANDLER_ID + operation.getId(); } } );
@Override public String getIdentifier() { return OPERATION_STATUS_HANDLER_ID + op.getId(); } } );
@Override public String getIdentifier() { return ROWS_HANDLER_ID + operation.getId(); } } );
private static Operation getOp( org.pentaho.di.engine.model.Transformation transformation, StepMeta step ) throws KettleException { return transformation.getOperations().stream() .filter( op -> step.getName().equals( op.getId() ) ) .findFirst() .orElseThrow( () -> new KettleException( "Could not find operation: " + step.getName() ) ); }
private void createHandlerToRows() throws KettleException { messageEventService.addHandler( Util.getOperationRowEvent( operation.getId() ), new MessageEventHandler() { @Override public void execute( Message message ) throws MessageEventHandlerExecutionException { PDIEvent<RemoteSource, Rows> data = (PDIEvent<RemoteSource, Rows>) message; if ( data.getData().getType().equals( OUT ) ) { data.getData().stream().forEach( r -> putRow( r ) ); } } @Override public String getIdentifier() { return ROWS_HANDLER_ID + operation.getId(); } } ); }
private void createHandlerToMetrics() throws KettleException { messageEventService.addHandler( Util.getMetricEvents( operation.getId() ), new MessageEventHandler() { @Override public void execute( Message message ) throws MessageEventHandlerExecutionException { PDIEvent<RemoteSource, Metrics> data = (PDIEvent<RemoteSource, Metrics>) message; if ( data.getData().getIn() > 0 ) { StepInterfaceWebSocketEngineAdapter.this.setLinesRead( data.getData().getIn() ); } if ( data.getData().getOut() > 0 ) { StepInterfaceWebSocketEngineAdapter.this.setLinesWritten( data.getData().getOut() ); } } @Override public String getIdentifier() { return METRICS_HANDLER_ID + operation.getId(); } } ); }
private void createHandlerToStatus() throws KettleException { messageEventService.addHandler( Util.getOperationStatusEvent( operation.getId() ), new MessageEventHandler() { @Override public void execute( Message message ) throws MessageEventHandlerExecutionException { PDIEvent<RemoteSource, Status> data = (PDIEvent<RemoteSource, Status>) message; switch ( data.getData() ) { case RUNNING: StepInterfaceWebSocketEngineAdapter.this.setRunning( true ); break; case PAUSED: StepInterfaceWebSocketEngineAdapter.this.setPaused( true ); break; case FAILED: StepInterfaceWebSocketEngineAdapter.this.setErrors( 1L ); case STOPPED: StepInterfaceWebSocketEngineAdapter.this.setStopped( true ); break; case FINISHED: StepInterfaceWebSocketEngineAdapter.this.setRunning( false ); break; } } @Override public String getIdentifier() { return OPERATION_STATUS_HANDLER_ID + operation.getId(); } } ); }
StepDataInterfaceWebSocketEngineAdapter( Operation op, MessageEventService messageEventService ) throws KettleException { messageEventService .addHandler( Util.getOperationStatusEvent( op.getId() ), new MessageEventHandler() { @Override public void execute( Message message ) throws MessageEventHandlerExecutionException { PDIEvent<RemoteSource, Status> data = (PDIEvent<RemoteSource, Status>) message; switch ( data.getData() ) { case FINISHED: stepExecutionStatus.set( STATUS_FINISHED ); break; case FAILED: case STOPPED: stepExecutionStatus.set( STATUS_STOPPED ); break; case PAUSED: stepExecutionStatus.set( STATUS_PAUSED ); break; case RUNNING: stepExecutionStatus.set( STATUS_RUNNING ); break; } } @Override public String getIdentifier() { return OPERATION_STATUS_HANDLER_ID + op.getId(); } } ); }
@Before public void before() throws KettleException { when( stepMeta.getName() ).thenReturn( "foo" ); when( op.getId() ).thenReturn( "Operation ID" ); messageEventService = new MessageEventService(); }
private void subscribeToOpLogging() throws KettleException { transformation.getOperations().stream().forEach( operation -> { try { messageEventService.addHandler( Util.getOperationLogEvent( operation.getId() ), new MessageEventHandler() { @Override public void execute( Message message ) throws MessageEventHandlerExecutionException { PDIEvent<RemoteSource, LogEntry> event = (PDIEvent<RemoteSource, LogEntry>) message; LogEntry logEntry = event.getData(); StepInterface stepInterface = findStepInterface( operation.getId(), 0 ); if ( stepInterface != null ) { LogChannelInterface logChannel = stepInterface.getLogChannel(); logToChannel( logChannel, logEntry ); } else { // Could not find step, log at transformation level instead logToChannel( getLogChannel(), logEntry ); } } @Override public String getIdentifier() { return OPERATION_LOG + operation.getId(); } } ); } catch ( HandlerRegistrationException e ) { getLogChannel().logError( "Error registering message handlers", e ); } } ); }
@Before public void before() throws KettleException { when( op.getId() ).thenReturn( "Operation ID" ); messageEventService = new MessageEventService(); stepDataInterfaceWebSocketEngineAdapter = new StepDataInterfaceWebSocketEngineAdapter( op, messageEventService ); }
@Test public void testHandlerCreation() throws KettleException { new StepInterfaceWebSocketEngineAdapter( op, messageEventService, stepMeta, transMeta, dataInterface, tran, Collections.emptyList() ); assertTrue( messageEventService.hasHandlers( Util.getOperationRowEvent( op.getId() ) ) ); assertTrue( messageEventService.hasHandlers( Util.getOperationStatusEvent( op.getId() ) ) ); assertTrue( messageEventService.hasHandlers( Util.getMetricEvents( op.getId() ) ) ); assertTrue( messageEventService.getHandlersFor( Util.getOperationRowEvent( op.getId() ) ).size() == 1 ); assertTrue( messageEventService.getHandlersFor( Util.getOperationStatusEvent( op.getId() ) ).size() == 1 ); assertTrue( messageEventService.getHandlersFor( Util.getMetricEvents( op.getId() ) ).size() == 1 ); } }
@Test public void simpleConvert() { TransMeta meta = new TransMeta(); meta.setFilename( "fileName" ); meta.addStep( new StepMeta( "stepName", stepMetaInterface ) ); Transformation trans = TransMetaConverter.convert( meta ); assertThat( trans.getId(), is( meta.getFilename() ) ); assertThat( trans.getOperations().size(), is( 1 ) ); assertThat( trans.getOperations().get( 0 ).getId(), is( "stepName" ) ); }
@Test public void errorHops() throws Exception { TransMeta meta = new TransMeta(); meta.setFilename( "fileName" ); StepMeta from = new StepMeta( "step1", stepMetaInterface ); meta.addStep( from ); StepMeta to = new StepMeta( "step2", stepMetaInterface ); meta.addStep( to ); meta.addTransHop( new TransHopMeta( from, to ) ); StepMeta error = new StepMeta( "errorHandler", stepMetaInterface ); meta.addStep( error ); TransHopMeta errorHop = new TransHopMeta( from, error ); errorHop.setErrorHop( true ); meta.addTransHop( errorHop ); Transformation trans = TransMetaConverter.convert( meta ); Map<String, List<Hop>> hops = trans.getHops().stream().collect( Collectors.groupingBy( Hop::getType ) ); List<Hop> normalHops = hops.get( Hop.TYPE_NORMAL ); assertThat( normalHops.size(), is( 1 ) ); assertThat( normalHops.get( 0 ).getTo().getId(), is( "step2" ) ); List<Hop> errorHops = hops.get( Hop.TYPE_ERROR ); assertThat( errorHops.size(), is( 1 ) ); assertThat( errorHops.get( 0 ).getTo().getId(), is( "errorHandler" ) ); assertThat( hops.values().stream() .flatMap( List::stream ) .map( Hop::getFrom ).map( Operation::getId ) .collect( Collectors.toList() ), everyItem( equalTo( "step1" ) ) ); }
@Test public void transWithHops() { TransMeta meta = new TransMeta(); meta.setFilename( "fileName" ); StepMeta from = new StepMeta( "step1", stepMetaInterface ); meta.addStep( from ); StepMeta to = new StepMeta( "step2", stepMetaInterface ); meta.addStep( to ); meta.addTransHop( new TransHopMeta( from, to ) ); Transformation trans = TransMetaConverter.convert( meta ); assertThat( trans.getId(), is( meta.getFilename() ) ); assertThat( trans.getOperations().size(), is( 2 ) ); assertThat( trans.getHops().size(), is( 1 ) ); assertThat( trans.getHops().get( 0 ).getFrom().getId(), is( from.getName() ) ); assertThat( trans.getHops().get( 0 ).getTo().getId(), is( to.getName() ) ); assertThat( trans.getHops().stream().map( Hop::getType ).collect( Collectors.toList() ), everyItem( is( Hop.TYPE_NORMAL ) ) ); }
@Test public void testRemovingDisabledInputSteps() { TransMeta trans = new TransMeta(); StepMeta inputToBeRemoved = new StepMeta( "InputToBeRemoved", stepMetaInterface ); trans.addStep( inputToBeRemoved ); StepMeta inputToStay = new StepMeta( "InputToStay", stepMetaInterface ); trans.addStep( inputToStay ); StepMeta inputReceiver1 = new StepMeta( "InputReceiver1", stepMetaInterface ); trans.addStep( inputReceiver1 ); StepMeta inputReceiver2 = new StepMeta( "InputReceiver2", stepMetaInterface ); trans.addStep( inputReceiver2 ); TransHopMeta hop1 = new TransHopMeta( inputToBeRemoved, inputReceiver1, false ); TransHopMeta hop2 = new TransHopMeta( inputToStay, inputReceiver1 ); TransHopMeta hop3 = new TransHopMeta( inputToBeRemoved, inputReceiver2, false ); trans.addTransHop( hop1 ); trans.addTransHop( hop2 ); trans.addTransHop( hop3 ); Transformation transformation = TransMetaConverter.convert( trans ); List<String> steps = transformation.getOperations().stream().map( op -> op.getId() ).collect( Collectors.toList() ); assertThat( "Only 2 ops should exist", steps.size(), is( 2 ) ); assertThat( steps, hasItems( "InputToStay", "InputReceiver1" ) ); List<String> hops = transformation.getHops().stream().map( hop -> hop.getId() ).collect( Collectors.toList() ); assertThat( "Only 1 hop should exist", hops.size(), is( 1 ) ); assertThat( hops, hasItems( "InputToStay -> InputReceiver1" ) ); }
transformation.getOperations().stream().map( op -> op.getId() ).collect( Collectors.toList() ); assertThat( "Only 5 ops should exist", steps.size(), is( 5 ) ); assertThat( steps, hasItems( "Start", "WithEnabledHop", "ShouldStay", "WithEnabledAndDisabledHops",