@Override protected RouteBuilder createSyndesisRouteBuilder() { return new SyndesisRouteBuilder("classpath:/io/syndesis/integration/runtime/steps/FunctionYamlTest-testStep.yml"); } }
@Override public Optional<ProcessorDefinition> handle(Filter step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { CamelContext context = routeBuilder.getContext(); Predicate predicate = JsonSimpleHelpers.getMandatorySimplePredicate(context, step, step.getExpression()); FilterDefinition filter = route.filter(predicate); routeBuilder.addSteps(filter, step.getSteps()); return Optional.empty(); } }
public Optional<ProcessorDefinition> addSteps(ProcessorDefinition route, Iterable<? extends Step> steps) { if (route != null && steps != null) { for (Step item : steps) { route = addStep(route, item).orElse(route); } } return Optional.of(route); }
public void configure() throws Exception { int flowIndex = 0; for (Flow flow : loadModel().getFlows()) { getContext().setStreamCaching(true); getContext().setTracing(true); boolean setId = route == null; route = findHandler(step).handle(step, route, this).orElse(route); if (setId) { route.id(name); route = addStep(route, step).orElse(route); getContext().addRoutePolicyFactory(new SingleMessageRoutePolicyFactory());
@Override public Optional<ProcessorDefinition> handle(Connector step, ProcessorDefinition definition, SyndesisRouteBuilder builder) { try { final CamelContext context = builder.getContext(); final TypeConverter converter = context.getTypeConverter(); final Map<String, Object> options = new HashMap<>(step.getProperties()); definition = builder.from(step.getComponentId()); } else { definition = definition.to(step.getComponentId());
@Override public Optional<ProcessorDefinition> handle(Function step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { final CamelContext context = routeBuilder.getContext(); final TypeConverter converter = context.getTypeConverter();
@Override public Optional<ProcessorDefinition> handle(Endpoint step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { final String uri = buildUri(step); if (!Strings.isEmpty(uri)) { if (route == null) { route = routeBuilder.from(uri); } else { route = route.to(uri); } } return Optional.of(route); }
@Override public Optional<ProcessorDefinition> handle(SetHeaders step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { Map<String, Object> headers = step.getHeaders(); if (headers != null) { for (Map.Entry<String, Object> entry : headers.entrySet()) { route.setHeader(entry.getKey(), routeBuilder.constant(entry.getValue())); } } return Optional.empty(); } }
@SuppressWarnings("unchecked") public <T extends Step> Optional<ProcessorDefinition> addStep(ProcessorDefinition route, T item) { if (route == null) { throw new IllegalArgumentException("You cannot use a " + item.getKind() + " step before you have started a flow"); } return findHandler(item).handle(item, route, this); }
@Override public Optional<ProcessorDefinition> handle(Throttle step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { ThrottleDefinition throttle = route.throttle(step.getMaximumRequests()); Long period = step.getPeriodMillis(); if (period != null) { throttle.timePeriodMillis(period); } return routeBuilder.addSteps(throttle, step.getSteps()); } }
protected SyndesisModel loadModel() throws Exception { try (InputStream is = ResourceHelper.resolveResourceAsInputStream(getContext().getClassResolver(), configurationUri)) { return is == null ? new SyndesisModel() : YamlHelpers.load(is); } }
@Override public Optional<ProcessorDefinition> handle(SetBody step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { return Optional.of(route.setBody(routeBuilder.constant(step.getBody()))); } }
@Override protected RouteBuilder createSyndesisRouteBuilder() { return new SyndesisRouteBuilder("classpath:/io/syndesis/integration/runtime/steps/ExtensionYamlTest-testStep.yml"); } }
@Override public Optional<ProcessorDefinition> handle(Split step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { CamelContext context = routeBuilder.getContext(); Expression expression = JsonSimpleHelpers.getMandatoryExpression(context, step, step.getExpression()); ProcessorDefinition split = route.split(expression).marshal().json(JsonLibrary.Jackson); routeBuilder.addSteps(split, step.getSteps()); return Optional.empty(); } }
@Override public Optional<ProcessorDefinition> handle(SplitInline step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { String languageName = step.getLanguage(); String expressionDefinition = step.getExpression(); if (ObjectHelper.isEmpty(languageName) && ObjectHelper.isEmpty(expressionDefinition)) { return Optional.of(route.split(Builder.body())); } else { Objects.requireNonNull(languageName, "Expression language should not be null"); Objects.requireNonNull(expressionDefinition, "Expression should not be null"); // A small hack until https://issues.apache.org/jira/browse/CAMEL-12079 // gets fixed so we can support the 'bean::method' annotation as done by // Function step definition if ("bean".equals(languageName)) { if (expressionDefinition.contains("::")) { expressionDefinition = expressionDefinition.replace("::", "?method="); } } final CamelContext context = routeBuilder.getContext(); final Language language = context.resolveLanguage(languageName); final Expression expression = language.createExpression(expressionDefinition); final ProcessorDefinition split = route.split(expression); return Optional.of(split); } } }
/** * To automatic add SyndesisRouteBuilder which loads the syndesis.yml file */ @Bean @ConditionalOnMissingBean public SyndesisRouteBuilder syndesisRouteBuilder() throws IOException { return new SyndesisRouteBuilder(configuration.getConfiguration()); } }
@Override public Optional<ProcessorDefinition> handle(Choice step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { final CamelContext context = routeBuilder.getContext(); final ChoiceDefinition choice = route.choice(); List<Filter> filters = ObjectHelper.supplyIfEmpty(step.getFilters(), Collections::<Filter>emptyList); for (Filter filter : filters) { Predicate predicate = JsonSimpleHelpers.getMandatorySimplePredicate(context, filter, filter.getExpression()); ChoiceDefinition when = choice.when(predicate); routeBuilder.addSteps(when, filter.getSteps()); } Otherwise otherwiseStep = step.getOtherwise(); if (otherwiseStep != null) { List<Step> otherwiseSteps = ObjectHelper.supplyIfEmpty(otherwiseStep.getSteps(), Collections::<Step>emptyList); if (!otherwiseSteps.isEmpty()) { routeBuilder.addSteps(choice.otherwise(), otherwiseSteps); } } return Optional.empty(); } }
@Override public Optional<ProcessorDefinition> handle(Extension step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { final CamelContext context = routeBuilder.getContext(); final TypeConverter converter = context.getTypeConverter(); final String target = step.getName(); if (!Strings.isEmpty(target)) { try { final Class<SyndesisStepExtension> clazz = context.getClassResolver().resolveMandatoryClass(target, SyndesisStepExtension.class); final SyndesisStepExtension stepExtension = context.getInjector().newInstance(clazz); final Map<String, Object> props = new HashMap<>(step.getProperties()); try { IntrospectionSupport.setProperties(context, converter, stepExtension, props); } catch (Exception e) { throw new IllegalStateException(e); } return stepExtension.configure(context, route, props); } catch (ClassNotFoundException e) { throw new IllegalStateException(e); } } return Optional.of(route); } }
@Override protected RoutesBuilder createRouteBuilder() throws Exception { final String path = getClass().getSimpleName() + ".yaml"; final RoutesBuilder builder = new SyndesisRouteBuilder("classpath:" + path); return builder; }
@Override protected RoutesBuilder createRouteBuilder() throws Exception { final String path = getClass().getSimpleName() + ".yaml"; final RoutesBuilder builder = new SyndesisRouteBuilder("classpath:" + path); return builder; }