@Override public String toString() { return "ConnectionDTO [id: " + getId() + "]"; } }
@Override public void verifyUpdate(ConnectionDTO connectionDTO) { verifyUpdate(locateConnection(connectionDTO.getId()), connectionDTO); }
private void mergeConnectionDiagnostics(final ProcessorDiagnosticsEntity clientEntity, final Map<NodeIdentifier, ProcessorDiagnosticsEntity> entityMap, final Function<ProcessorDiagnosticsEntity, Set<ConnectionDiagnosticsDTO>> extractConnections) { final Map<String, List<ConnectionDiagnosticsSnapshotDTO>> snapshotByConnectionId = new HashMap<>(); final Map<String, ConnectionDiagnosticsDTO> connectionById = new HashMap<>(); for (final Map.Entry<NodeIdentifier, ProcessorDiagnosticsEntity> entry : entityMap.entrySet()) { final NodeIdentifier nodeId = entry.getKey(); final ProcessorDiagnosticsEntity entity = entry.getValue(); final Set<ConnectionDiagnosticsDTO> connections = extractConnections.apply(entity); for (final ConnectionDiagnosticsDTO connectionDiagnostics : connections) { final String connectionId = connectionDiagnostics.getConnection().getId(); final ConnectionDiagnosticsSnapshotDTO snapshot = connectionDiagnostics.getAggregateSnapshot(); snapshot.setNodeIdentifier(nodeId.getApiAddress() + ":" + nodeId.getApiPort()); final List<ConnectionDiagnosticsSnapshotDTO> snapshots = snapshotByConnectionId.computeIfAbsent(connectionId, id -> new ArrayList<>()); snapshots.add(snapshot); if (entity == clientEntity){ connectionById.put(connectionId, connectionDiagnostics); } } } for (final Map.Entry<String, List<ConnectionDiagnosticsSnapshotDTO>> entry : snapshotByConnectionId.entrySet()) { final String connectionId = entry.getKey(); final List<ConnectionDiagnosticsSnapshotDTO> snapshots = entry.getValue(); final ConnectionDiagnosticsDTO dto = connectionById.get(connectionId); dto.setNodeSnapshots(snapshots); dto.setAggregateSnapshot(mergeConnectionSnapshots(snapshots)); } }
@Override public void verifyUpdateConnection(final ConnectionDTO connectionDTO) { // if connection does not exist, then the update request is likely creating it // so we don't verify since it will fail if (connectionDAO.hasConnection(connectionDTO.getId())) { connectionDAO.verifyUpdate(connectionDTO); } else { connectionDAO.verifyCreate(connectionDTO.getParentGroupId(), connectionDTO); } }
.forEach(id -> identifiers.add(id)); snippet.getConnections().stream() .map(conn -> conn.getId()) .forEach(id -> identifiers.add(id)); snippet.getInputPorts().stream()
@Override public ConnectionEntity createConnection(final Revision revision, final String groupId, final ConnectionDTO connectionDTO) { final RevisionUpdate<ConnectionDTO> snapshot = createComponent( revision, connectionDTO, () -> connectionDAO.createConnection(groupId, connectionDTO), connection -> dtoFactory.createConnectionDto(connection)); final Connection connection = connectionDAO.getConnection(connectionDTO.getId()); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(connection); final ConnectionStatusDTO status = dtoFactory.createConnectionStatusDto(controllerFacade.getConnectionStatus(connectionDTO.getId())); return entityFactory.createConnectionEntity(snapshot.getComponent(), dtoFactory.createRevisionDTO(snapshot.getLastModification()), permissions, status); }
public Connection updateConnectionAdvice(ProceedingJoinPoint proceedingJoinPoint, ConnectionDTO connectionDTO, ConnectionDAO connectionDAO) throws Throwable { Connection connection = connectionDAO.getConnection(connectionDTO.getId()); Connectable previousDestination = connection.getDestination(); Collection<Relationship> previousRelationships = connection.getRelationships();
final String connectionId = connectionDiagnostics.getConnection().getId(); return authorizableLookup.getConnection(connectionId).getAuthorizable().isAuthorized(authorizer, RequestAction.READ, user); };
@Override public Connection updateConnection(final ConnectionDTO connectionDTO) { final Connection connection = locateConnection(connectionDTO.getId()); final ProcessGroup group = connection.getProcessGroup(); throw new IllegalStateException("Connection with ID " + connectionDTO.getId() + " has conflicting Source ID");
@Override public ConnectionEntity updateConnection(final Revision revision, final ConnectionDTO connectionDTO) { final Connection connectionNode = connectionDAO.getConnection(connectionDTO.getId()); final RevisionUpdate<ConnectionDTO> snapshot = updateComponent( revision, connectionNode, () -> connectionDAO.updateConnection(connectionDTO), connection -> dtoFactory.createConnectionDto(connection)); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(connectionNode); final ConnectionStatusDTO status = dtoFactory.createConnectionStatusDto(controllerFacade.getConnectionStatus(connectionNode.getIdentifier())); return entityFactory.createConnectionEntity(snapshot.getComponent(), dtoFactory.createRevisionDTO(snapshot.getLastModification()), permissions, status); }
if (requestConnectionEntity.getComponent().getId() != null) { throw new IllegalArgumentException("Connection ID cannot be specified."); final Revision revision = getRevision(connectionEntity, connection.getId()); final ConnectionEntity entity = serviceFacade.createConnection(revision, groupId, connection); connectionResource.populateRemainingConnectionEntityContent(entity);
final Connection connection = group.getConnection(snippetConnection.getId());
final FlowChangeAction action = generateAuditRecord(connection.getId(), name, Component.Connection, Operation.Connect, timestamp); action.setActionDetails(connectDetails); actions.add(action);
final Connection connection = flowController.createConnection(connectionDTO.getId(), connectionDTO.getName(), source, destination, relationships);
cp.setId(generateId(connectionDTO.getId(), idGenerationSeed, isCopy)); cp.setSource(source); cp.setDestination(destination);
public ConnectionEntity createConnectionEntity(final ConnectionDTO dto, final RevisionDTO revision, final PermissionsDTO permissions, final ConnectionStatusDTO status) { final ConnectionEntity entity = new ConnectionEntity(); entity.setRevision(revision); if (dto != null) { entity.setPermissions(permissions); entity.setStatus(status); entity.setId(dto.getId()); entity.setPosition(dto.getPosition()); entity.setBends(dto.getBends()); entity.setLabelIndex(dto.getLabelIndex()); entity.setzIndex(dto.getzIndex()); entity.setSourceId(dto.getSource().getId()); entity.setSourceGroupId(dto.getSource().getGroupId()); entity.setSourceType(dto.getSource().getType()); entity.setDestinationId(dto.getDestination().getId()); entity.setDestinationGroupId(dto.getDestination().getGroupId()); entity.setDestinationType(dto.getDestination().getType()); if (permissions != null && permissions.getCanRead()) { entity.setComponent(dto); } } return entity; }
final ConnectionDTO dto = FlowFromDOMFactory.getConnection(connectionElement); final Connection connection = processGroup.getConnection(dto.getId()); connection.setName(dto.getName()); connection.setProcessGroup(processGroup);
public ConnectionDTO copy(final ConnectionDTO original) { final ConnectionDTO copy = new ConnectionDTO(); copy.setAvailableRelationships(copy(original.getAvailableRelationships())); copy.setDestination(original.getDestination()); copy.setPosition(original.getPosition()); copy.setId(original.getId()); copy.setName(original.getName()); copy.setParentGroupId(original.getParentGroupId()); copy.setSelectedRelationships(copy(original.getSelectedRelationships())); copy.setFlowFileExpiration(original.getFlowFileExpiration()); copy.setBackPressureObjectThreshold(original.getBackPressureObjectThreshold()); copy.setBackPressureDataSizeThreshold(original.getBackPressureDataSizeThreshold()); copy.setPrioritizers(copy(original.getPrioritizers())); copy.setSource(original.getSource()); copy.setzIndex(original.getzIndex()); copy.setLabelIndex(original.getLabelIndex()); copy.setBends(copy(original.getBends())); copy.setLoadBalancePartitionAttribute(original.getLoadBalancePartitionAttribute()); copy.setLoadBalanceStrategy(original.getLoadBalanceStrategy()); copy.setLoadBalanceCompression(original.getLoadBalanceCompression()); copy.setLoadBalanceStatus(original.getLoadBalanceStatus()); copy.setVersionedComponentId(original.getVersionedComponentId()); return copy; }
final Connection connection = flowManager.createConnection(connectionDTO.getId(), connectionDTO.getName(), source, destination, relationships); if (!topLevel) { connection.setVersionedComponentId(connectionDTO.getVersionedComponentId());