source: Ballon/out/artifacts/geisa_artifact/WEB-INF/lib/mysql-connector-java-5.1.21/src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java @ 848

/*
 Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
 

  The MySQL Connector/J is licensed under the terms of the GPLv2
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
  this software, see the FLOSS License Exception
  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.

  This program is free software; you can redistribute it and/or modify it under the terms
  of the GNU General Public License as published by the Free Software Foundation; version 2
  of the License.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with this
  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
  Floor, Boston, MA 02110-1301  USA



 */
package com.mysql.jdbc.jdbc2.optional;

import java.io.PrintWriter;
import java.io.Serializable;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.Properties;

import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.StringRefAddr;
import javax.sql.DataSource;

import com.mysql.jdbc.ConnectionPropertiesImpl;
import com.mysql.jdbc.NonRegisteringDriver;

/**
 * A JNDI DataSource for a Mysql JDBC connection
 * 
 * @author Mark Matthews
 */
public class MysqlDataSource extends ConnectionPropertiesImpl implements
                DataSource, Referenceable, Serializable  {

        static final long serialVersionUID = -5515846944416881264L;

        /** The driver to create connections with */
        protected final static NonRegisteringDriver mysqlDriver;

        static {
                try {
                        mysqlDriver = new NonRegisteringDriver();
                } catch (Exception E) {
                        throw new RuntimeException(
                                        "Can not load Driver class com.mysql.jdbc.Driver");
                }
        }

        /** Log stream */
        protected transient PrintWriter logWriter = null;

        /** Database Name */
        protected String databaseName = null;

        /** Character Encoding */
        protected String encoding = null;

        /** Hostname */
        protected String hostName = null;

        /** Password */
        protected String password = null;

        /** The profileSql property */
        protected String profileSql = "false";

        /** The JDBC URL */
        protected String url = null;

        /** User name */
        protected String user = null;

        /** Should we construct the URL, or has it been set explicitly */
        protected boolean explicitUrl = false;

        /** Port number */
        protected int port = 3306;

        /**
         * Default no-arg constructor for Serialization
         */
        public MysqlDataSource() {
        }

        /**
         * Creates a new connection using the already configured username and
         * password.
         * 
         * @return a connection to the database
         * 
         * @throws SQLException
         *             if an error occurs
         */
        public java.sql.Connection getConnection() throws SQLException {
                return getConnection(this.user, this.password);
        }

        /**
         * Creates a new connection with the given username and password
         * 
         * @param userID
         *            the user id to connect with
         * @param password
         *            the password to connect with
         * 
         * @return a connection to the database
         * 
         * @throws SQLException
         *             if an error occurs
         */
        public java.sql.Connection getConnection(String userID, String pass)
                        throws SQLException {
                Properties props = new Properties();

                if (userID != null) {
                        props.setProperty(NonRegisteringDriver.USER_PROPERTY_KEY, userID);
                }

                if (pass != null) {
                        props.setProperty(NonRegisteringDriver.PASSWORD_PROPERTY_KEY, pass);
                }

                exposeAsProperties(props);

                return getConnection(props);
        }

        /**
         * Sets the database name.
         * 
         * @param dbName
         *            the name of the database
         */
        public void setDatabaseName(String dbName) {
                this.databaseName = dbName;
        }

        /**
         * Gets the name of the database
         * 
         * @return the name of the database for this data source
         */
        public String getDatabaseName() {
                return (this.databaseName != null) ? this.databaseName : "";
        }

        /**
         * Sets the log writer for this data source.
         * 
         * @see javax.sql.DataSource#setLogWriter(PrintWriter)
         */
        public void setLogWriter(PrintWriter output) throws SQLException {
                this.logWriter = output;
        }

        /**
         * Returns the log writer for this data source
         * 
         * @return the log writer for this data source
         */
        public java.io.PrintWriter getLogWriter() {
                return this.logWriter;
        }

        /**
         * DOCUMENT ME!
         * 
         * @param seconds
         *            DOCUMENT ME!
         * 
         * @throws SQLException
         *             DOCUMENT ME!
         */
        public void setLoginTimeout(int seconds) throws SQLException {
        }

        /**
         * Returns the login timeout
         * 
         * @return the login timeout
         */
        public int getLoginTimeout() {
                return 0;
        }

        /**
         * Sets the password
         * 
         * @param pass
         *            the password
         */
        public void setPassword(String pass) {
                this.password = pass;
        }

        /**
         * Sets the database port.
         * 
         * @param p
         *            the port
         */
        public void setPort(int p) {
                this.port = p;
        }

        /**
         * Returns the port number
         * 
         * @return the port number
         */
        public int getPort() {
                return this.port;
        }

        /**
         * Sets the port number
         * 
         * @param p
         *            the port
         * 
         * @see #setPort
         */
        public void setPortNumber(int p) {
                setPort(p);
        }

        /**
         * Returns the port number
         * 
         * @return the port number
         */
        public int getPortNumber() {
                return getPort();
        }

        /**
         * DOCUMENT ME!
         * 
         * @param ref
         *            DOCUMENT ME!
         * 
         * @throws SQLException
         *             DOCUMENT ME!
         */
        public void setPropertiesViaRef(Reference ref) throws SQLException {
                super.initializeFromRef(ref);
        }

        /**
         * Required method to support this class as a <CODE>Referenceable</CODE>.
         * 
         * @return a Reference to this data source
         * 
         * @throws NamingException
         *             if a JNDI error occurs
         */
        public Reference getReference() throws NamingException {
                String factoryName = "com.mysql.jdbc.jdbc2.optional.MysqlDataSourceFactory";
                Reference ref = new Reference(getClass().getName(), factoryName, null);
                ref.add(new StringRefAddr(NonRegisteringDriver.USER_PROPERTY_KEY,
                                getUser()));
                ref.add(new StringRefAddr(NonRegisteringDriver.PASSWORD_PROPERTY_KEY,
                                this.password));
                ref.add(new StringRefAddr("serverName", getServerName()));
                ref.add(new StringRefAddr("port", "" + getPort()));
                ref.add(new StringRefAddr("databaseName", getDatabaseName()));
                ref.add(new StringRefAddr("url", getUrl()));
                ref.add(new StringRefAddr("explicitUrl", String
                                .valueOf(this.explicitUrl)));

                //
                // Now store all of the 'non-standard' properties...
                //
                try {
                        storeToRef(ref);
                } catch (SQLException sqlEx) {
                        throw new NamingException(sqlEx.getMessage());
                }

                return ref;
        }

        /**
         * Sets the server name.
         * 
         * @param serverName
         *            the server name
         */
        public void setServerName(String serverName) {
                this.hostName = serverName;
        }

        /**
         * Returns the name of the database server
         * 
         * @return the name of the database server
         */
        public String getServerName() {
                return (this.hostName != null) ? this.hostName : "";
        }

        //
        // I've seen application servers use both formats
        // URL or url (doh)
        //

        /**
         * Sets the URL for this connection
         * 
         * @param url
         *            the URL for this connection
         */
        public void setURL(String url) {
                setUrl(url);
        }

        /**
         * Returns the URL for this connection
         * 
         * @return the URL for this connection
         */
        public String getURL() {
                return getUrl();
        }

        /**
         * This method is used by the app server to set the url string specified
         * within the datasource deployment descriptor. It is discovered using
         * introspection and matches if property name in descriptor is "url".
         * 
         * @param url
         *            url to be used within driver.connect
         */
        public void setUrl(String url) {
                this.url = url;
                this.explicitUrl = true;
        }

        /**
         * Returns the JDBC URL that will be used to create the database connection.
         * 
         * @return the URL for this connection
         */
        public String getUrl() {
                if (!this.explicitUrl) {
                        String builtUrl = "jdbc:mysql://";
                        builtUrl = builtUrl + getServerName() + ":" + getPort() + "/"
                                        + getDatabaseName();

                        return builtUrl;
                }

                return this.url;
        }

        /**
         * Sets the user ID.
         * 
         * @param userID
         *            the User ID
         */
        public void setUser(String userID) {
                this.user = userID;
        }

        /**
         * Returns the configured user for this connection
         * 
         * @return the user for this connection
         */
        public String getUser() {
                return this.user;
        }

        /**
         * Creates a connection using the specified properties.
         * 
         * @param props
         *            the properties to connect with
         * 
         * @return a connection to the database
         * 
         * @throws SQLException
         *             if an error occurs
         */
        protected java.sql.Connection getConnection(Properties props)
                        throws SQLException {
                String jdbcUrlToUse = null;

                if (!this.explicitUrl) {
                        StringBuffer jdbcUrl = new StringBuffer("jdbc:mysql://");

                        if (this.hostName != null) {
                                jdbcUrl.append(this.hostName);
                        }

                        jdbcUrl.append(":");
                        jdbcUrl.append(this.port);
                        jdbcUrl.append("/");

                        if (this.databaseName != null) {
                                jdbcUrl.append(this.databaseName);
                        }

                        jdbcUrlToUse = jdbcUrl.toString();
                } else {
                        jdbcUrlToUse = this.url;
                }

                //
                // URL should take precedence over properties
                //
                
                Properties urlProps = mysqlDriver.parseURL(jdbcUrlToUse, null);
                urlProps.remove(NonRegisteringDriver.DBNAME_PROPERTY_KEY);
                urlProps.remove(NonRegisteringDriver.HOST_PROPERTY_KEY);
                urlProps.remove(NonRegisteringDriver.PORT_PROPERTY_KEY);
                
                Iterator<Object> keys = urlProps.keySet().iterator();
                
                while (keys.hasNext()) {
                        String key = (String)keys.next();
                        
                        props.setProperty(key, urlProps.getProperty(key));
                }
                
                return mysqlDriver.connect(jdbcUrlToUse, props);
        }
//
//      public boolean isWrapperFor(Class<?> iface) throws SQLException {
//              throw SQLError.notImplemented();
//      }
//
//      public <T> T unwrap(Class<T> iface) throws SQLException {
//              throw SQLError.notImplemented();
//      }
}