Examples with Port org.apache.nifi.connectable.Port used on opensource projects

Example 31 with Port

use of org.apache.nifi.connectable.Port in project nifi by apache.

the class StandardProcessGroup method addInputPort.

private Port addInputPort(final ProcessGroup destination, final VersionedPort proposed, final String componentIdSeed) {
    final Port port = flowController.createLocalInputPort(generateUuid(proposed.getIdentifier(), destination.getIdentifier(), componentIdSeed), proposed.getName());
    port.setVersionedComponentId(proposed.getIdentifier());
    destination.addInputPort(port);
    updatePort(port, proposed);
    return port;
}

Example 32 with Port

use of org.apache.nifi.connectable.Port in project nifi by apache.

the class StandardProcessGroup method verifyCanDelete.

@Override
public void verifyCanDelete(final Snippet snippet) throws IllegalStateException {
    readLock.lock();
    try {
        if (!id.equals(snippet.getParentGroupId())) {
            throw new IllegalStateException("Snippet belongs to ProcessGroup with ID " + snippet.getParentGroupId() + " but this ProcessGroup has id " + id);
        }
        if (!isDisconnected(snippet)) {
            throw new IllegalStateException("One or more components within the snippet is connected to a component outside of the snippet. Only a disconnected snippet may be moved.");
        }
        for (final String id : snippet.getConnections().keySet()) {
            final Connection connection = getConnection(id);
            if (connection == null) {
                throw new IllegalStateException("Snippet references Connection with ID " + id + ", which does not exist in this ProcessGroup");
            }
            connection.verifyCanDelete();
        }
        for (final String id : snippet.getFunnels().keySet()) {
            final Funnel funnel = getFunnel(id);
            if (funnel == null) {
                throw new IllegalStateException("Snippet references Funnel with ID " + id + ", which does not exist in this ProcessGroup");
            }
            funnel.verifyCanDelete(true);
        }
        for (final String id : snippet.getInputPorts().keySet()) {
            final Port port = getInputPort(id);
            if (port == null) {
                throw new IllegalStateException("Snippet references Input Port with ID " + id + ", which does not exist in this ProcessGroup");
            }
            port.verifyCanDelete(true);
        }
        for (final String id : snippet.getLabels().keySet()) {
            final Label label = getLabel(id);
            if (label == null) {
                throw new IllegalStateException("Snippet references Label with ID " + id + ", which does not exist in this ProcessGroup");
            }
        }
        for (final String id : snippet.getOutputPorts().keySet()) {
            final Port port = getOutputPort(id);
            if (port == null) {
                throw new IllegalStateException("Snippet references Output Port with ID " + id + ", which does not exist in this ProcessGroup");
            }
            port.verifyCanDelete(true);
        }
        for (final String id : snippet.getProcessGroups().keySet()) {
            final ProcessGroup group = getProcessGroup(id);
            if (group == null) {
                throw new IllegalStateException("Snippet references Process Group with ID " + id + ", which does not exist in this ProcessGroup");
            }
            group.verifyCanDelete(true);
        }
        for (final String id : snippet.getProcessors().keySet()) {
            final ProcessorNode processor = getProcessor(id);
            if (processor == null) {
                throw new IllegalStateException("Snippet references Processor with ID " + id + ", which does not exist in this ProcessGroup");
            }
            processor.verifyCanDelete(true);
        }
        for (final String id : snippet.getRemoteProcessGroups().keySet()) {
            final RemoteProcessGroup group = getRemoteProcessGroup(id);
            if (group == null) {
                throw new IllegalStateException("Snippet references Remote Process Group with ID " + id + ", which does not exist in this ProcessGroup");
            }
            group.verifyCanDelete(true);
        }
    } finally {
        readLock.unlock();
    }
}

Example 33 with Port

use of org.apache.nifi.connectable.Port in project nifi by apache.

the class StandardProcessGroup method verifyCanUpdate.

