package com.thinkbiganalytics.nifi.rest.support;
/*-
* #%L
* thinkbig-nifi-rest-model
* %%
* Copyright (C) 2017 ThinkBig Analytics
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.thinkbiganalytics.nifi.rest.model.NiFiAllowableValue;
import com.thinkbiganalytics.nifi.rest.model.NiFiPropertyDescriptor;
import com.thinkbiganalytics.nifi.rest.model.NiFiPropertyDescriptorTransform;
import com.thinkbiganalytics.nifi.rest.model.NifiProperty;
import org.apache.commons.lang3.StringUtils;
import org.apache.nifi.web.api.dto.ControllerServiceDTO;
import org.apache.nifi.web.api.dto.ProcessGroupDTO;
import org.apache.nifi.web.api.dto.ProcessorDTO;
import org.apache.nifi.web.api.dto.PropertyDescriptorDTO;
import org.apache.nifi.web.api.dto.TemplateDTO;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
/**
* Uitlity to extract properties and property info from NiFi
*/
public class NifiPropertyUtil {
/**
* map the incoming list of properties to a key,value map
*
* @param propertyList a list of properties
* @return a map with the {@link NifiProperty#getKey()} as the key and the {@link NifiProperty} as the value
*/
public static Map<String, NifiProperty> propertiesAsMap(List<NifiProperty> propertyList) {
Map<String, NifiProperty> map = new HashMap<String, NifiProperty>();
for (NifiProperty property : propertyList) {
map.put(property.getKey(), property);
}
return map;
}
/**
* For a given template object return the list of properties
*
* @param parentProcessGroup the parent group associated with the template
* @param dto the template
* @param propertyDescriptorTransform transformation utility
* @return the list of properties
*/
public static List<NifiProperty> getPropertiesForTemplate(ProcessGroupDTO parentProcessGroup, TemplateDTO dto, NiFiPropertyDescriptorTransform propertyDescriptorTransform) {
return getPropertiesForTemplate(parentProcessGroup, dto, propertyDescriptorTransform, false);
}
/**
* For a given template object return the list of properties. optionally choose to exclude any input processors from the property list
*
* @param parentProcessGroup the parent process group associated wiht the template
* @param dto the template
* @param propertyDescriptorTransform transformation utility
* @param excludeInputProcessors {@code true} removes the properties part of the input processors, {@code false} will include all properties in all processors of the template
*/
public static List<NifiProperty> getPropertiesForTemplate(ProcessGroupDTO parentProcessGroup, TemplateDTO dto, NiFiPropertyDescriptorTransform propertyDescriptorTransform,
boolean excludeInputProcessors) {
List<NifiProperty> properties = new ArrayList<NifiProperty>();
if (dto != null) {
List<ProcessorDTO> inputs = NifiTemplateUtil.getInputProcessorsForTemplate(dto);
Set<ProcessorDTO> processorDTOSet = NifiProcessUtil.getProcessors(dto, excludeInputProcessors);
Map<String, ProcessGroupDTO> groupMap = NifiProcessUtil.getProcessGroupsMap(dto);
for (ProcessorDTO processor : processorDTOSet) {
ProcessGroupDTO group = groupMap.get(processor.getParentGroupId());
if (group == null) {
group = parentProcessGroup;
}
List<NifiProperty> propertyList = getPropertiesForProcessor(group, processor, propertyDescriptorTransform);
//assign the property as an input property if it is one
if (NifiProcessUtil.findFirstProcessorsById(inputs, processor.getId()) != null) {
for (NifiProperty property : propertyList) {
property.setInputProperty(true);
}
}
properties.addAll(propertyList);
}
}
return properties;
}
/**
* Return a property matching a given processor name and property name
*
* @param processorName the processor name to match
* @param propertyName the name of hte {@link NifiProperty#getKey()}
* @param properties a list of properties to inspect
* @return the first property matching the processorName nad propertyName
*/
public static NifiProperty getProperty(final String processorName, final String propertyName, List<NifiProperty> properties) {
NifiProperty property = Iterables.tryFind(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.getProcessorName().equalsIgnoreCase(processorName) && property.getKey().equalsIgnoreCase(propertyName);
}
}).orNull();
return property;
}
/**
* Create a deep copy of properties to a new List
*
* @param properties a list of properties
* @return a new list containing the newly copied properties.
*/
public static List<NifiProperty> copyProperties(List<NifiProperty> properties) {
List<NifiProperty> copyList = new ArrayList<>();
for (NifiProperty property : properties) {
copyList.add(new NifiProperty(property));
}
return copyList;
}
/**
* Return all properties assocated with a given controller service
*
* @param service the service to inspect
* @param propertyDescriptorTransform the transform utility
* @return a list of properties on the service
*/
public static List<NifiProperty> getPropertiesForService(ControllerServiceDTO service, NiFiPropertyDescriptorTransform propertyDescriptorTransform) {
return service.getProperties().entrySet().stream()
.map(entry -> {
final NiFiPropertyDescriptor propertyDescriptor = propertyDescriptorTransform.toNiFiPropertyDescriptor(service.getDescriptors().get(entry.getKey()));
return new NifiProperty(service.getParentGroupId(), service.getId(), entry.getKey(), entry.getValue(), propertyDescriptor);
})
.collect(Collectors.toList());
}
/**
* Return a list of properties on a gi en processor
*
* @param processGroup the processors group
* @param processor the processor
* @param propertyDescriptorTransform the transform utility
* @return the list of properties on the processor
*/
public static List<NifiProperty> getPropertiesForProcessor(ProcessGroupDTO processGroup, ProcessorDTO processor, NiFiPropertyDescriptorTransform propertyDescriptorTransform) {
List<NifiProperty> properties = new ArrayList<>();
for (Map.Entry<String, String> entry : processor.getConfig().getProperties().entrySet()) {
PropertyDescriptorDTO descriptorDTO = processor.getConfig().getDescriptors().get(entry.getKey());
if (descriptorDTO != null) {
final NiFiPropertyDescriptor propertyDescriptor = propertyDescriptorTransform.toNiFiPropertyDescriptor(processor.getConfig().getDescriptors().get(entry.getKey()));
final NifiProperty property = new NifiProperty(processor.getParentGroupId(), processor.getId(), entry.getKey(), entry.getValue(), propertyDescriptor);
property.setProcessGroupName(processGroup.getName());
property.setProcessorName(processor.getName());
property.setProcessorType(processor.getType());
properties.add(property);
}
}
return properties;
}
/**
* Return all properties for a given process group
*
* @param processGroupDTO the process group to inspect
* @param propertyDescriptorTransform the transform utility
* @return the list of properties
*/
public static List<NifiProperty> getProperties(ProcessGroupDTO processGroupDTO, NiFiPropertyDescriptorTransform propertyDescriptorTransform) {
List<NifiProperty> properties = new ArrayList<NifiProperty>();
if (processGroupDTO != null) {
if (processGroupDTO.getContents().getProcessors() != null && !processGroupDTO.getContents().getProcessors().isEmpty()) {
for (ProcessorDTO processorDTO : processGroupDTO.getContents().getProcessors()) {
properties.addAll(NifiPropertyUtil.getPropertiesForProcessor(processGroupDTO, processorDTO, propertyDescriptorTransform));
}
}
if (processGroupDTO.getContents().getProcessGroups() != null && !processGroupDTO.getContents().getProcessGroups().isEmpty()) {
for (ProcessGroupDTO groupDTO : processGroupDTO.getContents().getProcessGroups()) {
properties.addAll(NifiPropertyUtil.getProperties(groupDTO, propertyDescriptorTransform));
}
}
}
return properties;
}
/**
* Return a map of processGroupId to a map of that groups processors and its respective propeties
*
* @param properties the properties to inspect
* @return a map with the key being the processGroupId and the value being a map of properties with its key being the processorId
*/
public static Map<String, Map<String, List<NifiProperty>>> groupPropertiesByProcessGroupAndProcessor(List<NifiProperty> properties) {
Map<String, Map<String, List<NifiProperty>>> processGroupProperties = new HashMap();
for (NifiProperty property : properties) {
String processGroup = property.getProcessGroupId();
String processorId = property.getProcessorId();
if (!processGroupProperties.containsKey(processGroup)) {
processGroupProperties.put(processGroup, new HashMap<String, List<NifiProperty>>());
}
if (!processGroupProperties.get(processGroup).containsKey(processorId)) {
processGroupProperties.get(processGroup).put(processorId, new ArrayList<NifiProperty>());
}
processGroupProperties.get(processGroup).get(processorId).add(property);
}
return processGroupProperties;
}
/**
* Groups the properties by their {@see NifiProperty#getIdKey}
* @param properties the properties to inspect
* @return a map with the property idKey (the processgroup+processorId+propertyKey, property)
*/
public static Map<String,NifiProperty> groupPropertiesByIdKey(List<NifiProperty> properties) {
Map<String, NifiProperty> map = new HashMap();
if(properties != null){
map = properties.stream().collect(Collectors.toMap(p -> p.getIdKey(), p-> p));
}
return map;
}
/**
* Return all properties for a given processor
*
* @param properties the properties to inspect
* @param processorId the processor id to match
* @return the list of properties for the processorId
*/
public static List<NifiProperty> getPropertiesForProcessor(List<NifiProperty> properties, final String processorId) {
return Lists.newArrayList(Iterables.filter(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.getProcessorId().equalsIgnoreCase(processorId);
}
}));
}
/**
* Updates the values of the destination properties that match the specified source properties.
*
* <p>Matches are made using the processor ID or name and the property key.</p>
*
* @param sourceGroupName name of the source process group
* @param destinationGroupName name of the destination process group
* @param destinationProperties properties of processors in the destination group
* @param sourceProperties properties of processors in the source group
* @return modified properties from the destination group
*/
@Nonnull
public static List<NifiProperty> matchAndSetPropertyValues(@Nonnull final String sourceGroupName, @Nonnull final String destinationGroupName,
@Nonnull final List<NifiProperty> destinationProperties, @Nullable final List<NifiProperty> sourceProperties) {
// Shortcut if there are no properties
if (destinationProperties.isEmpty() || sourceProperties == null || sourceProperties.isEmpty()) {
return Collections.emptyList();
}
// Create mappings for destination properties
final Map<String, NifiProperty> propertyById = new HashMap<>(destinationProperties.size());
final Map<String, NifiProperty> propertyByName = new HashMap<>(destinationProperties.size());
final Map<String, String> groupIdByName = new HashMap<>(destinationProperties.size());
final Map<String, String> processorIdByName = new HashMap<>(destinationProperties.size());
for (final NifiProperty property : destinationProperties) {
propertyById.put(property.getIdKey(), property);
propertyByName.put(property.getNameKey(), property);
groupIdByName.put(property.getProcessGroupName(), property.getProcessGroupId());
processorIdByName.put(property.getProcessorName(), property.getProcessorId());
}
// Match and update destination properties
final List<NifiProperty> modifiedProperties = new ArrayList<>(destinationProperties.size());
for (final NifiProperty sourceProperty : sourceProperties) {
// Update source property to match destination
sourceProperty.setTemplateProperty(new NifiProperty(sourceProperty));
if (sourceProperty.getProcessGroupName().equalsIgnoreCase(sourceGroupName)) {
sourceProperty.setProcessGroupName(destinationGroupName);
}
// Find destination property
NifiProperty destinationProperty = propertyById.get(sourceProperty.getIdKey());
if (destinationProperty == null) {
destinationProperty = propertyByName.get(sourceProperty.getNameKey());
}
if (destinationProperty != null) {
sourceProperty.setProcessGroupId(groupIdByName.get(destinationProperty.getProcessGroupName()));
sourceProperty.setProcessorId(processorIdByName.get(destinationProperty.getProcessorName()));
final String sourceValue = sourceProperty.getValue();
if (isValidPropertyValue(destinationProperty, sourceValue)) {
destinationProperty.setValue(sourceValue);
modifiedProperties.add(destinationProperty);
}
}
}
return modifiedProperties;
}
/**
* Validates that the specified value is valid for the property.
*
* @param property the property
* @param value the value to validate
* @return {@code true} if the value is valid for the property, or {@code false} otherwise
*/
private static boolean isValidPropertyValue(@Nonnull final NifiProperty property, final String value) {
// Check for list of allowable values
final Optional<List<NiFiAllowableValue>> allowableValues = Optional.of(property)
.map(NifiProperty::getPropertyDescriptor)
.map(NiFiPropertyDescriptor::getAllowableValues);
if (allowableValues.isPresent()) {
return allowableValues.get().stream()
.filter(allowableValue -> allowableValue.getValue().equals(value))
.findAny()
.isPresent();
}
return true;
}
/**
* find all properties whoes internal {@link NifiProperty#getIdKey()} matches that of the template properties
*
* @param templateProperties the properties that are part of the template
* @param nifiProperties the properties to inspect and match
* @param updateMode a mode indicating what should be inspected and updated
* @return a list of properties matching the templateProperties and the nifiProperties based upon their {@link NifiProperty#getIdKey()}
*/
public static List<NifiProperty> matchAndSetPropertyByIdKey(Collection<NifiProperty> templateProperties, List<NifiProperty> nifiProperties, PROPERTY_MATCH_AND_UPDATE_MODE updateMode) {
List<NifiProperty> matchedProperties = new ArrayList<>();
if (nifiProperties != null && !nifiProperties.isEmpty()) {
for (NifiProperty nifiProperty : nifiProperties) {
NifiProperty matched = matchPropertyByIdKey(templateProperties, nifiProperty, updateMode);
if (matched != null) {
matchedProperties.add(matched);
}
}
}
return matchedProperties;
}
/**
* Find all properties that have the same name and property key
*
* @param templateProperties the properties that are part of the template. These properties will get updated from the {@code nifiProperties} passed in if they match
* @param nifiProperties the properties to inspect and match
* @param updateMode a mode indicating what should be inspected and updated
* @return a list of matched properties
*/
public static List<NifiProperty> matchAndSetPropertyByProcessorName(Collection<NifiProperty> templateProperties, List<NifiProperty> nifiProperties, PROPERTY_MATCH_AND_UPDATE_MODE updateMode) {
List<NifiProperty> matchedProperties = new ArrayList<>();
if (nifiProperties != null && !nifiProperties.isEmpty()) {
for (NifiProperty nifiProperty : nifiProperties) {
NifiProperty matched = matchPropertyByProcessorName(templateProperties, nifiProperty, updateMode);
if (matched != null) {
matchedProperties.add(matched);
}
}
}
return matchedProperties;
}
/**
* Return the first property matching a given property key that is part of a processor with the supplied processorType
*
* @param properties a collection of properties to inspect
* @param processorType the type of processor to match
* @param propertyKey the name of the property to find
* @return the first property matching a given property key that is part of a processor with the supplied processorType
*/
public static NifiProperty findPropertyByProcessorType(Collection<NifiProperty> properties, final String processorType, final String propertyKey) {
List<NifiProperty> matchingProperties = Lists.newArrayList(Iterables.filter(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.getKey().equalsIgnoreCase(propertyKey) && property.getProcessorType().equalsIgnoreCase(processorType);
}
}));
if (matchingProperties != null && !matchingProperties.isEmpty()) {
return matchingProperties.get(0);
}
return null;
}
/**
* Return the first property matching a given property key that is part of a processor with the supplied name
*
* @param properties a collection of properties to inspect
* @param processorName the name of processor to match
* @param propertyKey the name of the property to find
* @return the first property matching a given property key that is part of a processor with the supplied name
*/
public static NifiProperty findPropertyByProcessorName(Collection<NifiProperty> properties, final String processorName, final String propertyKey) {
List<NifiProperty> matchingProperties = Lists.newArrayList(Iterables.filter(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.getKey().equalsIgnoreCase(propertyKey) && property.getProcessorName().equalsIgnoreCase(processorName);
}
}));
if (matchingProperties != null && !matchingProperties.isEmpty()) {
return matchingProperties.get(0);
}
return null;
}
/**
* update a given property with the values from the nifiProperty
*
* @param propertyToUpdate a property to update
* @param nifiProperty a property with values that will be set to the 'propertyToUpdate'
*/
private static void updateProperty(NifiProperty propertyToUpdate, NifiProperty nifiProperty, PROPERTY_MATCH_AND_UPDATE_MODE updateMode) {
propertyToUpdate.setValue(nifiProperty.getValue());
if(!PROPERTY_MATCH_AND_UPDATE_MODE.FEED_DETAILS_MATCH_TEMPLATE.equals(updateMode)){
//if its Not updating for editing a Feed then attempt to set the render type properties.
//otherwise the 'propertyToUpdate' will be the registeredTemplate property and should not be updated from the feed values as the template should drive how the feed is rendered.
propertyToUpdate.setInputProperty(nifiProperty.isInputProperty());
propertyToUpdate.setUserEditable(nifiProperty.isUserEditable());
propertyToUpdate.setSelected(nifiProperty.isSelected());
propertyToUpdate.setRenderType(nifiProperty.getRenderType());
propertyToUpdate.setSensitive(nifiProperty.isSensitive());
propertyToUpdate.setRequired(nifiProperty.isRequired());
if(nifiProperty.getPropertyDescriptor() != null) {
propertyToUpdate.setPropertyDescriptor(nifiProperty.getPropertyDescriptor());
}
if (nifiProperty.getRenderOptions() != null) {
propertyToUpdate.setRenderOptions(nifiProperty.getRenderOptions());
}
}
}
/**
* Return the first property matching the supplied nifiProperty {@link NifiProperty#getIdKey()}
*
* @param properties a collection of properties to inspect
* @param nifiProperty a property to check against
* @return the first property to match the supplied nifiProperty {@link NifiProperty#getIdKey()}
*/
public static NifiProperty findPropertyByIdKey(Collection<NifiProperty> properties, final NifiProperty nifiProperty) {
List<NifiProperty> matchingProperties = Lists.newArrayList(Iterables.filter(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.matchesIdKey(nifiProperty);
}
}));
if (matchingProperties != null && !matchingProperties.isEmpty()) {
return matchingProperties.get(0);
}
return null;
}
/**
* Return a list of all the input properties ( properties that are part of processors that dont have an incoming connections)
*
* @param properties a collection of properties to inspect
* @return a list of all the input properties ( properties that are part of processors that dont have an incoming connections)
*/
public static List<NifiProperty> findInputProperties(Collection<NifiProperty> properties) {
return Lists.newArrayList(Iterables.filter(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.isInputProperty();
}
}));
}
/**
* Return a list of all the input properties ( properties that are part of processors that dont have an incoming connections) that match the supplied processorType
*
* @param properties a collection of properties to inspect
* @param processorType the type of processor to match
* @return a list of all the input properties ( properties that are part of processors that dont have an incoming connections) that match the supplied processorType
*/
public static List<NifiProperty> findInputPropertyMatchingType(Collection<NifiProperty> properties, final String processorType) {
return Lists.newArrayList(Iterables.filter(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.isInputProperty() && property.getProcessorType().equalsIgnoreCase(processorType);
}
}));
}
/**
* Return the first property in the collection that matches the {@link NifiProperty#getKey()}
*
* @param properties a collection of properties to inspect
* @param propertyKey the key to match
* @return the first property in the collection that matches the {@link NifiProperty#getKey()}
*/
public static NifiProperty findFirstPropertyMatchingKey(Collection<NifiProperty> properties, final String propertyKey) {
if (properties != null) {
return Iterables.tryFind(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.getKey().equalsIgnoreCase(propertyKey);
}
}).orNull();
} else {
return null;
}
}
/**
* find properties in the supplied list, using the supplied predicate
*
* @param list1 a collection of properties
* @param predicate a predicate to filter
* @return the resulting filtered list
*/
public static List<NifiProperty> findProperties(Collection<NifiProperty> list1, Predicate<NifiProperty> predicate) {
return Lists.newArrayList(Iterables.filter(list1, predicate));
}
/**
* Find the first property in the collection that has a given processor name
*
* @param properties a collection of properties
* @param nifiProperty a property to check against looking at the {@link NifiProperty#processorName}
* @return a matching property
*/
public static NifiProperty findPropertyByProcessorName(Collection<NifiProperty> properties, final NifiProperty nifiProperty) {
List<NifiProperty> matchingProperties = Lists.newArrayList(Iterables.filter(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return property.getKey().equalsIgnoreCase(nifiProperty.getKey()) && property.getProcessorName().equalsIgnoreCase(nifiProperty.getProcessorName());
}
}));
if (matchingProperties != null && !matchingProperties.isEmpty()) {
return matchingProperties.get(0);
}
return null;
}
/**
* update the templateProperties with those that match the nifiProperty using the {@link NifiProperty#getIdKey()} to make the match
*
* @param templateProperties the properties to update
* @param nifiProperty the property to check
* @param updateMode a mode to update
* @return the property, or updated property if matched
*/
private static NifiProperty matchPropertyByIdKey(Collection<NifiProperty> templateProperties, final NifiProperty nifiProperty, PROPERTY_MATCH_AND_UPDATE_MODE updateMode) {
NifiProperty matchingProperty = findPropertyByIdKey(templateProperties, nifiProperty);
if (matchingProperty != null) {
updateMatchingProperty(matchingProperty, nifiProperty, updateMode);
}
return matchingProperty;
}
/**
* update the templateProperties with those that match the nifiProperty using the {@link NifiProperty#getProcessorName()} to make the match
*
* @param templateProperties the properties to update
* @param nifiProperty the property to check
* @param updateMode a mode to update
* @return the property, or updated property if matched
*/
private static NifiProperty matchPropertyByProcessorName(Collection<NifiProperty> templateProperties, final NifiProperty nifiProperty, PROPERTY_MATCH_AND_UPDATE_MODE updateMode) {
NifiProperty matchingProperty = findPropertyByProcessorName(templateProperties, nifiProperty);
if (matchingProperty != null) {
updateMatchingProperty(matchingProperty, nifiProperty, updateMode);
}
return matchingProperty;
}
/**
* Perform the update of the matching property, setting the property values to that of the supplied 'nifiProperty'
*
* @param matchingProperty a property to updated
* @param nifiProperty the property to use to update the matchingProperty
* @param updateMode a mode to update
*/
private static void updateMatchingProperty(NifiProperty matchingProperty, NifiProperty nifiProperty, PROPERTY_MATCH_AND_UPDATE_MODE updateMode) {
if (updateMode.performUpdate()) {
if (matchingProperty.getValue() == null || (matchingProperty.getValue() != null && (PROPERTY_MATCH_AND_UPDATE_MODE.UPDATE_ALL_PROPERTIES.equals(updateMode) || PROPERTY_MATCH_AND_UPDATE_MODE.FEED_DETAILS_MATCH_TEMPLATE.equals(updateMode) || (
PROPERTY_MATCH_AND_UPDATE_MODE.UPDATE_NON_EXPRESSION_PROPERTIES.equals(updateMode) && (
(!matchingProperty.getValue().contains("${metadata.")) || (matchingProperty.getValue()
.contains("${metadata.") && nifiProperty.getValue() != null && nifiProperty.getValue()
.contains("${metadata."))))))) {
updateProperty(matchingProperty, nifiProperty, updateMode);
}
}
}
/**
* Check to see if a collection of properties contains properties of a supplied processorType
*
* @param properties a collection of properties
* @param processorType a processor type to match
* @return {@code true} if the collection of properties contains the supplied processorType, {@code false} if the properties do not contain the processorType
*/
public static boolean containsPropertiesForProcessorMatchingType(Collection<NifiProperty> properties, final String processorType) {
if (StringUtils.isBlank(processorType)) {
return false;
}
return Iterables.tryFind(properties, new Predicate<NifiProperty>() {
@Override
public boolean apply(NifiProperty property) {
return processorType.equalsIgnoreCase(property.getProcessorType());
}
}).orNull() != null;
}
/**
* various modes used for updating properties
*/
public static enum PROPERTY_MATCH_AND_UPDATE_MODE {
/**
* this mode will not update any properties
*/
DONT_UPDATE,
/**
* this mode will update all the properties
*/
UPDATE_ALL_PROPERTIES,
/**
* this mode will skip over any properties with the ${metadata. prefix in the value string of the property
*/
UPDATE_NON_EXPRESSION_PROPERTIES,
/**
* update the template properties with the Feed properties
*/
FEED_DETAILS_MATCH_TEMPLATE;
/**
* @return true if the update should happen, false if not
*/
public boolean performUpdate() {
return !DONT_UPDATE.equals(this);
}
}
}