# HikariCP Controller Service

public class StandardHikariCPService extends AbstractControllerService implements HikariCPService {

    public static final PropertyDescriptor MY_PROPERTY = new PropertyDescriptor.Builder().name("MY_PROPERTY")
            .displayName("My Property").description("Example Property").required(true)
            .addValidator(StandardValidators.NON_EMPTY_VALIDATOR).build();

    private static final List<PropertyDescriptor> properties;

    static {
        final List<PropertyDescriptor> props = new ArrayList<>();
        props.add(MY_PROPERTY);
        properties = Collections.unmodifiableList(props);
    }

    @Override
    protected List<PropertyDescriptor> getSupportedPropertyDescriptors() {
        return properties;
    }

    /**
     * @param context the configuration context
     * @throws InitializationException if unable to create a database connection
     */
    @OnEnabled
    public void onEnabled(final ConfigurationContext context) throws InitializationException {

    }

    @OnDisabled
    public void shutdown() {

    }

    @Override
    public Connection getConnection() throws ProcessException {
        // TODO Auto-generated method stub
        return null;
    }

}

package com.mbio.custom.hikaricp;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.apache.derby.jdbc.ClientDataSource;
import org.apache.nifi.components.AllowableValue;
import org.apache.nifi.components.PropertyDescriptor;
import org.apache.nifi.processor.util.StandardValidators;
import org.postgresql.ds.PGSimpleDataSource;

public enum ConfigUtil {

    INSTANCE;
  
    private static List<PropertyDescriptor> properties;
  
    private static final AllowableValue DERBY_DS = new AllowableValue(
        ClientDataSource.class.getName(), "Apache Derby", "Apache Derby Datasource");
  
    private static final AllowableValue PGSQL_DS =
        new AllowableValue(PGSimpleDataSource.class.getName(), "PostgreSQL", "PostgreSQL Datasource");
  
    public static final PropertyDescriptor DATASOURCE_CLASSNAME = new PropertyDescriptor.Builder()
        .name("dataSourceClassName").displayName("Datasource classname")
        .description("Fully qualified classname of datasource")
        .allowableValues(getAllowableValue()).addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
        .required(true).build();
  
    public static final PropertyDescriptor USERNAME = new PropertyDescriptor.Builder()
        .name("userName").displayName("User Name").description("Database account user name")
        .addValidator(StandardValidators.NON_EMPTY_VALIDATOR).required(true).build();
  
    public static final PropertyDescriptor PASSWORD = new PropertyDescriptor.Builder()
        .name("password").displayName("Password").description("Database account password")
        .addValidator(StandardValidators.NON_EMPTY_VALIDATOR).required(true).sensitive(true).build();
  
    public static final PropertyDescriptor AUTO_COMMIT = new PropertyDescriptor.Builder()
        .name("autoCommit").displayName("Auto commit").description("Database account user name")
        .allowableValues("true", "false").defaultValue("true")
        .addValidator(StandardValidators.BOOLEAN_VALIDATOR).required(false).build();
  
    public static final PropertyDescriptor METRICS = new PropertyDescriptor.Builder().name("metrics")
        .displayName("Metrics").description("Whether or not to log metrics")
        .allowableValues("true", "false").defaultValue("false")
        .addValidator(StandardValidators.BOOLEAN_VALIDATOR).required(false).build();
  
    static {
      List<PropertyDescriptor> properties = new ArrayList<>();
      properties.add(DATASOURCE_CLASSNAME);
      properties.add(USERNAME);
      properties.add(PASSWORD);
      properties.add(AUTO_COMMIT);
      properties.add(METRICS);
      ConfigUtil.properties = Collections.unmodifiableList(properties);
    }
  
    public static List<PropertyDescriptor> getProperties() {
      return properties;
    }
  
    public static PropertyDescriptor getDynamicProperty(String propertyDescriptorName) {
      return new PropertyDescriptor.Builder().name(propertyDescriptorName).required(false)
          .addValidator(new DataSourcePropertyValidator()).dynamic(true).build();
    }
    
    private static AllowableValue[] getAllowableValue() {
      List<AllowableValue> values = new ArrayList<AllowableValue>();
      values.add(DERBY_DS);
      values.add(PGSQL_DS);
      
      return values.toArray(new AllowableValue[values.size()]);
    }
  
  }
  

package com.mbio.custom.hikaricp;

