public InstantiatedVersionedProcessGroup mapProcessGroup(final ProcessGroup group, final ControllerServiceProvider serviceProvider, final FlowRegistryClient registryClient, final boolean mapDescendantVersionedFlows) { versionedComponentIds.clear(); final InstantiatedVersionedProcessGroup mapped = mapGroup(group, serviceProvider, registryClient, true, mapDescendantVersionedFlows); populateReferencedAncestorVariables(group, mapped); return mapped; }
mapping.put(group.getInstanceId(), group.getIdentifier()); group.getProcessors().stream() .map(proc -> (InstantiatedVersionedProcessor) proc) .forEach(proc -> mapping.put(proc.getInstanceId(), proc.getIdentifier())); group.getFunnels().stream() .map(funnel -> (InstantiatedVersionedFunnel) funnel) .forEach(funnel -> mapping.put(funnel.getInstanceId(), funnel.getIdentifier())); group.getInputPorts().stream() .map(port -> (InstantiatedVersionedPort) port) .forEach(port -> mapping.put(port.getInstanceId(), port.getIdentifier())); group.getOutputPorts().stream() .map(port -> (InstantiatedVersionedPort) port) .forEach(port -> mapping.put(port.getInstanceId(), port.getIdentifier())); group.getControllerServices().stream() .map(service -> (InstantiatedVersionedControllerService) service) .forEach(service -> mapping.put(service.getInstanceId(), service.getIdentifier())); group.getLabels().stream() .map(label -> (InstantiatedVersionedLabel) label) .forEach(label -> mapping.put(label.getInstanceId(), label.getIdentifier())); group.getConnections().stream() .map(conn -> (InstantiatedVersionedConnection) conn) .forEach(conn -> mapping.put(conn.getInstanceId(), conn.getIdentifier())); group.getRemoteProcessGroups().stream() .map(rpg -> (InstantiatedVersionedRemoteProcessGroup) rpg) .forEach(rpg -> { mapping.put(rpg.getInstanceId(), rpg.getIdentifier()); if (rpg.getInputPorts() != null) { rpg.getInputPorts().stream()
private InstantiatedVersionedProcessGroup createFlowSnapshot(final String processGroupId) { final ProcessGroup processGroup = processGroupDAO.getProcessGroup(processGroupId); final NiFiRegistryFlowMapper mapper = new NiFiRegistryFlowMapper(controllerFacade.getExtensionManager()); final InstantiatedVersionedProcessGroup versionedGroup = mapper.mapProcessGroup(processGroup, controllerFacade.getControllerServiceProvider(), flowRegistryClient, false); return versionedGroup; }
public VersionedControllerService mapControllerService(final ControllerServiceNode controllerService, final ControllerServiceProvider serviceProvider) { final VersionedControllerService versionedService = new InstantiatedVersionedControllerService(controllerService.getIdentifier(), controllerService.getProcessGroupIdentifier()); versionedService.setIdentifier(getId(controllerService.getVersionedComponentId(), controllerService.getIdentifier())); versionedService.setGroupIdentifier(getGroupId(controllerService.getProcessGroupIdentifier())); versionedService.setName(controllerService.getName()); versionedService.setAnnotationData(controllerService.getAnnotationData()); versionedService.setBundle(mapBundle(controllerService.getBundleCoordinate())); versionedService.setComments(controllerService.getComments()); versionedService.setControllerServiceApis(mapControllerServiceApis(controllerService)); versionedService.setProperties(mapProperties(controllerService, serviceProvider)); versionedService.setPropertyDescriptors(mapPropertyDescriptors(controllerService)); versionedService.setType(controllerService.getCanonicalClassName()); return versionedService; }
public VersionedProcessor mapProcessor(final ProcessorNode procNode, final ControllerServiceProvider serviceProvider) { final VersionedProcessor processor = new InstantiatedVersionedProcessor(procNode.getIdentifier(), procNode.getProcessGroupIdentifier()); processor.setIdentifier(getId(procNode.getVersionedComponentId(), procNode.getIdentifier())); processor.setGroupIdentifier(getGroupId(procNode.getProcessGroupIdentifier())); processor.setType(procNode.getCanonicalClassName()); processor.setAnnotationData(procNode.getAnnotationData()); processor.setAutoTerminatedRelationships(procNode.getAutoTerminatedRelationships().stream().map(Relationship::getName).collect(Collectors.toSet())); processor.setBulletinLevel(procNode.getBulletinLevel().name()); processor.setBundle(mapBundle(procNode.getBundleCoordinate())); processor.setComments(procNode.getComments()); processor.setConcurrentlySchedulableTaskCount(procNode.getMaxConcurrentTasks()); processor.setExecutionNode(procNode.getExecutionNode().name()); processor.setName(procNode.getName()); processor.setPenaltyDuration(procNode.getPenalizationPeriod()); processor.setPosition(mapPosition(procNode.getPosition())); processor.setProperties(mapProperties(procNode, serviceProvider)); processor.setPropertyDescriptors(mapPropertyDescriptors(procNode)); processor.setRunDurationMillis(procNode.getRunDuration(TimeUnit.MILLISECONDS)); processor.setSchedulingPeriod(procNode.getSchedulingPeriod()); processor.setSchedulingStrategy(procNode.getSchedulingStrategy().name()); processor.setStyle(procNode.getStyle()); processor.setYieldDuration(procNode.getYieldPeriod()); return processor; }
public VersionedRemoteProcessGroup mapRemoteProcessGroup(final RemoteProcessGroup remoteGroup) { final VersionedRemoteProcessGroup rpg = new InstantiatedVersionedRemoteProcessGroup(remoteGroup.getIdentifier(), remoteGroup.getProcessGroupIdentifier()); rpg.setIdentifier(getId(remoteGroup.getVersionedComponentId(), remoteGroup.getIdentifier())); rpg.setGroupIdentifier(getGroupId(remoteGroup.getProcessGroupIdentifier())); rpg.setComments(remoteGroup.getComments()); rpg.setCommunicationsTimeout(remoteGroup.getCommunicationsTimeout()); rpg.setLocalNetworkInterface(remoteGroup.getNetworkInterface()); rpg.setName(remoteGroup.getName()); rpg.setInputPorts(remoteGroup.getInputPorts().stream() .map(port -> mapRemotePort(port, ComponentType.REMOTE_INPUT_PORT)) .collect(Collectors.toSet())); rpg.setOutputPorts(remoteGroup.getOutputPorts().stream() .map(port -> mapRemotePort(port, ComponentType.REMOTE_OUTPUT_PORT)) .collect(Collectors.toSet())); rpg.setPosition(mapPosition(remoteGroup.getPosition())); rpg.setProxyHost(remoteGroup.getProxyHost()); rpg.setProxyPort(remoteGroup.getProxyPort()); rpg.setProxyUser(remoteGroup.getProxyUser()); rpg.setTargetUri(remoteGroup.getTargetUri()); rpg.setTargetUris(remoteGroup.getTargetUris()); rpg.setTransportProtocol(remoteGroup.getTransportProtocol().name()); rpg.setYieldDuration(remoteGroup.getYieldDuration()); return rpg; }
public VersionedFunnel mapFunnel(final Funnel funnel) { final VersionedFunnel versionedFunnel = new InstantiatedVersionedFunnel(funnel.getIdentifier(), funnel.getProcessGroupIdentifier()); versionedFunnel.setIdentifier(getId(funnel.getVersionedComponentId(), funnel.getIdentifier())); versionedFunnel.setGroupIdentifier(getGroupId(funnel.getProcessGroupIdentifier())); versionedFunnel.setPosition(mapPosition(funnel.getPosition())); return versionedFunnel; }
public VersionedLabel mapLabel(final Label label) { final VersionedLabel versionedLabel = new InstantiatedVersionedLabel(label.getIdentifier(), label.getProcessGroupIdentifier()); versionedLabel.setIdentifier(getId(label.getVersionedComponentId(), label.getIdentifier())); versionedLabel.setGroupIdentifier(getGroupId(label.getProcessGroupIdentifier())); versionedLabel.setHeight(label.getSize().getHeight()); versionedLabel.setWidth(label.getSize().getWidth()); versionedLabel.setLabel(label.getValue()); versionedLabel.setPosition(mapPosition(label.getPosition())); versionedLabel.setStyle(label.getStyle()); return versionedLabel; }
public VersionedPort mapPort(final Port port) { final VersionedPort versionedPort = new InstantiatedVersionedPort(port.getIdentifier(), port.getProcessGroupIdentifier()); versionedPort.setIdentifier(getId(port.getVersionedComponentId(), port.getIdentifier())); versionedPort.setGroupIdentifier(getGroupId(port.getProcessGroupIdentifier())); versionedPort.setComments(port.getComments()); versionedPort.setConcurrentlySchedulableTaskCount(port.getMaxConcurrentTasks()); versionedPort.setName(port.getName()); versionedPort.setPosition(mapPosition(port.getPosition())); versionedPort.setType(PortType.valueOf(port.getConnectableType().name())); return versionedPort; }
public VersionedRemoteGroupPort mapRemotePort(final RemoteGroupPort remotePort, final ComponentType componentType) { final VersionedRemoteGroupPort port = new InstantiatedVersionedRemoteGroupPort(remotePort.getIdentifier(), remotePort.getRemoteProcessGroup().getIdentifier()); port.setIdentifier(getId(remotePort.getVersionedComponentId(), remotePort.getIdentifier())); port.setGroupIdentifier(getGroupId(remotePort.getRemoteProcessGroup().getIdentifier())); port.setComments(remotePort.getComments()); port.setConcurrentlySchedulableTaskCount(remotePort.getMaxConcurrentTasks()); port.setRemoteGroupId(getGroupId(remotePort.getRemoteProcessGroup().getIdentifier())); port.setName(remotePort.getName()); port.setUseCompression(remotePort.isUseCompression()); port.setBatchSize(mapBatchSettings(remotePort)); port.setTargetId(remotePort.getTargetIdentifier()); port.setComponentType(componentType); return port; }
public VersionedConnection mapConnection(final Connection connection) { final FlowFileQueue queue = connection.getFlowFileQueue(); final VersionedConnection versionedConnection = new InstantiatedVersionedConnection(connection.getIdentifier(), connection.getProcessGroup().getIdentifier()); versionedConnection.setIdentifier(getId(connection.getVersionedComponentId(), connection.getIdentifier())); versionedConnection.setGroupIdentifier(getGroupId(connection.getProcessGroup().getIdentifier())); versionedConnection.setName(connection.getName()); versionedConnection.setBackPressureDataSizeThreshold(queue.getBackPressureDataSizeThreshold()); versionedConnection.setBackPressureObjectThreshold(queue.getBackPressureObjectThreshold()); versionedConnection.setFlowFileExpiration(queue.getFlowFileExpiration()); versionedConnection.setLabelIndex(connection.getLabelIndex()); versionedConnection.setPrioritizers(queue.getPriorities().stream().map(p -> p.getClass().getName()).collect(Collectors.toList())); versionedConnection.setSelectedRelationships(connection.getRelationships().stream().map(Relationship::getName).collect(Collectors.toSet())); versionedConnection.setzIndex(connection.getZIndex()); final FlowFileQueue flowFileQueue = connection.getFlowFileQueue(); versionedConnection.setLoadBalanceStrategy(flowFileQueue.getLoadBalanceStrategy().name()); versionedConnection.setPartitioningAttribute(flowFileQueue.getPartitioningAttribute()); versionedConnection.setLoadBalanceCompression(flowFileQueue.getLoadBalanceCompression().name()); versionedConnection.setBends(connection.getBendPoints().stream() .map(this::mapPosition) .collect(Collectors.toList())); versionedConnection.setSource(mapConnectable(connection.getSource())); versionedConnection.setDestination(mapConnectable(connection.getDestination())); return versionedConnection; }
private AffectedComponentEntity createAffectedComponentEntity(final InstantiatedVersionedComponent instance, final String componentTypeName, final String componentState) { final AffectedComponentEntity entity = new AffectedComponentEntity(); entity.setRevision(dtoFactory.createRevisionDTO(revisionManager.getRevision(instance.getInstanceId()))); entity.setId(instance.getInstanceId()); final Authorizable authorizable = getAuthorizable(componentTypeName, instance); final PermissionsDTO permissionsDto = dtoFactory.createPermissionsDto(authorizable); entity.setPermissions(permissionsDto); final AffectedComponentDTO dto = new AffectedComponentDTO(); dto.setId(instance.getInstanceId()); dto.setReferenceType(componentTypeName); dto.setProcessGroupId(instance.getInstanceGroupId()); dto.setState(componentState); entity.setComponent(dto); return entity; }
public ConnectableComponent mapConnectable(final Connectable connectable) { final ConnectableComponent component = new InstantiatedConnectableComponent(connectable.getIdentifier(), connectable.getProcessGroupIdentifier()); final String versionedId = getIdOrThrow(connectable.getVersionedComponentId(), connectable.getIdentifier(), () -> new IllegalArgumentException("Unable to map Connectable Component with identifier " + connectable.getIdentifier() + " to any version-controlled component")); component.setId(versionedId); component.setComments(connectable.getComments()); final String groupId; if (connectable instanceof RemoteGroupPort) { final RemoteGroupPort port = (RemoteGroupPort) connectable; final RemoteProcessGroup rpg = port.getRemoteProcessGroup(); final Optional<String> rpgVersionedId = rpg.getVersionedComponentId(); groupId = getIdOrThrow(rpgVersionedId, rpg.getIdentifier(), () -> new IllegalArgumentException("Unable to find the Versioned Component ID for Remote Process Group that " + connectable + " belongs to")); } else { groupId = getIdOrThrow(connectable.getProcessGroup().getVersionedComponentId(), connectable.getProcessGroupIdentifier(), () -> new IllegalArgumentException("Unable to find the Versioned Component ID for the Process Group that " + connectable + " belongs to")); } component.setGroupId(groupId); component.setName(connectable.getName()); component.setType(ConnectableComponentType.valueOf(connectable.getConnectableType().name())); return component; }
private void populateVariableNames(final ProcessGroup group, final Set<String> variableNames) { if (group == null) { return; } group.getVariableRegistry().getVariableMap().keySet().stream() .map(VariableDescriptor::getName) .forEach(variableNames::add); populateVariableNames(group.getParent(), variableNames); }
private Map<String, String> mapProperties(final ComponentNode component, final ControllerServiceProvider serviceProvider) { final Map<String, String> mapped = new HashMap<>(); component.getProperties().keySet().stream() .filter(property -> !property.isSensitive()) .forEach(property -> { String value = component.getProperty(property); if (value == null) { value = property.getDefaultValue(); } if (value != null && property.getControllerServiceDefinition() != null) { // Property references a Controller Service. Instead of storing the existing value, we want // to store the Versioned Component ID of the service. final ControllerServiceNode controllerService = serviceProvider.getControllerServiceNode(value); if (controllerService != null) { value = getId(controllerService.getVersionedComponentId(), controllerService.getIdentifier()); } } mapped.put(property.getName(), value); }); return mapped; }
private List<ControllerServiceAPI> mapControllerServiceApis(final ControllerServiceNode service) { final Class<?> serviceClass = service.getControllerServiceImplementation().getClass(); final Set<Class<?>> serviceApiClasses = new HashSet<>(); // get all of it's interfaces to determine the controller service api's it implements final List<Class<?>> interfaces = ClassUtils.getAllInterfaces(serviceClass); for (final Class<?> i : interfaces) { // add all controller services that's not ControllerService itself if (ControllerService.class.isAssignableFrom(i) && !ControllerService.class.equals(i)) { serviceApiClasses.add(i); } } final List<ControllerServiceAPI> serviceApis = new ArrayList<>(); for (final Class<?> serviceApiClass : serviceApiClasses) { final BundleCoordinate bundleCoordinate = extensionManager.getBundle(serviceApiClass.getClassLoader()).getBundleDetails().getCoordinate(); final ControllerServiceAPI serviceApi = new ControllerServiceAPI(); serviceApi.setType(serviceApiClass.getName()); serviceApi.setBundle(mapBundle(bundleCoordinate)); serviceApis.add(serviceApi); } return serviceApis; }
@Override public ProcessGroup updateVersionControlInformation(final VersionControlInformationDTO versionControlInformation, final Map<String, String> versionedComponentMapping) { final String groupId = versionControlInformation.getGroupId(); final ProcessGroup group = locateProcessGroup(flowController, groupId); final String registryId = versionControlInformation.getRegistryId(); final FlowRegistry flowRegistry = flowController.getFlowRegistryClient().getFlowRegistry(registryId); final String registryName = flowRegistry == null ? registryId : flowRegistry.getName(); final NiFiRegistryFlowMapper mapper = new NiFiRegistryFlowMapper(flowController.getExtensionManager()); final VersionedProcessGroup flowSnapshot = mapper.mapProcessGroup(group, flowController.getControllerServiceProvider(), flowController.getFlowRegistryClient(), false); final StandardVersionControlInformation vci = StandardVersionControlInformation.Builder.fromDto(versionControlInformation) .registryName(registryName) .flowSnapshot(flowSnapshot) .build(); group.setVersionControlInformation(vci, versionedComponentMapping); group.onComponentModified(); return group; }
private Authorizable getAuthorizable(final String componentTypeName, final InstantiatedVersionedComponent versionedComponent) { final String componentId = versionedComponent.getInstanceId(); return authorizableLookup.getRemoteProcessGroup(versionedComponent.getInstanceGroupId()); return authorizableLookup.getRemoteProcessGroup(versionedComponent.getInstanceGroupId());
private void populateReferencedAncestorVariables(final ProcessGroup group, final VersionedProcessGroup versionedGroup) { final Set<String> ancestorVariableNames = new HashSet<>(); populateVariableNames(group.getParent(), ancestorVariableNames); final Map<String, String> implicitlyDefinedVariables = new HashMap<>(); for (final String variableName : ancestorVariableNames) { final boolean isReferenced = !group.getComponentsAffectedByVariable(variableName).isEmpty(); if (isReferenced) { final String value = group.getVariableRegistry().getVariableValue(variableName); implicitlyDefinedVariables.put(variableName, value); } } if (!implicitlyDefinedVariables.isEmpty()) { // Merge the implicit variables with the explicitly defined variables for the Process Group // and set those as the Versioned Group's variables. if (versionedGroup.getVariables() != null) { implicitlyDefinedVariables.putAll(versionedGroup.getVariables()); } versionedGroup.setVariables(implicitlyDefinedVariables); } }
private ComponentDifferenceDTO createComponentDifference(final FlowDifference difference) { VersionedComponent component = difference.getComponentA(); if (component == null || difference.getComponentB() instanceof InstantiatedVersionedComponent) { component = difference.getComponentB(); } final ComponentDifferenceDTO dto = new ComponentDifferenceDTO(); dto.setComponentName(component.getName()); dto.setComponentType(component.getComponentType().toString()); if (component instanceof InstantiatedVersionedComponent) { final InstantiatedVersionedComponent instantiatedComponent = (InstantiatedVersionedComponent) component; dto.setComponentId(instantiatedComponent.getInstanceId()); dto.setProcessGroupId(instantiatedComponent.getInstanceGroupId()); } else { dto.setComponentId(component.getIdentifier()); dto.setProcessGroupId(dto.getProcessGroupId()); } return dto; }