@Override
public void verifyCanUpdate(final VersionedFlowSnapshot updatedFlow, final boolean verifyConnectionRemoval, final boolean verifyNotDirty) {
    readLock.lock();
    try {
        final VersionControlInformation versionControlInfo = getVersionControlInformation();
        if (versionControlInfo != null) {
            if (!versionControlInfo.getFlowIdentifier().equals(updatedFlow.getSnapshotMetadata().getFlowIdentifier())) {
                throw new IllegalStateException(this + " is under version control but the given flow does not match the flow that this Process Group is synchronized with");
            }
            if (verifyNotDirty) {
                final VersionedFlowState flowState = versionControlInfo.getStatus().getState();
                final boolean modified = flowState == VersionedFlowState.LOCALLY_MODIFIED || flowState == VersionedFlowState.LOCALLY_MODIFIED_AND_STALE;
                final Set<FlowDifference> modifications = getModifications();
                if (modified) {
                    final String changes = modifications.stream().map(FlowDifference::toString).collect(Collectors.joining("\n"));
                    LOG.error("Cannot change the Version of the flow for {} because the Process Group has been modified ({} modifications) " + "since it was last synchronized with the Flow Registry. The following differences were found:\n{}", this, modifications.size(), changes);
                    throw new IllegalStateException("Cannot change the Version of the flow for " + this + " because the Process Group has been modified (" + modifications.size() + " modifications) since it was last synchronized with the Flow Registry. The Process Group must be" + " reverted to its original form before changing the version.");
                }
            }
            verifyNoDescendantsWithLocalModifications("be updated");
        }
        final VersionedProcessGroup flowContents = updatedFlow.getFlowContents();
        if (verifyConnectionRemoval) {
            // Determine which Connections have been removed.
            final Map<String, Connection> removedConnectionByVersionedId = new HashMap<>();
            // Populate the 'removedConnectionByVersionId' map with all Connections. We key off of the connection's VersionedComponentID
            // if it is populated. Otherwise, we key off of its actual ID. We do this because it allows us to then remove from this Map
            // any connection that does exist in the proposed flow. This results in us having a Map whose values are those Connections
            // that were removed. We can then check for any connections that have data in them. If any Connection is to be removed but
            // has data, then we should throw an IllegalStateException.
            findAllConnections().stream().forEach(conn -> removedConnectionByVersionedId.put(conn.getVersionedComponentId().orElse(conn.getIdentifier()), conn));
            final Set<String> proposedFlowConnectionIds = new HashSet<>();
            findAllConnectionIds(flowContents, proposedFlowConnectionIds);
            for (final String proposedConnectionId : proposedFlowConnectionIds) {
                removedConnectionByVersionedId.remove(proposedConnectionId);
            }
            // If any connection that was removed has data in it, throw an IllegalStateException
            for (final Connection connection : removedConnectionByVersionedId.values()) {
                final FlowFileQueue flowFileQueue = connection.getFlowFileQueue();
                if (!flowFileQueue.isEmpty()) {
                    throw new IllegalStateException(this + " cannot be updated to the proposed version of the flow because the " + "proposed version does not contain " + connection + " and the connection currently has data in the queue.");
                }
            }
        }
        // Determine which input ports were removed from this process group
        final Map<String, Port> removedInputPortsByVersionId = new HashMap<>();
        getInputPorts().stream().filter(port -> port.getVersionedComponentId().isPresent()).forEach(port -> removedInputPortsByVersionId.put(port.getVersionedComponentId().get(), port));
        flowContents.getInputPorts().stream().map(VersionedPort::getIdentifier).forEach(id -> removedInputPortsByVersionId.remove(id));
        // Ensure that there are no incoming connections for any Input Port that was removed.
        for (final Port inputPort : removedInputPortsByVersionId.values()) {
            final List<Connection> incomingConnections = inputPort.getIncomingConnections();
            if (!incomingConnections.isEmpty()) {
                throw new IllegalStateException(this + " cannot be updated to the proposed version of the flow because the proposed version does not contain the Input Port " + inputPort + " and the Input Port currently has an incoming connections");
            }
        }
        // Determine which output ports were removed from this process group
        final Map<String, Port> removedOutputPortsByVersionId = new HashMap<>();
        getOutputPorts().stream().filter(port -> port.getVersionedComponentId().isPresent()).forEach(port -> removedOutputPortsByVersionId.put(port.getVersionedComponentId().get(), port));
        flowContents.getOutputPorts().stream().map(VersionedPort::getIdentifier).forEach(id -> removedOutputPortsByVersionId.remove(id));
        // Ensure that there are no outgoing connections for any Output Port that was removed.
        for (final Port outputPort : removedOutputPortsByVersionId.values()) {
            final Set<Connection> outgoingConnections = outputPort.getConnections();
            if (!outgoingConnections.isEmpty()) {
                throw new IllegalStateException(this + " cannot be updated to the proposed version of the flow because the proposed version does not contain the Output Port " + outputPort + " and the Output Port currently has an outgoing connections");
            }
        }
        // Find any Process Groups that may have been deleted. If we find any Process Group that was deleted, and that Process Group
        // has Templates, then we fail because the Templates have to be removed first.
        final Map<String, VersionedProcessGroup> proposedProcessGroups = new HashMap<>();
        findAllProcessGroups(updatedFlow.getFlowContents(), proposedProcessGroups);
        for (final ProcessGroup childGroup : findAllProcessGroups()) {
            if (childGroup.getTemplates().isEmpty()) {
                continue;
            }
            final Optional<String> versionedIdOption = childGroup.getVersionedComponentId();
            if (!versionedIdOption.isPresent()) {
                continue;
            }
            final String versionedId = versionedIdOption.get();
            if (!proposedProcessGroups.containsKey(versionedId)) {
                // Process Group was removed.
                throw new IllegalStateException(this + " cannot be updated to the proposed version of the flow because the child " + childGroup + " that exists locally has one or more Templates, and the proposed flow does not contain these templates. " + "A Process Group cannot be deleted while it contains Templates. Please remove the Templates before attempting to change the version of the flow.");
            }
        }
        // Ensure that all Processors are instantiate-able.
        final Map<String, VersionedProcessor> proposedProcessors = new HashMap<>();
        findAllProcessors(updatedFlow.getFlowContents(), proposedProcessors);
        findAllProcessors().stream().filter(proc -> proc.getVersionedComponentId().isPresent()).forEach(proc -> proposedProcessors.remove(proc.getVersionedComponentId().get()));
        for (final VersionedProcessor processorToAdd : proposedProcessors.values()) {
            final BundleCoordinate coordinate = toCoordinate(processorToAdd.getBundle());
            try {
                flowController.createProcessor(processorToAdd.getType(), UUID.randomUUID().toString(), coordinate, false);
            } catch (Exception e) {
                throw new IllegalArgumentException("Unable to create Processor of type " + processorToAdd.getType(), e);
            }
        }
        // Ensure that all Controller Services are instantiate-able.
        final Map<String, VersionedControllerService> proposedServices = new HashMap<>();
        findAllControllerServices(updatedFlow.getFlowContents(), proposedServices);
        findAllControllerServices().stream().filter(service -> service.getVersionedComponentId().isPresent()).forEach(service -> proposedServices.remove(service.getVersionedComponentId().get()));
        for (final VersionedControllerService serviceToAdd : proposedServices.values()) {
            final BundleCoordinate coordinate = toCoordinate(serviceToAdd.getBundle());
            try {
                flowController.createControllerService(serviceToAdd.getType(), UUID.randomUUID().toString(), coordinate, Collections.emptySet(), false);
            } catch (Exception e) {
                throw new IllegalArgumentException("Unable to create Controller Service of type " + serviceToAdd.getType(), e);
            }
        }
        // Ensure that all Prioritizers are instantiate-able.
        final Map<String, VersionedConnection> proposedConnections = new HashMap<>();
        findAllConnections(updatedFlow.getFlowContents(), proposedConnections);
        findAllConnections().stream().filter(conn -> conn.getVersionedComponentId().isPresent()).forEach(conn -> proposedConnections.remove(conn.getVersionedComponentId().get()));
        for (final VersionedConnection connectionToAdd : proposedConnections.values()) {
            if (connectionToAdd.getPrioritizers() != null) {
                for (final String prioritizerType : connectionToAdd.getPrioritizers()) {
                    try {
                        flowController.createPrioritizer(prioritizerType);
                    } catch (Exception e) {
                        throw new IllegalArgumentException("Unable to create Prioritizer of type " + prioritizerType, e);
                    }
                }
            }
        }
    } finally {
        readLock.unlock();
    }
}

