use of ru.fix.completable.reactor.runtime.dsl.Processor in project completable-reactor by ru-fix.
the class CompletableReactorTest method detached_processor.
@Test
public void detached_processor() throws Exception {
IdProcessor detachedProcessor = new IdProcessor(3).withLaunchingLatch();
class Config {
final ReactorGraphBuilder builder = new ReactorGraphBuilder(this);
Processor<IdListPayload> idProcessor1 = buildProcessor(builder, new IdProcessor(1));
Processor<IdListPayload> idProcessor2 = buildProcessor(builder, new IdProcessor(2));
Processor<DetachedProcessorPayload> idProcessor3 = builder.processor().forPayload(DetachedProcessorPayload.class).withHandler(detachedProcessor::handle).withoutMerger().buildProcessor();
ReactorGraph buildGraph() {
return builder.payload(DetachedProcessorPayload.class).handle(idProcessor1).handle(idProcessor2).handle(idProcessor3).mergePoint(idProcessor1).on(Status.OK).merge(idProcessor2).mergePoint(idProcessor2).onAny().complete().coordinates().start(489, 96).proc(idProcessor1, 364, 178).proc(idProcessor2, 530, 180).proc(idProcessor3, 701, 172).merge(idProcessor1, 414, 268).merge(idProcessor2, 589, 341).complete(idProcessor2, 701, 378).buildGraph();
}
}
val graph = new Config().buildGraph();
printGraph(graph);
reactor.registerReactorGraph(graph);
CompletableReactor.Execution<DetachedProcessorPayload> result = reactor.submit(new DetachedProcessorPayload());
assertEquals(Arrays.asList(1, 2), result.getResultFuture().get(5, TimeUnit.SECONDS).getIdSequence());
assertTrue("result future is complete", result.getResultFuture().isDone());
assertFalse("execution chain is not complete since detached processor still working", result.getChainExecutionFuture().isDone());
detachedProcessor.launch();
result.getChainExecutionFuture().get(5, TimeUnit.SECONDS);
assertTrue("execution chain is complete when detached processor is finished", result.getChainExecutionFuture().isDone());
}
use of ru.fix.completable.reactor.runtime.dsl.Processor in project completable-reactor by ru-fix.
the class CompletableReactorTest method detached_merge_point_from_processors_merge_point.
@Test
public void detached_merge_point_from_processors_merge_point() throws Exception {
final int MERGE_POINT_ID = 42;
class Config {
ReactorGraphBuilder graphBuilder = new ReactorGraphBuilder(this);
Processor<IdListPayload> idProcessor0 = buildProcessor(graphBuilder, new IdProcessor(0));
Processor<IdListPayload> idProcessor1 = buildProcessor(graphBuilder, new IdProcessor(1));
MergePoint<DetachedMergePointFromProcessorsMergePointPayload> mergePoint = graphBuilder.mergePoint().forPayload(DetachedMergePointFromProcessorsMergePointPayload.class).withMerger("addMergePointId", new String[] { "Adds merge point id", "to payload sequence" }, pld -> {
pld.getIdSequence().add(MERGE_POINT_ID);
return Status.OK;
}).buildMergePoint();
ReactorGraph<DetachedMergePointFromProcessorsMergePointPayload> graph() {
return graphBuilder.payload(DetachedMergePointFromProcessorsMergePointPayload.class).handle(idProcessor0).handle(idProcessor1).mergePoint(idProcessor0).onAny().merge(idProcessor1).mergePoint(idProcessor1).onAny().merge(mergePoint).mergePoint(mergePoint).onAny().complete().coordinates().start(95, 62).proc(idProcessor0, 164, 131).proc(idProcessor1, 330, 127).merge(idProcessor0, 235, 224).merge(idProcessor1, 357, 241).merge(mergePoint, 461, 289).complete(mergePoint, 406, 369).buildGraph();
}
}
val graph = new Config().graph();
printGraph(graph);
reactor.registerReactorGraph(graph);
CompletableReactor.Execution<DetachedMergePointFromProcessorsMergePointPayload> result = reactor.submit(new DetachedMergePointFromProcessorsMergePointPayload());
DetachedMergePointFromProcessorsMergePointPayload resultPayload = result.getResultFuture().get(10, TimeUnit.SECONDS);
assertEquals(Arrays.asList(0, 1, 42), resultPayload.getIdSequence());
}
use of ru.fix.completable.reactor.runtime.dsl.Processor in project completable-reactor by ru-fix.
the class MockSubgraphTest method mock_subgraph.
@Test
public void mock_subgraph() throws Exception {
class Config {
final ReactorGraphBuilder graphBuilder = new ReactorGraphBuilder(this);
Processor<MainPayload> processor1 = graphBuilder.processor().forPayload(MainPayload.class).withHandler(new Processor1()::handle).withMerger((mainPayload, any) -> Status.OK).buildProcessor();
Subgraph<MainPayload> subgraph = graphBuilder.subgraph(SubgraphPayload.class).forPayload(MainPayload.class).passArg(pld -> new SubgraphPayload().setData(pld.getData())).withMerger((mainPayload, subgraphPayload) -> {
mainPayload.setData(subgraphPayload.getData());
return Status.OK;
}).buildSubgraph();
ReactorGraph<MainPayload> graph() {
return graphBuilder.payload(MainPayload.class).handle(processor1).mergePoint(processor1).onAny().handle(subgraph).mergePoint(subgraph).onAny().complete().coordinates().start(488, -51).proc(processor1, 483, 19).proc(subgraph, 465, 175).merge(processor1, 519, 104).merge(subgraph, 526, 259).complete(subgraph, 532, 336).buildGraph();
}
}
val graph = new Config().graph();
ReactorGraphBuilder.write(graph);
reactor.registerReactorGraph(graph);
// mocking subgraph behaviour
AtomicReference<SubgraphPayload> subgraphCapture = new AtomicReference<>();
reactor.registerReactorGraph(SubgraphPayload.class, payload -> {
subgraphCapture.set(payload);
return CompletableFuture.completedFuture(new SubgraphPayload().setData("mock-subgraph-data"));
});
// override subgraph implementation by async method
CompletableReactor.Execution<MainPayload> result = reactor.submit(new MainPayload().setData("main-payload-data"));
MainPayload mainGraphResultPayload = result.getResultFuture().get(10, TimeUnit.SECONDS);
assertNotNull(subgraphCapture.get());
assertEquals("main-payload-data", subgraphCapture.get().getData());
assertEquals("mock-subgraph-data", mainGraphResultPayload.getData());
}
use of ru.fix.completable.reactor.runtime.dsl.Processor in project completable-reactor by ru-fix.
the class TracingTest method trace_payload_if_payload_contain_special_id.
@Test
public void trace_payload_if_payload_contain_special_id() throws Exception {
class Config {
ReactorGraphBuilder graphBuilder = new ReactorGraphBuilder(this);
Processor<TracablePayload> processor1 = graphBuilder.processor().forPayload(TracablePayload.class).withHandler(new IdProcessor(1)::handle).withMerger((payload, any) -> Status.OK).buildProcessor();
Processor<TracablePayload> processor2 = graphBuilder.processor().forPayload(TracablePayload.class).withHandler(new IdProcessor(2)::handle).withMerger((payload, any) -> Status.OK).buildProcessor();
Processor<TracablePayload> processor3 = graphBuilder.processor().forPayload(TracablePayload.class).withHandler(new IdProcessor(3)::handle).withMerger((payload, any) -> Status.OK).buildProcessor();
ReactorGraph<TracablePayload> graph() {
return graphBuilder.payload(TracablePayload.class).handle(processor1).handle(processor2).mergePoint(processor1).onAny().merge(processor2).mergePoint(processor2).onAny().handle(processor3).mergePoint(processor3).onAny().complete().coordinates().buildGraph();
}
}
val graph = new Config().graph();
completableReactor.registerReactorGraph(graph);
val beforeHandle = new AtomicBoolean();
val beforeMerge = new AtomicBoolean();
val tracer = new LogTracer() {
@Override
public boolean isTraceable(Object payload) {
if (payload instanceof TracablePayload) {
return ((TracablePayload) payload).getNumber() == 42;
} else {
return false;
}
}
@Override
public Object beforeHandle(String identity, Object payload) {
if (((TracablePayload) payload).getNumber() == 42) {
beforeHandle.set(true);
}
return super.beforeHandle(identity, payload);
}
@Override
public Object beforeMerge(String identity, Object payload, Object handleResult) {
if (((TracablePayload) payload).getNumber() == 42) {
beforeMerge.set(true);
}
return super.beforeMerge(identity, payload, handleResult);
}
};
completableReactor.setTracer(tracer);
for (int num = 0; num < 1000; num++) {
completableReactor.submit(new TracablePayload().setNumber(num));
}
completableReactor.close();
assertTrue(beforeHandle.get());
assertTrue(beforeMerge.get());
}
use of ru.fix.completable.reactor.runtime.dsl.Processor in project completable-reactor by ru-fix.
the class CompletableReactorHandlerArgumentsTest method arguments_test_2.
@Test
public void arguments_test_2() throws Exception {
@Reactored("Payload with string")
@Data
class Payload {
String data;
}
class Service {
@Reactored("method with 6 arguments")
public CompletableFuture<String> foo(BigInteger arg1, long arg2) {
return CompletableFuture.completedFuture("" + arg1 + arg2);
}
}
final Service service = new Service();
class Config {
ReactorGraphBuilder graphBuilder = new ReactorGraphBuilder(this);
Processor<Payload> processor = graphBuilder.processor().forPayload(Payload.class).passArg(pld -> BigInteger.valueOf(6L)).passArg(pld -> 7L).withHandler(service::foo).withMerger((payload, result) -> {
payload.data = result;
return CompletableReactorTest.Status.OK;
}).buildProcessor();
ReactorGraph<Payload> graph() {
return graphBuilder.payload(Payload.class).handle(processor).mergePoint(processor).onAny().complete().coordinates().buildGraph();
}
}
val graph = new Config().graph();
reactor.registerReactorGraph(graph);
assertEquals("67", reactor.submit(new Payload()).getResultFuture().get(5, TimeUnit.SECONDS).getData());
}
Aggregations