import java.beans.Introspector;
import java.lang.reflect.Method;
import org.apache.nifi.components.ValidationContext;
import org.apache.nifi.components.ValidationResult;
import org.apache.nifi.components.Validator;

public class DataSourcePropertyValidator implements Validator {

  @Override
  public ValidationResult validate(String propertyName, String PropertyValue,
      ValidationContext context) {

    String dsClassName = context.getProperty(ConfigUtil.DATASOURCE_CLASSNAME).getValue();
    return new ValidationResult.Builder().subject(propertyName).input(PropertyValue)
        .valid(isValidProperty(dsClassName, propertyName))
        .explanation(propertyName + " is not a valid property").build();
  }

  private boolean isValidProperty(final String dsClassName, final String propertyName) {
    try {
      Class<?> dsClass = Class.forName(dsClassName);

      Method[] methods = dsClass.getMethods();

      for (Method method : methods) {

        String methodName = method.getName();
        if (methodName.startsWith("set")) {
          String dsProperty = Introspector.decapitalize(methodName.substring(3));
          if (dsProperty.equals(propertyName)) {
            return true;
          }
        }
      }

    } catch (Exception e) {
      return false;
    }
    return false;
  }
}

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
package com.mbio.custom.hikaricp;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

import com.codahale.metrics.MetricRegistry;
import com.zaxxer.hikari.HikariDataSource;

import org.apache.nifi.annotation.behavior.DynamicProperty;
import org.apache.nifi.annotation.documentation.CapabilityDescription;
import org.apache.nifi.annotation.documentation.Tags;
import org.apache.nifi.annotation.lifecycle.OnDisabled;
import org.apache.nifi.annotation.lifecycle.OnEnabled;
import org.apache.nifi.components.PropertyDescriptor;
import org.apache.nifi.controller.AbstractControllerService;
import org.apache.nifi.controller.ConfigurationContext;
import org.apache.nifi.processor.exception.ProcessException;
import org.apache.nifi.reporting.InitializationException;

@Tags({"DBCP", "SQL", "Database", "HikariCP", "NICE"})
@CapabilityDescription("Database connection pooling using HikariCP API")
@DynamicProperty(name = "DataSource property", value = "The value to set it to",
    description = "Property for the selected DataSource")
public class StandardHikariCPService extends AbstractControllerService implements HikariCPService {

    private AtomicReference<HikariDataSource> ds = new AtomicReference<>();

    @Override
    protected List<PropertyDescriptor> getSupportedPropertyDescriptors() {
      return ConfigUtil.getProperties();
    }
  
    @Override
    protected PropertyDescriptor getSupportedDynamicPropertyDescriptor(
        String propertyDescriptorName) {
  
      return ConfigUtil.getDynamicProperty(propertyDescriptorName);
    }
  
    /**
     * @param context the configuration context
     * @throws InitializationException if unable to create a database connection
     */
    @OnEnabled
    public void onEnabled(final ConfigurationContext context) throws InitializationException {
  
      HikariDataSource ds = new HikariDataSource();
  
      final String dsClassName = context.getProperty(ConfigUtil.DATASOURCE_CLASSNAME).getValue();
      final String userName = context.getProperty(ConfigUtil.USERNAME).getValue();
      final String password = context.getProperty(ConfigUtil.PASSWORD).getValue();
      final boolean autoCommit = context.getProperty(ConfigUtil.AUTO_COMMIT).asBoolean();
      final boolean metrics = context.getProperty(ConfigUtil.METRICS).asBoolean();
  
      ds.setDataSourceClassName(dsClassName);
      ds.setUsername(userName);
      ds.setPassword(password);
      ds.setAutoCommit(autoCommit);
  
      if (metrics) {
        ds.setMetricRegistry(new MetricRegistry());
      }
  
      context.getProperties().entrySet().parallelStream().filter(e -> e.getKey().isDynamic())
          .forEach(e -> {
            ds.addDataSourceProperty(e.getKey().getName(), e.getValue());
          });
  
      this.ds.set(ds);
    }
  
    @OnDisabled
    public void shutdown() {
      ds.get().close();
    }
  
    @Override
    public Connection getConnection() throws ProcessException {
      try {
        return ds.get().getConnection();
      }catch(SQLException e) {
        getLogger().error("Could not get connecdtion from datasources", e);
      }
      return null;
    }

}