MongoDbUri

/*
 * #%L
 * MongoDbUri.java - mongodb-async-driver - Allanbank Consulting, Inc.
 * %%
 * Copyright (C) 2011 - 2014 Allanbank Consulting, Inc.
 * %%
 * 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%
 */
package com.allanbank.mongodb;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import com.allanbank.mongodb.bson.element.UuidElement;

/**
 * MongoDbUri provides the ability to parse a MongoDB URI into fields.
 * <p>
 * The set of possible options is a combination of the <a
 * href="http://docs.mongodb.org/manual/reference/connection-string/">standard
 * MongoDB URI options</a> and the complete set of fields supported by the
 * {@link MongoClientConfiguration} class. The driver uses the Java beans
 * standard to define the label for each field.
 * </p>
 * See the <a
 * href="http://docs.mongodb.org/manual/reference/connection-string/">Connection
 * String</a> documentation for information on the standard options. The
 * following standard options are not supported by the driver:
 * <dl>
 * <dt>replicaSet</dt>
 * <dd>The driver does automatic cluster type discovery so this options is not
 * needed or used.</dd>
 * <dt>maxIdleTimeMS</dt>
 * <dd>The driver does not use a specific wait time. Instead the connection is
 * considered idle when it experiences a defined number of idle ticks. A tick is
 * defined by the {@link MongoClientConfiguration#setReadTimeout(int)
 * readTimeout} and the number of ticks is defined by
 * {@link MongoClientConfiguration#setMaxIdleTickCount(int) maxIdleTickCount}.</dd>
 * <dt>waitQueueMultiple</dt>
 * <dd>The driver does not queue requests waiting for a socket since it is
 * asynchronous. The closest option would be the
 * {@link MongoClientConfiguration#setMaxPendingOperationsPerConnection(int)
 * maxPendingOperationsPerConnection} which can be used to control how
 * aggressively the driver will apply back pressure.</dd>
 * <dt>waitQueueTimeoutMS</dt>
 * <dd>Similar to {@code waitQueueMultiple} this option does not make sense for
 * an asynchronous driver.</dd>
 * <dt>uuidRepresentation</dt>
 * <dd>The UUID representation can only be controlled via construction. See the
 * {@link UuidElement#UuidElement(String, byte, java.util.UUID)} and
 * {@link UuidElement#LEGACY_UUID_SUBTTYPE}.</dd>
 * </dl>
 * <p>
 * </p>
 * <p>
 * The current set of auto-mapped fields is listed below. See the linked
 * documentation for details on the fields values.
 * <ul>
 * <li>{@link MongoClientConfiguration#setAutoDiscoverServers(boolean)
 * autoDiscoverServers}</li>
 * <li>{@link MongoClientConfiguration#setConnectionModel(ConnectionModel)
 * connectionModel}</li>
 * <li>{@link MongoClientConfiguration#setConnectTimeout(int) connectTimeout}</li>
 * <li>{@link MongoClientConfiguration#setLockType(LockType) lockType}</li>
 * <li>{@link MongoClientConfiguration#setMaxCachedStringEntries(int)
 * maxCachedStringEntries}</li>
 * <li>{@link MongoClientConfiguration#setMaxCachedStringLength(int)
 * maxCachedStringLength}</li>
 * <li>{@link MongoClientConfiguration#setMaxConnectionCount(int)
 * maxConnectionCount}</li>
 * <li>{@link MongoClientConfiguration#setMaxIdleTickCount(int)
 * maxIdleTickCount}</li>
 * <li>
 * {@link MongoClientConfiguration#setMaxPendingOperationsPerConnection(int)
 * maxPendingOperationsPerConnection}</li>
 * <li>
 * {@link MongoClientConfiguration#setMaxSecondaryLag(long) maxSecondaryLag}</li>
 * <li>
 * {@link MongoClientConfiguration#setMinConnectionCount(int)
 * minConnectionCount}</li>
 * <li>
 * {@link MongoClientConfiguration#setReadTimeout(int) readTimeout}</li>
 * <li>
 * {@link MongoClientConfiguration#setReconnectTimeout(int) reconnectTimeout}</li>
 * <li>
 * {@link MongoClientConfiguration#setUsingSoKeepalive(boolean)
 * usingSoKeepalive}</li>
 * </ul>
 * </p>
 * <p>
 * Any credentials, default read preference, and default durability will also be
 * determined via the URI. See the {@link CredentialEditor},
 * {@link ReadPreferenceEditor}, and {@link DurabilityEditor} for details
 * </p>
 *
 * @see <a href="http://www.mongodb.org/display/DOCS/Connections"> MongoDB
 *      Connections</a>
 * @api.yes This class is part of the driver's API. Public and protected members
 *          will be deprecated for at least 1 non-bugfix release (version
 *          numbers are &lt;major&gt;.&lt;minor&gt;.&lt;bugfix&gt;) before being
 *          removed or modified.
 * @copyright 2012-2014, Allanbank Consulting, Inc., All Rights Reserved
 */
