final String flowId = versionedFlowDto.getFlowId() == null ? UUID.randomUUID().toString() : versionedFlowDto.getFlowId(); final VersionedFlow versionedFlow = new VersionedFlow(); versionedFlow.setBucketIdentifier(versionedFlowDto.getBucketId()); versionedFlow.setCreatedTimestamp(System.currentTimeMillis()); versionedFlow.setDescription(versionedFlowDto.getDescription()); versionedFlow.setModifiedTimestamp(versionedFlow.getCreatedTimestamp()); versionedFlow.setName(versionedFlowDto.getFlowName()); versionedFlow.setIdentifier(flowId); vci.setBucketId(bucket.getIdentifier()); vci.setBucketName(bucket.getName()); vci.setFlowId(flow.getIdentifier()); vci.setFlowName(flow.getName()); vci.setFlowDescription(flow.getDescription()); vci.setGroupId(groupId); vci.setRegistryId(registryId);
private VersionedFlowEntity createVersionedFlowEntity(final String registryId, final VersionedFlow versionedFlow) { if (versionedFlow == null) { return null; } final VersionedFlowDTO dto = new VersionedFlowDTO(); dto.setRegistryId(registryId); dto.setBucketId(versionedFlow.getBucketIdentifier()); dto.setFlowId(versionedFlow.getIdentifier()); dto.setFlowName(versionedFlow.getName()); dto.setDescription(versionedFlow.getDescription()); final VersionedFlowEntity entity = new VersionedFlowEntity(); entity.setVersionedFlow(dto); return entity; }
@Override public int getLatestVersion(final String bucketId, final String flowId, final NiFiUser user) throws IOException, NiFiRegistryException { return (int) getFlowClient(user).get(bucketId, flowId).getVersionCount(); }
@Override public ResolvedReference resolve(final CommandOption option, final Integer position) { final VersionedFlow versionedFlow = backRefs.get(position); if (versionedFlow != null) { if (option != null && option == CommandOption.BUCKET_ID) { return new ResolvedReference(option, position, versionedFlow.getBucketName(), versionedFlow.getBucketIdentifier()); } else { return new ResolvedReference(option, position, versionedFlow.getName(), versionedFlow.getIdentifier()); } } else { return null; } }
@Override public StringResult doExecute(final NiFiRegistryClient client, final Properties properties) throws ParseException, IOException, NiFiRegistryException { final String bucketId = getRequiredArg(properties, CommandOption.BUCKET_ID); final String flowName = getRequiredArg(properties, CommandOption.FLOW_NAME); final String flowDesc = getArg(properties, CommandOption.FLOW_DESC); final VersionedFlow flow = new VersionedFlow(); flow.setName(flowName); flow.setDescription(flowDesc); flow.setBucketIdentifier(bucketId); final FlowClient flowClient = client.getFlowClient(); final VersionedFlow createdFlow = flowClient.create(flow); return new StringResult(createdFlow.getIdentifier(), getContext().isInteractive()); } }
@Override protected void writeSimpleResult(PrintStream output) { if (versionedFlows.isEmpty()) { return; } final Table table = new Table.Builder() .column("#", 3, 3, false) .column("Name", 20, 36, true) .column("Id", 36, 36, false) .column("Description", 11, 40, true) .build(); for (int i = 0; i < versionedFlows.size(); ++i) { final VersionedFlow flow = versionedFlows.get(i); table.addRow(String.valueOf(i + 1), flow.getName(), flow.getIdentifier(), flow.getDescription()); } final TableWriter tableWriter = new DynamicTableWriter(); tableWriter.write(table, output); }
@Override public OkResult doExecute(final NiFiRegistryClient client, final Properties properties) throws IOException, NiFiRegistryException, ParseException { final String flowId = getRequiredArg(properties, CommandOption.FLOW_ID); final boolean forceDelete = properties.containsKey(CommandOption.FORCE.getLongName()); final FlowClient flowClient = client.getFlowClient(); final VersionedFlow versionedFlow = flowClient.get(flowId); final FlowSnapshotClient flowSnapshotClient = client.getFlowSnapshotClient(); final List<VersionedFlowSnapshotMetadata> snapshotMetadata = flowSnapshotClient.getSnapshotMetadata(flowId); if (snapshotMetadata != null && snapshotMetadata.size() > 0 && !forceDelete) { throw new NiFiRegistryException("Flow has versions, use --" + CommandOption.FORCE.getLongName() + " to delete"); } else { flowClient.delete(versionedFlow.getBucketIdentifier(), versionedFlow.getIdentifier()); return new OkResult(getContext().isInteractive()); } } }
public static VersionedFlow map(final BucketEntity bucketEntity, final FlowEntity flowEntity) { final VersionedFlow versionedFlow = new VersionedFlow(); versionedFlow.setIdentifier(flowEntity.getId()); versionedFlow.setBucketIdentifier(flowEntity.getBucketId()); versionedFlow.setName(flowEntity.getName()); versionedFlow.setDescription(flowEntity.getDescription()); versionedFlow.setCreatedTimestamp(flowEntity.getCreated().getTime()); versionedFlow.setModifiedTimestamp(flowEntity.getModified().getTime()); versionedFlow.setVersionCount(flowEntity.getSnapshotCount()); if (bucketEntity != null) { versionedFlow.setBucketName(bucketEntity.getName()); } else { versionedFlow.setBucketName(flowEntity.getBucketName()); } return versionedFlow; }
versionControlInfo.setFlowName(flow.getName()); versionControlInfo.setFlowDescription(flow.getDescription());
if (versionedFlow.getBucketIdentifier() != null && !bucketIdentifier.equals(versionedFlow.getBucketIdentifier())) { throw new IllegalArgumentException("Bucket identifiers must match"); if (versionedFlow.getBucketIdentifier() == null) { versionedFlow.setBucketIdentifier(bucketIdentifier); versionedFlow.setIdentifier(UUID.randomUUID().toString()); versionedFlow.setCreatedTimestamp(timestamp); versionedFlow.setModifiedTimestamp(timestamp); final List<FlowEntity> flowsWithSameName = metadataService.getFlowsByName(existingBucket.getId(), versionedFlow.getName()); if (flowsWithSameName != null && flowsWithSameName.size() > 0) { throw new IllegalStateException("A versioned flow with the same name already exists in the selected bucket");
public static FlowEntity map(final VersionedFlow versionedFlow) { final FlowEntity flowEntity = new FlowEntity(); flowEntity.setId(versionedFlow.getIdentifier()); flowEntity.setName(versionedFlow.getName()); flowEntity.setDescription(versionedFlow.getDescription()); flowEntity.setCreated(new Date(versionedFlow.getCreatedTimestamp())); flowEntity.setModified(new Date(versionedFlow.getModifiedTimestamp())); flowEntity.setType(BucketItemEntityType.FLOW); return flowEntity; }
final int latestVersion = (int) versionedFlow.getVersionCount(); vci.setBucketName(versionedFlow.getBucketName()); vci.setFlowName(versionedFlow.getName()); vci.setFlowDescription(versionedFlow.getDescription()); vci.setRegistryName(flowRegistry.getName());
versionControlInfoDto.setBucketName(bucket.getName()); versionControlInfoDto.setFlowId(snapshotMetadata.getFlowIdentifier()); versionControlInfoDto.setFlowName(flow.getName()); versionControlInfoDto.setFlowDescription(flow.getDescription()); versionControlInfoDto.setGroupId(groupId); versionControlInfoDto.setVersion(snapshotMetadata.getVersion()); versionControlInfoDto.setRegistryName(serviceFacade.getFlowRegistryName(entity.getRegistryId())); final VersionedFlowState flowState = snapshotMetadata.getVersion() == flow.getVersionCount() ? VersionedFlowState.UP_TO_DATE : VersionedFlowState.STALE; versionControlInfoDto.setState(flowState.name());
@Override public Set<VersionedFlow> getFlowsForUser(String registryId, String bucketId, NiFiUser user) { try { final FlowRegistry flowRegistry = flowRegistryClient.getFlowRegistry(registryId); if (flowRegistry == null) { throw new IllegalArgumentException("The specified registry id is unknown to this NiFi."); } final Set<VersionedFlow> flows = flowRegistry.getFlows(bucketId, user); final Set<VersionedFlow> sortedFlows = new TreeSet<>((f1, f2) -> f1.getName().compareTo(f2.getName())); sortedFlows.addAll(flows); return sortedFlows; } catch (final IOException | NiFiRegistryException ioe) { throw new NiFiCoreException("Unable to obtain listing of flows for bucket with ID " + bucketId + ": " + ioe, ioe); } }
metadata.setBucketIdentifier(versionedFlow.getBucketIdentifier()); metadata.setFlowIdentifier(flowId); metadata.setVersion(version);
vci.setBucketId(metadata.getBucketIdentifier()); vci.setBucketName(bucket.getName()); vci.setFlowDescription(flow.getDescription()); vci.setFlowId(flow.getIdentifier()); vci.setFlowName(flow.getName()); vci.setGroupId(groupId); vci.setRegistryId(requestVci.getRegistryId());
@Override public VersionedFlowSnapshot registerVersionedFlowSnapshot(final VersionedFlow flow, final VersionedProcessGroup snapshot, final String comments, final int expectedVersion, final NiFiUser user) throws IOException, NiFiRegistryException { final FlowSnapshotClient snapshotClient = getFlowSnapshotClient(user); final VersionedFlowSnapshot versionedFlowSnapshot = new VersionedFlowSnapshot(); versionedFlowSnapshot.setFlowContents(snapshot); final VersionedFlowSnapshotMetadata metadata = new VersionedFlowSnapshotMetadata(); metadata.setBucketIdentifier(flow.getBucketIdentifier()); metadata.setFlowIdentifier(flow.getIdentifier()); metadata.setAuthor(getIdentity(user)); metadata.setTimestamp(System.currentTimeMillis()); metadata.setVersion(expectedVersion); metadata.setComments(comments); versionedFlowSnapshot.setSnapshotMetadata(metadata); return snapshotClient.create(versionedFlowSnapshot); }
@Override public FlowControllerSchema apply(final VersionedFlowSnapshot versionedFlowSnapshot) { // If the VersionedFlowSnapshot came directly from NiFi Registry without modification, as would be the // case with C2 server, then we should have a non-null VersionedFlow, but if we're using a snapshot that // was export from another tool like the CLI, the flow may be null'd out, so fall back to root group. String name; String description; if (versionedFlowSnapshot.getFlow() == null) { name = versionedFlowSnapshot.getFlowContents().getName(); description = versionedFlowSnapshot.getFlowContents().getComments(); } else { name = versionedFlowSnapshot.getFlow().getName(); description = versionedFlowSnapshot.getFlow().getDescription(); } Map<String, Object> map = new HashMap<>(); map.put(CommonPropertyKeys.NAME_KEY, name); map.put(CommonPropertyKeys.COMMENT_KEY, description); return new FlowControllerSchema(map); } }
@Override public String toString() { final String flowName = (flow == null ? "null" : flow.getName()); return "VersionedFlowSnapshot[flowId=" + snapshotMetadata.getFlowIdentifier() + ", flowName=" + flowName + ", version=" + snapshotMetadata.getVersion() + ", comments=" + snapshotMetadata.getComments() + "]"; } }
if (StringUtils.isBlank(versionedFlow.getIdentifier())) { throw new IllegalArgumentException("Versioned flow identifier cannot be null or blank"); if (StringUtils.isBlank(versionedFlow.getBucketIdentifier())) { throw new IllegalArgumentException("Versioned flow bucket identifier cannot be null or blank"); if (versionedFlow.getName() != null && StringUtils.isBlank(versionedFlow.getName())) { throw new IllegalArgumentException("Versioned flow name cannot be blank"); final BucketEntity existingBucket = metadataService.getBucketById(versionedFlow.getBucketIdentifier()); if (existingBucket == null) { LOGGER.warn("The specified bucket id [{}] does not exist.", versionedFlow.getBucketIdentifier()); throw new ResourceNotFoundException("The specified bucket ID does not exist in this registry."); final FlowEntity existingFlow = metadataService.getFlowByIdWithSnapshotCounts(versionedFlow.getIdentifier()); if (existingFlow == null) { LOGGER.warn("The specified flow id [{}] does not exist.", versionedFlow.getIdentifier()); throw new ResourceNotFoundException("The specified flow ID does not exist in this bucket."); if (StringUtils.isNotBlank(versionedFlow.getName())) { final List<FlowEntity> flowsWithSameName = metadataService.getFlowsByName(existingBucket.getId(), versionedFlow.getName()); if (flowsWithSameName != null) { for (final FlowEntity flowWithSameName : flowsWithSameName) { if (StringUtils.isNotBlank(versionedFlow.getName())) { existingFlow.setName(versionedFlow.getName()); if (versionedFlow.getDescription() != null) { existingFlow.setDescription(versionedFlow.getDescription());