/** * To automatic add IntegrationRouteBuilder which loads syndesis integration * from classpath. */ @Bean @ConditionalOnMissingBean(IntegrationRouteBuilder.class) public RouteBuilder integrationRouteBuilder() { final String location = configuration.getConfigurationLocation(); final List<IntegrationStepHandler> handlers = new ArrayList<>(); // register handlers discovered from application context handlers.addAll(integrationStepHandlers); // register handlers discovered using service loader for (IntegrationStepHandler handler : ServiceLoader.load(IntegrationStepHandler.class, Thread.currentThread().getContextClassLoader())) { handlers.add(handler); } // IntegrationRouteBuilder automatically add known handlers to the list // of provided ones, know handlers have priority return new IntegrationRouteBuilder(location, handlers); }
@Override public void configure() throws Exception { final IntegrationDeployment deployment = loadDeployment(); final List<? extends Step> steps = deployment.getSpec().getSteps(); ProcessorDefinition route = null; for (int i = 0; i< steps.size(); i++) { final Step step = steps.get(i); if (i == 0 && !"endpoint".equals(step.getStepKind())) { throw new IllegalStateException("No connector found as first step (found: " + step.getKind() + ")"); } final IntegrationStepHandler handler = findHandler(step); final Optional<ProcessorDefinition> definition = handler.handle(step, route, this); if (route == null && definition.isPresent()) { definition.filter(RouteDefinition.class::isInstance) .map(RouteDefinition.class::cast) .map(rd -> rd.getInputs().get(0)) .ifPresent(rd -> { step.getId().ifPresent(rd::id); }); route = definition.get(); deployment.getIntegrationId().ifPresent(route::setId); } else { route = definition.map(rd -> { step.getId().ifPresent(rd::id); return rd; }).orElse(route); } } }
final RuntimeCamelCatalog catalog = builder.getContext().getRuntimeCamelCatalog(); final String uri = catalog.asEndpointUri(componentScheme, Map.class.cast(properties), false); route = builder.from(uri); } else { route = route.to(uri);
@Override public void configure() throws Exception { final Integration integration = loadIntegration(); final List<Flow> flows = integration.getFlows(); for (int f = 0; f < flows.size(); f++) { configureFlow(flows.get(f), String.valueOf(f)); } }
private void loadFragments(Step step) { if (StepKind.extension != step.getStepKind()) { return; } final StepAction action = step.getAction().filter(StepAction.class::isInstance).map(StepAction.class::cast).get(); if (action.getDescriptor().getKind() == StepAction.Kind.ENDPOINT) { final CamelContext context = getContext(); final String resource = action.getDescriptor().getResource(); if (ObjectHelper.isNotEmpty(resource) && resources.add(resource)) { final Object instance = mandatoryLoadResource(context, resource); final RoutesDefinition definitions = mandatoryConvertToRoutesDefinition(resource, instance); LOGGER.debug("Resolved resource: {} as {}", resource, instance.getClass()); try { context.addRouteDefinitions(definitions.getRoutes()); } catch (Exception e) { throw new IllegalStateException(e); } } } }
ProcessorDefinition<?> parent = configureRouteScheduler(flow); if (parent != null) { parent = parent.setHeader(IntegrationLoggingConstants.FLOW_ID, constant(flowId)); final String stepIndex = Integer.toString(i); final String stepId = step.getId().orElseGet(KeyGenerator::createKey); final IntegrationStepHandler handler = findHandler(step); loadFragments(step); if (definition.isPresent()) { parent = definition.get(); parent = configureRouteDefinition(parent, flowName, flowId, stepId); parent = parent.setHeader(IntegrationLoggingConstants.FLOW_ID, constant(flowId)); parent = parent.setHeader(IntegrationLoggingConstants.STEP_ID, constant(stepId)); parent = configureConnectorSplit(step, parent, flowIndex, stepIndex).orElse(parent); parent = parent.process(OutMessageCaptureProcessor.INSTANCE); parent = configureRouteDefinition(parent, flowName, flowId, stepId); if (i > 0) { parent = createPipeline(parent, stepId); Optional<Step> splitStep = getConnectorSplitAsStep(step); if (splitStep.isPresent()) { if (i > 0) { parent = parent.setHeader(IntegrationLoggingConstants.STEP_ID, constant(stepId)); parent = parent.process(new OutMessageCaptureProcessor());
@Test public void testHandlerLookup() { IntegrationRouteBuilder builder = new IntegrationRouteBuilder("", Collections.emptyList()); builder.findHandler( new Step.Builder() .stepKind(StepKind.endpoint) builder.findHandler( new Step.Builder() .stepKind(StepKind.endpoint) builder.findHandler( new Step.Builder() .stepKind(StepKind.endpoint) builder.findHandler( new Step.Builder() .stepKind(StepKind.endpoint) builder.findHandler( new Step.Builder() .stepKind(StepKind.template)
final CamelContext context = builder.getContext(); route.setHeader(entry.getKey(), builder.constant(entry.getValue()));
@Test public void testBuilder() throws Exception { IntegrationRuntimeConfiguration configuration = new IntegrationRuntimeConfiguration(); IntegrationRouteBuilder routeBuilder = new IntegrationRouteBuilder(configuration.getConfigurationLocation(), Collections.emptyList()); // initialize routes routeBuilder.configure(); // Dump routes as XML for troubleshooting dumpRoutes(new DefaultCamelContext(), routeBuilder.getRouteCollection()); RoutesDefinition routes = routeBuilder.getRouteCollection(); assertThat(routes.getRoutes()).hasSize(1); RouteDefinition route = routes.getRoutes().get(0); assertThat(route.getInputs()).hasSize(1); assertThat(route.getInputs().get(0)).hasFieldOrPropertyWithValue("uri", "direct:expression"); assertThat(route.getOutputs()).hasSize(4); assertThat(getOutput(route, 0)).isInstanceOf(SetHeaderDefinition.class); assertThat(getOutput(route, 1)).isInstanceOf(SetHeaderDefinition.class); assertThat(getOutput(route, 2)).isInstanceOf(ProcessDefinition.class); assertThat(getOutput(route, 3)).isInstanceOf(PipelineDefinition.class); assertThat(getOutput(route, 3).getOutputs()).hasSize(2); assertThat(getOutput(route, 3, 0)).isInstanceOf(SetHeaderDefinition.class); assertThat(getOutput(route, 3, 1)).isInstanceOf(SplitDefinition.class); assertThat(getOutput(route, 3, 1).getOutputs()).hasSize(2); assertThat(getOutput(route, 3, 1, 0)).isInstanceOf(ProcessDefinition.class); assertThat(getOutput(route, 3, 1, 1)).isInstanceOf(PipelineDefinition.class); assertThat(getOutput(route, 3, 1, 1).getOutputs()).hasSize(3); assertThat(getOutput(route, 3, 1, 1, 0)).isInstanceOf(SetHeaderDefinition.class); assertThat(getOutput(route, 3, 1, 1, 1)).isInstanceOf(ToDefinition.class); assertThat(getOutput(route, 3, 1, 1, 1)).hasFieldOrPropertyWithValue("uri", "mock:expression"); assertThat(getOutput(route, 3, 1, 1, 2)).isInstanceOf(ProcessDefinition.class); }
protected IntegrationDeployment loadDeployment() throws IOException { final IntegrationDeployment deployment; try (InputStream is = ResourceHelper.resolveResourceAsInputStream(getContext().getClassResolver(), configurationUri)) { if (is != null) { LOGGER.info("Loading integration from: {}", configurationUri); deployment = Json.mapper().readValue(is, IntegrationDeployment.class); } else { throw new IllegalStateException("Unable to load deployment: " + configurationUri); } } return deployment; }
route = builder.from(uri); } else { route = route.to(uri);
private ProcessorDefinition<PipelineDefinition> createPipeline(ProcessorDefinition<?> parent, String stepId) { return parent.pipeline() .id(String.format("step:%s", stepId)) .setHeader(IntegrationLoggingConstants.STEP_ID, constant(stepId)); }
final CamelContext context = builder.getContext(); route.setHeader(entry.getKey(), builder.constant(entry.getValue()));
protected Integration loadIntegration() throws IOException { final Integration integration; try (InputStream is = ResourceHelper.resolveResourceAsInputStream(getContext().getClassResolver(), configurationUri)) { if (is != null) { LOGGER.info("Loading integration from: {}", configurationUri); integration = Json.reader().forType(Integration.class).readValue(is); } else { throw new IllegalStateException("Unable to load deployment: " + configurationUri); } } return integration; }
routes.from("direct:getdata").bean(new Bean3());
final RuntimeCamelCatalog catalog = builder.getContext().getRuntimeCamelCatalog(); final String uri = catalog.asEndpointUri(componentScheme, Map.class.cast(properties), false); route = builder.from(uri); } else { route = route.to(uri);
@Override public void beforeApplicationStart(CamelContext camelContext) { final String location = configuration.getConfigurationLocation(); final List<IntegrationStepHandler> handlers = new ArrayList<>(); // register handlers discovered from application context handlers.addAll(integrationStepHandlers); // register handlers discovered using service loader for (IntegrationStepHandler handler : ServiceLoader.load(IntegrationStepHandler.class, Thread.currentThread().getContextClassLoader())) { handlers.add(handler); } // IntegrationRouteBuilder automatically add known handlers to // the list of provided ones, know handlers have priority final RouteBuilder routeBuilder = new IntegrationRouteBuilder(location, handlers, activityTracker); try { // Register routes to the camel context camelContext.addRoutes(routeBuilder); } catch (@SuppressWarnings("PMD.AvoidCatchingGenericException") Exception e) { throw new IllegalArgumentException(e); } }
@Override public Optional<ProcessorDefinition<?>> handle(Step step, ProcessorDefinition<?> route, IntegrationRouteBuilder builder, String flowIndex, String stepIndex) { ObjectHelper.notNull(route, "route"); final String expression = ObjectHelper.notNull(getFilterExpression(step), "expression"); final CamelContext context = builder.getContext(); final Predicate predicate = new JsonSimplePredicate(expression, context); final FilterDefinition filter = route.filter(predicate); return Optional.of(filter); }
/** * If the integration has a scheduler, start the route with a timer or quartz2 * endpoint. */ private ProcessorDefinition<?> configureRouteScheduler(final Flow flow) throws URISyntaxException { if (flow.getScheduler().isPresent()) { Scheduler scheduler = flow.getScheduler().get(); // We now support simple timer only, cron support will be supported // later on. if (scheduler.isTimer()) { Map<String, String> properties = new HashMap<>(); properties.put("timerName", "integration"); properties.put("period", scheduler.getExpression()); final RuntimeCamelCatalog catalog = getContext().getRuntimeCamelCatalog(); final String uri = catalog.asEndpointUri("timer", properties, false); RouteDefinition route = this.from(uri); route.getInputs().get(0).setId("integration-scheduler"); flow.getId().ifPresent(route::setId); return route; } else { throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getType()); } } return null; }
@Test public void testTokenizeBodyStep() throws Exception { final CamelContext context = new SpringCamelContext(applicationContext); try { final RouteBuilder routes = new IntegrationRouteBuilder( "classpath:/syndesis/integration/SplitStepHandlerJsonTest.json", Collections.emptyList() ); // Set up the camel context context.addRoutes(routes); context.start(); // Dump routes as XML for troubleshooting dumpRoutes(context); final ProducerTemplate template = context.createProducerTemplate(); final MockEndpoint result = context.getEndpoint("mock:expression", MockEndpoint.class); final String[] expected = { "a","b","c" }; final List<String> body = Arrays.asList(expected); result.expectedMessageCount(3); result.expectedBodiesReceived((Object[])expected); template.sendBody("direct:expression", body); result.assertIsSatisfied(); } finally { context.stop(); } }