@Override public boolean canHandle(Step step) { if (!"endpoint".equals(step.getStepKind()) && !"connector".equals(step.getStepKind())) { return false; } if (step.getConnection().isPresent()) { return false; } if (!step.getAction().filter(ConnectorAction.class::isInstance).isPresent()) { return false; } ConnectorAction action = step.getAction().filter(ConnectorAction.class::isInstance).map(ConnectorAction.class::cast).get(); if (action.getDescriptor() == null) { return false; } return action.getDescriptor().getComponentScheme().isPresent(); }
public List<? extends Step> encrypt(List<? extends Step> steps) { return steps.stream().map(x->{ if( x instanceof SimpleStep && x.getAction().isPresent() ) { Map<String, String> configuredProperties = encryptPropertyValues(x.getConfiguredProperties(), x.getAction().get().getProperties()); return new SimpleStep.Builder() .createFrom(x) .configuredProperties(configuredProperties) .build(); } else { return x; } }).collect(Collectors.toList()); }
public Optional<String> getId() { return step.getId(); }
@Override public boolean canHandle(Step step) { if (!"extension".equals(step.getStepKind())) { return false; } return step.getAction().filter(StepAction.class::isInstance).isPresent(); }
@Override public Collection<io.syndesis.integration.model.steps.Step> visit(StepVisitorContext stepContext) { try { Step step = stepContext.getStep(); Map<String, Object> stepMap = new HashMap<>(step.getConfiguredProperties()); stepMap.put("kind", step.getStepKind()); String json = OBJECT_MAPPER.writeValueAsString(stepMap); return Collections.singletonList( OBJECT_MAPPER.readValue(json, io.syndesis.integration.model.steps.Step.class) ); } catch (IOException e) { throw SyndesisServerException.launderThrowable(e); } } }
step.getAction() .filter(WithDependencies.class::isInstance) .map(WithDependencies.class::cast) .ifPresent(dependencies::addAll); List<Dependency> connectorDependecies = step.getConnection() .flatMap(Connection::getConnector) .map(WithDependencies::getDependencies) dependencies.addAll(connectorDependecies); List<Dependency> lookedUpConnectorDependecies = step.getConnection() .filter(c -> !c.getConnector().isPresent()) .flatMap(Connection::getConnectorId) step.getExtension() .map(WithDependencies::getDependencies) .ifPresent(dependencies::addAll); step.getExtension() .map(Extension::getExtensionId) .map(Dependency::extension)
public Optional<ProcessorDefinition> handle(Step step, ProcessorDefinition route, IntegrationRouteBuilder builder) { final Connection connection = step.getConnection().get(); final Connector connector = connection.getConnector().get(); final ConnectorAction action = step.getAction().filter(ConnectorAction.class::isInstance).map(ConnectorAction.class::cast).get(); final ConnectorDescriptor descriptor = action.getDescriptor(); final String index = step.getMetadata(Step.METADATA_STEP_INDEX).orElseThrow(() -> new IllegalArgumentException("Missing index for step:" + step)); final String componentScheme = action.getDescriptor().getCamelConnectorPrefix(); final Map<String, String> configuredProperties = CollectionsUtils.aggregate(connection.getConfiguredProperties(), step.getConfiguredProperties()); final Map<String, String> properties = CollectionsUtils.aggregate(connector.filterEndpointProperties(configuredProperties), action.filterEndpointProperties(configuredProperties));
.filter(step -> step.getStepKind().equals("endpoint")) .filter(step -> step.getAction().filter(ConnectorAction.class::isInstance).isPresent()) .filter(step -> step.getConnection().isPresent()) .forEach(step -> { final String index = step.getMetadata(Step.METADATA_STEP_INDEX).orElseThrow(() -> new IllegalArgumentException("Missing index for step:" + step)); final Connection connection = step.getConnection().get(); final ConnectorAction action = ConnectorAction.class.cast(step.getAction().get()); final ConnectorDescriptor descriptor = action.getDescriptor(); final Connector connector = resolveConnector(connection, dataManager);
@Override public Collection<io.syndesis.integration.model.steps.Step> visit(StepVisitorContext visitorContext) { final List<io.syndesis.integration.model.steps.Step> steps = new ArrayList<>(); final Step step = visitorContext.getStep(); final Connection connection = step.getConnection().orElseThrow(() -> new IllegalArgumentException("Missing connection for step:" + step)); final Connector connector = resolveConnector(connection, visitorContext.getGeneratorContext().getDataManager()); final ConnectorAction action = step.getAction() .filter(ConnectorAction.class::isInstance) .map(ConnectorAction.class::cast) .orElseThrow(() -> new IllegalArgumentException("Missing action for step:" + step)); if (Optionals.first(action.getDescriptor().getComponentScheme(), connector.getComponentScheme()).isPresent()) { // Connector steps.add(createConnector(visitorContext, step, connection, connector, action)); } else { // Endpoint steps.add(createEndpoint(visitorContext, step, connection, connector, action)); } // Add an inline splitter if defined action.getDescriptor().getSplit() .map(this::createSplitter) .ifPresent(steps::add); return steps; }
public Optional<ProcessorDefinition> handle(Step step, ProcessorDefinition route, IntegrationRouteBuilder builder) { final ConnectorAction action = step.getAction().filter(ConnectorAction.class::isInstance).map(ConnectorAction.class::cast).get(); final ConnectorDescriptor descriptor = action.getDescriptor(); final String index = step.getMetadata(Step.METADATA_STEP_INDEX).orElseThrow(() -> new IllegalArgumentException("Missing index for step:" + step)); final String componentScheme = action.getDescriptor().getComponentScheme().get(); final Map<String, String> configuredProperties = step.getConfiguredProperties(); final Map<String, String> properties = action.filterEndpointProperties(configuredProperties);
private void addToExport(JsonDB export, Integration integration) { addModelToExport(export, integration); for (Step step : integration.getSteps()) { Optional<Connection> c = step.getConnection(); if (c.isPresent()) { Connection connection = c.get(); addModelToExport(export, connection); Connector connector = integrationHandler.getDataManager().fetch(Connector.class, connection.getConnectorId().get()); if (connector != null) { addModelToExport(export, connector); } } Optional<Extension> e = step.getExtension(); if (e.isPresent()) { Extension extension = e.get(); addModelToExport(export, extension); } } }
public StepKind getStepKind() { return step.getStepKind(); }
final Step target; if (ExpressionFilterStep.STEP_KIND.equals(source.getStepKind())) { target = new ExpressionFilterStep.Builder() .createFrom(source) .putMetadata(Step.METADATA_STEP_INDEX, Integer.toString(i)) .build(); } else if (RuleFilterStep.STEP_KIND.equals(source.getStepKind())) { target = new RuleFilterStep.Builder() .createFrom(source) stepBuilder.putMetadata(Step.METADATA_STEP_INDEX, Integer.toString(i)); source.getConnection().ifPresent(connection -> {
public Optional<WithNameOverview> getAction() { return step.getAction().map(x -> new WithNameOverview(x)); } }
@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); } } }
public Optional<ConnectionOverview> getConnection() { return step.getConnection().map(x -> new ConnectionOverview(x)); }
@Override public Collection<io.syndesis.integration.model.steps.Step> visit(StepVisitorContext stepContext) { Map<String, String> configuredProperties = stepContext.getStep().getConfiguredProperties(); String resourceName = "mapping-step-" + stepContext.getIndex() + ".json"; try { byte[] resourceData = utf8(configuredProperties.get("atlasmapping")); stepContext.getGeneratorContext().addTarEntry("src/main/resources/" + resourceName, resourceData); return Collections.singletonList(new Endpoint("atlas:" + resourceName)); } catch (IOException e) { throw new IllegalStateException("Cannot write " + resourceName + ":" + e,e); } }
public Kind getKind() { return step.getKind(); }
@Override public Optional<ProcessorDefinition> handle(Step step, ProcessorDefinition route, IntegrationRouteBuilder builder) { ObjectHelper.notNull(route, "route"); final String index = step.getMetadata(Step.METADATA_STEP_INDEX).orElseThrow(() -> new IllegalArgumentException("Missing index for step:" + step)); return Optional.of( route.toF("atlas:mapping-step-%s.json", index) ); } }
step.getAction() .filter(WithDependencies.class::isInstance) .map(WithDependencies.class::cast) .ifPresent(dependencies::addAll); step.getConnection() .filter(c -> c.getConnector().isPresent()) .map(c -> c.getConnector().get()) .ifPresent(dependencies::addAll); step.getConnection() .filter(c -> Objects.nonNull(dataManager)) .filter(c -> !c.getConnector().isPresent()) .ifPresent(dependencies::addAll); step.getExtension() .map(WithDependencies::getDependencies) .ifPresent(dependencies::addAll); step.getExtension() .map(Extension::getExtensionId) .map(Dependency::extension)