ConfigurationPropertyReplacer.java

package com.thinkbiganalytics.nifi.feedmgr;

/*-
 * #%L
 * thinkbig-nifi-rest-client-api
 * %%
 * 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.thinkbiganalytics.nifi.rest.model.NiFiPropertyDescriptorTransform;
import com.thinkbiganalytics.nifi.rest.model.NifiProperty;

import org.apache.commons.collections.map.CaseInsensitiveMap;
import org.apache.commons.lang3.StringUtils;
import org.apache.nifi.web.api.dto.ControllerServiceDTO;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Auto Inject Property Values stored in the application.properties file
 * 3 use cases are supported
 * 1) store properties in the file starting with the prefix defined in the "PropertyExpressionResolver class"  default = config.
 * 2) store properties in the file starting with "nifi.<PROCESSORTYPE>.<PROPERTY_KEY>   where PROCESSORTYPE and PROPERTY_KEY are all lowercase and the spaces are substituted with underscore
 * 3) Global property replacement.  properties starting with "nifi.all_processors.<PROPERTY_KEY> will globally replace the value when the template is instantiated
 */
public class ConfigurationPropertyReplacer {


    public static final String NIF_EL_PROPERTY_REPLACEMENT_PREFIX = "$nifi{";

    /**
     * returns a new str in lowercase replacing spaces with _
     * @param str a string to parse
     * @return  a new str in lowercase replacing spaces with _
     */
    private static String toPropertyName(String str) {
        return str.toLowerCase().trim().replaceAll(" +", "_");
    }



    /**
     * return the application.properties property key for the specific property using the proocessor type as the key reference
     *
     * @param property the nifi property
     * @return the property key prepended with the "nifi.<processor type>."
     */
    public static String getProcessorPropertyConfigName(NifiProperty property) {
        String processorTypeName = "nifi." + toPropertyName(StringUtils.substringAfterLast(property.getProcessorType(), ".") + "." + property.getKey());
        return processorTypeName;
    }


    /**
     * return the application.properties property key for the specific property using the proocessor type as the key reference
     *
     * @param property the nifi property
     * @return the property key prepended with the "nifi.<processor type>[<processor name>]."
     */
    public static String getProcessorNamePropertyConfigName(NifiProperty property) {
        String processorTypeName = "nifi." + toPropertyName(StringUtils.substringAfterLast(property.getProcessorType(), ".") + "["+property.getProcessorName()+"]." + property.getKey());
        return processorTypeName;
    }


    /**
     * Return the application.properties property key for 'all_processors' matching the supplied NiFi property.
     *
     * @param property the nifi property to inspect
     * @return the property key prepended with the "nifi.all_processors."
     */
    public static String getGlobalAllProcessorsPropertyConfigName(NifiProperty property) {
        String processorTypeName = "nifi.all_processors." + toPropertyName(property.getKey());
        return processorTypeName;
    }

    /**
     * Replace the $nifi{} with ${}
     * @param value the property value
     * @return the replaced value
     */
    public static String fixNiFiExpressionPropertyValue(String value){
        if(StringUtils.isNotBlank(value)) {
            return StringUtils.replace(value, ConfigurationPropertyReplacer.NIF_EL_PROPERTY_REPLACEMENT_PREFIX, "${");
        }
        return value;
    }

    /**
     * This will replace the Map of Properties in the DTO but not persist back to Nifi.  You need to call the rest client to persist the change
     *
     * @param controllerServiceDTO        the controller service
     * @param properties                  the properties to set
     * @param propertyDescriptorTransform transformer
     * @return {@code true} if the properties were updated, {@code false} if not
     */
    public static boolean replaceControllerServiceProperties(ControllerServiceDTO controllerServiceDTO, Map<String, String> properties, NiFiPropertyDescriptorTransform propertyDescriptorTransform) {
        Set<String> changedProperties = new HashSet<>();
        if (controllerServiceDTO != null) {
            //check both Nifis Internal Key name as well as the Displayname to match the properties
            CaseInsensitiveMap propertyMap = new CaseInsensitiveMap(properties);
            Map<String, String> controllerServiceProperties = controllerServiceDTO.getProperties();

            controllerServiceProperties.entrySet().stream().filter(
                entry -> (propertyMap.containsKey(entry.getKey()) || (controllerServiceDTO.getDescriptors().get(entry.getKey()) != null && propertyMap
                    .containsKey(controllerServiceDTO.getDescriptors().get(entry.getKey()).getDisplayName().toLowerCase())))).
                forEach(entry -> {
                    boolean isSensitive = propertyDescriptorTransform.isSensitive(controllerServiceDTO.getDescriptors().get(entry.getKey()));
                    String value = (String) propertyMap.get(entry.getKey());
                    if (StringUtils.isBlank(value)) {
                        value = (String) propertyMap.get(controllerServiceDTO.getDescriptors().get(entry.getKey()).getDisplayName().toLowerCase());
                    }
                    if (!isSensitive || (isSensitive && StringUtils.isNotBlank(value))) {
                        entry.setValue(value);
                        changedProperties.add(entry.getKey());
                    }

                });
        }
        return !changedProperties.isEmpty();
    }

    private static String resolveValue(NifiProperty property, Map<String,Object> configProperties){
        Object value = null;
        if(configProperties != null) {
            //see if the processorType is configured
            String processorTypeWithProcessorNameProperty = getProcessorNamePropertyConfigName(property);
            value = configProperties.get(processorTypeWithProcessorNameProperty);
            if (value == null || StringUtils.isBlank(value.toString())) {
                String processorTypeProperty = getProcessorPropertyConfigName(property);
                value = configProperties.get(processorTypeProperty);
                if (value == null || StringUtils.isBlank(value.toString())) {
                    String globalPropertyType = getGlobalAllProcessorsPropertyConfigName(property);
                    value = configProperties.get(globalPropertyType);
                }
            }
            if(value != null){
                String updatedPropertyValue = fixNiFiExpressionPropertyValue(value.toString());
                return updatedPropertyValue;
            }
        }
        return null;


    }


    /**
     * @param property         the NifiProperty to replace
     * @param configProperties a Map of properties which will be looked to to match against the property key
     */
    public static boolean resolveStaticConfigurationProperty(NifiProperty property, Map<String, Object> configProperties) {
        String value = property.getValue();
        StringBuffer sb = null;

        if (configProperties != null && !configProperties.isEmpty()) {

            if (StringUtils.isNotBlank(value)) {
                Pattern variablePattern = Pattern.compile("\\$\\{(.*?)\\}");
                Matcher matchVariablePattern = variablePattern.matcher(value);
                while (matchVariablePattern.find()) {
                    if (sb == null) {
                        sb = new StringBuffer();
                    }
                    String group = matchVariablePattern.group();
                    int groupCount = matchVariablePattern.groupCount();
                    if (groupCount == 1) {

                        String variable = matchVariablePattern.group(1);
                        //lookup the variable
                        //first look at configuration properties
                        Object resolvedValue = configProperties.get(variable);
                        if (resolvedValue != null) {
                            matchVariablePattern.appendReplacement(sb, resolvedValue.toString());
                        }
                    }
                }
                if (sb != null) {
                    matchVariablePattern.appendTail(sb);
                }
            }
        }

        if (sb == null) {

            String updatedValue = resolveValue(property,configProperties);
            if(StringUtils.isNotBlank(updatedValue)) {
                sb = new StringBuffer();
                sb.append(updatedValue);
            }

        }
        if (sb != null) {
            property.setValue(StringUtils.trim(sb.toString()));
        }

        return sb != null;
    }

}