Examples with PortDTO org.apache.nifi.web.api.dto.PortDTO used on opensource projects

Example 16 with PortDTO

use of org.apache.nifi.web.api.dto.PortDTO in project nifi by apache.

the class StandardNiFiServiceFacade method updateOutputPort.

@Override
public PortEntity updateOutputPort(final Revision revision, final PortDTO outputPortDTO) {
    final Port outputPortNode = outputPortDAO.getPort(outputPortDTO.getId());
    final RevisionUpdate<PortDTO> snapshot = updateComponent(revision, outputPortNode, () -> outputPortDAO.updatePort(outputPortDTO), port -> dtoFactory.createPortDto(port));
    final PermissionsDTO permissions = dtoFactory.createPermissionsDto(outputPortNode);
    final PortStatusDTO status = dtoFactory.createPortStatusDto(controllerFacade.getOutputPortStatus(outputPortNode.getIdentifier()));
    final List<BulletinDTO> bulletins = dtoFactory.createBulletinDtos(bulletinRepository.findBulletinsForSource(outputPortNode.getIdentifier()));
    final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
    return entityFactory.createPortEntity(snapshot.getComponent(), dtoFactory.createRevisionDTO(snapshot.getLastModification()), permissions, status, bulletinEntities);
}

Example 17 with PortDTO

use of org.apache.nifi.web.api.dto.PortDTO in project nifi by apache.

the class OutputPortResource method updateOutputPort.

/**
 * Updates the specified output port.
 *
 * @param httpServletRequest request
 * @param id                 The id of the output port to update.
 * @param requestPortEntity         A outputPortEntity.
 * @return A outputPortEntity.
 */
@PUT
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
@Path("{id}")
@ApiOperation(value = "Updates an output port", response = PortEntity.class, authorizations = { @Authorization(value = "Write - /output-ports/{uuid}") })
@ApiResponses(value = { @ApiResponse(code = 400, message = "NiFi was unable to complete the request because it was invalid. The request should not be retried without modification."), @ApiResponse(code = 401, message = "Client could not be authenticated."), @ApiResponse(code = 403, message = "Client is not authorized to make this request."), @ApiResponse(code = 404, message = "The specified resource could not be found."), @ApiResponse(code = 409, message = "The request was valid but NiFi was not in the appropriate state to process it. Retrying the same request later may be successful.") })
public Response updateOutputPort(@Context final HttpServletRequest httpServletRequest, @ApiParam(value = "The output port id.", required = true) @PathParam("id") final String id, @ApiParam(value = "The output port configuration details.", required = true) final PortEntity requestPortEntity) {
    if (requestPortEntity == null || requestPortEntity.getComponent() == null) {
        throw new IllegalArgumentException("Output port details must be specified.");
    }
    if (requestPortEntity.getRevision() == null) {
        throw new IllegalArgumentException("Revision must be specified.");
    }
    // ensure the ids are the same
    PortDTO requestPortDTO = requestPortEntity.getComponent();
    if (!id.equals(requestPortDTO.getId())) {
        throw new IllegalArgumentException(String.format("The output port id (%s) in the request body does not equal the " + "output port id of the requested resource (%s).", requestPortDTO.getId(), id));
    }
    final PositionDTO proposedPosition = requestPortDTO.getPosition();
    if (proposedPosition != null) {
        if (proposedPosition.getX() == null || proposedPosition.getY() == null) {
            throw new IllegalArgumentException("The x and y coordinate of the proposed position must be specified.");
        }
    }
    if (isReplicateRequest()) {
        return replicate(HttpMethod.PUT, requestPortEntity);
    }
    // handle expects request (usually from the cluster manager)
    final Revision requestRevision = getRevision(requestPortEntity, id);
    return withWriteLock(serviceFacade, requestPortEntity, requestRevision, lookup -> {
        Authorizable authorizable = lookup.getOutputPort(id);
        authorizable.authorize(authorizer, RequestAction.WRITE, NiFiUserUtils.getNiFiUser());
    }, () -> serviceFacade.verifyUpdateOutputPort(requestPortDTO), (revision, portEntity) -> {
        final PortDTO portDTO = portEntity.getComponent();
        // update the output port
        final PortEntity entity = serviceFacade.updateOutputPort(revision, portDTO);
        populateRemainingOutputPortEntityContent(entity);
        return generateOkResponse(entity).build();
    });
}