public class MongoDbUri {
    /** The prefix for a MongoDB URI. */
    public static final String MONGODB_URI_PREFIX = "mongodb://";

    /** The prefix for a MongoDB URI that uses SSL. */
    public static final String MONGODBS_URI_PREFIX = "mongodbs://";

    /**
     * Tests if the {@code mongoDbUri} starts with the correct prefix to be a
     * MongoDB URI.
     *
     * @param mongoDbUri
     *            The presumed MongoDB URI.
     * @return True if the {@code mongoDbUri} starts with
     *         {@value #MONGODB_URI_PREFIX} of {@value #MONGODBS_URI_PREFIX}.
     */
    public static boolean isUri(final String mongoDbUri) {
        final String lower = mongoDbUri.toLowerCase(Locale.US);

        return lower.startsWith(MONGODB_URI_PREFIX)
                || lower.startsWith(MONGODBS_URI_PREFIX);
    }

    /** The database contained in the URI. */
    private final String myDatabase;

    /** The hosts contained in the URI. */
    private final List<String> myHosts;

    /** The options contained in the URI. */
    private final String myOptions;

    /** The database contained in the URI. */
    private final String myOriginalText;

    /** The password contained in the URI. */
    private final String myPassword;

    /** The user name contained in the URI. */
    private final String myUserName;

    /**
     * Set to true if the URL uses the {@value #MONGODBS_URI_PREFIX} prefix.
     */
    private final boolean myUseSsl;

    /**
     * Creates a new MongoDbUri.
     *
     * @param mongoDbUri
     *            The configuration for the connection to MongoDB expressed as a
     *            MongoDB URL.
     * @throws IllegalArgumentException
     *             If the <tt>mongoDbUri</tt> is not a properly formated MongoDB
     *             style URL.
     *
     * @see <a href="http://www.mongodb.org/display/DOCS/Connections"> MongoDB
     *      Connections</a>
     */
    public MongoDbUri(final String mongoDbUri) throws IllegalArgumentException {
        myOriginalText = mongoDbUri;

        String remaining;
        boolean useSsl = false;
        if (mongoDbUri == null) {
            throw new IllegalArgumentException(
                    "The MongoDB URI cannot be null.");
        }
        else if (mongoDbUri.substring(0, MONGODB_URI_PREFIX.length())
                .equalsIgnoreCase(MONGODB_URI_PREFIX)) {
            remaining = mongoDbUri.substring(MONGODB_URI_PREFIX.length());
        }
        else if (mongoDbUri.substring(0, MONGODBS_URI_PREFIX.length())
                .equalsIgnoreCase(MONGODBS_URI_PREFIX)) {
            remaining = mongoDbUri.substring(MONGODBS_URI_PREFIX.length());
            useSsl = true;
        }
        else {
            throw new IllegalArgumentException(
                    "The MongoDB URI must start with '" + MONGODB_URI_PREFIX
                            + "'.");
        }

        String userNamePassword;
        String hosts;

        int position = remaining.indexOf('@');
        if (position >= 0) {
            userNamePassword = remaining.substring(0, position);
            remaining = remaining.substring(position + 1);
        }
        else {
            userNamePassword = "";
        }

        // Figure out the DB - if any.
        position = remaining.indexOf('/');
        if (position >= 0) {
            hosts = remaining.substring(0, position);
            remaining = remaining.substring(position + 1);

            position = remaining.indexOf('?');
            if (position >= 0) {
                myDatabase = remaining.substring(0, position);
                myOptions = remaining.substring(position + 1);
            }
            else {
                myDatabase = remaining;
                myOptions = "";
            }
        }
        else {
            myDatabase = "";
            position = remaining.indexOf('?');
            if (position >= 0) {
                hosts = remaining.substring(0, position);
                myOptions = remaining.substring(position + 1);
            }
            else {
                hosts = remaining;
                myOptions = "";
            }
        }

        // Now the hosts.
        final StringTokenizer tokenizer = new StringTokenizer(hosts, ",");
        myHosts = new ArrayList<String>(tokenizer.countTokens());
        while (tokenizer.hasMoreTokens()) {
            myHosts.add(tokenizer.nextToken());
        }
        if (myHosts.isEmpty()) {
            throw new IllegalArgumentException(
                    "Must provide at least 1 host to connect to.");
        }

        // User name and password?
        if (!userNamePassword.isEmpty()) {
            position = userNamePassword.indexOf(':');
            if (position >= 0) {
                myUserName = userNamePassword.substring(0, position);
                myPassword = userNamePassword.substring(position + 1);
            }
            else {
                throw new IllegalArgumentException(
                        "The password for the user '" + userNamePassword
                                + "' must be provided.");
            }
        }
        else {
            myUserName = null;
            myPassword = null;
        }

        myUseSsl = useSsl;
    }

