private void updateControllerService(final ControllerServiceNode service, final VersionedControllerService proposed) { service.pauseValidationTrigger(); try { service.setAnnotationData(proposed.getAnnotationData()); service.setComments(proposed.getComments()); service.setName(proposed.getName()); final Map<String, String> properties = populatePropertiesMap(service.getProperties(), proposed.getProperties(), proposed.getPropertyDescriptors(), service.getProcessGroup()); service.setProperties(properties, true); if (!isEqual(service.getBundleCoordinate(), proposed.getBundle())) { final BundleCoordinate newBundleCoordinate = toCoordinate(proposed.getBundle()); final List<PropertyDescriptor> descriptors = new ArrayList<>(service.getProperties().keySet()); final Set<URL> additionalUrls = service.getAdditionalClasspathResources(descriptors); flowController.getReloadComponent().reload(service, proposed.getType(), newBundleCoordinate, additionalUrls); } } finally { service.resumeValidationTrigger(); } }
private ControllerServiceNode addControllerService(final ProcessGroup destination, final VersionedControllerService proposed, final String componentIdSeed) { final String type = proposed.getType(); final String id = generateUuid(proposed.getIdentifier(), destination.getIdentifier(), componentIdSeed); final Bundle bundle = proposed.getBundle(); final BundleCoordinate coordinate = toCoordinate(bundle); final boolean firstTimeAdded = true; final Set<URL> additionalUrls = Collections.emptySet(); final ControllerServiceNode newService = flowManager.createControllerService(type, id, coordinate, additionalUrls, firstTimeAdded, true); newService.setVersionedComponentId(proposed.getIdentifier()); destination.addControllerService(newService); updateControllerService(newService, proposed); return newService; }
public VersionedControllerService mapControllerService(final ControllerServiceNode controllerService, final ControllerServiceProvider serviceProvider) { final VersionedControllerService versionedService = new InstantiatedVersionedControllerService(controllerService.getIdentifier(), controllerService.getProcessGroupIdentifier()); versionedService.setIdentifier(getId(controllerService.getVersionedComponentId(), controllerService.getIdentifier())); versionedService.setGroupIdentifier(getGroupId(controllerService.getProcessGroupIdentifier())); versionedService.setName(controllerService.getName()); versionedService.setAnnotationData(controllerService.getAnnotationData()); versionedService.setBundle(mapBundle(controllerService.getBundleCoordinate())); versionedService.setComments(controllerService.getComments()); versionedService.setControllerServiceApis(mapControllerServiceApis(controllerService)); versionedService.setProperties(mapProperties(controllerService, serviceProvider)); versionedService.setPropertyDescriptors(mapPropertyDescriptors(controllerService)); versionedService.setType(controllerService.getCanonicalClassName()); return versionedService; }
private void verifyControllerServicesInVersionedFlow(final VersionedProcessGroup versionedFlow, final Map<String, Set<BundleCoordinate>> supportedTypes) { if (versionedFlow.getControllerServices() != null) { versionedFlow.getControllerServices().forEach(controllerService -> { if (supportedTypes.containsKey(controllerService.getType())) { if (controllerService.getBundle() == null) { throw new IllegalArgumentException("Controller Service bundle must be specified."); } verifyBundleInVersionedFlow(controllerService.getBundle(), supportedTypes.get(controllerService.getType())); } else { throw new IllegalStateException("Invalid Controller Service Type: " + controllerService.getType()); } }); } if (versionedFlow.getProcessGroups() != null) { versionedFlow.getProcessGroups().forEach(processGroup -> { verifyControllerServicesInVersionedFlow(processGroup, supportedTypes); }); } }
@Override public ControllerServiceSchema apply(final VersionedControllerService versionedControllerService) { Map<String, Object> map = new HashMap<>(); map.put(NAME_KEY, versionedControllerService.getName()); map.put(ID_KEY, versionedControllerService.getIdentifier()); map.put(TYPE_KEY, versionedControllerService.getType()); map.put(PROPERTIES_KEY, new HashMap<>(nullToEmpty(versionedControllerService.getProperties()))); String annotationData = versionedControllerService.getAnnotationData(); if(annotationData != null && !annotationData.isEmpty()) { map.put(ANNOTATION_DATA_KEY, annotationData); } return new ControllerServiceSchema(map); } }
private void compare(final VersionedControllerService serviceA, final VersionedControllerService serviceB, final Set<FlowDifference> differences) { if (compareComponents(serviceA, serviceB, differences)) { return; } addIfDifferent(differences, DifferenceType.ANNOTATION_DATA_CHANGED, serviceA, serviceB, VersionedControllerService::getAnnotationData); addIfDifferent(differences, DifferenceType.BUNDLE_CHANGED, serviceA, serviceB, VersionedControllerService::getBundle); compareProperties(serviceA, serviceB, serviceA.getProperties(), serviceB.getProperties(), serviceA.getPropertyDescriptors(), serviceB.getPropertyDescriptors(), differences); }
private void findAllControllerServices(final VersionedProcessGroup group, final Map<String, VersionedControllerService> map) { for (final VersionedControllerService service : group.getControllerServices()) { map.put(service.getIdentifier(), service); } for (final VersionedProcessGroup childGroup : group.getProcessGroups()) { findAllControllerServices(childGroup, map); } }
@Override public ControllerServiceSchema apply(final VersionedControllerService versionedControllerService) { Map<String, Object> map = new HashMap<>(); map.put(NAME_KEY, versionedControllerService.getName()); map.put(ID_KEY, versionedControllerService.getIdentifier()); map.put(TYPE_KEY, versionedControllerService.getType()); map.put(PROPERTIES_KEY, new HashMap<>(nullToEmpty(versionedControllerService.getProperties()))); String annotationData = versionedControllerService.getAnnotationData(); if(annotationData != null && !annotationData.isEmpty()) { map.put(ANNOTATION_DATA_KEY, annotationData); } return new ControllerServiceSchema(map); } }
private static void populateComponentTypes(final VersionedProcessGroup group, final Set<Tuple<String, BundleCoordinate>> componentTypes) { group.getProcessors().stream() .map(versionedProc -> new Tuple<>(versionedProc.getType(), createBundleCoordinate(versionedProc.getBundle()))) .forEach(componentTypes::add); group.getControllerServices().stream() .map(versionedSvc -> new Tuple<>(versionedSvc.getType(), createBundleCoordinate(versionedSvc.getBundle()))) .forEach(componentTypes::add); for (final VersionedProcessGroup childGroup : group.getProcessGroups()) { populateComponentTypes(childGroup, componentTypes); } }
ControllerServiceNode service = servicesByVersionedId.get(proposedService.getIdentifier()); if (service == null) { service = addControllerService(group, proposedService, componentIdSeed); final VersionedControllerService proposedService = entry.getValue(); if (updatedVersionedComponentIds.contains(proposedService.getIdentifier())) { updateControllerService(service, proposedService); LOG.info("Updated {}", service); controllerServicesRemoved.remove(proposedService.getIdentifier());