2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 * Modifications to the original nifi code for the ONAP project are made
18 * available under the Apache License, Version 2.0
20 package org.apache.nifi.web.api.dto;
22 import org.apache.commons.codec.digest.DigestUtils;
23 import org.apache.commons.lang3.ClassUtils;
24 import org.apache.commons.lang3.StringUtils;
25 import org.apache.nifi.action.Action;
26 import org.apache.nifi.action.component.details.ComponentDetails;
27 import org.apache.nifi.action.component.details.ExtensionDetails;
28 import org.apache.nifi.action.component.details.FlowChangeExtensionDetails;
29 import org.apache.nifi.action.component.details.FlowChangeRemoteProcessGroupDetails;
30 import org.apache.nifi.action.component.details.RemoteProcessGroupDetails;
31 import org.apache.nifi.action.details.ActionDetails;
32 import org.apache.nifi.action.details.ConfigureDetails;
33 import org.apache.nifi.action.details.ConnectDetails;
34 import org.apache.nifi.action.details.FlowChangeConfigureDetails;
35 import org.apache.nifi.action.details.FlowChangeConnectDetails;
36 import org.apache.nifi.action.details.FlowChangeMoveDetails;
37 import org.apache.nifi.action.details.FlowChangePurgeDetails;
38 import org.apache.nifi.action.details.MoveDetails;
39 import org.apache.nifi.action.details.PurgeDetails;
40 import org.apache.nifi.annotation.behavior.Restricted;
41 import org.apache.nifi.annotation.behavior.Restriction;
42 import org.apache.nifi.annotation.behavior.Stateful;
43 import org.apache.nifi.annotation.documentation.CapabilityDescription;
44 import org.apache.nifi.annotation.documentation.DeprecationNotice;
45 import org.apache.nifi.annotation.documentation.Tags;
46 import org.apache.nifi.authorization.AccessPolicy;
47 import org.apache.nifi.authorization.Authorizer;
48 import org.apache.nifi.authorization.AuthorizerCapabilityDetection;
49 import org.apache.nifi.authorization.Group;
50 import org.apache.nifi.authorization.RequestAction;
51 import org.apache.nifi.authorization.Resource;
52 import org.apache.nifi.authorization.User;
53 import org.apache.nifi.authorization.resource.Authorizable;
54 import org.apache.nifi.authorization.resource.ComponentAuthorizable;
55 import org.apache.nifi.authorization.resource.OperationAuthorizable;
56 import org.apache.nifi.authorization.user.NiFiUser;
57 import org.apache.nifi.authorization.user.NiFiUserUtils;
58 import org.apache.nifi.bundle.Bundle;
59 import org.apache.nifi.bundle.BundleCoordinate;
60 import org.apache.nifi.bundle.BundleDetails;
61 import org.apache.nifi.cluster.coordination.heartbeat.NodeHeartbeat;
62 import org.apache.nifi.cluster.coordination.node.NodeConnectionStatus;
63 import org.apache.nifi.cluster.event.NodeEvent;
64 import org.apache.nifi.cluster.manager.StatusMerger;
65 import org.apache.nifi.cluster.protocol.NodeIdentifier;
66 import org.apache.nifi.components.AllowableValue;
67 import org.apache.nifi.components.PropertyDescriptor;
68 import org.apache.nifi.components.ValidationResult;
69 import org.apache.nifi.components.state.Scope;
70 import org.apache.nifi.components.state.StateMap;
71 import org.apache.nifi.components.validation.ValidationStatus;
72 import org.apache.nifi.connectable.Connectable;
73 import org.apache.nifi.connectable.ConnectableType;
74 import org.apache.nifi.connectable.Connection;
75 import org.apache.nifi.connectable.Funnel;
76 import org.apache.nifi.connectable.Port;
77 import org.apache.nifi.connectable.Position;
78 import org.apache.nifi.controller.ActiveThreadInfo;
79 import org.apache.nifi.controller.ComponentNode;
80 import org.apache.nifi.controller.ControllerService;
81 import org.apache.nifi.controller.Counter;
82 import org.apache.nifi.controller.FlowController;
83 import org.apache.nifi.controller.ProcessorNode;
84 import org.apache.nifi.controller.ReportingTaskNode;
85 import org.apache.nifi.controller.Snippet;
86 import org.apache.nifi.controller.Template;
87 import org.apache.nifi.controller.label.Label;
88 import org.apache.nifi.controller.queue.DropFlowFileState;
89 import org.apache.nifi.controller.queue.DropFlowFileStatus;
90 import org.apache.nifi.controller.queue.FlowFileQueue;
91 import org.apache.nifi.controller.queue.FlowFileSummary;
92 import org.apache.nifi.controller.queue.ListFlowFileState;
93 import org.apache.nifi.controller.queue.ListFlowFileStatus;
94 import org.apache.nifi.controller.queue.LoadBalanceStrategy;
95 import org.apache.nifi.controller.queue.LocalQueuePartitionDiagnostics;
96 import org.apache.nifi.controller.queue.QueueDiagnostics;
97 import org.apache.nifi.controller.queue.QueueSize;
98 import org.apache.nifi.controller.queue.RemoteQueuePartitionDiagnostics;
99 import org.apache.nifi.controller.repository.FlowFileRecord;
100 import org.apache.nifi.controller.repository.claim.ContentClaim;
101 import org.apache.nifi.controller.repository.claim.ResourceClaim;
102 import org.apache.nifi.controller.service.ControllerServiceNode;
103 import org.apache.nifi.controller.service.ControllerServiceProvider;
104 import org.apache.nifi.controller.state.SortedStateUtils;
105 import org.apache.nifi.controller.status.ConnectionStatus;
106 import org.apache.nifi.controller.status.PortStatus;
107 import org.apache.nifi.controller.status.ProcessGroupStatus;
108 import org.apache.nifi.controller.status.ProcessorStatus;
109 import org.apache.nifi.controller.status.RemoteProcessGroupStatus;
110 import org.apache.nifi.controller.status.history.GarbageCollectionHistory;
111 import org.apache.nifi.controller.status.history.GarbageCollectionStatus;
112 import org.apache.nifi.diagnostics.GarbageCollection;
113 import org.apache.nifi.diagnostics.StorageUsage;
114 import org.apache.nifi.diagnostics.SystemDiagnostics;
115 import org.apache.nifi.expression.ExpressionLanguageScope;
116 import org.apache.nifi.flowfile.FlowFilePrioritizer;
117 import org.apache.nifi.flowfile.attributes.CoreAttributes;
118 import org.apache.nifi.groups.ProcessGroup;
119 import org.apache.nifi.groups.ProcessGroupCounts;
120 import org.apache.nifi.groups.RemoteProcessGroup;
121 import org.apache.nifi.groups.RemoteProcessGroupCounts;
122 import org.apache.nifi.history.History;
123 import org.apache.nifi.nar.ExtensionManager;
124 import org.apache.nifi.nar.NarClassLoadersHolder;
125 import org.apache.nifi.processor.Processor;
126 import org.apache.nifi.processor.Relationship;
127 import org.apache.nifi.provenance.lineage.ComputeLineageResult;
128 import org.apache.nifi.provenance.lineage.ComputeLineageSubmission;
129 import org.apache.nifi.provenance.lineage.LineageEdge;
130 import org.apache.nifi.provenance.lineage.LineageNode;
131 import org.apache.nifi.provenance.lineage.ProvenanceEventLineageNode;
132 import org.apache.nifi.registry.ComponentVariableRegistry;
133 import org.apache.nifi.registry.flow.FlowRegistry;
134 import org.apache.nifi.registry.flow.VersionControlInformation;
135 import org.apache.nifi.registry.flow.VersionedComponent;
136 import org.apache.nifi.registry.flow.VersionedFlowState;
137 import org.apache.nifi.registry.flow.VersionedFlowStatus;
138 import org.apache.nifi.registry.flow.diff.DifferenceType;
139 import org.apache.nifi.registry.flow.diff.FlowComparison;
140 import org.apache.nifi.registry.flow.diff.FlowDifference;
141 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedComponent;
142 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedConnection;
143 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedControllerService;
144 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedFunnel;
145 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedLabel;
146 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedPort;
147 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedProcessGroup;
148 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedProcessor;
149 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedRemoteGroupPort;
150 import org.apache.nifi.registry.flow.mapping.InstantiatedVersionedRemoteProcessGroup;
151 import org.apache.nifi.registry.variable.VariableRegistryUpdateRequest;
152 import org.apache.nifi.registry.variable.VariableRegistryUpdateStep;
153 import org.apache.nifi.remote.RemoteGroupPort;
154 import org.apache.nifi.remote.RootGroupPort;
155 import org.apache.nifi.reporting.Bulletin;
156 import org.apache.nifi.reporting.BulletinRepository;
157 import org.apache.nifi.reporting.ReportingTask;
158 import org.apache.nifi.scheduling.SchedulingStrategy;
159 import org.apache.nifi.util.FlowDifferenceFilters;
160 import org.apache.nifi.util.FormatUtils;
161 import org.apache.nifi.web.FlowModification;
162 import org.apache.nifi.web.Revision;
163 import org.apache.nifi.web.api.dto.action.ActionDTO;
164 import org.apache.nifi.web.api.dto.action.HistoryDTO;
165 import org.apache.nifi.web.api.dto.action.component.details.ComponentDetailsDTO;
166 import org.apache.nifi.web.api.dto.action.component.details.ExtensionDetailsDTO;
167 import org.apache.nifi.web.api.dto.action.component.details.RemoteProcessGroupDetailsDTO;
168 import org.apache.nifi.web.api.dto.action.details.ActionDetailsDTO;
169 import org.apache.nifi.web.api.dto.action.details.ConfigureDetailsDTO;
170 import org.apache.nifi.web.api.dto.action.details.ConnectDetailsDTO;
171 import org.apache.nifi.web.api.dto.action.details.MoveDetailsDTO;
172 import org.apache.nifi.web.api.dto.action.details.PurgeDetailsDTO;
173 import org.apache.nifi.web.api.dto.diagnostics.ClassLoaderDiagnosticsDTO;
174 import org.apache.nifi.web.api.dto.diagnostics.ConnectionDiagnosticsDTO;
175 import org.apache.nifi.web.api.dto.diagnostics.ConnectionDiagnosticsSnapshotDTO;
176 import org.apache.nifi.web.api.dto.diagnostics.ControllerServiceDiagnosticsDTO;
177 import org.apache.nifi.web.api.dto.diagnostics.GCDiagnosticsSnapshotDTO;
178 import org.apache.nifi.web.api.dto.diagnostics.GarbageCollectionDiagnosticsDTO;
179 import org.apache.nifi.web.api.dto.diagnostics.JVMControllerDiagnosticsSnapshotDTO;
180 import org.apache.nifi.web.api.dto.diagnostics.JVMDiagnosticsDTO;
181 import org.apache.nifi.web.api.dto.diagnostics.JVMDiagnosticsSnapshotDTO;
182 import org.apache.nifi.web.api.dto.diagnostics.JVMFlowDiagnosticsSnapshotDTO;
183 import org.apache.nifi.web.api.dto.diagnostics.JVMSystemDiagnosticsSnapshotDTO;
184 import org.apache.nifi.web.api.dto.diagnostics.LocalQueuePartitionDTO;
185 import org.apache.nifi.web.api.dto.diagnostics.ProcessorDiagnosticsDTO;
186 import org.apache.nifi.web.api.dto.diagnostics.RemoteQueuePartitionDTO;
187 import org.apache.nifi.web.api.dto.diagnostics.RepositoryUsageDTO;
188 import org.apache.nifi.web.api.dto.diagnostics.ThreadDumpDTO;
189 import org.apache.nifi.web.api.dto.flow.FlowBreadcrumbDTO;
190 import org.apache.nifi.web.api.dto.flow.FlowDTO;
191 import org.apache.nifi.web.api.dto.flow.ProcessGroupFlowDTO;
192 import org.apache.nifi.web.api.dto.provenance.lineage.LineageDTO;
193 import org.apache.nifi.web.api.dto.provenance.lineage.LineageRequestDTO;
194 import org.apache.nifi.web.api.dto.provenance.lineage.LineageRequestDTO.LineageRequestType;
195 import org.apache.nifi.web.api.dto.provenance.lineage.LineageResultsDTO;
196 import org.apache.nifi.web.api.dto.provenance.lineage.ProvenanceLinkDTO;
197 import org.apache.nifi.web.api.dto.provenance.lineage.ProvenanceNodeDTO;
198 import org.apache.nifi.web.api.dto.status.ConnectionStatusDTO;
199 import org.apache.nifi.web.api.dto.status.ConnectionStatusSnapshotDTO;
200 import org.apache.nifi.web.api.dto.status.PortStatusDTO;
201 import org.apache.nifi.web.api.dto.status.PortStatusSnapshotDTO;
202 import org.apache.nifi.web.api.dto.status.ProcessGroupStatusDTO;
203 import org.apache.nifi.web.api.dto.status.ProcessGroupStatusSnapshotDTO;
204 import org.apache.nifi.web.api.dto.status.ProcessorStatusDTO;
205 import org.apache.nifi.web.api.dto.status.ProcessorStatusSnapshotDTO;
206 import org.apache.nifi.web.api.dto.status.RemoteProcessGroupStatusDTO;
207 import org.apache.nifi.web.api.dto.status.RemoteProcessGroupStatusSnapshotDTO;
208 import org.apache.nifi.web.api.entity.AccessPolicyEntity;
209 import org.apache.nifi.web.api.entity.AccessPolicySummaryEntity;
210 import org.apache.nifi.web.api.entity.AffectedComponentEntity;
211 import org.apache.nifi.web.api.entity.AllowableValueEntity;
212 import org.apache.nifi.web.api.entity.BulletinEntity;
213 import org.apache.nifi.web.api.entity.ComponentReferenceEntity;
214 import org.apache.nifi.web.api.entity.ConnectionStatusSnapshotEntity;
215 import org.apache.nifi.web.api.entity.ControllerServiceEntity;
216 import org.apache.nifi.web.api.entity.FlowBreadcrumbEntity;
217 import org.apache.nifi.web.api.entity.PortEntity;
218 import org.apache.nifi.web.api.entity.PortStatusSnapshotEntity;
219 import org.apache.nifi.web.api.entity.ProcessGroupStatusSnapshotEntity;
220 import org.apache.nifi.web.api.entity.ProcessorEntity;
221 import org.apache.nifi.web.api.entity.ProcessorStatusSnapshotEntity;
222 import org.apache.nifi.web.api.entity.RemoteProcessGroupEntity;
223 import org.apache.nifi.web.api.entity.RemoteProcessGroupStatusSnapshotEntity;
224 import org.apache.nifi.web.api.entity.TenantEntity;
225 import org.apache.nifi.web.api.entity.VariableEntity;
226 import org.apache.nifi.web.controller.ControllerFacade;
227 import org.apache.nifi.web.revision.RevisionManager;
229 import javax.ws.rs.WebApplicationException;
230 import java.net.UnknownHostException;
231 import java.text.Collator;
232 import java.text.NumberFormat;
233 import java.util.ArrayList;
234 import java.util.Arrays;
235 import java.util.Collection;
236 import java.util.Collections;
237 import java.util.Comparator;
238 import java.util.Date;
239 import java.util.HashMap;
240 import java.util.HashSet;
241 import java.util.Iterator;
242 import java.util.LinkedHashMap;
243 import java.util.LinkedHashSet;
244 import java.util.List;
245 import java.util.Locale;
246 import java.util.Map;
247 import java.util.Map.Entry;
248 import java.util.Set;
249 import java.util.TimeZone;
250 import java.util.TreeMap;
251 import java.util.TreeSet;
252 import java.util.concurrent.TimeUnit;
253 import java.util.function.Function;
254 import java.util.function.Supplier;
255 import java.util.stream.Collectors;
256 import java.net.InetAddress;
259 public final class DtoFactory {
261 @SuppressWarnings("rawtypes")
262 private final static Comparator<Class> CLASS_NAME_COMPARATOR = new Comparator<Class>() {
264 public int compare(final Class class1, final Class class2) {
265 return Collator.getInstance(Locale.US).compare(class1.getSimpleName(), class2.getSimpleName());
268 public static final String SENSITIVE_VALUE_MASK = "********";
270 private BulletinRepository bulletinRepository;
271 private ControllerServiceProvider controllerServiceProvider;
272 private EntityFactory entityFactory;
273 private Authorizer authorizer;
274 private ExtensionManager extensionManager;
276 public ControllerConfigurationDTO createControllerConfigurationDto(final ControllerFacade controllerFacade) {
277 final ControllerConfigurationDTO dto = new ControllerConfigurationDTO();
278 dto.setMaxTimerDrivenThreadCount(controllerFacade.getMaxTimerDrivenThreadCount());
279 dto.setMaxEventDrivenThreadCount(controllerFacade.getMaxEventDrivenThreadCount());
283 public FlowConfigurationDTO createFlowConfigurationDto(final String autoRefreshInterval,
284 final Long defaultBackPressureObjectThreshold,
285 final String defaultBackPressureDataSizeThreshold,
286 final String dcaeDistributorApiHostname) {
287 final FlowConfigurationDTO dto = new FlowConfigurationDTO();
289 // get the refresh interval
290 final long refreshInterval = FormatUtils.getTimeDuration(autoRefreshInterval, TimeUnit.SECONDS);
291 dto.setAutoRefreshIntervalSeconds(refreshInterval);
292 dto.setSupportsManagedAuthorizer(AuthorizerCapabilityDetection.isManagedAuthorizer(authorizer));
293 dto.setSupportsConfigurableUsersAndGroups(AuthorizerCapabilityDetection.isConfigurableUserGroupProvider(authorizer));
294 dto.setSupportsConfigurableAuthorizer(AuthorizerCapabilityDetection.isConfigurableAccessPolicyProvider(authorizer));
296 /* Renu - getting host IP */
297 dto.setDcaeDistributorApiHostname(dcaeDistributorApiHostname);
299 final Date now = new Date();
300 dto.setTimeOffset(TimeZone.getDefault().getOffset(now.getTime()));
301 dto.setCurrentTime(now);
303 dto.setDefaultBackPressureDataSizeThreshold(defaultBackPressureDataSizeThreshold);
304 dto.setDefaultBackPressureObjectThreshold(defaultBackPressureObjectThreshold);
310 * Creates an ActionDTO for the specified Action.
312 * @param action action
315 public ActionDTO createActionDto(final Action action) {
316 final ActionDTO actionDto = new ActionDTO();
317 actionDto.setId(action.getId());
318 actionDto.setSourceId(action.getSourceId());
319 actionDto.setSourceName(action.getSourceName());
320 actionDto.setSourceType(action.getSourceType().toString());
321 actionDto.setTimestamp(action.getTimestamp());
322 actionDto.setUserIdentity(action.getUserIdentity());
323 actionDto.setOperation(action.getOperation().toString());
324 actionDto.setActionDetails(createActionDetailsDto(action.getActionDetails()));
325 actionDto.setComponentDetails(createComponentDetailsDto(action.getComponentDetails()));
331 * Creates an ActionDetailsDTO for the specified ActionDetails.
333 * @param actionDetails details
336 private ActionDetailsDTO createActionDetailsDto(final ActionDetails actionDetails) {
337 if (actionDetails == null) {
341 if (actionDetails instanceof FlowChangeConfigureDetails) {
342 final ConfigureDetailsDTO configureDetails = new ConfigureDetailsDTO();
343 configureDetails.setName(((ConfigureDetails) actionDetails).getName());
344 configureDetails.setPreviousValue(((ConfigureDetails) actionDetails).getPreviousValue());
345 configureDetails.setValue(((ConfigureDetails) actionDetails).getValue());
346 return configureDetails;
347 } else if (actionDetails instanceof FlowChangeConnectDetails) {
348 final ConnectDetailsDTO connectDetails = new ConnectDetailsDTO();
349 connectDetails.setSourceId(((ConnectDetails) actionDetails).getSourceId());
350 connectDetails.setSourceName(((ConnectDetails) actionDetails).getSourceName());
351 connectDetails.setSourceType(((ConnectDetails) actionDetails).getSourceType().toString());
352 connectDetails.setRelationship(((ConnectDetails) actionDetails).getRelationship());
353 connectDetails.setDestinationId(((ConnectDetails) actionDetails).getDestinationId());
354 connectDetails.setDestinationName(((ConnectDetails) actionDetails).getDestinationName());
355 connectDetails.setDestinationType(((ConnectDetails) actionDetails).getDestinationType().toString());
356 return connectDetails;
357 } else if (actionDetails instanceof FlowChangeMoveDetails) {
358 final MoveDetailsDTO moveDetails = new MoveDetailsDTO();
359 moveDetails.setPreviousGroup(((MoveDetails) actionDetails).getPreviousGroup());
360 moveDetails.setPreviousGroupId(((MoveDetails) actionDetails).getPreviousGroupId());
361 moveDetails.setGroup(((MoveDetails) actionDetails).getGroup());
362 moveDetails.setGroupId(((MoveDetails) actionDetails).getGroupId());
364 } else if (actionDetails instanceof FlowChangePurgeDetails) {
365 final PurgeDetailsDTO purgeDetails = new PurgeDetailsDTO();
366 purgeDetails.setEndDate(((PurgeDetails) actionDetails).getEndDate());
369 throw new WebApplicationException(new IllegalArgumentException(String.format("Unrecognized type of action details encountered %s during serialization.", actionDetails.toString())));
374 * Creates a ComponentDetailsDTO for the specified ComponentDetails.
376 * @param componentDetails details
379 private ComponentDetailsDTO createComponentDetailsDto(final ComponentDetails componentDetails) {
380 if (componentDetails == null) {
384 if (componentDetails instanceof FlowChangeExtensionDetails) {
385 final ExtensionDetailsDTO processorDetails = new ExtensionDetailsDTO();
386 processorDetails.setType(((ExtensionDetails) componentDetails).getType());
387 return processorDetails;
388 } else if (componentDetails instanceof FlowChangeRemoteProcessGroupDetails) {
389 final RemoteProcessGroupDetailsDTO remoteProcessGroupDetails = new RemoteProcessGroupDetailsDTO();
390 remoteProcessGroupDetails.setUri(((RemoteProcessGroupDetails) componentDetails).getUri());
391 return remoteProcessGroupDetails;
393 throw new WebApplicationException(new IllegalArgumentException(String.format("Unrecognized type of component details encountered %s during serialization. ", componentDetails.toString())));
398 * Creates a HistoryDTO from the specified History.
400 * @param history history
403 public HistoryDTO createHistoryDto(final History history) {
404 final HistoryDTO historyDto = new HistoryDTO();
405 historyDto.setTotal(history.getTotal());
406 historyDto.setLastRefreshed(history.getLastRefreshed());
411 * Creates a ComponentStateDTO for the given component and state's.
413 * @param componentId component id
414 * @param localState local state
415 * @param clusterState cluster state
418 public ComponentStateDTO createComponentStateDTO(final String componentId, final Class<?> componentClass, final StateMap localState, final StateMap clusterState) {
419 final ComponentStateDTO dto = new ComponentStateDTO();
420 dto.setComponentId(componentId);
421 dto.setStateDescription(getStateDescription(componentClass));
422 dto.setLocalState(createStateMapDTO(Scope.LOCAL, localState));
423 dto.setClusterState(createStateMapDTO(Scope.CLUSTER, clusterState));
428 * Gets the description of the state this component persists.
430 * @param componentClass the component class
431 * @return state description
433 private String getStateDescription(final Class<?> componentClass) {
434 final Stateful capabilityDesc = componentClass.getAnnotation(Stateful.class);
435 if (capabilityDesc != null) {
436 return capabilityDesc.description();
443 * Creates a StateMapDTO for the given scope and state map.
445 * @param scope the scope
446 * @param stateMap the state map
449 public StateMapDTO createStateMapDTO(final Scope scope, final StateMap stateMap) {
450 if (stateMap == null) {
454 final StateMapDTO dto = new StateMapDTO();
455 dto.setScope(scope.toString());
457 final TreeMap<String, String> sortedState = new TreeMap<>(SortedStateUtils.getKeyComparator());
458 final Map<String, String> state = stateMap.toMap();
459 sortedState.putAll(state);
462 final List<StateEntryDTO> stateEntries = new ArrayList<>();
463 final Set<Map.Entry<String, String>> entrySet = sortedState.entrySet();
464 for (final Iterator<Entry<String, String>> iter = entrySet.iterator(); iter.hasNext() && count++ < SortedStateUtils.MAX_COMPONENT_STATE_ENTRIES;) {
465 final Map.Entry<String, String> entry = iter.next();
466 final StateEntryDTO entryDTO = new StateEntryDTO();
467 entryDTO.setKey(entry.getKey());
468 entryDTO.setValue(entry.getValue());
469 stateEntries.add(entryDTO);
471 dto.setTotalEntryCount(state.size());
472 dto.setState(stateEntries);
478 * Creates CounterDTOs for each Counter specified.
480 * @param counterDtos dtos
483 public CountersSnapshotDTO createCountersDto(final Collection<CounterDTO> counterDtos) {
484 final CountersSnapshotDTO dto = new CountersSnapshotDTO();
485 dto.setCounters(counterDtos);
486 dto.setGenerated(new Date());
491 * Creates a CounterDTO from the specified Counter.
493 * @param counter counter
496 public CounterDTO createCounterDto(final Counter counter) {
497 final CounterDTO dto = new CounterDTO();
498 dto.setId(counter.getIdentifier());
499 dto.setContext(counter.getContext());
500 dto.setName(counter.getName());
501 dto.setValueCount(counter.getValue());
502 dto.setValue(FormatUtils.formatCount(counter.getValue()));
507 * Creates a PositionDTO from the specified position
509 * @param position position
512 public PositionDTO createPositionDto(final Position position) {
513 return new PositionDTO(position.getX(), position.getY());
516 private boolean isDropRequestComplete(final DropFlowFileState state) {
517 return DropFlowFileState.COMPLETE.equals(state) || DropFlowFileState.CANCELED.equals(state) || DropFlowFileState.FAILURE.equals(state);
521 * Creates a DropRequestDTO from the specified flow file status.
523 * @param dropRequest dropRequest
526 public DropRequestDTO createDropRequestDTO(final DropFlowFileStatus dropRequest) {
527 final DropRequestDTO dto = new DropRequestDTO();
528 dto.setId(dropRequest.getRequestIdentifier());
529 dto.setSubmissionTime(new Date(dropRequest.getRequestSubmissionTime()));
530 dto.setLastUpdated(new Date(dropRequest.getLastUpdated()));
531 dto.setState(dropRequest.getState().toString());
532 dto.setFailureReason(dropRequest.getFailureReason());
533 dto.setFinished(isDropRequestComplete(dropRequest.getState()));
535 final QueueSize dropped = dropRequest.getDroppedSize();
536 dto.setDroppedCount(dropped.getObjectCount());
537 dto.setDroppedSize(dropped.getByteCount());
538 dto.setDropped(FormatUtils.formatCount(dropped.getObjectCount()) + " / " + FormatUtils.formatDataSize(dropped.getByteCount()));
540 final QueueSize current = dropRequest.getCurrentSize();
541 dto.setCurrentCount(current.getObjectCount());
542 dto.setCurrentSize(current.getByteCount());
543 dto.setCurrent(FormatUtils.formatCount(current.getObjectCount()) + " / " + FormatUtils.formatDataSize(current.getByteCount()));
545 final QueueSize original = dropRequest.getOriginalSize();
546 dto.setOriginalCount(original.getObjectCount());
547 dto.setOriginalSize(original.getByteCount());
548 dto.setOriginal(FormatUtils.formatCount(original.getObjectCount()) + " / " + FormatUtils.formatDataSize(original.getByteCount()));
550 if (isDropRequestComplete(dropRequest.getState())) {
551 dto.setPercentCompleted(100);
553 dto.setPercentCompleted((dropped.getObjectCount() * 100) / original.getObjectCount());
559 private boolean isListingRequestComplete(final ListFlowFileState state) {
560 return ListFlowFileState.COMPLETE.equals(state) || ListFlowFileState.CANCELED.equals(state) || ListFlowFileState.FAILURE.equals(state);
563 private QueueSizeDTO createQueueSizeDTO(final QueueSize queueSize) {
564 final QueueSizeDTO dto = new QueueSizeDTO();
565 dto.setByteCount(queueSize.getByteCount());
566 dto.setObjectCount(queueSize.getObjectCount());
571 * Creates a ListingRequestDTO from the specified ListFlowFileStatus.
573 * @param listingRequest listingRequest
576 public ListingRequestDTO createListingRequestDTO(final ListFlowFileStatus listingRequest) {
577 final ListingRequestDTO dto = new ListingRequestDTO();
578 dto.setId(listingRequest.getRequestIdentifier());
579 dto.setSubmissionTime(new Date(listingRequest.getRequestSubmissionTime()));
580 dto.setLastUpdated(new Date(listingRequest.getLastUpdated()));
581 dto.setState(listingRequest.getState().toString());
582 dto.setFailureReason(listingRequest.getFailureReason());
583 dto.setFinished(isListingRequestComplete(listingRequest.getState()));
584 dto.setMaxResults(listingRequest.getMaxResults());
585 dto.setPercentCompleted(listingRequest.getCompletionPercentage());
587 dto.setQueueSize(createQueueSizeDTO(listingRequest.getQueueSize()));
589 if (isListingRequestComplete(listingRequest.getState())) {
590 final List<FlowFileSummary> flowFileSummaries = listingRequest.getFlowFileSummaries();
591 if (flowFileSummaries != null) {
592 final Date now = new Date();
593 final List<FlowFileSummaryDTO> summaryDtos = new ArrayList<>(flowFileSummaries.size());
594 for (final FlowFileSummary summary : flowFileSummaries) {
595 summaryDtos.add(createFlowFileSummaryDTO(summary, now));
597 dto.setFlowFileSummaries(summaryDtos);
605 * Creates a FlowFileSummaryDTO from the specified FlowFileSummary.
607 * @param summary summary
610 public FlowFileSummaryDTO createFlowFileSummaryDTO(final FlowFileSummary summary, final Date now) {
611 final FlowFileSummaryDTO dto = new FlowFileSummaryDTO();
612 dto.setUuid(summary.getUuid());
613 dto.setFilename(summary.getFilename());
615 dto.setPenalized(summary.isPenalized());
616 final long penaltyExpiration = summary.getPenaltyExpirationMillis() - now.getTime();
617 dto.setPenaltyExpiresIn(penaltyExpiration>=0?penaltyExpiration:0);
619 dto.setPosition(summary.getPosition());
620 dto.setSize(summary.getSize());
622 final long queuedDuration = now.getTime() - summary.getLastQueuedTime();
623 dto.setQueuedDuration(queuedDuration);
625 final long age = now.getTime() - summary.getLineageStartDate();
626 dto.setLineageDuration(age);
632 * Creates a FlowFileDTO from the specified FlowFileRecord.
634 * @param record record
637 public FlowFileDTO createFlowFileDTO(final FlowFileRecord record) {
638 final Date now = new Date();
639 final FlowFileDTO dto = new FlowFileDTO();
640 dto.setUuid(record.getAttribute(CoreAttributes.UUID.key()));
641 dto.setFilename(record.getAttribute(CoreAttributes.FILENAME.key()));
643 dto.setPenalized(record.isPenalized());
644 final long penaltyExpiration = record.getPenaltyExpirationMillis() - now.getTime();
645 dto.setPenaltyExpiresIn(penaltyExpiration>=0?penaltyExpiration:0);
647 dto.setSize(record.getSize());
648 dto.setAttributes(record.getAttributes());
650 final long queuedDuration = now.getTime() - record.getLastQueueDate();
651 dto.setQueuedDuration(queuedDuration);
653 final long age = now.getTime() - record.getLineageStartDate();
654 dto.setLineageDuration(age);
656 final ContentClaim contentClaim = record.getContentClaim();
657 if (contentClaim != null) {
658 final ResourceClaim resourceClaim = contentClaim.getResourceClaim();
659 dto.setContentClaimSection(resourceClaim.getSection());
660 dto.setContentClaimContainer(resourceClaim.getContainer());
661 dto.setContentClaimIdentifier(resourceClaim.getId());
662 dto.setContentClaimOffset(contentClaim.getOffset() + record.getContentClaimOffset());
663 dto.setContentClaimFileSizeBytes(record.getSize());
664 dto.setContentClaimFileSize(FormatUtils.formatDataSize(record.getSize()));
671 * Creates a ConnectionDTO from the specified Connection.
673 * @param connection connection
676 public ConnectionDTO createConnectionDto(final Connection connection) {
677 if (connection == null) {
681 final ConnectionDTO dto = new ConnectionDTO();
683 dto.setId(connection.getIdentifier());
684 dto.setParentGroupId(connection.getProcessGroup().getIdentifier());
686 final List<PositionDTO> bendPoints = new ArrayList<>();
687 for (final Position bendPoint : connection.getBendPoints()) {
688 bendPoints.add(createPositionDto(bendPoint));
690 dto.setBends(bendPoints);
691 dto.setName(connection.getName());
692 dto.setLabelIndex(connection.getLabelIndex());
693 dto.setzIndex(connection.getZIndex());
694 dto.setSource(createConnectableDto(connection.getSource()));
695 dto.setDestination(createConnectableDto(connection.getDestination()));
696 dto.setVersionedComponentId(connection.getVersionedComponentId().orElse(null));
698 final FlowFileQueue flowFileQueue = connection.getFlowFileQueue();
700 dto.setBackPressureObjectThreshold(flowFileQueue.getBackPressureObjectThreshold());
701 dto.setBackPressureDataSizeThreshold(flowFileQueue.getBackPressureDataSizeThreshold());
702 dto.setFlowFileExpiration(flowFileQueue.getFlowFileExpiration());
703 dto.setPrioritizers(new ArrayList<String>());
704 for (final FlowFilePrioritizer comparator : flowFileQueue.getPriorities()) {
705 dto.getPrioritizers().add(comparator.getClass().getCanonicalName());
708 // For ports, we do not want to populate the relationships.
709 for (final Relationship selectedRelationship : connection.getRelationships()) {
710 if (!Relationship.ANONYMOUS.equals(selectedRelationship)) {
711 if (dto.getSelectedRelationships() == null) {
712 dto.setSelectedRelationships(new TreeSet<String>(Collator.getInstance(Locale.US)));
715 dto.getSelectedRelationships().add(selectedRelationship.getName());
719 // For ports, we do not want to populate the relationships.
720 for (final Relationship availableRelationship : connection.getSource().getRelationships()) {
721 if (!Relationship.ANONYMOUS.equals(availableRelationship)) {
722 if (dto.getAvailableRelationships() == null) {
723 dto.setAvailableRelationships(new TreeSet<String>(Collator.getInstance(Locale.US)));
726 dto.getAvailableRelationships().add(availableRelationship.getName());
730 final LoadBalanceStrategy loadBalanceStrategy = flowFileQueue.getLoadBalanceStrategy();
731 dto.setLoadBalancePartitionAttribute(flowFileQueue.getPartitioningAttribute());
732 dto.setLoadBalanceStrategy(loadBalanceStrategy.name());
733 dto.setLoadBalanceCompression(flowFileQueue.getLoadBalanceCompression().name());
735 if (loadBalanceStrategy == LoadBalanceStrategy.DO_NOT_LOAD_BALANCE) {
736 dto.setLoadBalanceStatus(ConnectionDTO.LOAD_BALANCE_NOT_CONFIGURED);
737 } else if (flowFileQueue.isActivelyLoadBalancing()) {
738 dto.setLoadBalanceStatus(ConnectionDTO.LOAD_BALANCE_ACTIVE);
740 dto.setLoadBalanceStatus(ConnectionDTO.LOAD_BALANCE_INACTIVE);
747 * Creates a ConnectableDTO from the specified Connectable.
749 * @param connectable connectable
752 public ConnectableDTO createConnectableDto(final Connectable connectable) {
753 if (connectable == null) {
757 boolean isAuthorized = connectable.isAuthorized(authorizer, RequestAction.READ, NiFiUserUtils.getNiFiUser());
759 final ConnectableDTO dto = new ConnectableDTO();
760 dto.setId(connectable.getIdentifier());
761 dto.setName(isAuthorized ? connectable.getName() : connectable.getIdentifier());
762 dto.setType(connectable.getConnectableType().name());
763 dto.setVersionedComponentId(connectable.getVersionedComponentId().orElse(null));
765 if (connectable instanceof RemoteGroupPort) {
766 final RemoteGroupPort remoteGroupPort = (RemoteGroupPort) connectable;
767 final RemoteProcessGroup remoteGroup = remoteGroupPort.getRemoteProcessGroup();
768 dto.setGroupId(remoteGroup.getIdentifier());
769 dto.setRunning(remoteGroupPort.isTargetRunning());
770 dto.setTransmitting(remoteGroupPort.isRunning());
771 dto.setExists(remoteGroupPort.getTargetExists());
773 dto.setComments(remoteGroup.getComments());
776 dto.setGroupId(connectable.getProcessGroup().getIdentifier());
777 dto.setRunning(connectable.isRunning());
779 dto.setComments(connectable.getComments());
787 * Creates a LabelDTO from the specified Label.
792 public LabelDTO createLabelDto(final Label label) {
797 final LabelDTO dto = new LabelDTO();
798 dto.setId(label.getIdentifier());
799 dto.setPosition(createPositionDto(label.getPosition()));
800 dto.setStyle(label.getStyle());
801 dto.setHeight(label.getSize().getHeight());
802 dto.setWidth(label.getSize().getWidth());
803 dto.setLabel(label.getValue());
804 dto.setParentGroupId(label.getProcessGroup().getIdentifier());
805 dto.setVersionedComponentId(label.getVersionedComponentId().orElse(null));
811 * Creates a {@link UserDTO} from the specified {@link User}.
816 public UserDTO createUserDto(final User user, final Set<TenantEntity> groups, final Set<AccessPolicySummaryEntity> accessPolicies) {
821 final UserDTO dto = new UserDTO();
822 dto.setId(user.getIdentifier());
823 dto.setUserGroups(groups);
824 dto.setIdentity(user.getIdentity());
825 dto.setConfigurable(AuthorizerCapabilityDetection.isUserConfigurable(authorizer, user));
826 dto.setAccessPolicies(accessPolicies);
832 * Creates a {@link TenantDTO} from the specified {@link User}.
837 public TenantDTO createTenantDTO(User user) {
842 final TenantDTO dto = new TenantDTO();
843 dto.setId(user.getIdentifier());
844 dto.setIdentity(user.getIdentity());
845 dto.setConfigurable(AuthorizerCapabilityDetection.isUserConfigurable(authorizer, user));
851 * Creates a {@link UserGroupDTO} from the specified {@link Group}.
853 * @param userGroup user group
856 public UserGroupDTO createUserGroupDto(final Group userGroup, Set<TenantEntity> users, final Set<AccessPolicySummaryEntity> accessPolicies) {
857 if (userGroup == null) {
861 // convert to access policies to handle backward compatibility due to incorrect
862 // type in the UserGroupDTO
863 final Set<AccessPolicyEntity> policies = accessPolicies.stream().map(summaryEntity -> {
864 final AccessPolicyDTO policy = new AccessPolicyDTO();
865 policy.setId(summaryEntity.getId());
867 if (summaryEntity.getPermissions().getCanRead()) {
868 final AccessPolicySummaryDTO summary = summaryEntity.getComponent();
869 policy.setResource(summary.getResource());
870 policy.setAction(summary.getAction());
871 policy.setConfigurable(summary.getConfigurable());
872 policy.setComponentReference(summary.getComponentReference());
875 return entityFactory.createAccessPolicyEntity(policy, summaryEntity.getRevision(), summaryEntity.getPermissions());
876 }).collect(Collectors.toSet());
878 final UserGroupDTO dto = new UserGroupDTO();
879 dto.setId(userGroup.getIdentifier());
881 dto.setIdentity(userGroup.getName());
882 dto.setConfigurable(AuthorizerCapabilityDetection.isGroupConfigurable(authorizer, userGroup));
883 dto.setAccessPolicies(policies);
889 * Creates a {@link TenantDTO} from the specified {@link User}.
891 * @param userGroup user
894 public TenantDTO createTenantDTO(Group userGroup) {
895 if (userGroup == null) {
899 final TenantDTO dto = new TenantDTO();
900 dto.setId(userGroup.getIdentifier());
901 dto.setIdentity(userGroup.getName());
902 dto.setConfigurable(AuthorizerCapabilityDetection.isGroupConfigurable(authorizer, userGroup));
908 * Creates a FunnelDTO from the specified Funnel.
910 * @param funnel funnel
913 public FunnelDTO createFunnelDto(final Funnel funnel) {
914 if (funnel == null) {
918 final FunnelDTO dto = new FunnelDTO();
919 dto.setId(funnel.getIdentifier());
920 dto.setPosition(createPositionDto(funnel.getPosition()));
921 dto.setParentGroupId(funnel.getProcessGroup().getIdentifier());
922 dto.setVersionedComponentId(funnel.getVersionedComponentId().orElse(null));
928 * Creates a SnippetDTO from the specified Snippet.
930 * @param snippet snippet
933 public SnippetDTO createSnippetDto(final Snippet snippet) {
934 final SnippetDTO dto = new SnippetDTO();
935 dto.setId(snippet.getId());
936 dto.setParentGroupId(snippet.getParentGroupId());
938 // populate the snippet contents ids
939 dto.setConnections(mapRevisionToDto(snippet.getConnections()));
940 dto.setFunnels(mapRevisionToDto(snippet.getFunnels()));
941 dto.setInputPorts(mapRevisionToDto(snippet.getInputPorts()));
942 dto.setLabels(mapRevisionToDto(snippet.getLabels()));
943 dto.setOutputPorts(mapRevisionToDto(snippet.getOutputPorts()));
944 dto.setProcessGroups(mapRevisionToDto(snippet.getProcessGroups()));
945 dto.setProcessors(mapRevisionToDto(snippet.getProcessors()));
946 dto.setRemoteProcessGroups(mapRevisionToDto(snippet.getRemoteProcessGroups()));
951 private Map<String, RevisionDTO> mapRevisionToDto(final Map<String, Revision> revisionMap) {
952 final Map<String, RevisionDTO> dtos = new HashMap<>(revisionMap.size());
953 for (final Map.Entry<String, Revision> entry : revisionMap.entrySet()) {
954 final Revision revision = entry.getValue();
955 final RevisionDTO revisionDto = new RevisionDTO();
956 revisionDto.setClientId(revision.getClientId());
957 revisionDto.setVersion(revision.getVersion());
959 dtos.put(entry.getKey(), revisionDto);
965 * Creates a TemplateDTO from the specified template.
967 * @param template template
970 public TemplateDTO createTemplateDTO(final Template template) {
971 if (template == null) {
975 final TemplateDTO original = template.getDetails();
977 final TemplateDTO copy = new TemplateDTO();
978 copy.setId(original.getId());
979 copy.setGroupId(template.getProcessGroup().getIdentifier());
980 copy.setName(original.getName());
981 copy.setDescription(original.getDescription());
982 copy.setTimestamp(original.getTimestamp());
983 copy.setUri(original.getUri());
984 copy.setEncodingVersion(original.getEncodingVersion());
990 public RemoteProcessGroupStatusDTO createRemoteProcessGroupStatusDto(final RemoteProcessGroup remoteProcessGroup, final RemoteProcessGroupStatus remoteProcessGroupStatus) {
991 final RemoteProcessGroupStatusDTO dto = new RemoteProcessGroupStatusDTO();
992 dto.setId(remoteProcessGroupStatus.getId());
993 dto.setGroupId(remoteProcessGroupStatus.getGroupId());
994 dto.setTargetUri(remoteProcessGroupStatus.getTargetUri());
995 dto.setName(remoteProcessGroupStatus.getName());
996 dto.setTransmissionStatus(remoteProcessGroupStatus.getTransmissionStatus().toString());
997 dto.setStatsLastRefreshed(new Date());
998 dto.setValidationStatus(getRemoteProcessGroupValidationStatus(remoteProcessGroup).name());
1000 final RemoteProcessGroupStatusSnapshotDTO snapshot = new RemoteProcessGroupStatusSnapshotDTO();
1001 dto.setAggregateSnapshot(snapshot);
1003 snapshot.setId(remoteProcessGroupStatus.getId());
1004 snapshot.setGroupId(remoteProcessGroupStatus.getGroupId());
1005 snapshot.setName(remoteProcessGroupStatus.getName());
1006 snapshot.setTargetUri(remoteProcessGroupStatus.getTargetUri());
1007 snapshot.setTransmissionStatus(remoteProcessGroupStatus.getTransmissionStatus().toString());
1009 snapshot.setActiveThreadCount(remoteProcessGroupStatus.getActiveThreadCount());
1010 snapshot.setFlowFilesSent(remoteProcessGroupStatus.getSentCount());
1011 snapshot.setBytesSent(remoteProcessGroupStatus.getSentContentSize());
1012 snapshot.setFlowFilesReceived(remoteProcessGroupStatus.getReceivedCount());
1013 snapshot.setBytesReceived(remoteProcessGroupStatus.getReceivedContentSize());
1015 StatusMerger.updatePrettyPrintedFields(snapshot);
1019 private ValidationStatus getRemoteProcessGroupValidationStatus(RemoteProcessGroup remoteProcessGroup) {
1020 final boolean hasAuthIssue = remoteProcessGroup.getAuthorizationIssue() != null && !remoteProcessGroup.getAuthorizationIssue().isEmpty();
1021 final Collection<ValidationResult> validationResults = remoteProcessGroup.validate();
1022 final boolean hasValidationIssue = validationResults != null && !validationResults.isEmpty();
1023 return hasAuthIssue || hasValidationIssue ? ValidationStatus.INVALID : ValidationStatus.VALID;
1026 public ProcessGroupStatusDTO createConciseProcessGroupStatusDto(final ProcessGroupStatus processGroupStatus) {
1027 final ProcessGroupStatusDTO processGroupStatusDto = new ProcessGroupStatusDTO();
1028 processGroupStatusDto.setId(processGroupStatus.getId());
1029 processGroupStatusDto.setName(processGroupStatus.getName());
1030 processGroupStatusDto.setStatsLastRefreshed(new Date());
1032 final ProcessGroupStatusSnapshotDTO snapshot = new ProcessGroupStatusSnapshotDTO();
1033 processGroupStatusDto.setAggregateSnapshot(snapshot);
1035 snapshot.setId(processGroupStatus.getId());
1036 snapshot.setName(processGroupStatus.getName());
1038 if (processGroupStatus.getVersionedFlowState() != null) {
1039 snapshot.setVersionedFlowState(processGroupStatus.getVersionedFlowState().name());
1042 snapshot.setFlowFilesQueued(processGroupStatus.getQueuedCount());
1043 snapshot.setBytesQueued(processGroupStatus.getQueuedContentSize());
1044 snapshot.setBytesRead(processGroupStatus.getBytesRead());
1045 snapshot.setBytesWritten(processGroupStatus.getBytesWritten());
1046 snapshot.setFlowFilesIn(processGroupStatus.getInputCount());
1047 snapshot.setBytesIn(processGroupStatus.getInputContentSize());
1048 snapshot.setFlowFilesOut(processGroupStatus.getOutputCount());
1049 snapshot.setBytesOut(processGroupStatus.getOutputContentSize());
1050 snapshot.setFlowFilesTransferred(processGroupStatus.getFlowFilesTransferred());
1051 snapshot.setBytesTransferred(processGroupStatus.getBytesTransferred());
1052 snapshot.setFlowFilesSent(processGroupStatus.getFlowFilesSent());
1053 snapshot.setBytesSent(processGroupStatus.getBytesSent());
1054 snapshot.setFlowFilesReceived(processGroupStatus.getFlowFilesReceived());
1055 snapshot.setBytesReceived(processGroupStatus.getBytesReceived());
1057 snapshot.setActiveThreadCount(processGroupStatus.getActiveThreadCount());
1058 snapshot.setTerminatedThreadCount(processGroupStatus.getTerminatedThreadCount());
1060 StatusMerger.updatePrettyPrintedFields(snapshot);
1061 return processGroupStatusDto;
1064 public ProcessGroupStatusDTO createProcessGroupStatusDto(final ProcessGroup processGroup, final ProcessGroupStatus processGroupStatus) {
1065 final ProcessGroupStatusDTO processGroupStatusDto = createConciseProcessGroupStatusDto(processGroupStatus);
1066 final ProcessGroupStatusSnapshotDTO snapshot = processGroupStatusDto.getAggregateSnapshot();
1069 final Collection<ProcessorStatusSnapshotEntity> processorStatusSnapshotEntities = new ArrayList<>();
1070 snapshot.setProcessorStatusSnapshots(processorStatusSnapshotEntities);
1071 final Collection<ProcessorStatus> processorStatusCollection = processGroupStatus.getProcessorStatus();
1072 if (processorStatusCollection != null) {
1073 for (final ProcessorStatus processorStatus : processorStatusCollection) {
1074 final ProcessorStatusDTO processorStatusDto = createProcessorStatusDto(processorStatus);
1075 final ProcessorNode processor = processGroup.findProcessor(processorStatusDto.getId());
1076 final PermissionsDTO processorPermissions = createPermissionsDto(processor);
1077 processorStatusSnapshotEntities.add(entityFactory.createProcessorStatusSnapshotEntity(processorStatusDto.getAggregateSnapshot(), processorPermissions));
1081 // connection status
1082 final Collection<ConnectionStatusSnapshotEntity> connectionStatusDtoCollection = new ArrayList<>();
1083 snapshot.setConnectionStatusSnapshots(connectionStatusDtoCollection);
1084 final Collection<ConnectionStatus> connectionStatusCollection = processGroupStatus.getConnectionStatus();
1085 if (connectionStatusCollection != null) {
1086 for (final ConnectionStatus connectionStatus : connectionStatusCollection) {
1087 final ConnectionStatusDTO connectionStatusDto = createConnectionStatusDto(connectionStatus);
1088 final Connection connection = processGroup.findConnection(connectionStatusDto.getId());
1089 final PermissionsDTO connectionPermissions = createPermissionsDto(connection);
1090 connectionStatusDtoCollection.add(entityFactory.createConnectionStatusSnapshotEntity(connectionStatusDto.getAggregateSnapshot(), connectionPermissions));
1094 // local child process groups
1095 final Collection<ProcessGroupStatusSnapshotEntity> childProcessGroupStatusDtoCollection = new ArrayList<>();
1096 snapshot.setProcessGroupStatusSnapshots(childProcessGroupStatusDtoCollection);
1097 final Collection<ProcessGroupStatus> childProcessGroupStatusCollection = processGroupStatus.getProcessGroupStatus();
1098 if (childProcessGroupStatusCollection != null) {
1099 for (final ProcessGroupStatus childProcessGroupStatus : childProcessGroupStatusCollection) {
1100 final ProcessGroupStatusDTO childProcessGroupStatusDto = createProcessGroupStatusDto(processGroup, childProcessGroupStatus);
1101 final ProcessGroup childProcessGroup = processGroup.findProcessGroup(childProcessGroupStatusDto.getId());
1102 final PermissionsDTO childProcessGroupPermissions = createPermissionsDto(childProcessGroup);
1103 childProcessGroupStatusDtoCollection.add(entityFactory.createProcessGroupStatusSnapshotEntity(childProcessGroupStatusDto.getAggregateSnapshot(), childProcessGroupPermissions));
1107 // remote child process groups
1108 final Collection<RemoteProcessGroupStatusSnapshotEntity> childRemoteProcessGroupStatusDtoCollection = new ArrayList<>();
1109 snapshot.setRemoteProcessGroupStatusSnapshots(childRemoteProcessGroupStatusDtoCollection);
1110 final Collection<RemoteProcessGroupStatus> childRemoteProcessGroupStatusCollection = processGroupStatus.getRemoteProcessGroupStatus();
1111 if (childRemoteProcessGroupStatusCollection != null) {
1112 for (final RemoteProcessGroupStatus childRemoteProcessGroupStatus : childRemoteProcessGroupStatusCollection) {
1113 final RemoteProcessGroup remoteProcessGroup = processGroup.findRemoteProcessGroup(childRemoteProcessGroupStatus.getId());
1114 final RemoteProcessGroupStatusDTO childRemoteProcessGroupStatusDto = createRemoteProcessGroupStatusDto(remoteProcessGroup, childRemoteProcessGroupStatus);
1115 final PermissionsDTO remoteProcessGroupPermissions = createPermissionsDto(remoteProcessGroup);
1116 childRemoteProcessGroupStatusDtoCollection.add(entityFactory.createRemoteProcessGroupStatusSnapshotEntity(childRemoteProcessGroupStatusDto.getAggregateSnapshot(),
1117 remoteProcessGroupPermissions));
1122 final Collection<PortStatusSnapshotEntity> inputPortStatusDtoCollection = new ArrayList<>();
1123 snapshot.setInputPortStatusSnapshots(inputPortStatusDtoCollection);
1124 final Collection<PortStatus> inputPortStatusCollection = processGroupStatus.getInputPortStatus();
1125 if (inputPortStatusCollection != null) {
1126 for (final PortStatus portStatus : inputPortStatusCollection) {
1127 final PortStatusDTO portStatusDto = createPortStatusDto(portStatus);
1128 final Port inputPort = processGroup.findInputPort(portStatus.getId());
1129 final PermissionsDTO inputPortPermissions = createPermissionsDto(inputPort);
1130 inputPortStatusDtoCollection.add(entityFactory.createPortStatusSnapshotEntity(portStatusDto.getAggregateSnapshot(), inputPortPermissions));
1135 final Collection<PortStatusSnapshotEntity> outputPortStatusDtoCollection = new ArrayList<>();
1136 snapshot.setOutputPortStatusSnapshots(outputPortStatusDtoCollection);
1137 final Collection<PortStatus> outputPortStatusCollection = processGroupStatus.getOutputPortStatus();
1138 if (outputPortStatusCollection != null) {
1139 for (final PortStatus portStatus : outputPortStatusCollection) {
1140 final PortStatusDTO portStatusDto = createPortStatusDto(portStatus);
1141 final Port outputPort = processGroup.findOutputPort(portStatus.getId());
1142 final PermissionsDTO outputPortPermissions = createPermissionsDto(outputPort);
1143 outputPortStatusDtoCollection.add(entityFactory.createPortStatusSnapshotEntity(portStatusDto.getAggregateSnapshot(), outputPortPermissions));
1147 return processGroupStatusDto;
1150 public ConnectionStatusDTO createConnectionStatusDto(final ConnectionStatus connectionStatus) {
1151 final ConnectionStatusDTO connectionStatusDto = new ConnectionStatusDTO();
1152 connectionStatusDto.setGroupId(connectionStatus.getGroupId());
1153 connectionStatusDto.setId(connectionStatus.getId());
1154 connectionStatusDto.setName(connectionStatus.getName());
1155 connectionStatusDto.setSourceId(connectionStatus.getSourceId());
1156 connectionStatusDto.setSourceName(connectionStatus.getSourceName());
1157 connectionStatusDto.setDestinationId(connectionStatus.getDestinationId());
1158 connectionStatusDto.setDestinationName(connectionStatus.getDestinationName());
1159 connectionStatusDto.setStatsLastRefreshed(new Date());
1161 final ConnectionStatusSnapshotDTO snapshot = new ConnectionStatusSnapshotDTO();
1162 connectionStatusDto.setAggregateSnapshot(snapshot);
1164 snapshot.setId(connectionStatus.getId());
1165 snapshot.setGroupId(connectionStatus.getGroupId());
1166 snapshot.setName(connectionStatus.getName());
1167 snapshot.setSourceName(connectionStatus.getSourceName());
1168 snapshot.setDestinationName(connectionStatus.getDestinationName());
1170 snapshot.setFlowFilesQueued(connectionStatus.getQueuedCount());
1171 snapshot.setBytesQueued(connectionStatus.getQueuedBytes());
1173 snapshot.setFlowFilesIn(connectionStatus.getInputCount());
1174 snapshot.setBytesIn(connectionStatus.getInputBytes());
1176 snapshot.setFlowFilesOut(connectionStatus.getOutputCount());
1177 snapshot.setBytesOut(connectionStatus.getOutputBytes());
1179 if (connectionStatus.getBackPressureObjectThreshold() > 0) {
1180 snapshot.setPercentUseCount(Math.min(100, StatusMerger.getUtilization(connectionStatus.getQueuedCount(), connectionStatus.getBackPressureObjectThreshold())));
1182 if (connectionStatus.getBackPressureBytesThreshold() > 0) {
1183 snapshot.setPercentUseBytes(Math.min(100, StatusMerger.getUtilization(connectionStatus.getQueuedBytes(), connectionStatus.getBackPressureBytesThreshold())));
1186 StatusMerger.updatePrettyPrintedFields(snapshot);
1188 return connectionStatusDto;
1191 public ProcessorStatusDTO createProcessorStatusDto(final ProcessorStatus procStatus) {
1192 final ProcessorStatusDTO dto = new ProcessorStatusDTO();
1193 dto.setId(procStatus.getId());
1194 dto.setGroupId(procStatus.getGroupId());
1195 dto.setName(procStatus.getName());
1196 dto.setStatsLastRefreshed(new Date());
1197 dto.setRunStatus(procStatus.getRunStatus().toString());
1199 final ProcessorStatusSnapshotDTO snapshot = new ProcessorStatusSnapshotDTO();
1200 dto.setAggregateSnapshot(snapshot);
1202 snapshot.setId(procStatus.getId());
1203 snapshot.setGroupId(procStatus.getGroupId());
1204 snapshot.setName(procStatus.getName());
1206 snapshot.setFlowFilesOut(procStatus.getOutputCount());
1207 snapshot.setBytesOut(procStatus.getOutputBytes());
1209 snapshot.setFlowFilesIn(procStatus.getInputCount());
1210 snapshot.setBytesIn(procStatus.getInputBytes());
1212 snapshot.setBytesRead(procStatus.getBytesRead());
1213 snapshot.setBytesWritten(procStatus.getBytesWritten());
1215 snapshot.setTaskCount(procStatus.getInvocations());
1216 snapshot.setTasksDurationNanos(procStatus.getProcessingNanos());
1217 snapshot.setTasksDuration(FormatUtils.formatHoursMinutesSeconds(procStatus.getProcessingNanos(), TimeUnit.NANOSECONDS));
1219 // determine the run status
1220 snapshot.setRunStatus(procStatus.getRunStatus().toString());
1221 snapshot.setExecutionNode(procStatus.getExecutionNode().toString());
1223 snapshot.setActiveThreadCount(procStatus.getActiveThreadCount());
1224 snapshot.setTerminatedThreadCount(procStatus.getTerminatedThreadCount());
1225 snapshot.setType(procStatus.getType());
1227 StatusMerger.updatePrettyPrintedFields(snapshot);
1232 * Creates a PortStatusDTO for the specified PortStatus.
1234 * @param portStatus status
1237 public PortStatusDTO createPortStatusDto(final PortStatus portStatus) {
1238 final PortStatusDTO dto = new PortStatusDTO();
1239 dto.setId(portStatus.getId());
1240 dto.setGroupId(portStatus.getGroupId());
1241 dto.setName(portStatus.getName());
1242 dto.setRunStatus(portStatus.getRunStatus().toString());
1243 dto.setTransmitting(portStatus.isTransmitting());
1244 dto.setStatsLastRefreshed(new Date());
1246 final PortStatusSnapshotDTO snapshot = new PortStatusSnapshotDTO();
1247 dto.setAggregateSnapshot(snapshot);
1249 snapshot.setId(portStatus.getId());
1250 snapshot.setGroupId(portStatus.getGroupId());
1251 snapshot.setName(portStatus.getName());
1252 snapshot.setRunStatus(portStatus.getRunStatus().toString());
1254 snapshot.setActiveThreadCount(portStatus.getActiveThreadCount());
1255 snapshot.setFlowFilesOut(portStatus.getOutputCount());
1256 snapshot.setBytesOut(portStatus.getOutputBytes());
1258 snapshot.setFlowFilesIn(portStatus.getInputCount());
1259 snapshot.setBytesIn(portStatus.getInputBytes());
1260 StatusMerger.updatePrettyPrintedFields(snapshot);
1266 * Copies the specified snippet.
1268 * @param originalSnippet snippet
1271 public FlowSnippetDTO copySnippetContents(final FlowSnippetDTO originalSnippet) {
1272 final FlowSnippetDTO copySnippet = new FlowSnippetDTO();
1274 if (originalSnippet.getConnections() != null) {
1275 for (final ConnectionDTO connection : originalSnippet.getConnections()) {
1276 copySnippet.getConnections().add(copy(connection));
1279 if (originalSnippet.getInputPorts() != null) {
1280 for (final PortDTO port : originalSnippet.getInputPorts()) {
1281 copySnippet.getInputPorts().add(copy(port));
1284 if (originalSnippet.getOutputPorts() != null) {
1285 for (final PortDTO port : originalSnippet.getOutputPorts()) {
1286 copySnippet.getOutputPorts().add(copy(port));
1289 if (originalSnippet.getProcessGroups() != null) {
1290 for (final ProcessGroupDTO processGroup : originalSnippet.getProcessGroups()) {
1291 copySnippet.getProcessGroups().add(copy(processGroup, true));
1294 if (originalSnippet.getProcessors() != null) {
1295 for (final ProcessorDTO processor : originalSnippet.getProcessors()) {
1296 copySnippet.getProcessors().add(copy(processor));
1299 if (originalSnippet.getLabels() != null) {
1300 for (final LabelDTO label : originalSnippet.getLabels()) {
1301 copySnippet.getLabels().add(copy(label));
1304 if (originalSnippet.getFunnels() != null) {
1305 for (final FunnelDTO funnel : originalSnippet.getFunnels()) {
1306 copySnippet.getFunnels().add(copy(funnel));
1309 if (originalSnippet.getRemoteProcessGroups() != null) {
1310 for (final RemoteProcessGroupDTO remoteGroup : originalSnippet.getRemoteProcessGroups()) {
1311 copySnippet.getRemoteProcessGroups().add(copy(remoteGroup));
1314 if (originalSnippet.getControllerServices() != null) {
1315 for (final ControllerServiceDTO controllerService : originalSnippet.getControllerServices()) {
1316 copySnippet.getControllerServices().add(copy(controllerService));
1324 * Creates a PortDTO from the specified Port.
1329 public PortDTO createPortDto(final Port port) {
1334 final PortDTO dto = new PortDTO();
1335 dto.setId(port.getIdentifier());
1336 dto.setPosition(createPositionDto(port.getPosition()));
1337 dto.setName(port.getName());
1338 dto.setComments(port.getComments());
1339 dto.setConcurrentlySchedulableTaskCount(port.getMaxConcurrentTasks());
1340 dto.setParentGroupId(port.getProcessGroup().getIdentifier());
1341 dto.setState(port.getScheduledState().toString());
1342 dto.setType(port.getConnectableType().name());
1343 dto.setVersionedComponentId(port.getVersionedComponentId().orElse(null));
1345 // if this port is on the root group, determine if its actually connected to another nifi
1346 if (port instanceof RootGroupPort) {
1347 final RootGroupPort rootGroupPort = (RootGroupPort) port;
1348 dto.setTransmitting(rootGroupPort.isTransmitting());
1349 dto.setGroupAccessControl(rootGroupPort.getGroupAccessControl());
1350 dto.setUserAccessControl(rootGroupPort.getUserAccessControl());
1353 final Collection<ValidationResult> validationErrors = port.getValidationErrors();
1354 if (validationErrors != null && !validationErrors.isEmpty()) {
1355 final List<String> errors = new ArrayList<>();
1356 for (final ValidationResult validationResult : validationErrors) {
1357 errors.add(validationResult.toString());
1360 dto.setValidationErrors(errors);
1366 public ReportingTaskDTO createReportingTaskDto(final ReportingTaskNode reportingTaskNode) {
1367 final BundleCoordinate bundleCoordinate = reportingTaskNode.getBundleCoordinate();
1368 final List<Bundle> compatibleBundles = extensionManager.getBundles(reportingTaskNode.getCanonicalClassName()).stream().filter(bundle -> {
1369 final BundleCoordinate coordinate = bundle.getBundleDetails().getCoordinate();
1370 return bundleCoordinate.getGroup().equals(coordinate.getGroup()) && bundleCoordinate.getId().equals(coordinate.getId());
1371 }).collect(Collectors.toList());
1373 final ReportingTaskDTO dto = new ReportingTaskDTO();
1374 dto.setId(reportingTaskNode.getIdentifier());
1375 dto.setName(reportingTaskNode.getName());
1376 dto.setType(reportingTaskNode.getCanonicalClassName());
1377 dto.setBundle(createBundleDto(bundleCoordinate));
1378 dto.setSchedulingStrategy(reportingTaskNode.getSchedulingStrategy().name());
1379 dto.setSchedulingPeriod(reportingTaskNode.getSchedulingPeriod());
1380 dto.setState(reportingTaskNode.getScheduledState().name());
1381 dto.setActiveThreadCount(reportingTaskNode.getActiveThreadCount());
1382 dto.setAnnotationData(reportingTaskNode.getAnnotationData());
1383 dto.setComments(reportingTaskNode.getComments());
1384 dto.setPersistsState(reportingTaskNode.getReportingTask().getClass().isAnnotationPresent(Stateful.class));
1385 dto.setRestricted(reportingTaskNode.isRestricted());
1386 dto.setDeprecated(reportingTaskNode.isDeprecated());
1387 dto.setExtensionMissing(reportingTaskNode.isExtensionMissing());
1388 dto.setMultipleVersionsAvailable(compatibleBundles.size() > 1);
1390 final Map<String, String> defaultSchedulingPeriod = new HashMap<>();
1391 defaultSchedulingPeriod.put(SchedulingStrategy.TIMER_DRIVEN.name(), SchedulingStrategy.TIMER_DRIVEN.getDefaultSchedulingPeriod());
1392 defaultSchedulingPeriod.put(SchedulingStrategy.CRON_DRIVEN.name(), SchedulingStrategy.CRON_DRIVEN.getDefaultSchedulingPeriod());
1393 dto.setDefaultSchedulingPeriod(defaultSchedulingPeriod);
1395 // sort a copy of the properties
1396 final Map<PropertyDescriptor, String> sortedProperties = new TreeMap<>(new Comparator<PropertyDescriptor>() {
1398 public int compare(final PropertyDescriptor o1, final PropertyDescriptor o2) {
1399 return Collator.getInstance(Locale.US).compare(o1.getName(), o2.getName());
1402 sortedProperties.putAll(reportingTaskNode.getProperties());
1404 // get the property order from the reporting task
1405 final ReportingTask reportingTask = reportingTaskNode.getReportingTask();
1406 final Map<PropertyDescriptor, String> orderedProperties = new LinkedHashMap<>();
1407 final List<PropertyDescriptor> descriptors = reportingTask.getPropertyDescriptors();
1408 if (descriptors != null && !descriptors.isEmpty()) {
1409 for (final PropertyDescriptor descriptor : descriptors) {
1410 orderedProperties.put(descriptor, null);
1413 orderedProperties.putAll(sortedProperties);
1415 // build the descriptor and property dtos
1416 dto.setDescriptors(new LinkedHashMap<String, PropertyDescriptorDTO>());
1417 dto.setProperties(new LinkedHashMap<String, String>());
1418 for (final Map.Entry<PropertyDescriptor, String> entry : orderedProperties.entrySet()) {
1419 final PropertyDescriptor descriptor = entry.getKey();
1421 // store the property descriptor
1422 dto.getDescriptors().put(descriptor.getName(), createPropertyDescriptorDto(descriptor, null));
1424 // determine the property value - don't include sensitive properties
1425 String propertyValue = entry.getValue();
1426 if (propertyValue != null && descriptor.isSensitive()) {
1427 propertyValue = SENSITIVE_VALUE_MASK;
1430 // set the property value
1431 dto.getProperties().put(descriptor.getName(), propertyValue);
1434 final ValidationStatus validationStatus = reportingTaskNode.getValidationStatus(1, TimeUnit.MILLISECONDS);
1435 dto.setValidationStatus(validationStatus.name());
1437 // add the validation errors
1438 final Collection<ValidationResult> validationErrors = reportingTaskNode.getValidationErrors();
1439 if (validationErrors != null && !validationErrors.isEmpty()) {
1440 final List<String> errors = new ArrayList<>();
1441 for (final ValidationResult validationResult : validationErrors) {
1442 errors.add(validationResult.toString());
1445 dto.setValidationErrors(errors);
1451 public ControllerServiceDTO createControllerServiceDto(final ControllerServiceNode controllerServiceNode) {
1452 final BundleCoordinate bundleCoordinate = controllerServiceNode.getBundleCoordinate();
1453 final List<Bundle> compatibleBundles = extensionManager.getBundles(controllerServiceNode.getCanonicalClassName()).stream().filter(bundle -> {
1454 final BundleCoordinate coordinate = bundle.getBundleDetails().getCoordinate();
1455 return bundleCoordinate.getGroup().equals(coordinate.getGroup()) && bundleCoordinate.getId().equals(coordinate.getId());
1456 }).collect(Collectors.toList());
1458 final ControllerServiceDTO dto = new ControllerServiceDTO();
1459 dto.setId(controllerServiceNode.getIdentifier());
1460 dto.setParentGroupId(controllerServiceNode.getProcessGroup() == null ? null : controllerServiceNode.getProcessGroup().getIdentifier());
1461 dto.setName(controllerServiceNode.getName());
1462 dto.setType(controllerServiceNode.getCanonicalClassName());
1463 dto.setBundle(createBundleDto(bundleCoordinate));
1464 dto.setControllerServiceApis(createControllerServiceApiDto(controllerServiceNode.getControllerServiceImplementation().getClass()));
1465 dto.setState(controllerServiceNode.getState().name());
1466 dto.setAnnotationData(controllerServiceNode.getAnnotationData());
1467 dto.setComments(controllerServiceNode.getComments());
1468 dto.setPersistsState(controllerServiceNode.getControllerServiceImplementation().getClass().isAnnotationPresent(Stateful.class));
1469 dto.setRestricted(controllerServiceNode.isRestricted());
1470 dto.setDeprecated(controllerServiceNode.isDeprecated());
1471 dto.setExtensionMissing(controllerServiceNode.isExtensionMissing());
1472 dto.setMultipleVersionsAvailable(compatibleBundles.size() > 1);
1473 dto.setVersionedComponentId(controllerServiceNode.getVersionedComponentId().orElse(null));
1475 // sort a copy of the properties
1476 final Map<PropertyDescriptor, String> sortedProperties = new TreeMap<>(new Comparator<PropertyDescriptor>() {
1478 public int compare(final PropertyDescriptor o1, final PropertyDescriptor o2) {
1479 return Collator.getInstance(Locale.US).compare(o1.getName(), o2.getName());
1482 sortedProperties.putAll(controllerServiceNode.getProperties());
1484 // get the property order from the controller service
1485 final ControllerService controllerService = controllerServiceNode.getControllerServiceImplementation();
1486 final Map<PropertyDescriptor, String> orderedProperties = new LinkedHashMap<>();
1487 final List<PropertyDescriptor> descriptors = controllerService.getPropertyDescriptors();
1488 if (descriptors != null && !descriptors.isEmpty()) {
1489 for (final PropertyDescriptor descriptor : descriptors) {
1490 orderedProperties.put(descriptor, null);
1493 orderedProperties.putAll(sortedProperties);
1495 // build the descriptor and property dtos
1496 dto.setDescriptors(new LinkedHashMap<String, PropertyDescriptorDTO>());
1497 dto.setProperties(new LinkedHashMap<String, String>());
1498 for (final Map.Entry<PropertyDescriptor, String> entry : orderedProperties.entrySet()) {
1499 final PropertyDescriptor descriptor = entry.getKey();
1501 // store the property descriptor
1502 final String groupId = controllerServiceNode.getProcessGroup() == null ? null : controllerServiceNode.getProcessGroup().getIdentifier();
1503 dto.getDescriptors().put(descriptor.getName(), createPropertyDescriptorDto(descriptor, groupId));
1505 // determine the property value - don't include sensitive properties
1506 String propertyValue = entry.getValue();
1507 if (propertyValue != null && descriptor.isSensitive()) {
1508 propertyValue = SENSITIVE_VALUE_MASK;
1511 // set the property value
1512 dto.getProperties().put(descriptor.getName(), propertyValue);
1515 dto.setValidationStatus(controllerServiceNode.getValidationStatus(1, TimeUnit.MILLISECONDS).name());
1517 // add the validation errors
1518 final Collection<ValidationResult> validationErrors = controllerServiceNode.getValidationErrors();
1519 if (validationErrors != null && !validationErrors.isEmpty()) {
1520 final List<String> errors = new ArrayList<>();
1521 for (final ValidationResult validationResult : validationErrors) {
1522 errors.add(validationResult.toString());
1525 dto.setValidationErrors(errors);
1531 public ControllerServiceReferencingComponentDTO createControllerServiceReferencingComponentDTO(final ComponentNode component) {
1532 final ControllerServiceReferencingComponentDTO dto = new ControllerServiceReferencingComponentDTO();
1533 dto.setId(component.getIdentifier());
1534 dto.setName(component.getName());
1536 String processGroupId = null;
1537 List<PropertyDescriptor> propertyDescriptors = null;
1538 Collection<ValidationResult> validationErrors = null;
1539 if (component instanceof ProcessorNode) {
1540 final ProcessorNode node = ((ProcessorNode) component);
1541 dto.setGroupId(node.getProcessGroup().getIdentifier());
1542 dto.setState(node.getScheduledState().name());
1543 dto.setActiveThreadCount(node.getActiveThreadCount());
1544 dto.setType(node.getComponentType());
1545 dto.setReferenceType(Processor.class.getSimpleName());
1547 propertyDescriptors = node.getProcessor().getPropertyDescriptors();
1548 validationErrors = node.getValidationErrors();
1549 processGroupId = node.getProcessGroup().getIdentifier();
1550 } else if (component instanceof ControllerServiceNode) {
1551 final ControllerServiceNode node = ((ControllerServiceNode) component);
1552 dto.setState(node.getState().name());
1553 dto.setType(node.getComponentType());
1554 dto.setReferenceType(ControllerService.class.getSimpleName());
1556 propertyDescriptors = node.getControllerServiceImplementation().getPropertyDescriptors();
1557 validationErrors = node.getValidationErrors();
1558 processGroupId = node.getProcessGroup() == null ? null : node.getProcessGroup().getIdentifier();
1559 } else if (component instanceof ReportingTaskNode) {
1560 final ReportingTaskNode node = ((ReportingTaskNode) component);
1561 dto.setState(node.getScheduledState().name());
1562 dto.setActiveThreadCount(node.getActiveThreadCount());
1563 dto.setType(node.getComponentType());
1564 dto.setReferenceType(ReportingTask.class.getSimpleName());
1566 propertyDescriptors = node.getReportingTask().getPropertyDescriptors();
1567 validationErrors = node.getValidationErrors();
1568 processGroupId = null;
1571 // ensure descriptors is non null
1572 if (propertyDescriptors == null) {
1573 propertyDescriptors = new ArrayList<>();
1576 // process properties unconditionally since dynamic properties are available here and not in getPropertyDescriptors
1577 final Map<PropertyDescriptor, String> sortedProperties = new TreeMap<>(new Comparator<PropertyDescriptor>() {
1579 public int compare(final PropertyDescriptor o1, final PropertyDescriptor o2) {
1580 return Collator.getInstance(Locale.US).compare(o1.getName(), o2.getName());
1583 sortedProperties.putAll(component.getProperties());
1585 final Map<PropertyDescriptor, String> orderedProperties = new LinkedHashMap<>();
1586 for (final PropertyDescriptor descriptor : propertyDescriptors) {
1587 orderedProperties.put(descriptor, null);
1589 orderedProperties.putAll(sortedProperties);
1591 // build the descriptor and property dtos
1592 dto.setDescriptors(new LinkedHashMap<String, PropertyDescriptorDTO>());
1593 dto.setProperties(new LinkedHashMap<String, String>());
1594 for (final Map.Entry<PropertyDescriptor, String> entry : orderedProperties.entrySet()) {
1595 final PropertyDescriptor descriptor = entry.getKey();
1597 // store the property descriptor
1598 dto.getDescriptors().put(descriptor.getName(), createPropertyDescriptorDto(descriptor, processGroupId));
1600 // determine the property value - don't include sensitive properties
1601 String propertyValue = entry.getValue();
1602 if (propertyValue != null && descriptor.isSensitive()) {
1603 propertyValue = SENSITIVE_VALUE_MASK;
1606 // set the property value
1607 dto.getProperties().put(descriptor.getName(), propertyValue);
1610 if (validationErrors != null && !validationErrors.isEmpty()) {
1611 final List<String> errors = new ArrayList<>();
1612 for (final ValidationResult validationResult : validationErrors) {
1613 errors.add(validationResult.toString());
1616 dto.setValidationErrors(errors);
1622 public RemoteProcessGroupPortDTO createRemoteProcessGroupPortDto(final RemoteGroupPort port) {
1627 final RemoteProcessGroupPortDTO dto = new RemoteProcessGroupPortDTO();
1628 dto.setId(port.getIdentifier());
1629 dto.setGroupId(port.getRemoteProcessGroup().getIdentifier());
1630 dto.setTargetId(port.getTargetIdentifier());
1631 dto.setName(port.getName());
1632 dto.setComments(port.getComments());
1633 dto.setTransmitting(port.isRunning());
1634 dto.setTargetRunning(port.isTargetRunning());
1635 dto.setConcurrentlySchedulableTaskCount(port.getMaxConcurrentTasks());
1636 dto.setUseCompression(port.isUseCompression());
1637 dto.setExists(port.getTargetExists());
1638 dto.setVersionedComponentId(port.getVersionedComponentId().orElse(null));
1640 final BatchSettingsDTO batchDTO = new BatchSettingsDTO();
1641 batchDTO.setCount(port.getBatchCount());
1642 batchDTO.setSize(port.getBatchSize());
1643 batchDTO.setDuration(port.getBatchDuration());
1644 dto.setBatchSettings(batchDTO);
1646 // determine if this port is currently connected to another component locally
1647 if (ConnectableType.REMOTE_OUTPUT_PORT.equals(port.getConnectableType())) {
1648 dto.setConnected(!port.getConnections().isEmpty());
1650 dto.setConnected(port.hasIncomingConnection());
1657 * Creates a RemoteProcessGroupDTO from the specified RemoteProcessGroup.
1659 * @param group group
1662 public RemoteProcessGroupDTO createRemoteProcessGroupDto(final RemoteProcessGroup group) {
1663 if (group == null) {
1667 final Set<RemoteProcessGroupPortDTO> inputPorts = new HashSet<>();
1668 final Set<RemoteProcessGroupPortDTO> outputPorts = new HashSet<>();
1670 int activeRemoteInputPortCount = 0;
1671 int inactiveRemoteInputPortCount = 0;
1672 for (final Port port : group.getInputPorts()) {
1673 inputPorts.add(createRemoteProcessGroupPortDto((RemoteGroupPort) port));
1675 if (port.hasIncomingConnection()) {
1676 if (port.isRunning()) {
1677 activeRemoteInputPortCount++;
1679 inactiveRemoteInputPortCount++;
1684 int activeRemoteOutputPortCount = 0;
1685 int inactiveRemoteOutputPortCount = 0;
1686 for (final Port port : group.getOutputPorts()) {
1687 outputPorts.add(createRemoteProcessGroupPortDto((RemoteGroupPort) port));
1689 if (!port.getConnections().isEmpty()) {
1690 if (port.isRunning()) {
1691 activeRemoteOutputPortCount++;
1693 inactiveRemoteOutputPortCount++;
1698 final RemoteProcessGroupContentsDTO contents = new RemoteProcessGroupContentsDTO();
1699 contents.setInputPorts(inputPorts);
1700 contents.setOutputPorts(outputPorts);
1702 final RemoteProcessGroupDTO dto = new RemoteProcessGroupDTO();
1703 dto.setId(group.getIdentifier());
1704 dto.setName(group.getName());
1705 dto.setPosition(createPositionDto(group.getPosition()));
1706 dto.setComments(group.getComments());
1707 dto.setTransmitting(group.isTransmitting());
1708 dto.setCommunicationsTimeout(group.getCommunicationsTimeout());
1709 dto.setYieldDuration(group.getYieldDuration());
1710 dto.setParentGroupId(group.getProcessGroup().getIdentifier());
1711 dto.setTargetUris(group.getTargetUris());
1712 dto.setFlowRefreshed(group.getLastRefreshTime());
1713 dto.setContents(contents);
1714 dto.setTransportProtocol(group.getTransportProtocol().name());
1715 dto.setProxyHost(group.getProxyHost());
1716 dto.setProxyPort(group.getProxyPort());
1717 dto.setProxyUser(group.getProxyUser());
1718 if (!StringUtils.isEmpty(group.getProxyPassword())) {
1719 dto.setProxyPassword(SENSITIVE_VALUE_MASK);
1722 // only specify the secure flag if we know the target system has site to site enabled
1723 if (group.isSiteToSiteEnabled()) {
1724 dto.setTargetSecure(group.getSecureFlag());
1727 if (group.getAuthorizationIssue() != null) {
1728 dto.setAuthorizationIssues(Arrays.asList(group.getAuthorizationIssue()));
1731 final Collection<ValidationResult> validationErrors = group.validate();
1732 if (validationErrors != null && !validationErrors.isEmpty()) {
1733 final List<String> errors = new ArrayList<>();
1734 for (final ValidationResult validationResult : validationErrors) {
1735 errors.add(validationResult.toString());
1738 dto.setValidationErrors(errors);
1741 dto.setLocalNetworkInterface(group.getNetworkInterface());
1743 dto.setActiveRemoteInputPortCount(activeRemoteInputPortCount);
1744 dto.setInactiveRemoteInputPortCount(inactiveRemoteInputPortCount);
1745 dto.setActiveRemoteOutputPortCount(activeRemoteOutputPortCount);
1746 dto.setInactiveRemoteOutputPortCount(inactiveRemoteOutputPortCount);
1747 dto.setVersionedComponentId(group.getVersionedComponentId().orElse(null));
1749 final RemoteProcessGroupCounts counts = group.getCounts();
1750 if (counts != null) {
1751 dto.setInputPortCount(counts.getInputPortCount());
1752 dto.setOutputPortCount(counts.getOutputPortCount());
1759 * Creates a FlowBreadcrumbEntity from the specified parent ProcessGroup.
1761 * @param group group
1764 private FlowBreadcrumbEntity createBreadcrumbEntity(final ProcessGroup group) {
1765 if (group == null) {
1769 final FlowBreadcrumbDTO dto = createBreadcrumbDto(group);
1770 final PermissionsDTO permissions = createPermissionsDto(group);
1771 final FlowBreadcrumbEntity entity = entityFactory.createFlowBreadcrumbEntity(dto, permissions);
1773 if (group.getParent() != null) {
1774 entity.setParentBreadcrumb(createBreadcrumbEntity(group.getParent()));
1781 * Creates a FlowBreadcrumbDTO from the specified parent ProcessGroup.
1783 * @param group group
1786 private FlowBreadcrumbDTO createBreadcrumbDto(final ProcessGroup group) {
1787 if (group == null) {
1791 final FlowBreadcrumbDTO dto = new FlowBreadcrumbDTO();
1792 dto.setId(group.getIdentifier());
1793 dto.setName(group.getName());
1795 final VersionControlInformationDTO versionControlInformation = createVersionControlInformationDto(group);
1796 dto.setVersionControlInformation(versionControlInformation);
1801 public ComponentReferenceDTO createComponentReferenceDto(final Authorizable authorizable) {
1802 if (authorizable == null || !(authorizable instanceof ComponentAuthorizable)) {
1806 final ComponentAuthorizable componentAuthorizable = (ComponentAuthorizable) authorizable;
1807 final ComponentReferenceDTO dto = new ComponentReferenceDTO();
1808 dto.setId(componentAuthorizable.getIdentifier());
1809 dto.setParentGroupId(componentAuthorizable.getProcessGroupIdentifier());
1810 dto.setName(authorizable.getResource().getName());
1815 public AccessPolicySummaryDTO createAccessPolicySummaryDto(final AccessPolicy accessPolicy, final ComponentReferenceEntity componentReference) {
1816 if (accessPolicy == null) {
1820 final AccessPolicySummaryDTO dto = new AccessPolicySummaryDTO();
1821 dto.setId(accessPolicy.getIdentifier());
1822 dto.setResource(accessPolicy.getResource());
1823 dto.setAction(accessPolicy.getAction().toString());
1824 dto.setConfigurable(AuthorizerCapabilityDetection.isAccessPolicyConfigurable(authorizer, accessPolicy));
1825 dto.setComponentReference(componentReference);
1829 public AccessPolicyDTO createAccessPolicyDto(final AccessPolicy accessPolicy, final Set<TenantEntity> userGroups,
1830 final Set<TenantEntity> users, final ComponentReferenceEntity componentReference) {
1832 if (accessPolicy == null) {
1836 final AccessPolicyDTO dto = new AccessPolicyDTO();
1837 dto.setUserGroups(userGroups);
1838 dto.setUsers(users);
1839 dto.setId(accessPolicy.getIdentifier());
1840 dto.setResource(accessPolicy.getResource());
1841 dto.setAction(accessPolicy.getAction().toString());
1842 dto.setConfigurable(AuthorizerCapabilityDetection.isAccessPolicyConfigurable(authorizer, accessPolicy));
1843 dto.setComponentReference(componentReference);
1848 * Creates the PermissionsDTO based on the specified Authorizable.
1850 * @param authorizable authorizable
1853 public PermissionsDTO createPermissionsDto(final Authorizable authorizable) {
1854 return createPermissionsDto(authorizable, NiFiUserUtils.getNiFiUser());
1858 * Creates the PermissionsDTO based on the specified Authorizable for the given user
1860 * @param authorizable authorizable
1861 * @param user the NiFi User for which the Permissions are being created
1864 public PermissionsDTO createPermissionsDto(final Authorizable authorizable, final NiFiUser user) {
1865 final PermissionsDTO dto = new PermissionsDTO();
1866 dto.setCanRead(authorizable.isAuthorized(authorizer, RequestAction.READ, user));
1867 dto.setCanWrite(authorizable.isAuthorized(authorizer, RequestAction.WRITE, user));
1871 public AffectedComponentEntity createAffectedComponentEntity(final ProcessorEntity processorEntity) {
1872 if (processorEntity == null) {
1876 final AffectedComponentEntity component = new AffectedComponentEntity();
1877 component.setBulletins(processorEntity.getBulletins());
1878 component.setId(processorEntity.getId());
1879 component.setPermissions(processorEntity.getPermissions());
1880 component.setPosition(processorEntity.getPosition());
1881 component.setRevision(processorEntity.getRevision());
1882 component.setUri(processorEntity.getUri());
1884 final ProcessorDTO processorDto = processorEntity.getComponent();
1885 final AffectedComponentDTO componentDto = new AffectedComponentDTO();
1886 componentDto.setId(processorDto.getId());
1887 componentDto.setName(processorDto.getName());
1888 componentDto.setProcessGroupId(processorDto.getParentGroupId());
1889 componentDto.setReferenceType(AffectedComponentDTO.COMPONENT_TYPE_PROCESSOR);
1890 componentDto.setState(processorDto.getState());
1891 componentDto.setValidationErrors(processorDto.getValidationErrors());
1892 component.setComponent(componentDto);
1897 public AffectedComponentEntity createAffectedComponentEntity(final PortEntity portEntity, final String referenceType) {
1898 if (portEntity == null) {
1902 final AffectedComponentEntity component = new AffectedComponentEntity();
1903 component.setBulletins(portEntity.getBulletins());
1904 component.setId(portEntity.getId());
1905 component.setPermissions(portEntity.getPermissions());
1906 component.setPosition(portEntity.getPosition());
1907 component.setRevision(portEntity.getRevision());
1908 component.setUri(portEntity.getUri());
1910 final PortDTO portDto = portEntity.getComponent();
1911 final AffectedComponentDTO componentDto = new AffectedComponentDTO();
1912 componentDto.setId(portDto.getId());
1913 componentDto.setName(portDto.getName());
1914 componentDto.setProcessGroupId(portDto.getParentGroupId());
1915 componentDto.setReferenceType(referenceType);
1916 componentDto.setState(portDto.getState());
1917 componentDto.setValidationErrors(portDto.getValidationErrors());
1918 component.setComponent(componentDto);
1923 public AffectedComponentEntity createAffectedComponentEntity(final ControllerServiceEntity serviceEntity) {
1924 if (serviceEntity == null) {
1928 final AffectedComponentEntity component = new AffectedComponentEntity();
1929 component.setBulletins(serviceEntity.getBulletins());
1930 component.setId(serviceEntity.getId());
1931 component.setPermissions(serviceEntity.getPermissions());
1932 component.setPosition(serviceEntity.getPosition());
1933 component.setRevision(serviceEntity.getRevision());
1934 component.setUri(serviceEntity.getUri());
1936 final ControllerServiceDTO serviceDto = serviceEntity.getComponent();
1937 final AffectedComponentDTO componentDto = new AffectedComponentDTO();
1938 componentDto.setId(serviceDto.getId());
1939 componentDto.setName(serviceDto.getName());
1940 componentDto.setProcessGroupId(serviceDto.getParentGroupId());
1941 componentDto.setReferenceType(AffectedComponentDTO.COMPONENT_TYPE_CONTROLLER_SERVICE);
1942 componentDto.setState(serviceDto.getState());
1943 componentDto.setValidationErrors(serviceDto.getValidationErrors());
1944 component.setComponent(componentDto);
1949 public AffectedComponentEntity createAffectedComponentEntity(final RemoteProcessGroupPortDTO remotePortDto, final String referenceType, final RemoteProcessGroupEntity rpgEntity) {
1950 if (remotePortDto == null) {
1954 final AffectedComponentEntity component = new AffectedComponentEntity();
1955 component.setId(remotePortDto.getId());
1956 component.setPermissions(rpgEntity.getPermissions());
1957 component.setRevision(rpgEntity.getRevision());
1958 component.setUri(rpgEntity.getUri());
1960 final AffectedComponentDTO componentDto = new AffectedComponentDTO();
1961 componentDto.setId(remotePortDto.getId());
1962 componentDto.setName(remotePortDto.getName());
1963 componentDto.setProcessGroupId(remotePortDto.getGroupId());
1964 componentDto.setReferenceType(referenceType);
1965 componentDto.setState(remotePortDto.isTransmitting() ? "Running" : "Stopped");
1966 component.setComponent(componentDto);
1972 public AffectedComponentDTO createAffectedComponentDto(final ComponentNode component) {
1973 final AffectedComponentDTO dto = new AffectedComponentDTO();
1974 dto.setId(component.getIdentifier());
1975 dto.setName(component.getName());
1976 dto.setProcessGroupId(component.getProcessGroupIdentifier());
1978 if (component instanceof ProcessorNode) {
1979 final ProcessorNode node = ((ProcessorNode) component);
1980 dto.setState(node.getScheduledState().name());
1981 dto.setActiveThreadCount(node.getActiveThreadCount());
1982 dto.setReferenceType(AffectedComponentDTO.COMPONENT_TYPE_PROCESSOR);
1983 } else if (component instanceof ControllerServiceNode) {
1984 final ControllerServiceNode node = ((ControllerServiceNode) component);
1985 dto.setState(node.getState().name());
1986 dto.setReferenceType(AffectedComponentDTO.COMPONENT_TYPE_CONTROLLER_SERVICE);
1989 final Collection<ValidationResult> validationErrors = component.getValidationErrors();
1990 if (validationErrors != null && !validationErrors.isEmpty()) {
1991 final List<String> errors = new ArrayList<>();
1992 for (final ValidationResult validationResult : validationErrors) {
1993 errors.add(validationResult.toString());
1996 dto.setValidationErrors(errors);
2003 * Creates a ProcessGroupDTO from the specified ProcessGroup.
2005 * @param group group
2008 public ProcessGroupDTO createProcessGroupDto(final ProcessGroup group) {
2009 return createProcessGroupDto(group, false);
2012 public ProcessGroupFlowDTO createProcessGroupFlowDto(final ProcessGroup group, final ProcessGroupStatus groupStatus, final RevisionManager revisionManager,
2013 final Function<ProcessGroup, List<BulletinEntity>> getProcessGroupBulletins) {
2015 final ProcessGroupFlowDTO dto = new ProcessGroupFlowDTO();
2016 dto.setId(group.getIdentifier());
2017 dto.setLastRefreshed(new Date());
2018 dto.setBreadcrumb(createBreadcrumbEntity(group));
2019 dto.setFlow(createFlowDto(group, groupStatus, revisionManager, getProcessGroupBulletins));
2021 final ProcessGroup parent = group.getParent();
2022 if (parent != null) {
2023 dto.setParentGroupId(parent.getIdentifier());
2029 public FlowDTO createFlowDto(final ProcessGroup group, final ProcessGroupStatus groupStatus, final FlowSnippetDTO snippet, final RevisionManager revisionManager,
2030 final Function<ProcessGroup, List<BulletinEntity>> getProcessGroupBulletins) {
2031 if (snippet == null) {
2035 final FlowDTO flow = new FlowDTO();
2037 for (final ConnectionDTO snippetConnection : snippet.getConnections()) {
2038 final Connection connection = group.getConnection(snippetConnection.getId());
2040 // marshal the actual connection as the snippet is pruned
2041 final ConnectionDTO dto = createConnectionDto(connection);
2042 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(connection.getIdentifier()));
2043 final PermissionsDTO accessPolicy = createPermissionsDto(connection);
2044 final ConnectionStatusDTO status = getComponentStatus(
2045 () -> groupStatus.getConnectionStatus().stream().filter(connectionStatus -> connection.getIdentifier().equals(connectionStatus.getId())).findFirst().orElse(null),
2046 connectionStatus -> createConnectionStatusDto(connectionStatus)
2048 flow.getConnections().add(entityFactory.createConnectionEntity(dto, revision, accessPolicy, status));
2051 for (final FunnelDTO snippetFunnel : snippet.getFunnels()) {
2052 final Funnel funnel = group.getFunnel(snippetFunnel.getId());
2054 // marshal the actual funnel as the snippet is pruned
2055 final FunnelDTO dto = createFunnelDto(funnel);
2056 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(funnel.getIdentifier()));
2057 final PermissionsDTO accessPolicy = createPermissionsDto(funnel);
2058 flow.getFunnels().add(entityFactory.createFunnelEntity(dto, revision, accessPolicy));
2061 for (final PortDTO snippetInputPort : snippet.getInputPorts()) {
2062 final Port inputPort = group.getInputPort(snippetInputPort.getId());
2064 // marshal the actual port as the snippet is pruned
2065 final PortDTO dto = createPortDto(inputPort);
2066 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(inputPort.getIdentifier()));
2067 final PermissionsDTO permissions = createPermissionsDto(inputPort);
2068 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(inputPort));
2069 final PortStatusDTO status = getComponentStatus(
2070 () -> groupStatus.getInputPortStatus().stream().filter(inputPortStatus -> inputPort.getIdentifier().equals(inputPortStatus.getId())).findFirst().orElse(null),
2071 inputPortStatus -> createPortStatusDto(inputPortStatus)
2073 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(inputPort.getIdentifier()));
2074 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2075 flow.getInputPorts().add(entityFactory.createPortEntity(dto, revision, permissions, operatePermissions, status, bulletinEntities));
2078 for (final PortDTO snippetOutputPort : snippet.getOutputPorts()) {
2079 final Port outputPort = group.getOutputPort(snippetOutputPort.getId());
2081 // marshal the actual port as the snippet is pruned
2082 final PortDTO dto = createPortDto(outputPort);
2083 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(outputPort.getIdentifier()));
2084 final PermissionsDTO permissions = createPermissionsDto(outputPort);
2085 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(outputPort));
2086 final PortStatusDTO status = getComponentStatus(
2087 () -> groupStatus.getOutputPortStatus().stream().filter(outputPortStatus -> outputPort.getIdentifier().equals(outputPortStatus.getId())).findFirst().orElse(null),
2088 outputPortStatus -> createPortStatusDto(outputPortStatus)
2090 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(outputPort.getIdentifier()));
2091 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2092 flow.getOutputPorts().add(entityFactory.createPortEntity(dto, revision, permissions, operatePermissions, status, bulletinEntities));
2095 for (final LabelDTO snippetLabel : snippet.getLabels()) {
2096 final Label label = group.getLabel(snippetLabel.getId());
2098 // marshal the actual label as the snippet is pruned
2099 final LabelDTO dto = createLabelDto(label);
2100 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(label.getIdentifier()));
2101 final PermissionsDTO accessPolicy = createPermissionsDto(label);
2102 flow.getLabels().add(entityFactory.createLabelEntity(dto, revision, accessPolicy));
2105 for (final ProcessGroupDTO snippetProcessGroup : snippet.getProcessGroups()) {
2106 final ProcessGroup processGroup = group.getProcessGroup(snippetProcessGroup.getId());
2108 // marshal the actual group as the snippet is pruned
2109 final ProcessGroupDTO dto = createProcessGroupDto(processGroup);
2110 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(processGroup.getIdentifier()));
2111 final PermissionsDTO permissions = createPermissionsDto(processGroup);
2112 final ProcessGroupStatusDTO status = getComponentStatus(
2113 () -> groupStatus.getProcessGroupStatus().stream().filter(processGroupStatus -> processGroup.getIdentifier().equals(processGroupStatus.getId())).findFirst().orElse(null),
2114 processGroupStatus -> createConciseProcessGroupStatusDto(processGroupStatus)
2116 final List<BulletinEntity> bulletins = getProcessGroupBulletins.apply(processGroup);
2117 flow.getProcessGroups().add(entityFactory.createProcessGroupEntity(dto, revision, permissions, status, bulletins));
2120 for (final ProcessorDTO snippetProcessor : snippet.getProcessors()) {
2121 final ProcessorNode processor = group.getProcessor(snippetProcessor.getId());
2123 // marshal the actual processor as the snippet is pruned
2124 final ProcessorDTO dto = createProcessorDto(processor);
2125 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(processor.getIdentifier()));
2126 final PermissionsDTO permissions = createPermissionsDto(processor);
2127 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(processor));
2128 final ProcessorStatusDTO status = getComponentStatus(
2129 () -> groupStatus.getProcessorStatus().stream().filter(processorStatus -> processor.getIdentifier().equals(processorStatus.getId())).findFirst().orElse(null),
2130 processorStatus -> createProcessorStatusDto(processorStatus)
2132 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(processor.getIdentifier()));
2133 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2134 flow.getProcessors().add(entityFactory.createProcessorEntity(dto, revision, permissions, operatePermissions, status, bulletinEntities));
2137 for (final RemoteProcessGroupDTO snippetRemoteProcessGroup : snippet.getRemoteProcessGroups()) {
2138 final RemoteProcessGroup remoteProcessGroup = group.getRemoteProcessGroup(snippetRemoteProcessGroup.getId());
2140 // marshal the actual rpm as the snippet is pruned
2141 final RemoteProcessGroupDTO dto = createRemoteProcessGroupDto(remoteProcessGroup);
2142 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(remoteProcessGroup.getIdentifier()));
2143 final PermissionsDTO permissions = createPermissionsDto(remoteProcessGroup);
2144 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(remoteProcessGroup));
2145 final RemoteProcessGroupStatusDTO status = getComponentStatus(
2146 () -> groupStatus.getRemoteProcessGroupStatus().stream().filter(rpgStatus -> remoteProcessGroup.getIdentifier().equals(rpgStatus.getId())).findFirst().orElse(null),
2147 remoteProcessGroupStatus -> createRemoteProcessGroupStatusDto(remoteProcessGroup, remoteProcessGroupStatus)
2149 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(remoteProcessGroup.getIdentifier()));
2150 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2151 flow.getRemoteProcessGroups().add(entityFactory.createRemoteProcessGroupEntity(dto, revision, permissions, operatePermissions, status, bulletinEntities));
2157 private <T, S> T getComponentStatus(final Supplier<S> getComponentStatus, final Function<S, T> convertToDto) {
2159 final S status = getComponentStatus.get();
2160 if (status != null) {
2161 statusDTO = convertToDto.apply(status);
2168 public FlowDTO createFlowDto(final ProcessGroup group, final ProcessGroupStatus groupStatus, final RevisionManager revisionManager,
2169 final Function<ProcessGroup, List<BulletinEntity>> getProcessGroupBulletins) {
2170 final FlowDTO dto = new FlowDTO();
2172 for (final ProcessorNode procNode : group.getProcessors()) {
2173 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(procNode.getIdentifier()));
2174 final PermissionsDTO permissions = createPermissionsDto(procNode);
2175 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(procNode));
2176 final ProcessorStatusDTO status = getComponentStatus(
2177 () -> groupStatus.getProcessorStatus().stream().filter(processorStatus -> procNode.getIdentifier().equals(processorStatus.getId())).findFirst().orElse(null),
2178 processorStatus -> createProcessorStatusDto(processorStatus)
2180 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(procNode.getIdentifier()));
2181 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2182 dto.getProcessors().add(entityFactory.createProcessorEntity(createProcessorDto(procNode), revision, permissions, operatePermissions, status, bulletinEntities));
2185 for (final Connection connNode : group.getConnections()) {
2186 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(connNode.getIdentifier()));
2187 final PermissionsDTO permissions = createPermissionsDto(connNode);
2188 final ConnectionStatusDTO status = getComponentStatus(
2189 () -> groupStatus.getConnectionStatus().stream().filter(connectionStatus -> connNode.getIdentifier().equals(connectionStatus.getId())).findFirst().orElse(null),
2190 connectionStatus -> createConnectionStatusDto(connectionStatus)
2192 dto.getConnections().add(entityFactory.createConnectionEntity(createConnectionDto(connNode), revision, permissions, status));
2195 for (final Label label : group.getLabels()) {
2196 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(label.getIdentifier()));
2197 final PermissionsDTO permissions = createPermissionsDto(label);
2198 dto.getLabels().add(entityFactory.createLabelEntity(createLabelDto(label), revision, permissions));
2201 for (final Funnel funnel : group.getFunnels()) {
2202 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(funnel.getIdentifier()));
2203 final PermissionsDTO permissions = createPermissionsDto(funnel);
2204 dto.getFunnels().add(entityFactory.createFunnelEntity(createFunnelDto(funnel), revision, permissions));
2207 for (final ProcessGroup childGroup : group.getProcessGroups()) {
2208 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(childGroup.getIdentifier()));
2209 final PermissionsDTO permissions = createPermissionsDto(childGroup);
2210 final ProcessGroupStatusDTO status = getComponentStatus(
2211 () -> groupStatus.getProcessGroupStatus().stream().filter(processGroupStatus -> childGroup.getIdentifier().equals(processGroupStatus.getId())).findFirst().orElse(null),
2212 processGroupStatus -> createConciseProcessGroupStatusDto(processGroupStatus)
2214 final List<BulletinEntity> bulletins = getProcessGroupBulletins.apply(childGroup);
2215 dto.getProcessGroups().add(entityFactory.createProcessGroupEntity(createProcessGroupDto(childGroup), revision, permissions, status, bulletins));
2218 for (final RemoteProcessGroup rpg : group.getRemoteProcessGroups()) {
2219 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(rpg.getIdentifier()));
2220 final PermissionsDTO permissions = createPermissionsDto(rpg);
2221 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(rpg));
2222 final RemoteProcessGroupStatusDTO status = getComponentStatus(
2223 () -> groupStatus.getRemoteProcessGroupStatus().stream().filter(remoteProcessGroupStatus -> rpg.getIdentifier().equals(remoteProcessGroupStatus.getId())).findFirst().orElse(null),
2224 remoteProcessGroupStatus -> createRemoteProcessGroupStatusDto(rpg, remoteProcessGroupStatus)
2226 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(rpg.getIdentifier()));
2227 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2228 dto.getRemoteProcessGroups().add(entityFactory.createRemoteProcessGroupEntity(createRemoteProcessGroupDto(rpg), revision, permissions, operatePermissions, status, bulletinEntities));
2231 for (final Port inputPort : group.getInputPorts()) {
2232 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(inputPort.getIdentifier()));
2233 final PermissionsDTO permissions = createPermissionsDto(inputPort);
2234 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(inputPort));
2235 final PortStatusDTO status = getComponentStatus(
2236 () -> groupStatus.getInputPortStatus().stream().filter(inputPortStatus -> inputPort.getIdentifier().equals(inputPortStatus.getId())).findFirst().orElse(null),
2237 inputPortStatus -> createPortStatusDto(inputPortStatus)
2239 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(inputPort.getIdentifier()));
2240 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2241 dto.getInputPorts().add(entityFactory.createPortEntity(createPortDto(inputPort), revision, permissions, operatePermissions, status, bulletinEntities));
2244 for (final Port outputPort : group.getOutputPorts()) {
2245 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(outputPort.getIdentifier()));
2246 final PermissionsDTO permissions = createPermissionsDto(outputPort);
2247 final PermissionsDTO operatePermissions = createPermissionsDto(new OperationAuthorizable(outputPort));
2248 final PortStatusDTO status = getComponentStatus(
2249 () -> groupStatus.getOutputPortStatus().stream().filter(outputPortStatus -> outputPort.getIdentifier().equals(outputPortStatus.getId())).findFirst().orElse(null),
2250 outputPortStatus -> createPortStatusDto(outputPortStatus)
2252 final List<BulletinDTO> bulletins = createBulletinDtos(bulletinRepository.findBulletinsForSource(outputPort.getIdentifier()));
2253 final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList());
2254 dto.getOutputPorts().add(entityFactory.createPortEntity(createPortDto(outputPort), revision, permissions, operatePermissions, status, bulletinEntities));
2261 * Creates a ProcessGroupDTO from the specified ProcessGroup.
2263 * @param group group
2264 * @param recurse recurse
2267 public ProcessGroupDTO createProcessGroupDto(final ProcessGroup group, final boolean recurse) {
2268 final ProcessGroupDTO dto = createConciseProcessGroupDto(group);
2269 dto.setContents(createProcessGroupContentsDto(group, recurse));
2274 * Creates a ProcessGroupDTO from the specified ProcessGroup.
2276 * @param group group
2279 private ProcessGroupDTO createConciseProcessGroupDto(final ProcessGroup group) {
2280 if (group == null) {
2284 final ProcessGroupDTO dto = new ProcessGroupDTO();
2285 dto.setId(group.getIdentifier());
2286 dto.setPosition(createPositionDto(group.getPosition()));
2287 dto.setComments(group.getComments());
2288 dto.setName(group.getName());
2289 dto.setVersionedComponentId(group.getVersionedComponentId().orElse(null));
2290 dto.setVersionControlInformation(createVersionControlInformationDto(group));
2292 final Map<String, String> variables = group.getVariableRegistry().getVariableMap().entrySet().stream()
2293 .collect(Collectors.toMap(entry -> entry.getKey().getName(), entry -> entry.getValue()));
2294 dto.setVariables(variables);
2296 final ProcessGroup parentGroup = group.getParent();
2297 if (parentGroup != null) {
2298 dto.setParentGroupId(parentGroup.getIdentifier());
2301 final ProcessGroupCounts counts = group.getCounts();
2302 dto.setRunningCount(counts.getRunningCount());
2303 dto.setStoppedCount(counts.getStoppedCount());
2304 dto.setInvalidCount(counts.getInvalidCount());
2305 dto.setDisabledCount(counts.getDisabledCount());
2306 dto.setInputPortCount(counts.getInputPortCount());
2307 dto.setOutputPortCount(counts.getOutputPortCount());
2308 dto.setActiveRemotePortCount(counts.getActiveRemotePortCount());
2309 dto.setInactiveRemotePortCount(counts.getInactiveRemotePortCount());
2310 dto.setUpToDateCount(counts.getUpToDateCount());
2311 dto.setLocallyModifiedCount(counts.getLocallyModifiedCount());
2312 dto.setStaleCount(counts.getStaleCount());
2313 dto.setLocallyModifiedAndStaleCount(counts.getLocallyModifiedAndStaleCount());
2314 dto.setSyncFailureCount(counts.getSyncFailureCount());
2320 public Set<ComponentDifferenceDTO> createComponentDifferenceDtos(final FlowComparison comparison) {
2321 final Map<ComponentDifferenceDTO, List<DifferenceDTO>> differencesByComponent = new HashMap<>();
2323 for (final FlowDifference difference : comparison.getDifferences()) {
2324 // Ignore these as local differences for now because we can't do anything with it
2325 if (difference.getDifferenceType() == DifferenceType.BUNDLE_CHANGED) {
2329 // Ignore differences for adding remote ports
2330 if (FlowDifferenceFilters.isAddedOrRemovedRemotePort(difference)) {
2334 if (FlowDifferenceFilters.isIgnorableVersionedFlowCoordinateChange(difference)) {
2338 final ComponentDifferenceDTO componentDiff = createComponentDifference(difference);
2339 final List<DifferenceDTO> differences = differencesByComponent.computeIfAbsent(componentDiff, key -> new ArrayList<>());
2341 final DifferenceDTO dto = new DifferenceDTO();
2342 dto.setDifferenceType(difference.getDifferenceType().getDescription());
2343 dto.setDifference(difference.getDescription());
2345 differences.add(dto);
2348 for (final Map.Entry<ComponentDifferenceDTO, List<DifferenceDTO>> entry : differencesByComponent.entrySet()) {
2349 entry.getKey().setDifferences(entry.getValue());
2352 return differencesByComponent.keySet();
2355 private ComponentDifferenceDTO createComponentDifference(final FlowDifference difference) {
2356 VersionedComponent component = difference.getComponentA();
2357 if (component == null || difference.getComponentB() instanceof InstantiatedVersionedComponent) {
2358 component = difference.getComponentB();
2361 final ComponentDifferenceDTO dto = new ComponentDifferenceDTO();
2362 dto.setComponentName(component.getName());
2363 dto.setComponentType(component.getComponentType().toString());
2365 if (component instanceof InstantiatedVersionedComponent) {
2366 final InstantiatedVersionedComponent instantiatedComponent = (InstantiatedVersionedComponent) component;
2367 dto.setComponentId(instantiatedComponent.getInstanceId());
2368 dto.setProcessGroupId(instantiatedComponent.getInstanceGroupId());
2370 dto.setComponentId(component.getIdentifier());
2371 dto.setProcessGroupId(dto.getProcessGroupId());
2378 public VersionControlInformationDTO createVersionControlInformationDto(final ProcessGroup group) {
2379 if (group == null) {
2383 final VersionControlInformation versionControlInfo = group.getVersionControlInformation();
2384 if (versionControlInfo == null) {
2388 final VersionControlInformationDTO dto = new VersionControlInformationDTO();
2389 dto.setGroupId(group.getIdentifier());
2390 dto.setRegistryId(versionControlInfo.getRegistryIdentifier());
2391 dto.setRegistryName(versionControlInfo.getRegistryName());
2392 dto.setBucketId(versionControlInfo.getBucketIdentifier());
2393 dto.setBucketName(versionControlInfo.getBucketName());
2394 dto.setFlowId(versionControlInfo.getFlowIdentifier());
2395 dto.setFlowName(versionControlInfo.getFlowName());
2396 dto.setFlowDescription(versionControlInfo.getFlowDescription());
2397 dto.setVersion(versionControlInfo.getVersion());
2399 final VersionedFlowStatus status = versionControlInfo.getStatus();
2400 final VersionedFlowState state = status.getState();
2401 dto.setState(state == null ? null : state.name());
2402 dto.setStateExplanation(status.getStateExplanation());
2407 public Map<String, String> createVersionControlComponentMappingDto(final InstantiatedVersionedProcessGroup group) {
2408 final Map<String, String> mapping = new HashMap<>();
2410 mapping.put(group.getInstanceId(), group.getIdentifier());
2411 group.getProcessors().stream()
2412 .map(proc -> (InstantiatedVersionedProcessor) proc)
2413 .forEach(proc -> mapping.put(proc.getInstanceId(), proc.getIdentifier()));
2414 group.getFunnels().stream()
2415 .map(funnel -> (InstantiatedVersionedFunnel) funnel)
2416 .forEach(funnel -> mapping.put(funnel.getInstanceId(), funnel.getIdentifier()));
2417 group.getInputPorts().stream()
2418 .map(port -> (InstantiatedVersionedPort) port)
2419 .forEach(port -> mapping.put(port.getInstanceId(), port.getIdentifier()));
2420 group.getOutputPorts().stream()
2421 .map(port -> (InstantiatedVersionedPort) port)
2422 .forEach(port -> mapping.put(port.getInstanceId(), port.getIdentifier()));
2423 group.getControllerServices().stream()
2424 .map(service -> (InstantiatedVersionedControllerService) service)
2425 .forEach(service -> mapping.put(service.getInstanceId(), service.getIdentifier()));
2426 group.getLabels().stream()
2427 .map(label -> (InstantiatedVersionedLabel) label)
2428 .forEach(label -> mapping.put(label.getInstanceId(), label.getIdentifier()));
2429 group.getConnections().stream()
2430 .map(conn -> (InstantiatedVersionedConnection) conn)
2431 .forEach(conn -> mapping.put(conn.getInstanceId(), conn.getIdentifier()));
2432 group.getRemoteProcessGroups().stream()
2433 .map(rpg -> (InstantiatedVersionedRemoteProcessGroup) rpg)
2435 mapping.put(rpg.getInstanceId(), rpg.getIdentifier());
2437 if (rpg.getInputPorts() != null) {
2438 rpg.getInputPorts().stream()
2439 .map(port -> (InstantiatedVersionedRemoteGroupPort) port)
2440 .forEach(port -> mapping.put(port.getInstanceId(), port.getIdentifier()));
2443 if (rpg.getOutputPorts() != null) {
2444 rpg.getOutputPorts().stream()
2445 .map(port -> (InstantiatedVersionedRemoteGroupPort) port)
2446 .forEach(port -> mapping.put(port.getInstanceId(), port.getIdentifier()));
2450 group.getProcessGroups().stream()
2451 .map(child -> (InstantiatedVersionedProcessGroup) child)
2453 final Map<String, String> childMapping = createVersionControlComponentMappingDto(child);
2454 mapping.putAll(childMapping);
2462 * Creates a ProcessGroupContentDTO from the specified ProcessGroup.
2464 * @param group group
2465 * @param recurse recurse
2468 private FlowSnippetDTO createProcessGroupContentsDto(final ProcessGroup group, final boolean recurse) {
2469 if (group == null) {
2473 final FlowSnippetDTO dto = new FlowSnippetDTO();
2475 for (final ProcessorNode procNode : group.getProcessors()) {
2476 dto.getProcessors().add(createProcessorDto(procNode));
2479 for (final Connection connNode : group.getConnections()) {
2480 dto.getConnections().add(createConnectionDto(connNode));
2483 for (final Label label : group.getLabels()) {
2484 dto.getLabels().add(createLabelDto(label));
2487 for (final Funnel funnel : group.getFunnels()) {
2488 dto.getFunnels().add(createFunnelDto(funnel));
2491 for (final ProcessGroup childGroup : group.getProcessGroups()) {
2493 dto.getProcessGroups().add(createProcessGroupDto(childGroup, recurse));
2495 dto.getProcessGroups().add(createConciseProcessGroupDto(childGroup));
2499 for (final RemoteProcessGroup remoteProcessGroup : group.getRemoteProcessGroups()) {
2500 dto.getRemoteProcessGroups().add(createRemoteProcessGroupDto(remoteProcessGroup));
2503 for (final Port inputPort : group.getInputPorts()) {
2504 dto.getInputPorts().add(createPortDto(inputPort));
2507 for (final Port outputPort : group.getOutputPorts()) {
2508 dto.getOutputPorts().add(createPortDto(outputPort));
2514 private boolean isRestricted(final Class<?> cls) {
2515 return cls.isAnnotationPresent(Restricted.class);
2518 private String getUsageRestriction(final Class<?> cls) {
2519 final Restricted restricted = cls.getAnnotation(Restricted.class);
2521 if (restricted == null) {
2525 if (StringUtils.isBlank(restricted.value())) {
2529 return restricted.value();
2532 private Set<ExplicitRestrictionDTO> getExplicitRestrictions(final Class<?> cls) {
2533 final Restricted restricted = cls.getAnnotation(Restricted.class);
2535 if (restricted == null) {
2539 final Restriction[] restrictions = restricted.restrictions();
2541 if (restrictions == null || restrictions.length == 0) {
2545 return Arrays.stream(restrictions).map(restriction -> {
2546 final RequiredPermissionDTO requiredPermission = new RequiredPermissionDTO();
2547 requiredPermission.setId(restriction.requiredPermission().getPermissionIdentifier());
2548 requiredPermission.setLabel(restriction.requiredPermission().getPermissionLabel());
2550 final ExplicitRestrictionDTO usageRestriction = new ExplicitRestrictionDTO();
2551 usageRestriction.setRequiredPermission(requiredPermission);
2552 usageRestriction.setExplanation(restriction.explanation());
2553 return usageRestriction;
2554 }).collect(Collectors.toSet());
2557 private String getDeprecationReason(final Class<?> cls) {
2558 final DeprecationNotice deprecationNotice = cls.getAnnotation(DeprecationNotice.class);
2559 return deprecationNotice == null ? null : deprecationNotice.reason();
2562 public Set<AffectedComponentEntity> createAffectedComponentEntities(final Set<ComponentNode> affectedComponents, final RevisionManager revisionManager) {
2563 return affectedComponents.stream()
2565 final AffectedComponentDTO affectedComponent = createAffectedComponentDto(component);
2566 final PermissionsDTO permissions = createPermissionsDto(component);
2567 final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(component.getIdentifier()));
2568 return entityFactory.createAffectedComponentEntity(affectedComponent, revision, permissions);
2570 .collect(Collectors.toSet());
2573 public VariableRegistryDTO createVariableRegistryDto(final ProcessGroup processGroup, final RevisionManager revisionManager) {
2574 final ComponentVariableRegistry variableRegistry = processGroup.getVariableRegistry();
2576 final List<String> variableNames = variableRegistry.getVariableMap().keySet().stream()
2577 .map(descriptor -> descriptor.getName())
2578 .collect(Collectors.toList());
2580 final Set<VariableEntity> variableEntities = new LinkedHashSet<>();
2582 for (final String variableName : variableNames) {
2583 final VariableDTO variableDto = new VariableDTO();
2584 variableDto.setName(variableName);
2585 variableDto.setValue(variableRegistry.getVariableValue(variableName));
2586 variableDto.setProcessGroupId(processGroup.getIdentifier());
2588 final Set<AffectedComponentEntity> affectedComponentEntities = createAffectedComponentEntities(processGroup.getComponentsAffectedByVariable(variableName), revisionManager);
2590 boolean canWrite = true;
2591 for (final AffectedComponentEntity affectedComponent : affectedComponentEntities) {
2592 final PermissionsDTO permissions = affectedComponent.getPermissions();
2593 if (!permissions.getCanRead() || !permissions.getCanWrite()) {
2599 variableDto.setAffectedComponents(affectedComponentEntities);
2601 final VariableEntity variableEntity = new VariableEntity();
2602 variableEntity.setVariable(variableDto);
2603 variableEntity.setCanWrite(canWrite);
2605 variableEntities.add(variableEntity);
2608 final VariableRegistryDTO registryDto = new VariableRegistryDTO();
2609 registryDto.setProcessGroupId(processGroup.getIdentifier());
2610 registryDto.setVariables(variableEntities);
2615 public VariableRegistryUpdateRequestDTO createVariableRegistryUpdateRequestDto(final VariableRegistryUpdateRequest request) {
2616 final VariableRegistryUpdateRequestDTO dto = new VariableRegistryUpdateRequestDTO();
2617 dto.setComplete(request.isComplete());
2618 dto.setFailureReason(request.getFailureReason());
2619 dto.setLastUpdated(request.getLastUpdated());
2620 dto.setProcessGroupId(request.getProcessGroupId());
2621 dto.setRequestId(request.getRequestId());
2622 dto.setSubmissionTime(request.getSubmissionTime());
2624 final List<VariableRegistryUpdateStepDTO> updateSteps = new ArrayList<>();
2625 updateSteps.add(createVariableRegistryUpdateStepDto(request.getIdentifyRelevantComponentsStep()));
2626 updateSteps.add(createVariableRegistryUpdateStepDto(request.getStopProcessorsStep()));
2627 updateSteps.add(createVariableRegistryUpdateStepDto(request.getDisableServicesStep()));
2628 updateSteps.add(createVariableRegistryUpdateStepDto(request.getApplyUpdatesStep()));
2629 updateSteps.add(createVariableRegistryUpdateStepDto(request.getEnableServicesStep()));
2630 updateSteps.add(createVariableRegistryUpdateStepDto(request.getStartProcessorsStep()));
2631 dto.setUpdateSteps(updateSteps);
2633 dto.setAffectedComponents(new HashSet<>(request.getAffectedComponents().values()));
2638 public VariableRegistryUpdateStepDTO createVariableRegistryUpdateStepDto(final VariableRegistryUpdateStep step) {
2639 final VariableRegistryUpdateStepDTO dto = new VariableRegistryUpdateStepDTO();
2640 dto.setComplete(step.isComplete());
2641 dto.setDescription(step.getDescription());
2642 dto.setFailureReason(step.getFailureReason());
2647 public VariableRegistryDTO populateAffectedComponents(final VariableRegistryDTO variableRegistry, final ProcessGroup group, final RevisionManager revisionManager) {
2648 if (!group.getIdentifier().equals(variableRegistry.getProcessGroupId())) {
2649 throw new IllegalArgumentException("Variable Registry does not have the same Group ID as the given Process Group");
2652 final Set<VariableEntity> variableEntities = new LinkedHashSet<>();
2654 if (variableRegistry.getVariables() != null) {
2655 for (final VariableEntity inputEntity : variableRegistry.getVariables()) {
2656 final VariableEntity entity = new VariableEntity();
2658 final VariableDTO inputDto = inputEntity.getVariable();
2659 final VariableDTO variableDto = new VariableDTO();
2660 variableDto.setName(inputDto.getName());
2661 variableDto.setValue(inputDto.getValue());
2662 variableDto.setProcessGroupId(group.getIdentifier());
2664 final Set<AffectedComponentEntity> affectedComponentEntities = createAffectedComponentEntities(group.getComponentsAffectedByVariable(variableDto.getName()), revisionManager);
2666 boolean canWrite = true;
2667 for (final AffectedComponentEntity affectedComponent : affectedComponentEntities) {
2668 final PermissionsDTO permissions = affectedComponent.getPermissions();
2669 if (!permissions.getCanRead() || !permissions.getCanWrite()) {
2675 variableDto.setAffectedComponents(affectedComponentEntities);
2677 entity.setCanWrite(canWrite);
2678 entity.setVariable(inputDto);
2680 variableEntities.add(entity);
2684 final VariableRegistryDTO registryDto = new VariableRegistryDTO();
2685 registryDto.setProcessGroupId(group.getIdentifier());
2686 registryDto.setVariables(variableEntities);
2693 * Gets the capability description from the specified class.
2695 private String getCapabilityDescription(final Class<?> cls) {
2696 final CapabilityDescription capabilityDesc = cls.getAnnotation(CapabilityDescription.class);
2697 return capabilityDesc == null ? null : capabilityDesc.value();
2701 * Gets the tags from the specified class.
2703 private Set<String> getTags(final Class<?> cls) {
2704 final Set<String> tags = new HashSet<>();
2705 final Tags tagsAnnotation = cls.getAnnotation(Tags.class);
2706 if (tagsAnnotation != null) {
2707 for (final String tag : tagsAnnotation.value()) {
2712 if (cls.isAnnotationPresent(Restricted.class)) {
2713 tags.add("restricted");
2720 * Creates a bundle DTO from the specified class.
2722 * @param coordinate bundle coordinates
2725 public BundleDTO createBundleDto(final BundleCoordinate coordinate) {
2726 final BundleDTO dto = new BundleDTO();
2727 dto.setGroup(coordinate.getGroup());
2728 dto.setArtifact(coordinate.getId());
2729 dto.setVersion(coordinate.getVersion());
2733 private List<ControllerServiceApiDTO> createControllerServiceApiDto(final Class cls) {
2734 final Set<Class> serviceApis = new HashSet<>();
2736 // if this is a controller service
2737 if (ControllerService.class.isAssignableFrom(cls)) {
2738 // get all of it's interfaces to determine the controller service api's it implements
2739 final List<Class<?>> interfaces = ClassUtils.getAllInterfaces(cls);
2740 for (final Class i : interfaces) {
2741 // add all controller services that's not ControllerService itself
2742 if (ControllerService.class.isAssignableFrom(i) && !ControllerService.class.equals(i)) {
2747 final List<ControllerServiceApiDTO> dtos = new ArrayList<>();
2748 for (final Class serviceApi : serviceApis) {
2749 final Bundle bundle = extensionManager.getBundle(serviceApi.getClassLoader());
2750 final BundleCoordinate bundleCoordinate = bundle.getBundleDetails().getCoordinate();
2752 final ControllerServiceApiDTO dto = new ControllerServiceApiDTO();
2753 dto.setType(serviceApi.getName());
2754 dto.setBundle(createBundleDto(bundleCoordinate));
2764 * Gets the DocumentedTypeDTOs from the specified classes.
2766 * @param classes classes
2767 * @param bundleGroupFilter if specified, must be member of bundle group
2768 * @param bundleArtifactFilter if specified, must be member of bundle artifact
2769 * @param typeFilter if specified, type must match
2772 public Set<DocumentedTypeDTO> fromDocumentedTypes(final Map<Class, Bundle> classes, final String bundleGroupFilter, final String bundleArtifactFilter, final String typeFilter) {
2773 final Set<DocumentedTypeDTO> types = new LinkedHashSet<>();
2774 final List<Class> sortedClasses = new ArrayList<>(classes.keySet());
2775 Collections.sort(sortedClasses, CLASS_NAME_COMPARATOR);
2777 for (final Class cls : sortedClasses) {
2778 final Bundle bundle = classes.get(cls);
2779 final BundleCoordinate coordinate = bundle.getBundleDetails().getCoordinate();
2781 // only include classes that meet the criteria if specified
2782 if (bundleGroupFilter != null && !bundleGroupFilter.equals(coordinate.getGroup())) {
2785 if (bundleArtifactFilter != null && !bundleArtifactFilter.equals(coordinate.getId())) {
2788 if (typeFilter != null && !typeFilter.equals(cls.getName())) {
2792 final DocumentedTypeDTO dto = new DocumentedTypeDTO();
2793 dto.setType(cls.getName());
2794 dto.setBundle(createBundleDto(coordinate));
2795 dto.setControllerServiceApis(createControllerServiceApiDto(cls));
2796 dto.setDescription(getCapabilityDescription(cls));
2797 dto.setRestricted(isRestricted(cls));
2798 dto.setUsageRestriction(getUsageRestriction(cls));
2799 dto.setExplicitRestrictions(getExplicitRestrictions(cls));
2800 dto.setDeprecationReason(getDeprecationReason(cls));
2801 dto.setTags(getTags(cls));
2809 * Gets the DocumentedTypeDTOs from the specified classes.
2811 * @param classes classes
2812 * @param bundleGroupFilter if specified, must be member of bundle group
2813 * @param bundleArtifactFilter if specified, must be member of bundle artifact
2814 * @param typeFilter if specified, type must match
2817 public Set<DocumentedTypeDTO> fromDocumentedTypes(final Set<Class> classes, final String bundleGroupFilter, final String bundleArtifactFilter, final String typeFilter) {
2818 final Map<Class, Bundle> classBundles = new HashMap<>();
2819 for (final Class cls : classes) {
2820 classBundles.put(cls, extensionManager.getBundle(cls.getClassLoader()));
2822 return fromDocumentedTypes(classBundles, bundleGroupFilter, bundleArtifactFilter, typeFilter);
2826 * Creates a ProcessorDTO from the specified ProcessorNode.
2831 public ProcessorDTO createProcessorDto(final ProcessorNode node) {
2836 final BundleCoordinate bundleCoordinate = node.getBundleCoordinate();
2837 final List<Bundle> compatibleBundles = extensionManager.getBundles(node.getCanonicalClassName()).stream().filter(bundle -> {
2838 final BundleCoordinate coordinate = bundle.getBundleDetails().getCoordinate();
2839 return bundleCoordinate.getGroup().equals(coordinate.getGroup()) && bundleCoordinate.getId().equals(coordinate.getId());
2840 }).collect(Collectors.toList());
2842 final ProcessorDTO dto = new ProcessorDTO();
2843 dto.setId(node.getIdentifier());
2844 dto.setPosition(createPositionDto(node.getPosition()));
2845 dto.setStyle(node.getStyle());
2846 dto.setParentGroupId(node.getProcessGroup().getIdentifier());
2847 dto.setInputRequirement(node.getInputRequirement().name());
2848 dto.setPersistsState(node.getProcessor().getClass().isAnnotationPresent(Stateful.class));
2849 dto.setRestricted(node.isRestricted());
2850 dto.setDeprecated(node.isDeprecated());
2851 dto.setExecutionNodeRestricted(node.isExecutionNodeRestricted());
2852 dto.setExtensionMissing(node.isExtensionMissing());
2853 dto.setMultipleVersionsAvailable(compatibleBundles.size() > 1);
2854 dto.setVersionedComponentId(node.getVersionedComponentId().orElse(null));
2856 dto.setType(node.getCanonicalClassName());
2857 dto.setBundle(createBundleDto(bundleCoordinate));
2858 dto.setName(node.getName());
2859 dto.setState(node.getScheduledState().toString());
2861 // build the relationship dtos
2862 final List<RelationshipDTO> relationships = new ArrayList<>();
2863 for (final Relationship rel : node.getRelationships()) {
2864 final RelationshipDTO relationshipDTO = new RelationshipDTO();
2865 relationshipDTO.setDescription(rel.getDescription());
2866 relationshipDTO.setName(rel.getName());
2867 relationshipDTO.setAutoTerminate(node.isAutoTerminated(rel));
2868 relationships.add(relationshipDTO);
2871 // sort the relationships
2872 Collections.sort(relationships, new Comparator<RelationshipDTO>() {
2874 public int compare(final RelationshipDTO r1, final RelationshipDTO r2) {
2875 return Collator.getInstance(Locale.US).compare(r1.getName(), r2.getName());
2879 // set the relationships
2880 dto.setRelationships(relationships);
2882 dto.setDescription(getCapabilityDescription(node.getClass()));
2883 dto.setSupportsParallelProcessing(!node.isTriggeredSerially());
2884 dto.setSupportsEventDriven(node.isEventDrivenSupported());
2885 dto.setSupportsBatching(node.isSessionBatchingSupported());
2886 dto.setConfig(createProcessorConfigDto(node));
2888 final ValidationStatus validationStatus = node.getValidationStatus(1, TimeUnit.MILLISECONDS);
2889 dto.setValidationStatus(validationStatus.name());
2891 final Collection<ValidationResult> validationErrors = node.getValidationErrors();
2892 if (validationErrors != null && !validationErrors.isEmpty()) {
2893 final List<String> errors = new ArrayList<>();
2894 for (final ValidationResult validationResult : validationErrors) {
2895 errors.add(validationResult.toString());
2898 dto.setValidationErrors(errors);
2905 * Creates a BulletinBoardDTO for the specified bulletins.
2907 * @param bulletins bulletins
2910 public BulletinBoardDTO createBulletinBoardDto(final List<BulletinEntity> bulletins) {
2911 // sort the bulletins
2912 Collections.sort(bulletins, new Comparator<BulletinEntity>() {
2914 public int compare(final BulletinEntity bulletin1, final BulletinEntity bulletin2) {
2915 if (bulletin1 == null && bulletin2 == null) {
2917 } else if (bulletin1 == null) {
2919 } else if (bulletin2 == null) {
2923 final Date timestamp1 = bulletin1.getTimestamp();
2924 final Date timestamp2 = bulletin2.getTimestamp();
2925 if (timestamp1 == null && timestamp2 == null) {
2927 } else if (timestamp1 == null) {
2929 } else if (timestamp2 == null) {
2932 return timestamp1.compareTo(timestamp2);
2937 // create the bulletin board
2938 final BulletinBoardDTO bulletinBoard = new BulletinBoardDTO();
2939 bulletinBoard.setBulletins(bulletins);
2940 bulletinBoard.setGenerated(new Date());
2941 return bulletinBoard;
2945 * Creates BulletinDTOs for the specified Bulletins.
2947 * @param bulletins bulletin
2950 public List<BulletinDTO> createBulletinDtos(final List<Bulletin> bulletins) {
2951 final List<BulletinDTO> bulletinDtos = new ArrayList<>(bulletins.size());
2952 for (final Bulletin bulletin : bulletins) {
2953 bulletinDtos.add(createBulletinDto(bulletin));
2955 return bulletinDtos;
2959 * Creates a BulletinDTO for the specified Bulletin.
2961 * @param bulletin bulletin
2964 public BulletinDTO createBulletinDto(final Bulletin bulletin) {
2965 final BulletinDTO dto = new BulletinDTO();
2966 dto.setId(bulletin.getId());
2967 dto.setNodeAddress(bulletin.getNodeAddress());
2968 dto.setTimestamp(bulletin.getTimestamp());
2969 dto.setGroupId(bulletin.getGroupId());
2970 dto.setSourceId(bulletin.getSourceId());
2971 dto.setSourceName(bulletin.getSourceName());
2972 dto.setCategory(bulletin.getCategory());
2973 dto.setLevel(bulletin.getLevel());
2974 dto.setMessage(bulletin.getMessage());
2979 * Creates a ProvenanceEventNodeDTO for the specified ProvenanceEventLineageNode.
2984 public ProvenanceNodeDTO createProvenanceEventNodeDTO(final ProvenanceEventLineageNode node) {
2985 final ProvenanceNodeDTO dto = new ProvenanceNodeDTO();
2986 dto.setId(node.getIdentifier());
2987 dto.setType("EVENT");
2988 dto.setEventType(node.getEventType().toString());
2989 dto.setTimestamp(new Date(node.getTimestamp()));
2990 dto.setMillis(node.getTimestamp());
2991 dto.setFlowFileUuid(node.getFlowFileUuid());
2992 dto.setParentUuids(node.getParentUuids());
2993 dto.setChildUuids(node.getChildUuids());
2998 * Creates a FlowFileNodeDTO for the specified LineageNode.
3003 public ProvenanceNodeDTO createFlowFileNodeDTO(final LineageNode node) {
3004 final ProvenanceNodeDTO dto = new ProvenanceNodeDTO();
3005 dto.setId(node.getIdentifier());
3006 dto.setType("FLOWFILE");
3007 dto.setTimestamp(new Date(node.getTimestamp()));
3008 dto.setMillis(node.getTimestamp());
3009 dto.setFlowFileUuid(node.getFlowFileUuid());
3014 * Creates a ProvenanceLinkDTO for the specified LineageEdge.
3019 public ProvenanceLinkDTO createProvenanceLinkDTO(final LineageEdge edge) {
3020 final LineageNode source = edge.getSource();
3021 final LineageNode target = edge.getDestination();
3023 final ProvenanceLinkDTO dto = new ProvenanceLinkDTO();
3024 dto.setTimestamp(new Date(target.getTimestamp()));
3025 dto.setMillis(target.getTimestamp());
3026 dto.setFlowFileUuid(edge.getUuid());
3027 dto.setSourceId(source.getIdentifier());
3028 dto.setTargetId(target.getIdentifier());
3033 * Creates a LineageDTO for the specified Lineage.
3035 * @param computeLineageSubmission submission
3038 public LineageDTO createLineageDto(final ComputeLineageSubmission computeLineageSubmission) {
3039 // build the lineage dto
3040 final LineageDTO dto = new LineageDTO();
3041 final LineageRequestDTO requestDto = new LineageRequestDTO();
3042 final LineageResultsDTO resultsDto = new LineageResultsDTO();
3044 // include the original request and results
3045 dto.setRequest(requestDto);
3046 dto.setResults(resultsDto);
3048 // rebuild the request from the submission object
3049 switch (computeLineageSubmission.getLineageComputationType()) {
3050 case EXPAND_CHILDREN:
3051 requestDto.setEventId(computeLineageSubmission.getExpandedEventId());
3052 requestDto.setLineageRequestType(LineageRequestType.CHILDREN);
3054 case EXPAND_PARENTS:
3055 requestDto.setEventId(computeLineageSubmission.getExpandedEventId());
3056 requestDto.setLineageRequestType(LineageRequestType.PARENTS);
3058 case FLOWFILE_LINEAGE:
3059 final Collection<String> uuids = computeLineageSubmission.getLineageFlowFileUuids();
3060 if (uuids.size() == 1) {
3061 requestDto.setUuid(uuids.iterator().next());
3063 requestDto.setEventId(computeLineageSubmission.getExpandedEventId());
3064 requestDto.setLineageRequestType(LineageRequestType.FLOWFILE);
3068 // include lineage details
3069 dto.setId(computeLineageSubmission.getLineageIdentifier());
3070 dto.setSubmissionTime(computeLineageSubmission.getSubmissionTime());
3072 // create the results dto
3073 final ComputeLineageResult results = computeLineageSubmission.getResult();
3074 dto.setFinished(results.isFinished());
3075 dto.setPercentCompleted(results.getPercentComplete());
3076 dto.setExpiration(results.getExpiration());
3078 final List<LineageNode> nodes = results.getNodes();
3079 final List<LineageEdge> edges = results.getEdges();
3081 final List<ProvenanceNodeDTO> nodeDtos = new ArrayList<>();
3082 if (results.isFinished()) {
3083 // create the node dto's
3084 for (final LineageNode node : nodes) {
3085 switch (node.getNodeType()) {
3087 nodeDtos.add(createFlowFileNodeDTO(node));
3089 case PROVENANCE_EVENT_NODE:
3090 nodeDtos.add(createProvenanceEventNodeDTO((ProvenanceEventLineageNode) node));
3095 resultsDto.setNodes(nodeDtos);
3097 // include any errors
3098 if (results.getError() != null) {
3099 final Set<String> errors = new HashSet<>();
3100 errors.add(results.getError());
3101 resultsDto.setErrors(errors);
3104 // create the link dto's
3105 final List<ProvenanceLinkDTO> linkDtos = new ArrayList<>();
3106 for (final LineageEdge edge : edges) {
3107 linkDtos.add(createProvenanceLinkDTO(edge));
3109 resultsDto.setLinks(linkDtos);
3115 * Creates a SystemDiagnosticsDTO for the specified SystemDiagnostics.
3117 * @param sysDiagnostics diags
3120 public SystemDiagnosticsDTO createSystemDiagnosticsDto(final SystemDiagnostics sysDiagnostics) {
3122 final SystemDiagnosticsDTO dto = new SystemDiagnosticsDTO();
3123 final SystemDiagnosticsSnapshotDTO snapshot = new SystemDiagnosticsSnapshotDTO();
3124 dto.setAggregateSnapshot(snapshot);
3126 snapshot.setStatsLastRefreshed(new Date(sysDiagnostics.getCreationTimestamp()));
3129 snapshot.setAvailableProcessors(sysDiagnostics.getAvailableProcessors());
3130 snapshot.setProcessorLoadAverage(sysDiagnostics.getProcessorLoadAverage());
3133 snapshot.setDaemonThreads(sysDiagnostics.getDaemonThreads());
3134 snapshot.setTotalThreads(sysDiagnostics.getTotalThreads());
3137 snapshot.setMaxHeap(FormatUtils.formatDataSize(sysDiagnostics.getMaxHeap()));
3138 snapshot.setMaxHeapBytes(sysDiagnostics.getMaxHeap());
3139 snapshot.setTotalHeap(FormatUtils.formatDataSize(sysDiagnostics.getTotalHeap()));
3140 snapshot.setTotalHeapBytes(sysDiagnostics.getTotalHeap());
3141 snapshot.setUsedHeap(FormatUtils.formatDataSize(sysDiagnostics.getUsedHeap()));
3142 snapshot.setUsedHeapBytes(sysDiagnostics.getUsedHeap());
3143 snapshot.setFreeHeap(FormatUtils.formatDataSize(sysDiagnostics.getFreeHeap()));
3144 snapshot.setFreeHeapBytes(sysDiagnostics.getFreeHeap());
3145 if (sysDiagnostics.getHeapUtilization() != -1) {
3146 snapshot.setHeapUtilization(FormatUtils.formatUtilization(sysDiagnostics.getHeapUtilization()));
3150 snapshot.setMaxNonHeap(FormatUtils.formatDataSize(sysDiagnostics.getMaxNonHeap()));
3151 snapshot.setMaxNonHeapBytes(sysDiagnostics.getMaxNonHeap());
3152 snapshot.setTotalNonHeap(FormatUtils.formatDataSize(sysDiagnostics.getTotalNonHeap()));
3153 snapshot.setTotalNonHeapBytes(sysDiagnostics.getTotalNonHeap());
3154 snapshot.setUsedNonHeap(FormatUtils.formatDataSize(sysDiagnostics.getUsedNonHeap()));
3155 snapshot.setUsedNonHeapBytes(sysDiagnostics.getUsedNonHeap());
3156 snapshot.setFreeNonHeap(FormatUtils.formatDataSize(sysDiagnostics.getFreeNonHeap()));
3157 snapshot.setFreeNonHeapBytes(sysDiagnostics.getFreeNonHeap());
3158 if (sysDiagnostics.getNonHeapUtilization() != -1) {
3159 snapshot.setNonHeapUtilization(FormatUtils.formatUtilization(sysDiagnostics.getNonHeapUtilization()));
3162 // flow file disk usage
3163 final SystemDiagnosticsSnapshotDTO.StorageUsageDTO flowFileRepositoryStorageUsageDto = createStorageUsageDTO(null, sysDiagnostics.getFlowFileRepositoryStorageUsage());
3164 snapshot.setFlowFileRepositoryStorageUsage(flowFileRepositoryStorageUsageDto);
3166 // content disk usage
3167 final Set<SystemDiagnosticsSnapshotDTO.StorageUsageDTO> contentRepositoryStorageUsageDtos = new LinkedHashSet<>();
3168 snapshot.setContentRepositoryStorageUsage(contentRepositoryStorageUsageDtos);
3169 for (final Map.Entry<String, StorageUsage> entry : sysDiagnostics.getContentRepositoryStorageUsage().entrySet()) {
3170 contentRepositoryStorageUsageDtos.add(createStorageUsageDTO(entry.getKey(), entry.getValue()));
3173 // provenance disk usage
3174 final Set<SystemDiagnosticsSnapshotDTO.StorageUsageDTO> provenanceRepositoryStorageUsageDtos = new LinkedHashSet<>();
3175 snapshot.setProvenanceRepositoryStorageUsage(provenanceRepositoryStorageUsageDtos);
3176 for (final Map.Entry<String, StorageUsage> entry : sysDiagnostics.getProvenanceRepositoryStorageUsage().entrySet()) {
3177 provenanceRepositoryStorageUsageDtos.add(createStorageUsageDTO(entry.getKey(), entry.getValue()));
3180 // garbage collection
3181 final Set<SystemDiagnosticsSnapshotDTO.GarbageCollectionDTO> garbageCollectionDtos = new LinkedHashSet<>();
3182 snapshot.setGarbageCollection(garbageCollectionDtos);
3183 for (final Map.Entry<String, GarbageCollection> entry : sysDiagnostics.getGarbageCollection().entrySet()) {
3184 garbageCollectionDtos.add(createGarbageCollectionDTO(entry.getKey(), entry.getValue()));
3188 final SystemDiagnosticsSnapshotDTO.VersionInfoDTO versionInfoDto = createVersionInfoDTO();
3189 snapshot.setVersionInfo(versionInfoDto);
3192 snapshot.setUptime(FormatUtils.formatHoursMinutesSeconds(sysDiagnostics.getUptime(), TimeUnit.MILLISECONDS));
3198 * Creates a StorageUsageDTO from the specified StorageUsage.
3200 * @param identifier id
3201 * @param storageUsage usage
3204 public SystemDiagnosticsSnapshotDTO.StorageUsageDTO createStorageUsageDTO(final String identifier, final StorageUsage storageUsage) {
3205 final SystemDiagnosticsSnapshotDTO.StorageUsageDTO dto = new SystemDiagnosticsSnapshotDTO.StorageUsageDTO();
3206 dto.setIdentifier(identifier);
3207 dto.setFreeSpace(FormatUtils.formatDataSize(storageUsage.getFreeSpace()));
3208 dto.setTotalSpace(FormatUtils.formatDataSize(storageUsage.getTotalSpace()));
3209 dto.setUsedSpace(FormatUtils.formatDataSize(storageUsage.getUsedSpace()));
3210 dto.setFreeSpaceBytes(storageUsage.getFreeSpace());
3211 dto.setTotalSpaceBytes(storageUsage.getTotalSpace());
3212 dto.setUsedSpaceBytes(storageUsage.getUsedSpace());
3213 dto.setUtilization(FormatUtils.formatUtilization(storageUsage.getDiskUtilization()));
3218 * Creates a GarbageCollectionDTO from the specified GarbageCollection.
3221 * @param garbageCollection gc
3224 public SystemDiagnosticsSnapshotDTO.GarbageCollectionDTO createGarbageCollectionDTO(final String name, final GarbageCollection garbageCollection) {
3225 final SystemDiagnosticsSnapshotDTO.GarbageCollectionDTO dto = new SystemDiagnosticsSnapshotDTO.GarbageCollectionDTO();
3227 dto.setCollectionCount(garbageCollection.getCollectionCount());
3228 dto.setCollectionTime(FormatUtils.formatHoursMinutesSeconds(garbageCollection.getCollectionTime(), TimeUnit.MILLISECONDS));
3229 dto.setCollectionMillis(garbageCollection.getCollectionTime());
3233 public SystemDiagnosticsSnapshotDTO.VersionInfoDTO createVersionInfoDTO() {
3234 final SystemDiagnosticsSnapshotDTO.VersionInfoDTO dto = new SystemDiagnosticsSnapshotDTO.VersionInfoDTO();
3235 dto.setJavaVendor(System.getProperty("java.vendor"));
3236 dto.setJavaVersion(System.getProperty("java.version"));
3237 dto.setOsName(System.getProperty("os.name"));
3238 dto.setOsVersion(System.getProperty("os.version"));
3239 dto.setOsArchitecture(System.getProperty("os.arch"));
3241 final Bundle frameworkBundle = NarClassLoadersHolder.getInstance().getFrameworkBundle();
3242 if (frameworkBundle != null) {
3243 final BundleDetails frameworkDetails = frameworkBundle.getBundleDetails();
3245 dto.setNiFiVersion(frameworkDetails.getCoordinate().getVersion());
3248 dto.setBuildTag(frameworkDetails.getBuildTag());
3249 dto.setBuildRevision(frameworkDetails.getBuildRevision());
3250 dto.setBuildBranch(frameworkDetails.getBuildBranch());
3251 dto.setBuildTimestamp(frameworkDetails.getBuildTimestampDate());
3258 * Creates a ResourceDTO from the specified Resource.
3260 * @param resource resource
3263 public ResourceDTO createResourceDto(final Resource resource) {
3264 final ResourceDTO dto = new ResourceDTO();
3265 dto.setIdentifier(resource.getIdentifier());
3266 dto.setName(resource.getName());
3271 * Creates a ProcessorDiagnosticsDTO from the given Processor and status information with some additional supporting information
3273 * @param procNode the processor to create diagnostics for
3274 * @param procStatus the status of given processor
3275 * @param bulletinRepo the bulletin repository
3276 * @param flowController flowController
3277 * @param serviceEntityFactory function for creating a ControllerServiceEntity from a given ID
3278 * @return ProcessorDiagnosticsDTO for the given Processor
3280 public ProcessorDiagnosticsDTO createProcessorDiagnosticsDto(final ProcessorNode procNode, final ProcessorStatus procStatus, final BulletinRepository bulletinRepo,
3281 final FlowController flowController, final Function<String, ControllerServiceEntity> serviceEntityFactory) {
3283 final ProcessorDiagnosticsDTO procDiagnostics = new ProcessorDiagnosticsDTO();
3285 procDiagnostics.setClassLoaderDiagnostics(createClassLoaderDiagnosticsDto(procNode));
3286 procDiagnostics.setIncomingConnections(procNode.getIncomingConnections().stream()
3287 .map(this::createConnectionDiagnosticsDto)
3288 .collect(Collectors.toSet()));
3289 procDiagnostics.setOutgoingConnections(procNode.getConnections().stream()
3290 .map(this::createConnectionDiagnosticsDto)
3291 .collect(Collectors.toSet()));
3292 procDiagnostics.setJvmDiagnostics(createJvmDiagnosticsDto(flowController));
3293 procDiagnostics.setProcessor(createProcessorDto(procNode));
3294 procDiagnostics.setProcessorStatus(createProcessorStatusDto(procStatus));
3295 procDiagnostics.setThreadDumps(createThreadDumpDtos(procNode));
3297 final Set<ControllerServiceDiagnosticsDTO> referencedServiceDiagnostics = createReferencedServiceDiagnostics(procNode.getProperties(),
3298 flowController.getControllerServiceProvider(), serviceEntityFactory);
3299 procDiagnostics.setReferencedControllerServices(referencedServiceDiagnostics);
3301 return procDiagnostics;
3304 private Set<ControllerServiceDiagnosticsDTO> createReferencedServiceDiagnostics(final Map<PropertyDescriptor, String> properties, final ControllerServiceProvider serviceProvider,
3305 final Function<String, ControllerServiceEntity> serviceEntityFactory) {
3307 final Set<ControllerServiceDiagnosticsDTO> referencedServiceDiagnostics = new HashSet<>();
3308 for (final Map.Entry<PropertyDescriptor, String> entry : properties.entrySet()) {
3309 final PropertyDescriptor descriptor = entry.getKey();
3310 if (descriptor.getControllerServiceDefinition() == null) {
3314 final String serviceId = entry.getValue();
3315 if (serviceId == null) {
3319 final ControllerServiceNode serviceNode = serviceProvider.getControllerServiceNode(serviceId);
3320 if (serviceNode == null) {
3324 final ControllerServiceDiagnosticsDTO serviceDiagnostics = createControllerServiceDiagnosticsDto(serviceNode, serviceEntityFactory, serviceProvider);
3325 if (serviceDiagnostics != null) {
3326 referencedServiceDiagnostics.add(serviceDiagnostics);
3330 return referencedServiceDiagnostics;
3334 * Creates a ControllerServiceDiagnosticsDTO from the given Controller Service with some additional supporting information
3336 * @param serviceNode the controller service to create diagnostics for
3337 * @param serviceEntityFactory a function to convert a controller service id to a controller service entity
3338 * @param serviceProvider the controller service provider
3339 * @return ControllerServiceDiagnosticsDTO for the given Controller Service
3341 public ControllerServiceDiagnosticsDTO createControllerServiceDiagnosticsDto(final ControllerServiceNode serviceNode, final Function<String, ControllerServiceEntity> serviceEntityFactory,
3342 final ControllerServiceProvider serviceProvider) {
3344 final ControllerServiceDiagnosticsDTO serviceDiagnostics = new ControllerServiceDiagnosticsDTO();
3345 final ControllerServiceEntity serviceEntity = serviceEntityFactory.apply(serviceNode.getIdentifier());
3346 serviceDiagnostics.setControllerService(serviceEntity);
3348 serviceDiagnostics.setClassLoaderDiagnostics(createClassLoaderDiagnosticsDto(serviceNode));
3349 return serviceDiagnostics;
3353 private ClassLoaderDiagnosticsDTO createClassLoaderDiagnosticsDto(final ControllerServiceNode serviceNode) {
3354 ClassLoader componentClassLoader = extensionManager.getInstanceClassLoader(serviceNode.getIdentifier());
3355 if (componentClassLoader == null) {
3356 componentClassLoader = serviceNode.getControllerServiceImplementation().getClass().getClassLoader();
3359 return createClassLoaderDiagnosticsDto(componentClassLoader);
3363 private ClassLoaderDiagnosticsDTO createClassLoaderDiagnosticsDto(final ProcessorNode procNode) {
3364 ClassLoader componentClassLoader = extensionManager.getInstanceClassLoader(procNode.getIdentifier());
3365 if (componentClassLoader == null) {
3366 componentClassLoader = procNode.getProcessor().getClass().getClassLoader();
3369 return createClassLoaderDiagnosticsDto(componentClassLoader);
3372 private ClassLoaderDiagnosticsDTO createClassLoaderDiagnosticsDto(final ClassLoader classLoader) {
3373 final ClassLoaderDiagnosticsDTO dto = new ClassLoaderDiagnosticsDTO();
3375 final Bundle bundle = extensionManager.getBundle(classLoader);
3376 if (bundle != null) {
3377 dto.setBundle(createBundleDto(bundle.getBundleDetails().getCoordinate()));
3380 final ClassLoader parentClassLoader = classLoader.getParent();
3381 if (parentClassLoader != null) {
3382 dto.setParentClassLoader(createClassLoaderDiagnosticsDto(parentClassLoader));
3389 private ConnectionDiagnosticsDTO createConnectionDiagnosticsDto(final Connection connection) {
3390 final ConnectionDiagnosticsDTO dto = new ConnectionDiagnosticsDTO();
3391 dto.setConnection(createConnectionDto(connection));
3392 dto.setAggregateSnapshot(createConnectionDiagnosticsSnapshotDto(connection));
3396 private ConnectionDiagnosticsSnapshotDTO createConnectionDiagnosticsSnapshotDto(final Connection connection) {
3397 final ConnectionDiagnosticsSnapshotDTO dto = new ConnectionDiagnosticsSnapshotDTO();
3399 final QueueDiagnostics queueDiagnostics = connection.getFlowFileQueue().getQueueDiagnostics();
3401 final FlowFileQueue queue = connection.getFlowFileQueue();
3402 final QueueSize totalSize = queue.size();
3403 dto.setTotalByteCount(totalSize.getByteCount());
3404 dto.setTotalFlowFileCount(totalSize.getObjectCount());
3406 final LocalQueuePartitionDiagnostics localDiagnostics = queueDiagnostics.getLocalQueuePartitionDiagnostics();
3407 dto.setLocalQueuePartition(createLocalQueuePartitionDto(localDiagnostics));
3409 final List<RemoteQueuePartitionDiagnostics> remoteDiagnostics = queueDiagnostics.getRemoteQueuePartitionDiagnostics();
3410 if (remoteDiagnostics != null) {
3411 final List<RemoteQueuePartitionDTO> remoteDiagnosticsDtos = remoteDiagnostics.stream()
3412 .map(this::createRemoteQueuePartitionDto)
3413 .collect(Collectors.toList());
3415 dto.setRemoteQueuePartitions(remoteDiagnosticsDtos);
3421 private LocalQueuePartitionDTO createLocalQueuePartitionDto(final LocalQueuePartitionDiagnostics queueDiagnostics) {
3422 final LocalQueuePartitionDTO dto = new LocalQueuePartitionDTO();
3424 final QueueSize activeSize = queueDiagnostics.getActiveQueueSize();
3425 dto.setActiveQueueByteCount(activeSize.getByteCount());
3426 dto.setActiveQueueFlowFileCount(activeSize.getObjectCount());
3428 final QueueSize inFlightSize = queueDiagnostics.getUnacknowledgedQueueSize();
3429 dto.setInFlightByteCount(inFlightSize.getByteCount());
3430 dto.setInFlightFlowFileCount(inFlightSize.getObjectCount());
3432 final QueueSize swapSize = queueDiagnostics.getSwapQueueSize();
3433 dto.setSwapByteCount(swapSize.getByteCount());
3434 dto.setSwapFlowFileCount(swapSize.getObjectCount());
3435 dto.setSwapFiles(queueDiagnostics.getSwapFileCount());
3437 dto.setTotalByteCount(activeSize.getByteCount() + inFlightSize.getByteCount() + swapSize.getByteCount());
3438 dto.setTotalFlowFileCount(activeSize.getObjectCount() + inFlightSize.getObjectCount() + swapSize.getObjectCount());
3440 dto.setAllActiveQueueFlowFilesPenalized(queueDiagnostics.isAllActiveFlowFilesPenalized());
3441 dto.setAnyActiveQueueFlowFilesPenalized(queueDiagnostics.isAnyActiveFlowFilePenalized());
3446 private RemoteQueuePartitionDTO createRemoteQueuePartitionDto(final RemoteQueuePartitionDiagnostics queueDiagnostics) {
3447 final RemoteQueuePartitionDTO dto = new RemoteQueuePartitionDTO();
3449 dto.setNodeIdentifier(queueDiagnostics.getNodeIdentifier());
3451 final QueueSize activeSize = queueDiagnostics.getActiveQueueSize();
3452 dto.setActiveQueueByteCount(activeSize.getByteCount());
3453 dto.setActiveQueueFlowFileCount(activeSize.getObjectCount());
3455 final QueueSize inFlightSize = queueDiagnostics.getUnacknowledgedQueueSize();
3456 dto.setInFlightByteCount(inFlightSize.getByteCount());
3457 dto.setInFlightFlowFileCount(inFlightSize.getObjectCount());
3459 final QueueSize swapSize = queueDiagnostics.getSwapQueueSize();
3460 dto.setSwapByteCount(swapSize.getByteCount());
3461 dto.setSwapFlowFileCount(swapSize.getObjectCount());
3462 dto.setSwapFiles(queueDiagnostics.getSwapFileCount());
3464 dto.setTotalByteCount(activeSize.getByteCount() + inFlightSize.getByteCount() + swapSize.getByteCount());
3465 dto.setTotalFlowFileCount(activeSize.getObjectCount() + inFlightSize.getObjectCount() + swapSize.getObjectCount());
3470 private JVMDiagnosticsDTO createJvmDiagnosticsDto(final FlowController flowController) {
3471 final JVMDiagnosticsDTO dto = new JVMDiagnosticsDTO();
3472 dto.setAggregateSnapshot(createJvmDiagnosticsSnapshotDto(flowController));
3473 dto.setClustered(flowController.isClustered());
3474 dto.setConnected(flowController.isConnected());
3478 private JVMDiagnosticsSnapshotDTO createJvmDiagnosticsSnapshotDto(final FlowController flowController) {
3479 final JVMDiagnosticsSnapshotDTO dto = new JVMDiagnosticsSnapshotDTO();
3481 final JVMControllerDiagnosticsSnapshotDTO controllerDiagnosticsDto = new JVMControllerDiagnosticsSnapshotDTO();
3482 final JVMFlowDiagnosticsSnapshotDTO flowDiagnosticsDto = new JVMFlowDiagnosticsSnapshotDTO();
3483 final JVMSystemDiagnosticsSnapshotDTO systemDiagnosticsDto = new JVMSystemDiagnosticsSnapshotDTO();
3485 dto.setControllerDiagnostics(controllerDiagnosticsDto);
3486 dto.setFlowDiagnosticsDto(flowDiagnosticsDto);
3487 dto.setSystemDiagnosticsDto(systemDiagnosticsDto);
3489 final SystemDiagnostics systemDiagnostics = flowController.getSystemDiagnostics();
3491 // flow-related information
3492 final Set<BundleDTO> bundlesLoaded = extensionManager.getAllBundles().stream()
3493 .map(bundle -> bundle.getBundleDetails().getCoordinate())
3494 .sorted((a, b) -> a.getCoordinate().compareTo(b.getCoordinate()))
3495 .map(this::createBundleDto)
3496 .collect(Collectors.toCollection(LinkedHashSet::new));
3498 flowDiagnosticsDto.setActiveEventDrivenThreads(flowController.getActiveEventDrivenThreadCount());
3499 flowDiagnosticsDto.setActiveTimerDrivenThreads(flowController.getActiveTimerDrivenThreadCount());
3500 flowDiagnosticsDto.setBundlesLoaded(bundlesLoaded);
3501 flowDiagnosticsDto.setTimeZone(System.getProperty("user.timezone"));
3502 flowDiagnosticsDto.setUptime(FormatUtils.formatHoursMinutesSeconds(systemDiagnostics.getUptime(), TimeUnit.MILLISECONDS));
3504 // controller-related information
3505 controllerDiagnosticsDto.setClusterCoordinator(flowController.isClusterCoordinator());
3506 controllerDiagnosticsDto.setPrimaryNode(flowController.isPrimary());
3507 controllerDiagnosticsDto.setMaxEventDrivenThreads(flowController.getMaxEventDrivenThreadCount());
3508 controllerDiagnosticsDto.setMaxTimerDrivenThreads(flowController.getMaxTimerDrivenThreadCount());
3510 // system-related information
3511 systemDiagnosticsDto.setMaxOpenFileDescriptors(systemDiagnostics.getMaxOpenFileHandles());
3512 systemDiagnosticsDto.setOpenFileDescriptors(systemDiagnostics.getOpenFileHandles());
3513 systemDiagnosticsDto.setPhysicalMemoryBytes(systemDiagnostics.getTotalPhysicalMemory());
3514 systemDiagnosticsDto.setPhysicalMemory(FormatUtils.formatDataSize(systemDiagnostics.getTotalPhysicalMemory()));
3516 final NumberFormat percentageFormat = NumberFormat.getPercentInstance();
3517 percentageFormat.setMaximumFractionDigits(2);
3519 final Set<RepositoryUsageDTO> contentRepoUsage = new HashSet<>();
3520 for (final Map.Entry<String, StorageUsage> entry : systemDiagnostics.getContentRepositoryStorageUsage().entrySet()) {
3521 final String repoName = entry.getKey();
3522 final StorageUsage usage = entry.getValue();
3524 final RepositoryUsageDTO usageDto = new RepositoryUsageDTO();
3525 usageDto.setName(repoName);
3527 usageDto.setFileStoreHash(DigestUtils.sha256Hex(flowController.getContentRepoFileStoreName(repoName)));
3528 usageDto.setFreeSpace(FormatUtils.formatDataSize(usage.getFreeSpace()));
3529 usageDto.setFreeSpaceBytes(usage.getFreeSpace());
3530 usageDto.setTotalSpace(FormatUtils.formatDataSize(usage.getTotalSpace()));
3531 usageDto.setTotalSpaceBytes(usage.getTotalSpace());
3533 final double usedPercentage = (usage.getTotalSpace() - usage.getFreeSpace()) / (double) usage.getTotalSpace();
3534 final String utilization = percentageFormat.format(usedPercentage);
3535 usageDto.setUtilization(utilization);
3536 contentRepoUsage.add(usageDto);
3539 final Set<RepositoryUsageDTO> provRepoUsage = new HashSet<>();
3540 for (final Map.Entry<String, StorageUsage> entry : systemDiagnostics.getProvenanceRepositoryStorageUsage().entrySet()) {
3541 final String repoName = entry.getKey();
3542 final StorageUsage usage = entry.getValue();
3544 final RepositoryUsageDTO usageDto = new RepositoryUsageDTO();
3545 usageDto.setName(repoName);
3547 usageDto.setFileStoreHash(DigestUtils.sha256Hex(flowController.getProvenanceRepoFileStoreName(repoName)));
3548 usageDto.setFreeSpace(FormatUtils.formatDataSize(usage.getFreeSpace()));
3549 usageDto.setFreeSpaceBytes(usage.getFreeSpace());
3550 usageDto.setTotalSpace(FormatUtils.formatDataSize(usage.getTotalSpace()));
3551 usageDto.setTotalSpaceBytes(usage.getTotalSpace());
3553 final double usedPercentage = (usage.getTotalSpace() - usage.getFreeSpace()) / (double) usage.getTotalSpace();
3554 final String utilization = percentageFormat.format(usedPercentage);
3555 usageDto.setUtilization(utilization);
3556 provRepoUsage.add(usageDto);
3559 final RepositoryUsageDTO flowFileRepoUsage = new RepositoryUsageDTO();
3560 for (final Map.Entry<String, StorageUsage> entry : systemDiagnostics.getProvenanceRepositoryStorageUsage().entrySet()) {
3561 final String repoName = entry.getKey();
3562 final StorageUsage usage = entry.getValue();
3564 flowFileRepoUsage.setName(repoName);
3566 flowFileRepoUsage.setFileStoreHash(DigestUtils.sha256Hex(flowController.getFlowRepoFileStoreName()));
3567 flowFileRepoUsage.setFreeSpace(FormatUtils.formatDataSize(usage.getFreeSpace()));
3568 flowFileRepoUsage.setFreeSpaceBytes(usage.getFreeSpace());
3569 flowFileRepoUsage.setTotalSpace(FormatUtils.formatDataSize(usage.getTotalSpace()));
3570 flowFileRepoUsage.setTotalSpaceBytes(usage.getTotalSpace());
3572 final double usedPercentage = (usage.getTotalSpace() - usage.getFreeSpace()) / (double) usage.getTotalSpace();
3573 final String utilization = percentageFormat.format(usedPercentage);
3574 flowFileRepoUsage.setUtilization(utilization);
3577 systemDiagnosticsDto.setContentRepositoryStorageUsage(contentRepoUsage);
3578 systemDiagnosticsDto.setCpuCores(systemDiagnostics.getAvailableProcessors());
3579 systemDiagnosticsDto.setCpuLoadAverage(systemDiagnostics.getProcessorLoadAverage());
3580 systemDiagnosticsDto.setFlowFileRepositoryStorageUsage(flowFileRepoUsage);
3581 systemDiagnosticsDto.setMaxHeapBytes(systemDiagnostics.getMaxHeap());
3582 systemDiagnosticsDto.setMaxHeap(FormatUtils.formatDataSize(systemDiagnostics.getMaxHeap()));
3583 systemDiagnosticsDto.setProvenanceRepositoryStorageUsage(provRepoUsage);
3585 // Create the Garbage Collection History info
3586 final GarbageCollectionHistory gcHistory = flowController.getGarbageCollectionHistory();
3587 final List<GarbageCollectionDiagnosticsDTO> gcDiagnostics = new ArrayList<>();
3588 for (final String memoryManager : gcHistory.getMemoryManagerNames()) {
3589 final List<GarbageCollectionStatus> statuses = gcHistory.getGarbageCollectionStatuses(memoryManager);
3591 final List<GCDiagnosticsSnapshotDTO> gcSnapshots = new ArrayList<>();
3592 for (final GarbageCollectionStatus status : statuses) {
3593 final GCDiagnosticsSnapshotDTO snapshotDto = new GCDiagnosticsSnapshotDTO();
3594 snapshotDto.setTimestamp(status.getTimestamp());
3595 snapshotDto.setCollectionCount(status.getCollectionCount());
3596 snapshotDto.setCollectionMillis(status.getCollectionMillis());
3597 gcSnapshots.add(snapshotDto);
3600 gcSnapshots.sort(Comparator.comparing(GCDiagnosticsSnapshotDTO::getTimestamp).reversed());
3602 final GarbageCollectionDiagnosticsDTO gcDto = new GarbageCollectionDiagnosticsDTO();
3603 gcDto.setMemoryManagerName(memoryManager);
3604 gcDto.setSnapshots(gcSnapshots);
3605 gcDiagnostics.add(gcDto);
3608 systemDiagnosticsDto.setGarbageCollectionDiagnostics(gcDiagnostics);
3613 private List<ThreadDumpDTO> createThreadDumpDtos(final ProcessorNode procNode) {
3614 final List<ThreadDumpDTO> threadDumps = new ArrayList<>();
3616 final List<ActiveThreadInfo> activeThreads = procNode.getActiveThreads();
3617 for (final ActiveThreadInfo threadInfo : activeThreads) {
3618 final ThreadDumpDTO dto = new ThreadDumpDTO();
3619 dto.setStackTrace(threadInfo.getStackTrace());
3620 dto.setThreadActiveMillis(threadInfo.getActiveMillis());
3621 dto.setThreadName(threadInfo.getThreadName());
3622 dto.setTaskTerminated(threadInfo.isTerminated());
3623 threadDumps.add(dto);
3630 * Creates a ProcessorConfigDTO from the specified ProcessorNode.
3632 * @param procNode node
3635 public ProcessorConfigDTO createProcessorConfigDto(final ProcessorNode procNode) {
3636 if (procNode == null) {
3640 final ProcessorConfigDTO dto = new ProcessorConfigDTO();
3642 // sort a copy of the properties
3643 final Map<PropertyDescriptor, String> sortedProperties = new TreeMap<>(new Comparator<PropertyDescriptor>() {
3645 public int compare(final PropertyDescriptor o1, final PropertyDescriptor o2) {
3646 return Collator.getInstance(Locale.US).compare(o1.getName(), o2.getName());
3649 sortedProperties.putAll(procNode.getProperties());
3651 // get the property order from the processor
3652 final Processor processor = procNode.getProcessor();
3653 final Map<PropertyDescriptor, String> orderedProperties = new LinkedHashMap<>();
3654 final List<PropertyDescriptor> descriptors = processor.getPropertyDescriptors();
3655 if (descriptors != null && !descriptors.isEmpty()) {
3656 for (final PropertyDescriptor descriptor : descriptors) {
3657 orderedProperties.put(descriptor, null);
3660 orderedProperties.putAll(sortedProperties);
3662 // build the descriptor and property dtos
3663 dto.setDescriptors(new LinkedHashMap<String, PropertyDescriptorDTO>());
3664 dto.setProperties(new LinkedHashMap<String, String>());
3665 for (final Map.Entry<PropertyDescriptor, String> entry : orderedProperties.entrySet()) {
3666 final PropertyDescriptor descriptor = entry.getKey();
3668 // store the property descriptor
3669 dto.getDescriptors().put(descriptor.getName(), createPropertyDescriptorDto(descriptor, procNode.getProcessGroup().getIdentifier()));
3671 // determine the property value - don't include sensitive properties
3672 String propertyValue = entry.getValue();
3673 if (propertyValue != null && descriptor.isSensitive()) {
3674 propertyValue = SENSITIVE_VALUE_MASK;
3675 } else if (propertyValue == null && descriptor.getDefaultValue() != null) {
3676 propertyValue = descriptor.getDefaultValue();
3679 // set the property value
3680 dto.getProperties().put(descriptor.getName(), propertyValue);
3683 dto.setSchedulingPeriod(procNode.getSchedulingPeriod());
3684 dto.setPenaltyDuration(procNode.getPenalizationPeriod());
3685 dto.setYieldDuration(procNode.getYieldPeriod());
3686 dto.setRunDurationMillis(procNode.getRunDuration(TimeUnit.MILLISECONDS));
3687 dto.setConcurrentlySchedulableTaskCount(procNode.getMaxConcurrentTasks());
3688 dto.setLossTolerant(procNode.isLossTolerant());
3689 dto.setComments(procNode.getComments());
3690 dto.setBulletinLevel(procNode.getBulletinLevel().name());
3691 dto.setSchedulingStrategy(procNode.getSchedulingStrategy().name());
3692 dto.setExecutionNode(procNode.getExecutionNode().name());
3693 dto.setAnnotationData(procNode.getAnnotationData());
3695 // set up the default values for concurrent tasks and scheduling period
3696 final Map<String, String> defaultConcurrentTasks = new HashMap<>();
3697 defaultConcurrentTasks.put(SchedulingStrategy.TIMER_DRIVEN.name(), String.valueOf(SchedulingStrategy.TIMER_DRIVEN.getDefaultConcurrentTasks()));
3698 defaultConcurrentTasks.put(SchedulingStrategy.EVENT_DRIVEN.name(), String.valueOf(SchedulingStrategy.EVENT_DRIVEN.getDefaultConcurrentTasks()));
3699 defaultConcurrentTasks.put(SchedulingStrategy.CRON_DRIVEN.name(), String.valueOf(SchedulingStrategy.CRON_DRIVEN.getDefaultConcurrentTasks()));
3700 dto.setDefaultConcurrentTasks(defaultConcurrentTasks);
3702 final Map<String, String> defaultSchedulingPeriod = new HashMap<>();
3703 defaultSchedulingPeriod.put(SchedulingStrategy.TIMER_DRIVEN.name(), SchedulingStrategy.TIMER_DRIVEN.getDefaultSchedulingPeriod());
3704 defaultSchedulingPeriod.put(SchedulingStrategy.CRON_DRIVEN.name(), SchedulingStrategy.CRON_DRIVEN.getDefaultSchedulingPeriod());
3705 dto.setDefaultSchedulingPeriod(defaultSchedulingPeriod);
3711 * Creates a PropertyDesriptorDTO from the specified PropertyDesriptor.
3713 * @param propertyDescriptor descriptor
3714 * @param groupId the Identifier of the Process Group that the component belongs to
3717 public PropertyDescriptorDTO createPropertyDescriptorDto(final PropertyDescriptor propertyDescriptor, final String groupId) {
3718 if (propertyDescriptor == null) {
3722 final PropertyDescriptorDTO dto = new PropertyDescriptorDTO();
3724 dto.setName(propertyDescriptor.getName());
3725 dto.setDisplayName(propertyDescriptor.getDisplayName());
3726 dto.setRequired(propertyDescriptor.isRequired());
3727 dto.setSensitive(propertyDescriptor.isSensitive());
3728 dto.setDynamic(propertyDescriptor.isDynamic());
3729 dto.setDescription(propertyDescriptor.getDescription());
3730 dto.setDefaultValue(propertyDescriptor.getDefaultValue());
3731 dto.setSupportsEl(propertyDescriptor.isExpressionLanguageSupported());
3733 // to support legacy/deprecated method .expressionLanguageSupported(true)
3734 String description = propertyDescriptor.isExpressionLanguageSupported()
3735 && propertyDescriptor.getExpressionLanguageScope().equals(ExpressionLanguageScope.NONE)
3736 ? "true (undefined scope)" : propertyDescriptor.getExpressionLanguageScope().getDescription();
3737 dto.setExpressionLanguageScope(description);
3739 // set the identifies controller service is applicable
3740 if (propertyDescriptor.getControllerServiceDefinition() != null) {
3741 final Class serviceClass = propertyDescriptor.getControllerServiceDefinition();
3742 final Bundle serviceBundle = extensionManager.getBundle(serviceClass.getClassLoader());
3744 dto.setIdentifiesControllerService(serviceClass.getName());
3745 dto.setIdentifiesControllerServiceBundle(createBundleDto(serviceBundle.getBundleDetails().getCoordinate()));
3748 final Class<? extends ControllerService> serviceDefinition = propertyDescriptor.getControllerServiceDefinition();
3749 if (propertyDescriptor.getAllowableValues() == null) {
3750 if (serviceDefinition == null) {
3751 dto.setAllowableValues(null);
3753 final List<AllowableValueEntity> allowableValues = new ArrayList<>();
3754 final List<String> controllerServiceIdentifiers = new ArrayList<>(controllerServiceProvider.getControllerServiceIdentifiers(serviceDefinition, groupId));
3755 Collections.sort(controllerServiceIdentifiers, Collator.getInstance(Locale.US));
3756 for (final String serviceIdentifier : controllerServiceIdentifiers) {
3757 final ControllerServiceNode service = controllerServiceProvider.getControllerServiceNode(serviceIdentifier);
3758 final boolean isServiceAuthorized = service.isAuthorized(authorizer, RequestAction.READ, NiFiUserUtils.getNiFiUser());
3759 final String displayName = isServiceAuthorized ? service.getName() : serviceIdentifier;
3761 final AllowableValueDTO allowableValue = new AllowableValueDTO();
3762 allowableValue.setDisplayName(displayName);
3763 allowableValue.setValue(serviceIdentifier);
3764 allowableValues.add(entityFactory.createAllowableValueEntity(allowableValue, isServiceAuthorized));
3766 dto.setAllowableValues(allowableValues);
3769 final List<AllowableValueEntity> allowableValues = new ArrayList<>();
3770 for (final AllowableValue allowableValue : propertyDescriptor.getAllowableValues()) {
3771 final AllowableValueDTO allowableValueDto = new AllowableValueDTO();
3772 allowableValueDto.setDisplayName(allowableValue.getDisplayName());
3773 allowableValueDto.setValue(allowableValue.getValue());
3774 allowableValueDto.setDescription(allowableValue.getDescription());
3775 allowableValues.add(entityFactory.createAllowableValueEntity(allowableValueDto, true));
3778 dto.setAllowableValues(allowableValues);
3785 public LabelDTO copy(final LabelDTO original) {
3786 final LabelDTO copy = new LabelDTO();
3787 copy.setId(original.getId());
3788 copy.setParentGroupId(original.getParentGroupId());
3789 copy.setLabel(original.getLabel());
3790 copy.setStyle(copy(original.getStyle()));
3791 copy.setPosition(original.getPosition());
3792 copy.setWidth(original.getWidth());
3793 copy.setHeight(original.getHeight());
3794 copy.setVersionedComponentId(original.getVersionedComponentId());
3799 public ControllerServiceDTO copy(final ControllerServiceDTO original) {
3800 final ControllerServiceDTO copy = new ControllerServiceDTO();
3801 copy.setAnnotationData(original.getAnnotationData());
3802 copy.setControllerServiceApis(original.getControllerServiceApis());
3803 copy.setComments(original.getComments());
3804 copy.setCustomUiUrl(original.getCustomUiUrl());
3805 copy.setDescriptors(copy(original.getDescriptors()));
3806 copy.setId(original.getId());
3807 copy.setParentGroupId(original.getParentGroupId());
3808 copy.setName(original.getName());
3809 copy.setProperties(copy(original.getProperties()));
3810 copy.setReferencingComponents(copy(original.getReferencingComponents()));
3811 copy.setState(original.getState());
3812 copy.setType(original.getType());
3813 copy.setBundle(copy(original.getBundle()));
3814 copy.setExtensionMissing(original.getExtensionMissing());
3815 copy.setMultipleVersionsAvailable(original.getMultipleVersionsAvailable());
3816 copy.setPersistsState(original.getPersistsState());
3817 copy.setValidationErrors(copy(original.getValidationErrors()));
3818 copy.setValidationStatus(original.getValidationStatus());
3819 copy.setVersionedComponentId(original.getVersionedComponentId());
3823 public FunnelDTO copy(final FunnelDTO original) {
3824 final FunnelDTO copy = new FunnelDTO();
3825 copy.setId(original.getId());
3826 copy.setParentGroupId(original.getParentGroupId());
3827 copy.setPosition(original.getPosition());
3828 copy.setVersionedComponentId(original.getVersionedComponentId());
3833 private <T> List<T> copy(final List<T> original) {
3834 if (original == null) {
3837 return new ArrayList<>(original);
3841 private <T> List<T> copy(final Collection<T> original) {
3842 if (original == null) {
3845 return new ArrayList<>(original);
3849 private <T> Set<T> copy(final Set<T> original) {
3850 if (original == null) {
3853 return new LinkedHashSet<>(original);
3857 private <S, T> Map<S, T> copy(final Map<S, T> original) {
3858 if (original == null) {
3861 return new LinkedHashMap<>(original);
3865 public BundleDTO copy(final BundleDTO original) {
3866 if (original == null) {
3870 final BundleDTO copy = new BundleDTO();
3871 copy.setGroup(original.getGroup());
3872 copy.setArtifact(original.getArtifact());
3873 copy.setVersion(original.getVersion());
3877 public ProcessorDTO copy(final ProcessorDTO original) {
3878 final ProcessorDTO copy = new ProcessorDTO();
3879 copy.setConfig(copy(original.getConfig()));
3880 copy.setPosition(original.getPosition());
3881 copy.setId(original.getId());
3882 copy.setName(original.getName());
3883 copy.setDescription(original.getDescription());
3884 copy.setParentGroupId(original.getParentGroupId());
3885 copy.setRelationships(copy(original.getRelationships()));
3886 copy.setState(original.getState());
3887 copy.setStyle(copy(original.getStyle()));
3888 copy.setType(original.getType());
3889 copy.setBundle(copy(original.getBundle()));
3890 copy.setSupportsParallelProcessing(original.getSupportsParallelProcessing());
3891 copy.setSupportsEventDriven(original.getSupportsEventDriven());
3892 copy.setSupportsBatching(original.getSupportsBatching());
3893 copy.setPersistsState(original.getPersistsState());
3894 copy.setExecutionNodeRestricted(original.isExecutionNodeRestricted());
3895 copy.setExtensionMissing(original.getExtensionMissing());
3896 copy.setMultipleVersionsAvailable(original.getMultipleVersionsAvailable());
3897 copy.setValidationErrors(copy(original.getValidationErrors()));
3898 copy.setValidationStatus(original.getValidationStatus());
3899 copy.setVersionedComponentId(original.getVersionedComponentId());
3904 private ProcessorConfigDTO copy(final ProcessorConfigDTO original) {
3905 final ProcessorConfigDTO copy = new ProcessorConfigDTO();
3906 copy.setAnnotationData(original.getAnnotationData());
3907 copy.setAutoTerminatedRelationships(copy(original.getAutoTerminatedRelationships()));
3908 copy.setComments(original.getComments());
3909 copy.setSchedulingStrategy(original.getSchedulingStrategy());
3910 copy.setExecutionNode(original.getExecutionNode());
3911 copy.setConcurrentlySchedulableTaskCount(original.getConcurrentlySchedulableTaskCount());
3912 copy.setCustomUiUrl(original.getCustomUiUrl());
3913 copy.setDescriptors(copy(original.getDescriptors()));
3914 copy.setProperties(copy(original.getProperties()));
3915 copy.setSchedulingPeriod(original.getSchedulingPeriod());
3916 copy.setPenaltyDuration(original.getPenaltyDuration());
3917 copy.setYieldDuration(original.getYieldDuration());
3918 copy.setRunDurationMillis(original.getRunDurationMillis());
3919 copy.setBulletinLevel(original.getBulletinLevel());
3920 copy.setDefaultConcurrentTasks(original.getDefaultConcurrentTasks());
3921 copy.setDefaultSchedulingPeriod(original.getDefaultSchedulingPeriod());
3922 copy.setLossTolerant(original.isLossTolerant());
3927 public ConnectionDTO copy(final ConnectionDTO original) {
3928 final ConnectionDTO copy = new ConnectionDTO();
3929 copy.setAvailableRelationships(copy(original.getAvailableRelationships()));
3930 copy.setDestination(original.getDestination());
3931 copy.setPosition(original.getPosition());
3932 copy.setId(original.getId());
3933 copy.setName(original.getName());
3934 copy.setParentGroupId(original.getParentGroupId());
3935 copy.setSelectedRelationships(copy(original.getSelectedRelationships()));
3936 copy.setFlowFileExpiration(original.getFlowFileExpiration());
3937 copy.setBackPressureObjectThreshold(original.getBackPressureObjectThreshold());
3938 copy.setBackPressureDataSizeThreshold(original.getBackPressureDataSizeThreshold());
3939 copy.setPrioritizers(copy(original.getPrioritizers()));
3940 copy.setSource(original.getSource());
3941 copy.setzIndex(original.getzIndex());
3942 copy.setLabelIndex(original.getLabelIndex());
3943 copy.setBends(copy(original.getBends()));
3944 copy.setLoadBalancePartitionAttribute(original.getLoadBalancePartitionAttribute());
3945 copy.setLoadBalanceStrategy(original.getLoadBalanceStrategy());
3946 copy.setLoadBalanceCompression(original.getLoadBalanceCompression());
3947 copy.setLoadBalanceStatus(original.getLoadBalanceStatus());
3948 copy.setVersionedComponentId(original.getVersionedComponentId());
3953 public BulletinDTO copy(final BulletinDTO original) {
3954 final BulletinDTO copy = new BulletinDTO();
3955 copy.setId(original.getId());
3956 copy.setTimestamp(original.getTimestamp());
3957 copy.setGroupId(original.getGroupId());
3958 copy.setSourceId(original.getSourceId());
3959 copy.setSourceName(original.getSourceName());
3960 copy.setCategory(original.getCategory());
3961 copy.setLevel(original.getLevel());
3962 copy.setMessage(original.getMessage());
3963 copy.setNodeAddress(original.getNodeAddress());
3967 public PortDTO copy(final PortDTO original) {
3968 final PortDTO copy = new PortDTO();
3969 copy.setPosition(original.getPosition());
3970 copy.setId(original.getId());
3971 copy.setName(original.getName());
3972 copy.setComments(original.getComments());
3973 copy.setParentGroupId(original.getParentGroupId());
3974 copy.setState(original.getState());
3975 copy.setType(original.getType());
3976 copy.setTransmitting(original.isTransmitting());
3977 copy.setConcurrentlySchedulableTaskCount(original.getConcurrentlySchedulableTaskCount());
3978 copy.setUserAccessControl(copy(original.getUserAccessControl()));
3979 copy.setGroupAccessControl(copy(original.getGroupAccessControl()));
3980 copy.setValidationErrors(copy(original.getValidationErrors()));
3981 copy.setVersionedComponentId(original.getVersionedComponentId());
3985 public RemoteProcessGroupPortDTO copy(final RemoteProcessGroupPortDTO original) {
3986 final RemoteProcessGroupPortDTO copy = new RemoteProcessGroupPortDTO();
3987 copy.setId(original.getId());
3988 copy.setTargetId(original.getTargetId());
3989 copy.setGroupId(original.getGroupId());
3990 copy.setName(original.getName());
3991 copy.setComments(original.getComments());
3992 copy.setConnected(original.isConnected());
3993 copy.setTargetRunning(original.isTargetRunning());
3994 copy.setTransmitting(original.isTransmitting());
3995 copy.setConcurrentlySchedulableTaskCount(original.getConcurrentlySchedulableTaskCount());
3996 copy.setUseCompression(original.getUseCompression());
3997 copy.setExists(original.getExists());
3998 copy.setVersionedComponentId(original.getVersionedComponentId());
4000 final BatchSettingsDTO batchOrg = original.getBatchSettings();
4001 if (batchOrg != null) {
4002 final BatchSettingsDTO batchCopy = new BatchSettingsDTO();
4003 batchCopy.setCount(batchOrg.getCount());
4004 batchCopy.setSize(batchOrg.getSize());
4005 batchCopy.setDuration(batchOrg.getDuration());
4006 copy.setBatchSettings(batchCopy);
4011 public ProcessGroupDTO copy(final ProcessGroupDTO original, final boolean deep) {
4012 final ProcessGroupDTO copy = new ProcessGroupDTO();
4013 copy.setComments(original.getComments());
4014 copy.setContents(copy(original.getContents(), deep));
4015 copy.setPosition(original.getPosition());
4016 copy.setId(original.getId());
4017 copy.setInputPortCount(original.getInputPortCount());
4018 copy.setInvalidCount(original.getInvalidCount());
4019 copy.setName(original.getName());
4020 copy.setVersionControlInformation(copy(original.getVersionControlInformation()));
4021 copy.setOutputPortCount(original.getOutputPortCount());
4022 copy.setParentGroupId(original.getParentGroupId());
4023 copy.setVersionedComponentId(original.getVersionedComponentId());
4025 copy.setRunningCount(original.getRunningCount());
4026 copy.setStoppedCount(original.getStoppedCount());
4027 copy.setDisabledCount(original.getDisabledCount());
4028 copy.setActiveRemotePortCount(original.getActiveRemotePortCount());
4029 copy.setInactiveRemotePortCount(original.getInactiveRemotePortCount());
4031 copy.setUpToDateCount(original.getUpToDateCount());
4032 copy.setLocallyModifiedCount(original.getLocallyModifiedCount());
4033 copy.setStaleCount(original.getStaleCount());
4034 copy.setLocallyModifiedAndStaleCount(original.getLocallyModifiedAndStaleCount());
4035 copy.setSyncFailureCount(original.getSyncFailureCount());
4037 if (original.getVariables() != null) {
4038 copy.setVariables(new HashMap<>(original.getVariables()));
4044 public VersionControlInformationDTO copy(final VersionControlInformationDTO original) {
4045 if (original == null) {
4049 final VersionControlInformationDTO copy = new VersionControlInformationDTO();
4050 copy.setRegistryId(original.getRegistryId());
4051 copy.setRegistryName(original.getRegistryName());
4052 copy.setBucketId(original.getBucketId());
4053 copy.setBucketName(original.getBucketName());
4054 copy.setFlowId(original.getFlowId());
4055 copy.setFlowName(original.getFlowName());
4056 copy.setFlowDescription(original.getFlowDescription());
4057 copy.setVersion(original.getVersion());
4058 copy.setState(original.getState());
4059 copy.setStateExplanation(original.getStateExplanation());
4063 public RemoteProcessGroupDTO copy(final RemoteProcessGroupDTO original) {
4064 final RemoteProcessGroupContentsDTO originalContents = original.getContents();
4065 final RemoteProcessGroupContentsDTO copyContents = new RemoteProcessGroupContentsDTO();
4067 if (originalContents.getInputPorts() != null) {
4068 final Set<RemoteProcessGroupPortDTO> inputPorts = new HashSet<>();
4069 for (final RemoteProcessGroupPortDTO port : originalContents.getInputPorts()) {
4070 inputPorts.add(copy(port));
4072 copyContents.setInputPorts(inputPorts);
4075 if (originalContents.getOutputPorts() != null) {
4076 final Set<RemoteProcessGroupPortDTO> outputPorts = new HashSet<>();
4077 for (final RemoteProcessGroupPortDTO port : originalContents.getOutputPorts()) {
4078 outputPorts.add(copy(port));
4080 copyContents.setOutputPorts(outputPorts);
4083 final RemoteProcessGroupDTO copy = new RemoteProcessGroupDTO();
4084 copy.setComments(original.getComments());
4085 copy.setPosition(original.getPosition());
4086 copy.setId(original.getId());
4087 copy.setCommunicationsTimeout(original.getCommunicationsTimeout());
4088 copy.setYieldDuration(original.getYieldDuration());
4089 copy.setName(original.getName());
4090 copy.setInputPortCount(original.getInputPortCount());
4091 copy.setOutputPortCount(original.getOutputPortCount());
4092 copy.setActiveRemoteInputPortCount(original.getActiveRemoteInputPortCount());
4093 copy.setInactiveRemoteInputPortCount(original.getInactiveRemoteInputPortCount());
4094 copy.setActiveRemoteOutputPortCount(original.getActiveRemoteOutputPortCount());
4095 copy.setInactiveRemoteOutputPortCount(original.getInactiveRemoteOutputPortCount());
4096 copy.setParentGroupId(original.getParentGroupId());
4097 copy.setTargetUris(original.getTargetUris());
4098 copy.setTransportProtocol(original.getTransportProtocol());
4099 copy.setProxyHost(original.getProxyHost());
4100 copy.setProxyPort(original.getProxyPort());
4101 copy.setProxyUser(original.getProxyUser());
4102 copy.setProxyPassword(original.getProxyPassword());
4103 copy.setLocalNetworkInterface(original.getLocalNetworkInterface());
4104 copy.setVersionedComponentId(original.getVersionedComponentId());
4106 copy.setContents(copyContents);
4111 public ConnectableDTO createConnectableDto(final PortDTO port, final ConnectableType type) {
4112 final ConnectableDTO connectable = new ConnectableDTO();
4113 connectable.setGroupId(port.getParentGroupId());
4114 connectable.setId(port.getId());
4115 connectable.setName(port.getName());
4116 connectable.setType(type.name());
4117 connectable.setVersionedComponentId(port.getVersionedComponentId());
4121 public ConnectableDTO createConnectableDto(final ProcessorDTO processor) {
4122 final ConnectableDTO connectable = new ConnectableDTO();
4123 connectable.setGroupId(processor.getParentGroupId());
4124 connectable.setId(processor.getId());
4125 connectable.setName(processor.getName());
4126 connectable.setType(ConnectableType.PROCESSOR.name());
4127 connectable.setVersionedComponentId(processor.getVersionedComponentId());
4131 public ConnectableDTO createConnectableDto(final FunnelDTO funnel) {
4132 final ConnectableDTO connectable = new ConnectableDTO();
4133 connectable.setGroupId(funnel.getParentGroupId());
4134 connectable.setId(funnel.getId());
4135 connectable.setType(ConnectableType.FUNNEL.name());
4136 connectable.setVersionedComponentId(funnel.getVersionedComponentId());
4140 public ConnectableDTO createConnectableDto(final RemoteProcessGroupPortDTO remoteGroupPort, final ConnectableType type) {
4141 final ConnectableDTO connectable = new ConnectableDTO();
4142 connectable.setGroupId(remoteGroupPort.getGroupId());
4143 connectable.setId(remoteGroupPort.getId());
4144 connectable.setName(remoteGroupPort.getName());
4145 connectable.setType(type.name());
4146 connectable.setVersionedComponentId(connectable.getVersionedComponentId());
4152 * @param original orig
4153 * @param deep if <code>true</code>, all Connections, ProcessGroups, Ports, Processors, etc. will be copied. If <code>false</code>, the copy will have links to the same objects referenced by
4154 * <code>original</code>.
4158 private FlowSnippetDTO copy(final FlowSnippetDTO original, final boolean deep) {
4159 final FlowSnippetDTO copy = new FlowSnippetDTO();
4161 final Set<ConnectionDTO> connections = new LinkedHashSet<>();
4162 final Set<ProcessGroupDTO> groups = new LinkedHashSet<>();
4163 final Set<PortDTO> inputPorts = new LinkedHashSet<>();
4164 final Set<PortDTO> outputPorts = new LinkedHashSet<>();
4165 final Set<LabelDTO> labels = new LinkedHashSet<>();
4166 final Set<ProcessorDTO> processors = new LinkedHashSet<>();
4167 final Set<RemoteProcessGroupDTO> remoteProcessGroups = new LinkedHashSet<>();
4168 final Set<FunnelDTO> funnels = new LinkedHashSet<>();
4169 final Set<ControllerServiceDTO> controllerServices = new LinkedHashSet<>();
4172 for (final ProcessGroupDTO group : original.getProcessGroups()) {
4173 groups.add(copy(group, deep));
4176 for (final PortDTO port : original.getInputPorts()) {
4177 inputPorts.add(copy(port));
4180 for (final PortDTO port : original.getOutputPorts()) {
4181 outputPorts.add(copy(port));
4184 for (final LabelDTO label : original.getLabels()) {
4185 labels.add(copy(label));
4188 for (final ProcessorDTO processor : original.getProcessors()) {
4189 processors.add(copy(processor));
4192 for (final RemoteProcessGroupDTO remoteGroup : original.getRemoteProcessGroups()) {
4193 remoteProcessGroups.add(copy(remoteGroup));
4196 for (final FunnelDTO funnel : original.getFunnels()) {
4197 funnels.add(copy(funnel));
4200 for (final ConnectionDTO connection : original.getConnections()) {
4201 connections.add(copy(connection));
4204 for (final ControllerServiceDTO controllerService : original.getControllerServices()) {
4205 controllerServices.add(copy(controllerService));
4208 if (original.getConnections() != null) {
4209 connections.addAll(copy(original.getConnections()));
4211 if (original.getProcessGroups() != null) {
4212 groups.addAll(copy(original.getProcessGroups()));
4214 if (original.getInputPorts() != null) {
4215 inputPorts.addAll(copy(original.getInputPorts()));
4217 if (original.getOutputPorts() != null) {
4218 outputPorts.addAll(copy(original.getOutputPorts()));
4220 if (original.getLabels() != null) {
4221 labels.addAll(copy(original.getLabels()));
4223 if (original.getProcessors() != null) {
4224 processors.addAll(copy(original.getProcessors()));
4226 if (original.getRemoteProcessGroups() != null) {
4227 remoteProcessGroups.addAll(copy(original.getRemoteProcessGroups()));
4229 if (original.getFunnels() != null) {
4230 funnels.addAll(copy(original.getFunnels()));
4232 if (original.getControllerServices() != null) {
4233 controllerServices.addAll(copy(original.getControllerServices()));
4237 copy.setConnections(connections);
4238 copy.setProcessGroups(groups);
4239 copy.setInputPorts(inputPorts);
4240 copy.setLabels(labels);
4241 copy.setOutputPorts(outputPorts);
4242 copy.setProcessors(processors);
4243 copy.setRemoteProcessGroups(remoteProcessGroups);
4244 copy.setFunnels(funnels);
4245 copy.setControllerServices(controllerServices);
4251 * Factory method for creating a new RevisionDTO based on this controller.
4253 * @param lastMod mod
4256 public RevisionDTO createRevisionDTO(final FlowModification lastMod) {
4257 final Revision revision = lastMod.getRevision();
4260 final RevisionDTO revisionDTO = new RevisionDTO();
4261 revisionDTO.setVersion(revision.getVersion());
4262 revisionDTO.setClientId(revision.getClientId());
4263 revisionDTO.setLastModifier(lastMod.getLastModifier());
4268 public RevisionDTO createRevisionDTO(final Revision revision) {
4269 final RevisionDTO dto = new RevisionDTO();
4270 dto.setVersion(revision.getVersion());
4271 dto.setClientId(revision.getClientId());
4275 public NodeDTO createNodeDTO(final NodeIdentifier nodeId, final NodeConnectionStatus status, final NodeHeartbeat nodeHeartbeat, final List<NodeEvent> events, final Set<String> roles) {
4276 final NodeDTO nodeDto = new NodeDTO();
4278 // populate node dto
4279 nodeDto.setNodeId(nodeId.getId());
4280 nodeDto.setAddress(nodeId.getApiAddress());
4281 nodeDto.setApiPort(nodeId.getApiPort());
4282 nodeDto.setStatus(status.getState().name());
4283 nodeDto.setRoles(roles);
4284 if (status.getConnectionRequestTime() != null) {
4285 final Date connectionRequested = new Date(status.getConnectionRequestTime());
4286 nodeDto.setConnectionRequested(connectionRequested);
4289 // only connected nodes have heartbeats
4290 if (nodeHeartbeat != null) {
4291 final Date heartbeat = new Date(nodeHeartbeat.getTimestamp());
4292 nodeDto.setHeartbeat(heartbeat);
4293 nodeDto.setNodeStartTime(new Date(nodeHeartbeat.getSystemStartTime()));
4294 nodeDto.setActiveThreadCount(nodeHeartbeat.getActiveThreadCount());
4295 nodeDto.setQueued(FormatUtils.formatCount(nodeHeartbeat.getFlowFileCount()) + " / " + FormatUtils.formatDataSize(nodeHeartbeat.getFlowFileBytes()));
4298 // populate node events
4299 final List<NodeEvent> nodeEvents = new ArrayList<>(events);
4300 Collections.sort(nodeEvents, new Comparator<NodeEvent>() {
4302 public int compare(final NodeEvent event1, final NodeEvent event2) {
4303 return new Date(event2.getTimestamp()).compareTo(new Date(event1.getTimestamp()));
4307 // create the node event dtos
4308 final List<NodeEventDTO> nodeEventDtos = new ArrayList<>();
4309 for (final NodeEvent event : nodeEvents) {
4310 // create node event dto
4311 final NodeEventDTO nodeEventDto = new NodeEventDTO();
4312 nodeEventDtos.add(nodeEventDto);
4314 // populate node event dto
4315 nodeEventDto.setMessage(event.getMessage());
4316 nodeEventDto.setCategory(event.getSeverity().name());
4317 nodeEventDto.setTimestamp(new Date(event.getTimestamp()));
4319 nodeDto.setEvents(nodeEventDtos);
4324 public RegistryDTO createRegistryDto(FlowRegistry registry) {
4325 final RegistryDTO dto = new RegistryDTO();
4326 dto.setDescription(registry.getDescription());
4327 dto.setId(registry.getIdentifier());
4328 dto.setName(registry.getName());
4329 dto.setUri(registry.getURL());
4335 public void setControllerServiceProvider(final ControllerServiceProvider controllerServiceProvider) {
4336 this.controllerServiceProvider = controllerServiceProvider;
4339 public void setAuthorizer(final Authorizer authorizer) {
4340 this.authorizer = authorizer;
4343 public void setEntityFactory(final EntityFactory entityFactory) {
4344 this.entityFactory = entityFactory;
4347 public void setBulletinRepository(BulletinRepository bulletinRepository) {
4348 this.bulletinRepository = bulletinRepository;
4351 public void setExtensionManager(ExtensionManager extensionManager) {
4352 this.extensionManager = extensionManager;