private void copyEdges(InputComponent inputComponent) { List<Edge> edgesTo = originTopologyDag.getEdgesTo(inputComponent); edgesTo.forEach(e -> { OutputComponent from = e.getFrom(); InputComponent to = e.getTo(); Edge newEdge = new Edge(e.getId(), e.getFrom(), e.getTo(), e.getStreamGroupings()); StreamlineSource replacedSource = sourceToReplacedTestSourceMap.get(from.getName()); StreamlineProcessor replacedProcessorSource = processorToReplacedTestProcessorMap.get(from.getName()); StreamlineSink replacedSink = sinkToReplacedTestSinkMap.get(to.getName()); StreamlineProcessor replacedProcessorSink = processorToReplacedTestProcessorMap.get(to.getName()); if (replacedSource != null) { newEdge.setFrom(replacedSource); } else if (replacedProcessorSource != null) { newEdge.setFrom(replacedProcessorSource); } if (replacedSink != null) { newEdge.setTo(replacedSink); } else if (replacedProcessorSink != null) { newEdge.setTo(replacedProcessorSink); } testTopologyDag.addEdge(newEdge); }); }
public void addEdge(Edge edge) { for (StreamGrouping streamGrouping : edge.getStreamGroupings()) { addEdge(edge.getId(), edge.getFrom(), edge.getTo(), streamGrouping); } }
private void doAddEdge(String id, OutputComponent from, InputComponent to, StreamGrouping streamGrouping) { List<Edge> edges = dag.get(from); if (edges == null) { edges = new ArrayList<>(); dag.put(from, edges); } // output component is already connected to input component, just add the stream grouping for (Edge e : edges) { if (e.getTo().equals(to)) { e.addStreamGrouping(streamGrouping); return; } } edges.add(new Edge(id, from, to, streamGrouping)); }
public void removeEdge(OutputComponent from, InputComponent to, String streamId, Stream.Grouping grouping) { Iterator<Edge> it = dag.get(from).iterator(); while (it.hasNext()) { Edge e = it.next(); if (e.getTo().equals(to)) { e.removeStreamGrouping(new StreamGrouping(from.getOutputStream(streamId), grouping)); if(e.getStreamGroupings().isEmpty()) { it.remove(); } break; } } }
@Override public void visit(Edge edge) { if (sourceYamlComponentExists(edge) && !edgeAlreadyAddedComponents.contains(getFluxId(edge.getFrom()))) { for (StreamGrouping streamGrouping : edge.getStreamGroupings()) { addEdge(edge.getFrom(), edge.getTo(), streamGrouping.getStream().getId(), streamGrouping.getGrouping(), streamGrouping.getFields()); } } }
public Edge getStreamlineEdge(TopologyEdge topologyEdge) { Edge edge = new Edge(); edge.setId(topologyEdge.getId().toString()); edge.setFrom(getOutputComponent(topologyEdge)); edge.setTo(getInputComponent(topologyEdge)); Set<StreamGrouping> streamGroupings = new HashSet<>(); for (TopologyEdge.StreamGrouping streamGrouping : topologyEdge.getStreamGroupings()) { Stream stream = getStream(catalogService.getStreamInfo(topologyEdge.getTopologyId(), streamGrouping.getStreamId(), topologyEdge.getVersionId())); Stream.Grouping grouping = Stream.Grouping.valueOf(streamGrouping.getGrouping().name()); streamGroupings.add(new StreamGrouping(stream, grouping, streamGrouping.getFields())); } edge.addStreamGroupings(streamGroupings); return edge; }
public List<Edge> getEdgesTo(Component component) { List<Edge> result = new ArrayList<>(); for (List<Edge> edges : dag.values()) { for (Edge edge : edges) { if (edge.getTo().equals(component)) { result.add(edge); } } } return result; }
private boolean sourceYamlComponentExists(Edge edge) { for (Map.Entry<String, Map<String, Object>> entry : keysAndComponents) { String id = (String) entry.getValue().get(YAML_KEY_ID); if (getFluxId(edge.getFrom()).equals(id)) { return true; } } return false; }
Set<String> inStreams = topologyDag.getEdgesTo(rulesProcessor) .stream() .flatMap(e -> e.getStreamGroupings() .stream() .map(sg -> sg.getStream().getId()))
public void visit(Edge edge) { TopologyEdge topologyEdge = streamCatalogService.getTopologyEdge(topologyId, Long.parseLong(edge.getId())); topologyData.addEdge(topologyEdge); }
public void ensureValid(TopologyDag dag) { if (dag.getComponents().isEmpty()) { throw new IllegalStateException("Empty topology"); } java.util.Optional<OutputComponent> processor = dag.getOutputComponents().stream() .filter(x -> x instanceof StreamlineProcessor) .findFirst(); if (!processor.isPresent()) { java.util.Optional<OutputComponent> sourceWithOutgoingEdge = dag.getOutputComponents().stream() .filter(x -> x instanceof StreamlineSource && !dag.getEdgesFrom(x).isEmpty()) .findFirst(); if (!sourceWithOutgoingEdge.isPresent()) { throw new IllegalStateException("Topology does not contain a processor or a source with an outgoing edge"); } } Optional<Edge> edge = dag.getAllEdges().stream() .filter(e -> e.getStreamGroupings().stream().anyMatch(g -> !g.isValid())) .findFirst(); if (edge.isPresent()) { throw new IllegalStateException("Topology edge between " + edge.get().getFrom().getName() + " and " + edge.get().getTo().getName() + " has invalid stream grouping."); } }
/** * Returns all the components adjacent to the given component. * * @param component the component * @return List of all adjacent components */ public List<Component> adjacent(Component component) { List<Component> adj = new ArrayList<>(); List<Edge> edges = dag.get(component); if (edges != null) { for(Edge edge: edges) { adj.add(edge.getTo()); } } return adj; }
private void wireWindowedRulesProcessor(RulesProcessor windowedRulesProcessor, List<Edge> inEdges, List<Edge> outEdges) { for (Edge edge : inEdges) { for (StreamGrouping streamGrouping : edge.getStreamGroupings()) { addEdge(edge.getFrom(), windowedRulesProcessor, streamGrouping.getStream().getId(), streamGrouping.getGrouping(), streamGrouping.getFields()); } } for (Edge edge : outEdges) { for (StreamGrouping streamGrouping : edge.getStreamGroupings()) { addEdge(windowedRulesProcessor, edge.getTo(), streamGrouping.getStream().getId(), streamGrouping.getGrouping(), streamGrouping.getFields()); } } }
public void removeEdge(OutputComponent from, InputComponent to) { ensureValid(from, to); Iterator<Edge> it = dag.get(from).iterator(); while (it.hasNext()) { if (it.next().getTo().equals(to)) { it.remove(); } } }