Example 18 with PortDTO

use of org.apache.nifi.web.api.dto.PortDTO in project nifi by apache.

the class TestHttpClient method before.

@Before
public void before() throws Exception {
    System.setProperty("org.slf4j.simpleLogger.log.org.apache.nifi.remote", "TRACE");
    System.setProperty("org.slf4j.simpleLogger.log.org.apache.nifi.remote.protocol.http.HttpClientTransaction", "DEBUG");
    testCaseFinished = new CountDownLatch(1);
    final PeerDTO peer = new PeerDTO();
    peer.setHostname("localhost");
    peer.setPort(httpConnector.getLocalPort());
    peer.setFlowFileCount(10);
    peer.setSecure(false);
    peers = new HashSet<>();
    peers.add(peer);
    final PeerDTO peerSecure = new PeerDTO();
    peerSecure.setHostname("localhost");
    peerSecure.setPort(sslConnector.getLocalPort());
    peerSecure.setFlowFileCount(10);
    peerSecure.setSecure(true);
    peersSecure = new HashSet<>();
    peersSecure.add(peerSecure);
    inputPorts = new HashSet<>();
    final PortDTO runningInputPort = new PortDTO();
    runningInputPort.setName("input-running");
    runningInputPort.setId("input-running-id");
    runningInputPort.setType("INPUT_PORT");
    runningInputPort.setState(ScheduledState.RUNNING.name());
    inputPorts.add(runningInputPort);
    final PortDTO timeoutInputPort = new PortDTO();
    timeoutInputPort.setName("input-timeout");
    timeoutInputPort.setId("input-timeout-id");
    timeoutInputPort.setType("INPUT_PORT");
    timeoutInputPort.setState(ScheduledState.RUNNING.name());
    inputPorts.add(timeoutInputPort);
    final PortDTO timeoutDataExInputPort = new PortDTO();
    timeoutDataExInputPort.setName("input-timeout-data-ex");
    timeoutDataExInputPort.setId("input-timeout-data-ex-id");
    timeoutDataExInputPort.setType("INPUT_PORT");
    timeoutDataExInputPort.setState(ScheduledState.RUNNING.name());
    inputPorts.add(timeoutDataExInputPort);
    final PortDTO accessDeniedInputPort = new PortDTO();
    accessDeniedInputPort.setName("input-access-denied");
    accessDeniedInputPort.setId("input-access-denied-id");
    accessDeniedInputPort.setType("INPUT_PORT");
    accessDeniedInputPort.setState(ScheduledState.RUNNING.name());
    inputPorts.add(accessDeniedInputPort);
    outputPorts = new HashSet<>();
    final PortDTO runningOutputPort = new PortDTO();
    runningOutputPort.setName("output-running");
    runningOutputPort.setId("output-running-id");
    runningOutputPort.setType("OUTPUT_PORT");
    runningOutputPort.setState(ScheduledState.RUNNING.name());
    outputPorts.add(runningOutputPort);
    final PortDTO timeoutOutputPort = new PortDTO();
    timeoutOutputPort.setName("output-timeout");
    timeoutOutputPort.setId("output-timeout-id");
    timeoutOutputPort.setType("OUTPUT_PORT");
    timeoutOutputPort.setState(ScheduledState.RUNNING.name());
    outputPorts.add(timeoutOutputPort);
    final PortDTO timeoutDataExOutputPort = new PortDTO();
    timeoutDataExOutputPort.setName("output-timeout-data-ex");
    timeoutDataExOutputPort.setId("output-timeout-data-ex-id");
    timeoutDataExOutputPort.setType("OUTPUT_PORT");
    timeoutDataExOutputPort.setState(ScheduledState.RUNNING.name());
    outputPorts.add(timeoutDataExOutputPort);
}