    /**
     * Returns the database contained in the URI.
     *
     * @return The database contained in the URI.
     */
    public String getDatabase() {
        return myDatabase;
    }

    /**
     * Returns the hosts contained in the URI.
     *
     * @return The hosts contained in the URI.
     */
    public List<String> getHosts() {
        return Collections.unmodifiableList(myHosts);
    }

    /**
     * Returns the options contained in the URI. Will never be null bu may be an
     * empty string.
     *
     * @return The options contained in the URI.
     */
    public String getOptions() {
        return myOptions;
    }

    /**
     * Returns the options contained in the URI parsed into a map of token
     * values.
     *
     * @return The options contained in the URI.
     */
    public Map<String, String> getParsedOptions() {
        final Map<String, String> parsedOptions = new LinkedHashMap<String, String>();
        final StringTokenizer tokenizer = new StringTokenizer(getOptions(),
                "?;&");
        while (tokenizer.hasMoreTokens()) {
            String property;
            String value;

            final String propertyAndValue = tokenizer.nextToken();
            final int position = propertyAndValue.indexOf('=');
            if (position >= 0) {
                property = propertyAndValue.substring(0, position);
                value = propertyAndValue.substring(position + 1);
            }
            else {
                property = propertyAndValue;
                value = Boolean.TRUE.toString();
            }

            // Normalize the names..
            property = property.toLowerCase(Locale.US);

            // Put the option at the end.
            parsedOptions.remove(property);
            parsedOptions.put(property, value);
        }

        return parsedOptions;
    }

    /**
     * Returns the password contained in the URI. May be <code>null</code>.
     *
     * @return The password contained in the URI.
     */
    public String getPassword() {
        return myPassword;
    }

    /**
     * Returns the user name contained in the URI. May be <code>null</code>.
     *
     * @return The user name contained in the URI.
     */
    public String getUserName() {
        return myUserName;
    }

    /**
     * Returns the values for a single property. This allows for duplicate
     * values.
     *
     * @param field
     *            The field to return all values for.
     * @return The options contained in the URI.
     */
    public List<String> getValuesFor(final String field) {
        final List<String> values = new ArrayList<String>();
        final StringTokenizer tokenizer = new StringTokenizer(getOptions(),
                "?;&");
        while (tokenizer.hasMoreTokens()) {
            String property;
            String value;

            final String propertyAndValue = tokenizer.nextToken();
            final int position = propertyAndValue.indexOf('=');
            if (position >= 0) {
                property = propertyAndValue.substring(0, position);
                value = propertyAndValue.substring(position + 1);
            }
            else {
                property = propertyAndValue;
                value = Boolean.TRUE.toString();
            }

            if (field.equalsIgnoreCase(property)) {
                values.add(value);
            }
        }

        return values;
    }

    /**
     * Returns true if the URL uses the {@value #MONGODBS_URI_PREFIX} prefix.
     *
     * @return True if the URL uses the {@value #MONGODBS_URI_PREFIX} prefix.
     */
    public boolean isUseSsl() {
        return myUseSsl;
    }

    /**
     * {@inheritDoc}
     * <p>
     * Overridden to return the string used to construct the URI.
     * </p>
     */
    @Override
    public String toString() {
        return myOriginalText;
    }

}