Example 34 with Port

use of org.apache.nifi.connectable.Port in project nifi by apache.

the class StandardProcessGroup method updateRemoteProcessGroup.

private void updateRemoteProcessGroup(final RemoteProcessGroup rpg, final VersionedRemoteProcessGroup proposed, final String componentIdSeed) {
    rpg.setComments(proposed.getComments());
    rpg.setCommunicationsTimeout(proposed.getCommunicationsTimeout());
    rpg.setInputPorts(proposed.getInputPorts() == null ? Collections.emptySet() : proposed.getInputPorts().stream().map(port -> createPortDescriptor(port, componentIdSeed, rpg.getIdentifier())).collect(Collectors.toSet()), false);
    rpg.setName(proposed.getName());
    rpg.setNetworkInterface(proposed.getLocalNetworkInterface());
    rpg.setOutputPorts(proposed.getOutputPorts() == null ? Collections.emptySet() : proposed.getOutputPorts().stream().map(port -> createPortDescriptor(port, componentIdSeed, rpg.getIdentifier())).collect(Collectors.toSet()), false);
    rpg.setPosition(new Position(proposed.getPosition().getX(), proposed.getPosition().getY()));
    rpg.setProxyHost(proposed.getProxyHost());
    rpg.setProxyPort(proposed.getProxyPort());
    rpg.setProxyUser(proposed.getProxyUser());
    rpg.setTransportProtocol(SiteToSiteTransportProtocol.valueOf(proposed.getTransportProtocol()));
    rpg.setYieldDuration(proposed.getYieldDuration());
}

Example 35 with Port

use of org.apache.nifi.connectable.Port in project nifi by apache.

the class StandardProcessGroup method removeInputPort.

@Override
public void removeInputPort(final Port port) {
    writeLock.lock();
    try {
        final Port toRemove = inputPorts.get(requireNonNull(port).getIdentifier());
        if (toRemove == null) {
            throw new IllegalStateException(port.getIdentifier() + " is not an Input Port of this Process Group");
        }
        port.verifyCanDelete();
        for (final Connection conn : port.getConnections()) {
            conn.verifyCanDelete();
        }
        if (port.isRunning()) {
            stopInputPort(port);
        }
        // must copy to avoid a concurrent modification
        final Set<Connection> copy = new HashSet<>(port.getConnections());
        for (final Connection conn : copy) {
            removeConnection(conn);
        }
        final Port removed = inputPorts.remove(port.getIdentifier());
        if (removed == null) {
            throw new IllegalStateException(port.getIdentifier() + " is not an Input Port of this Process Group");
        }
        onComponentModified();
        flowController.onInputPortRemoved(port);
        LOG.info("Input Port {} removed from flow", port);
    } finally {
        writeLock.unlock();
    }
}