# JNDIBasedDataSourceRepository.java

    /*
     *  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.
     */
    /**
     * To change this template use File | Settings | File Templates.
     */
    package org.apache.synapse.commons.datasource;

    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.apache.synapse.commons.SynapseCommonsException;
    import org.apache.synapse.commons.util.MiscellaneousUtil;
    import org.apache.synapse.commons.util.RMIRegistryController;
    import org.wso2.securevault.SecurityConstants;

    import javax.naming.*;
    import javax.sql.DataSource;
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    import java.util.*;

    /**
     * Keep all DataSources in the JNDI Tree
     */
    public class JNDIBasedDataSourceRepository implements DataSourceRepository {

        private static Log log = LogFactory.getLog(JNDIBasedDataSourceRepository.class);

        private InitialContext initialContext;
        private Properties jndiProperties;
        private final Map<String, InitialContext> perDataSourceICMap
                = new HashMap<String, InitialContext>();
        private final List<String> cachedNameList = new ArrayList<String>();
        private final List<Integer> cachedPorts = new ArrayList<Integer>();

        private boolean initialized = false;

        public void init(Properties jndiEnv) {

            initialized = true;
            if (jndiEnv == null || jndiEnv.isEmpty()) {
                if (log.isDebugEnabled()) {
                    log.debug("Provided global JNDI environment properties is empty or null.");
                }
                return;
            }

            if (isValid(jndiEnv)) {
                jndiProperties = createJNDIEnvironment(jndiEnv, null);
                initialContext = createInitialContext(jndiProperties);
            }
        }

        /**
         * Register a DataSource in the JNDI tree
         *
         * @see DataSourceRepository#register(DataSourceInformation)
         */
        public void register(DataSourceInformation information) {

            validateInitialized();
            String dataSourceName = information.getDatasourceName();
            validateDSName(dataSourceName);
            Properties properties = information.getProperties();

            InitialContext context = null;
            Properties jndiEvn = null;

            if (properties == null || properties.isEmpty()) {
                if (initialContext != null) {
                    context = initialContext;
                    if (log.isDebugEnabled()) {
                        log.debug("Empty JNDI properties for datasource " + dataSourceName);
                        log.debug("Using system-wide jndi properties : " + jndiProperties);
                    }

                    jndiEvn = jndiProperties;
                }
            }

            if (context == null) {

                jndiEvn = createJNDIEnvironment(properties, information.getAlias());
                context = createInitialContext(jndiEvn);

                if (context == null) {

                    validateInitialContext(initialContext);
                    context = initialContext;

                    if (log.isDebugEnabled()) {
                        log.debug("Cannot create a name context with provided jndi properties : " +
                                jndiEvn);
                        log.debug("Using system-wide JNDI properties : " + jndiProperties);
                    }

                    jndiEvn = jndiProperties;
                } else {
                    perDataSourceICMap.put(dataSourceName, context);
                }
            }

            String dsType = information.getType();
            String driver = information.getDriver();
            String url = information.getUrl();

            String user = information.getSecretInformation().getUser();
            String password = information.getSecretInformation().getResolvedSecret();

            String maxActive = String.valueOf(information.getMaxActive());
            String maxIdle = String.valueOf(information.getMaxIdle());
            String maxWait = String.valueOf(information.getMaxWait());

            //populates context tree
            populateContextTree(context, dataSourceName);

            if (DataSourceInformation.BASIC_DATA_SOURCE.equals(dsType)) {

                Reference ref = new Reference("javax.sql.DataSource",
                        "org.apache.commons.dbcp.BasicDataSourceFactory", null);

                ref.add(new StringRefAddr(DataSourceConstants.PROP_DRIVER_CLS_NAME,
                        driver));
                ref.add(new StringRefAddr(DataSourceConstants.PROP_URL, url));
                ref.add(new StringRefAddr(SecurityConstants.PROP_USER_NAME, user));
                ref.add(new StringRefAddr(SecurityConstants.PROP_PASSWORD, password));
                ref.add(new StringRefAddr(DataSourceConstants.PROP_MAX_ACTIVE, maxActive));
                ref.add(new StringRefAddr(DataSourceConstants.PROP_MAX_IDLE, maxIdle));
                ref.add(new StringRefAddr(DataSourceConstants.PROP_MAX_WAIT, maxWait));

                // set BasicDataSource specific parameters
                setBasicDataSourceParameters(ref, information);
                //set default jndiProperties for reference
                setCommonParameters(ref, information);

                try {

                    if (log.isDebugEnabled()) {
                        log.debug("Registering a DataSource with name : " +
                                dataSourceName + " in the JNDI tree with jndiProperties : " + jndiEvn);
                    }

                    context.rebind(dataSourceName, ref);
                } catch (NamingException e) {
                    String msg = " Error binding name ' " + dataSourceName + " ' to " +
                            "the DataSource(BasicDataSource) reference";
                    throw new SynapseCommonsException(msg, e, log);
                }

            } else if (DataSourceInformation.PER_USER_POOL_DATA_SOURCE.equals(dsType)) {

                // Construct DriverAdapterCPDS reference
                String className = (String) information.getParameter(
                        DataSourceConstants.PROP_CPDS_ADAPTER +
                                DataSourceConstants.DOT_STRING +
                                DataSourceConstants.PROP_CPDS_CLASS_NAME);
                String factory = (String) information.getParameter(
                        DataSourceConstants.PROP_CPDS_ADAPTER +
                                DataSourceConstants.DOT_STRING +
                                DataSourceConstants.PROP_CPDS_FACTORY);
                String name = (String) information.getParameter(
                        DataSourceConstants.PROP_CPDS_ADAPTER +
                                DataSourceConstants.DOT_STRING +
                                DataSourceConstants.PROP_CPDS_NAME);

                Reference cpdsRef =
                        new Reference(className, factory, null);

                cpdsRef.add(new StringRefAddr(DataSourceConstants.PROP_DRIVER, driver));
                cpdsRef.add(new StringRefAddr(DataSourceConstants.PROP_URL, url));
                cpdsRef.add(new StringRefAddr(DataSourceConstants.PROP_USER, user));
                cpdsRef.add(new StringRefAddr(SecurityConstants.PROP_PASSWORD,
                        password));

                try {
                    context.rebind(name, cpdsRef);
                } catch (NamingException e) {
                    String msg = "Error binding name '" + name + "' to " +
                            "the DriverAdapterCPDS reference";
                    throw new SynapseCommonsException(msg, e, log);
                }

                // Construct PerUserPoolDataSource reference
                Reference ref =
                        new Reference("org.apache.commons.dbcp.datasources.PerUserPoolDataSource",
                                "org.apache.commons.dbcp.datasources.PerUserPoolDataSourceFactory",
                                null);

                ref.add(new BinaryRefAddr(
                        DataSourceConstants.PROP_JNDI_ENV,
                        MiscellaneousUtil.serialize(jndiEvn)));
                ref.add(new StringRefAddr(
                        DataSourceConstants.PROP_DATA_SOURCE_NAME, name));
                ref.add(new StringRefAddr(
                        DataSourceConstants.PROP_DEFAULT_MAX_ACTIVE, maxActive));
                ref.add(new StringRefAddr(
                        DataSourceConstants.PROP_DEFAULT_MAX_IDLE, maxIdle));
                ref.add(new StringRefAddr(
                        DataSourceConstants.PROP_DEFAULT_MAX_WAIT, maxWait));

                //set default jndiProperties for reference
                setCommonParameters(ref, information);

                try {

                    if (log.isDebugEnabled()) {
                        log.debug("Registering a DataSource with name : " +
                                dataSourceName + " in the JNDI tree with jndiProperties : " + jndiEvn);
                    }

                    context.rebind(dataSourceName, ref);
                } catch (NamingException e) {
                    String msg = "Error binding name ' " + dataSourceName + " ' to " +
                            "the PerUserPoolDataSource reference";
                    throw new SynapseCommonsException(msg, e, log);
                }

            } else {
                throw new SynapseCommonsException("Unsupported data source type : " + dsType, log);
            }
            cachedNameList.add(dataSourceName);
        }

        public void unRegister(String name) {

            InitialContext context = getCachedInitialContext(name);
            try {
                context.unbind(name);
            } catch (NamingException e) {
                throw new SynapseCommonsException("Error removing a Datasource with name : " +
                        name + " from the JNDI context : " + initialContext, e);
            }
            cachedNameList.remove(name);
        }

        /**
         * Get a DatSource which has been registered in the JNDI tree
         *
         * @see DataSourceRepository#lookUp(String)
         */
        public DataSource lookUp(String dsName) {

            validateInitialized();
            validateDSName(dsName);
            if (!cachedNameList.contains(dsName)) {
                if (log.isDebugEnabled()) {
                    log.debug("There is no Datasource with name " + dsName +
                            " in JNDI Datasource Repository");
                }
                return null;
            }
            if (log.isDebugEnabled()) {
                log.debug("Getting a DataSource with name : " + dsName + " from the JNDI tree.");
            }

            InitialContext context = getCachedInitialContext(dsName);
            return DataSourceFinder.find(dsName, context);
        }

        public void clear() {
            initialized = false;
            initialContext = null;
            jndiProperties.clear();
            perDataSourceICMap.clear();
            cachedNameList.clear();
            for (int port : cachedPorts) {
                RMIRegistryController.getInstance().removeLocalRegistry(port);
            }
            cachedPorts.clear();
        }

        private InitialContext getCachedInitialContext(String name) {
            InitialContext context = perDataSourceICMap.get(name);
            if (context == null) {
                validateInitialContext(initialContext);
                context = initialContext;
            }
            return context;
        }

        /**
         * Helper method to set all default parameter for naming reference of data source
         *
         * @param reference   The naming reference instance
         * @param information DataSourceInformation instance
         */
        private static void setCommonParameters(Reference reference, DataSourceInformation information) {

            reference.add(new StringRefAddr(DataSourceConstants.PROP_DEFAULT_AUTO_COMMIT,
                    String.valueOf(information.isDefaultAutoCommit())));
            reference.add(new StringRefAddr(DataSourceConstants.PROP_DEFAULT_READ_ONLY,
                    String.valueOf(information.isDefaultReadOnly())));
            reference.add(new StringRefAddr(DataSourceConstants.PROP_TEST_ON_BORROW,
                    String.valueOf(information.isTestOnBorrow())));
            reference.add(new StringRefAddr(DataSourceConstants.PROP_TEST_ON_RETURN,
                    String.valueOf(information.isTestOnReturn())));
            reference.add(new StringRefAddr(
                    DataSourceConstants.PROP_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
                    String.valueOf(information.getTimeBetweenEvictionRunsMillis())));
            reference.add(new StringRefAddr(
                    DataSourceConstants.PROP_NUM_TESTS_PER_EVICTION_RUN,
                    String.valueOf(information.getNumTestsPerEvictionRun())));
            reference.add(new StringRefAddr(
                    DataSourceConstants.PROP_MIN_EVICTABLE_IDLE_TIME_MILLIS,
                    String.valueOf(information.getMinEvictableIdleTimeMillis())));
            reference.add(new StringRefAddr(
                    DataSourceConstants.PROP_TEST_WHILE_IDLE,
                    String.valueOf(information.isTestWhileIdle())));

            String validationQuery = information.getValidationQuery();

            if (validationQuery != null && !"".equals(validationQuery)) {
                reference.add(new StringRefAddr(
                        DataSourceConstants.PROP_VALIDATION_QUERY, validationQuery));
            }
        }

        /**
         * Helper method to set all BasicDataSource specific parameter
         *
         * @param ref         The naming reference instance
         * @param information DataSourceInformation instance
         */
        private static void setBasicDataSourceParameters(Reference ref,
                                                         DataSourceInformation information) {

            int defaultTransactionIsolation = information.getDefaultTransactionIsolation();
            String defaultCatalog = information.getDefaultCatalog();

            if (defaultTransactionIsolation != -1) {
                ref.add(new StringRefAddr(
                        DataSourceConstants.PROP_DEFAULT_TRANSACTION_ISOLATION,
                        String.valueOf(defaultTransactionIsolation)));
            }

            ref.add(new StringRefAddr(DataSourceConstants.PROP_MIN_IDLE,
                    String.valueOf(information.getMaxIdle())));
            ref.add(new StringRefAddr(
                    DataSourceConstants.PROP_ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED,
                    String.valueOf(information.isAccessToUnderlyingConnectionAllowed())));
            ref.add(new StringRefAddr(
                    DataSourceConstants.PROP_REMOVE_ABANDONED,
                    String.valueOf(information.isRemoveAbandoned())));
            ref.add(new StringRefAddr(DataSourceConstants.PROP_REMOVE_ABANDONED_TIMEOUT,
                    String.valueOf(information.getRemoveAbandonedTimeout())));
            ref.add(new StringRefAddr(
                    DataSourceConstants.PROP_LOG_ABANDONED,
                    String.valueOf(information.isLogAbandoned())));
            ref.add(new StringRefAddr(
                    DataSourceConstants.PROP_POOL_PREPARED_STATEMENTS,
                    String.valueOf(information.isPoolPreparedStatements())));
            ref.add(new StringRefAddr(DataSourceConstants.PROP_MAX_OPEN_PREPARED_STATEMENTS,
                    String.valueOf(information.getMaxOpenPreparedStatements())));
            ref.add(new StringRefAddr(
                    DataSourceConstants.PROP_INITIAL_SIZE, String.valueOf(
                            information.getInitialSize())));

            if (defaultCatalog != null && !"".equals(defaultCatalog)) {
                ref.add(new StringRefAddr
                        (DataSourceConstants.PROP_DEFAULT_CATALOG, defaultCatalog));
            }
        }

        /**
         * Helper method to create context tree for a given path
         *
         * @param initialContext The root context
         * @param path           The path of the resource
         */
        private static void populateContextTree(InitialContext initialContext, String path) {

            String[] paths = path.split("/");
            if (paths != null && paths.length > 1) {

                Context context = initialContext;
                for (String path1 : paths) {

                    try {
                        assert context != null;
                        context = context.createSubcontext(path1);
                        if (context == null) {
                            throw new SynapseCommonsException("sub context " + path1 + " could not" +
                                    " be created", log);
                        }

                    } catch (NamingException e) {
                        throw new SynapseCommonsException("Unable to create sub context : " + path1,
                                e, log);
                    }
                }
            }
        }

        private Properties createJNDIEnvironment(Properties dsProperties, String name) {

            String namingFactory = DataSourceConstants.DEFAULT_IC_FACTORY;
            String providerUrl = null;
            int port = DataSourceConstants.DEFAULT_PROVIDER_PORT;
            String providerPort = null;
            // setting naming provider
            Properties jndiEvn = new Properties();  //This is needed for PerUserPoolDatasource

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

                if (log.isDebugEnabled()) {
                    log.debug("Using properties " + dsProperties + " to create JNDI Environment");
                }

                StringBuffer buffer = new StringBuffer();
                buffer.append(DataSourceConstants.PROP_SYNAPSE_PREFIX_DS);
                buffer.append(DataSourceConstants.DOT_STRING);
                if (name != null && !"".equals(name)) {
                    buffer.append(name);
                    buffer.append(DataSourceConstants.DOT_STRING);
                }
                // The prefix for root level jndiProperties
                String rootPrefix = buffer.toString();

                namingFactory = MiscellaneousUtil.getProperty(
                        dsProperties, rootPrefix + DataSourceConstants.PROP_IC_FACTORY,
                        DataSourceConstants.DEFAULT_IC_FACTORY);

                //Provider URL
                providerUrl = MiscellaneousUtil.getProperty(
                        dsProperties, rootPrefix + DataSourceConstants.PROP_PROVIDER_URL,
                        null);
                providerPort =
                        MiscellaneousUtil.getProperty(dsProperties, rootPrefix +
                                DataSourceConstants.PROP_PROVIDER_PORT,
                                String.valueOf(DataSourceConstants.DEFAULT_PROVIDER_PORT));

            }

            jndiEvn.put(Context.INITIAL_CONTEXT_FACTORY, namingFactory);

            if (providerUrl != null && !"".equals(providerUrl)) {
                if (log.isDebugEnabled()) {
                    log.debug("Using provided initial context provider url :" + providerUrl);
                }

            } else {
                if (log.isDebugEnabled()) {
                    log.debug("No initial context provider url...creaeting a new one");
                }
                String providerHost = "localhost";
                try {
                    InetAddress addr = InetAddress.getLocalHost();
                    if (addr != null) {
                        String hostname = addr.getHostName();
                        if (hostname == null) {
                            String ipAddr = addr.getHostAddress();
                            if (ipAddr != null) {
                                providerHost = ipAddr;
                            }
                        } else {
                            providerHost = hostname;
                        }
                    }
                } catch (UnknownHostException e) {
                    log.warn("Unable to determine hostname or IP address.. Using localhost", e);
                }

                // default port for RMI registry

                if (providerPort != null) {
                    try {
                        port = Integer.parseInt(providerPort);
                    } catch (NumberFormatException ignored) {
                    }
                }

                // Create a RMI local registry
                RMIRegistryController.getInstance().createLocalRegistry(port);
                cachedPorts.add(port);
                providerUrl = "rmi://" + providerHost + ":" + port;

            }

            jndiEvn.put(Context.PROVIDER_URL, providerUrl);

            log.info("DataSources will be registered in the JNDI context with provider PROP_URL : " +
                    providerUrl);
            return jndiEvn;
        }

        public boolean isInitialized() {
            return initialized;
        }

        private void validateInitialized() {
            if (!isInitialized()) {
                throw new SynapseCommonsException("Datasource repository has not been initialized " +
                        "yet", log);
            }
        }

        private void validateDSName(String dataSourceName) {
            if (dataSourceName == null || "".equals(dataSourceName)) {
                throw new SynapseCommonsException("Invalid DataSource configuration !! -" +
                        "DataSource Name cannot be found ", log);
            }
        }

        private void validateInitialContext(InitialContext initialContext) {
            if (initialContext == null) {
                throw new SynapseCommonsException("InitialContext cannot be found.", log);
            }
        }

        private InitialContext createInitialContext(Properties jndiEnv) {

            if (jndiEnv == null || jndiEnv.isEmpty()) {
                return null;
            }
            try {

                if (log.isDebugEnabled()) {
                    log.debug("Initiating a Naming context with JNDI " +
                            "environment jndiProperties :  " + jndiEnv);
                }

                return new InitialContext(jndiEnv);

            } catch (NamingException e) {
                throw new SynapseCommonsException("Error creating a InitialContext" +
                        " with JNDI env jndiProperties : " + jndiEnv, log);
            }
        }

        private boolean isValid(Properties dsProperties) {

            String dataSources = MiscellaneousUtil.getProperty(dsProperties,
                    DataSourceConstants.PROP_SYNAPSE_PREFIX_DS, null);

            if (dataSources != null && !"".equals(dataSources)) {
                String[] dataSourcesNames = dataSources.split(",");
                return !(dataSourcesNames == null || dataSourcesNames.length == 0);
            }

            return false;
        }
    }