Example 19 with PortDTO

use of org.apache.nifi.web.api.dto.PortDTO in project nifi by apache.

the class SnippetUtils method resolveNameConflicts.

private void resolveNameConflicts(final FlowSnippetDTO snippetContents, final ProcessGroup group) {
    // get a list of all names of ports so that we can rename the ports as needed.
    final List<String> existingPortNames = new ArrayList<>();
    for (final Port inputPort : group.getInputPorts()) {
        existingPortNames.add(inputPort.getName());
    }
    for (final Port outputPort : group.getOutputPorts()) {
        existingPortNames.add(outputPort.getName());
    }
    // rename ports
    if (snippetContents.getInputPorts() != null) {
        for (final PortDTO portDTO : snippetContents.getInputPorts()) {
            String portName = portDTO.getName();
            while (existingPortNames.contains(portName)) {
                portName = "Copy of " + portName;
            }
            portDTO.setName(portName);
            existingPortNames.add(portDTO.getName());
        }
    }
    if (snippetContents.getOutputPorts() != null) {
        for (final PortDTO portDTO : snippetContents.getOutputPorts()) {
            String portName = portDTO.getName();
            while (existingPortNames.contains(portName)) {
                portName = "Copy of " + portName;
            }
            portDTO.setName(portName);
            existingPortNames.add(portDTO.getName());
        }
    }
    // get a list of all names of process groups so that we can rename as needed.
    final Set<String> groupNames = new HashSet<>();
    for (final ProcessGroup childGroup : group.getProcessGroups()) {
        groupNames.add(childGroup.getName());
    }
    if (snippetContents.getProcessGroups() != null) {
        for (final ProcessGroupDTO groupDTO : snippetContents.getProcessGroups()) {
            // 'Copy of...' so we do this only if there is no Version Control Information present.
            if (groupDTO.getVersionControlInformation() == null) {
                String groupName = groupDTO.getName();
                while (groupNames.contains(groupName)) {
                    groupName = "Copy of " + groupName;
                }
                groupDTO.setName(groupName);
            }
            groupNames.add(groupDTO.getName());
        }
    }
}

Example 20 with PortDTO

use of org.apache.nifi.web.api.dto.PortDTO in project nifi by apache.

the class NiFiWebApiTest method populateFlow.

public static void populateFlow(Client client, String baseUrl, NiFiTestUser user, String clientId) throws Exception {
    // -----------------------------------------------
    // Create a source processor
    // -----------------------------------------------
    // create the local selection processor
    ProcessorDTO processorDTO = new ProcessorDTO();
    processorDTO.setName("Pick up");
    processorDTO.setType(SourceTestProcessor.class.getName());
    // create the revision
    final RevisionDTO revision = new RevisionDTO();
    revision.setClientId(clientId);
    revision.setVersion(0l);
    // create the local selection processor entity
    ProcessorEntity processorEntity = new ProcessorEntity();
    processorEntity.setRevision(revision);
    processorEntity.setComponent(processorDTO);
    // add the processor
    Response response = user.testPost(baseUrl + "/process-groups/root/processors", processorEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
    // get the processors id
    processorEntity = response.readEntity(ProcessorEntity.class);
    processorDTO = processorEntity.getComponent();
    String localSelectionId = processorDTO.getId();
    String localSelectionGroupId = processorDTO.getParentGroupId();
    // -----------------------------------------------
    // Create a termination processor
    // -----------------------------------------------
    // create the termination processor
    processorDTO = new ProcessorDTO();
    processorDTO.setName("End");
    processorDTO.setType(TerminationTestProcessor.class.getName());
    // create the termination processor entity
    processorEntity = new ProcessorEntity();
    processorEntity.setRevision(revision);
    processorEntity.setComponent(processorDTO);
    // add the processor
    response = user.testPost(baseUrl + "/process-groups/root/processors", processorEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
    // get the processors id
    processorEntity = response.readEntity(ProcessorEntity.class);
    processorDTO = processorEntity.getComponent();
    String terminationId = processorDTO.getId();
    String terminationGroupId = processorDTO.getParentGroupId();
    // -----------------------------------------------
    // Connect the two processors
    // -----------------------------------------------
    ConnectableDTO source = new ConnectableDTO();
    source.setId(localSelectionId);
    source.setGroupId(localSelectionGroupId);
    source.setType(ConnectableType.PROCESSOR.name());
    ConnectableDTO target = new ConnectableDTO();
    target.setId(terminationId);
    target.setGroupId(terminationGroupId);
    target.setType(ConnectableType.PROCESSOR.name());
    // create the relationships
    Set<String> relationships = new HashSet<>();
    relationships.add("success");
    // create the connection
    ConnectionDTO connectionDTO = new ConnectionDTO();
    connectionDTO.setSource(source);
    connectionDTO.setDestination(target);
    connectionDTO.setSelectedRelationships(relationships);
    // create the connection entity
    ConnectionEntity connectionEntity = new ConnectionEntity();
    connectionEntity.setRevision(revision);
    connectionEntity.setComponent(connectionDTO);
    // add the processor
    response = user.testPost(baseUrl + "/process-groups/root/connections", connectionEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
    // -----------------------------------------------
    // Create a label
    // -----------------------------------------------
    // create the label
    LabelDTO labelDTO = new LabelDTO();
    labelDTO.setLabel("Test label");
    // create the label entity
    LabelEntity labelEntity = new LabelEntity();
    labelEntity.setRevision(revision);
    labelEntity.setComponent(labelDTO);
    // add the label
    response = user.testPost(baseUrl + "/process-groups/root/labels", labelEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
    // -----------------------------------------------
    // Create a funnel
    // -----------------------------------------------
    // create the funnel
    FunnelDTO funnelDTO = new FunnelDTO();
    // create the funnel entity
    FunnelEntity funnelEntity = new FunnelEntity();
    funnelEntity.setRevision(revision);
    funnelEntity.setComponent(funnelDTO);
    // add the funnel
    response = user.testPost(baseUrl + "/process-groups/root/funnels", funnelEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
    // -----------------------------------------------
    // Create a process group
    // -----------------------------------------------
    // create the process group
    ProcessGroupDTO processGroup = new ProcessGroupDTO();
    processGroup.setName("group name");
    // create the process group entity
    ProcessGroupEntity processGroupEntity = new ProcessGroupEntity();
    processGroupEntity.setRevision(revision);
    processGroupEntity.setComponent(processGroup);
    // add the process group
    response = user.testPost(baseUrl + "/process-groups/root/process-groups", processGroupEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
    // -----------------------------------------------
    // Create an input port
    // -----------------------------------------------
    // create the input port
    PortDTO inputPort = new PortDTO();
    inputPort.setName("input");
    // create the input port entity
    PortEntity inputPortEntity = new PortEntity();
    inputPortEntity.setRevision(revision);
    inputPortEntity.setComponent(inputPort);
    // add the input port
    response = user.testPost(baseUrl + "/process-groups/root/input-ports", inputPortEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
    // -----------------------------------------------
    // Create a output ports
    // -----------------------------------------------
    // create the process group
    PortDTO outputPort = new PortDTO();
    outputPort.setName("output");
    // create the process group entity
    PortEntity outputPortEntity = new PortEntity();
    outputPortEntity.setRevision(revision);
    outputPortEntity.setComponent(outputPort);
    // add the output port
    response = user.testPost(baseUrl + "/process-groups/root/output-ports", outputPortEntity);
    // ensure a successful response
    if (Response.Status.CREATED.getStatusCode() != response.getStatusInfo().getStatusCode()) {
        // since it was unable to create the component attempt to extract an
        // error message from the response body
        final String responseEntity = response.readEntity(String.class);
        throw new Exception("Unable to populate initial flow: " + responseEntity);
    }
}