Added last file, the DatabaseLocationParser itself

etc/log4j.properties

@@ -3,7 +3,7 @@
 !-----------------------------------------------------------------------------!
 
 #log4j.rootLogger=debug, R
-log4j.rootLogger=R
+log4j.rootLogger=DEBUG, R
 
 
 log4j.logger.com.ibatis=DEBUG, R

uk/ac/sanger/artemis/util/DatabaseLocationParser.java

+/* DatabaseLocationParser.java
+ *
+ * created: Jun 2013
+ *
+ * This file is part of Artemis
+ *
+ * Copyright (C) 2001  Genome Research Limited
+ *
+ * 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; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+package uk.ac.sanger.artemis.util;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+/**
+ *
+ * @author esr
+ */
+public class DatabaseLocationParser {
+
+    private String host;
+    private String database;
+    private int port = 0;
+//    private String username;
+//    private String ssl_param;
+    private String db_engine = "postgresql";
+    private String protocol = "jdbc";
+    private static org.apache.log4j.Logger logger4j =
+            org.apache.log4j.Logger.getLogger(DatabaseLocationParser.class);
+    /**
+     * Desire use of Protocol in the final URL. i.e., "jdbc:"
+     */
+    public static final int PROTOCOL = 1;
+    /**
+     * Desire use of scheme in final url. i.e., "postgres://"
+     */
+    public static final int SCHEME = 2;
+    /**
+     * Desire use of database name in final url.
+     *
+     */
+    public static final int DATABASE_NAME = 4;
+    /**
+     * Desire listing of query parameters in final url. e.g.,
+     * "user=name&ssl=true"
+     */
+    public static final int QUERY_PARAMS = 8;
+    private Map<String, String> params = new HashMap<String, String>();
+
+    /**
+     * Empty initializer
+     */
+    public DatabaseLocationParser() {
+    }
+
+    /**
+     * Create a new DLP object from a given URL
+     *
+     * @param url
+     */
+    public DatabaseLocationParser(String url) {
+        setFromURLString(url);
+    }
+
+    /**
+     * Set the URL internally and parse out important portions.
+     *
+     * @param url
+     */
+    private void setFromURLString(String url) {
+        logger4j.debug("DLP was called with a URL of [" + url + "]");
+        try {
+            //"jdbc:postgres://localhost:5432/drupal6?user=drupal6&ssl=true";
+
+            //If it's prefixed, remove that so URI parsing is correct
+            if (url.startsWith("jdbc:")) {
+                url = url.substring(5);
+            }
+            if (!url.startsWith(db_engine + "://")) {
+                url = db_engine + "://" + url;
+            }
+
+
+            URI db_loc = new URI(url);
+
+            logger4j.debug("URI " + db_loc.toString());
+            logger4j.debug("Host: " + db_loc.getHost());
+            logger4j.debug("Port: " + db_loc.getPort());
+            logger4j.debug("Engine: " + db_loc.getScheme());
+            logger4j.debug("DB: " + db_loc.getPath());
+
+            host = db_loc.getHost();
+
+            database = db_loc.getPath().substring(1);
+
+            port = db_loc.getPort();
+
+            db_engine = db_loc.getScheme();
+
+            //Split on '&' and parse each subunit
+            String[] query_params = db_loc.getQuery().split("&");
+            for (int i = 0; i < query_params.length; i++) {
+                //Split based on the equals sign
+                logger4j.debug("Given a parameter:" + query_params[i]);
+                String[] parts = query_params[i].split("=");
+
+
+                //This will fail for input like user=chad=o&ssl=true
+                //As we'll only grab user=chad
+                // Then again, who has an equals sign in their username
+                if (parts.length > 1) {
+                    params.put(parts[0], parts[1]);
+                    logger4j.debug("[" + parts[0] + "," + parts[1] + "]");
+
+                } else {
+                    // This might fail strangely, but then again they're providing funky URLs
+                    params.put("user", parts[0]);
+                    logger4j.debug("[user," + parts[0] + "]");
+                }
+            }
+        } catch (URISyntaxException ex) {
+            logger4j.warn("Error parsing URL [" + url + "]" + ex);
+        }
+        logger4j.debug("This has a complete_url of [" + getCompleteURL() + "]");
+    }
+
+    /**
+     * Returns the complete URL
+     *
+     * @return complete url
+     */
+    public String getCompleteURL() {
+        return getURLWithFixes(PROTOCOL | SCHEME
+                | DATABASE_NAME | QUERY_PARAMS);
+    }
+
+    /**
+     * Returns the URL as required for a DriverManager.getConnection object
+     *
+     * @return url as required for a SQL connection
+     */
+    public String getConnectionString() {
+        return getURLWithFixes(PROTOCOL | SCHEME
+                | DATABASE_NAME | QUERY_PARAMS);
+    }
+
+    /**
+     * Returns the unprefixed URL, for classes that automatically prepend
+     * 'jdbc:postgres://'.
+     *
+     * This is important for uk/ac/sanger/artemis/chado/DbSqlConfig.java
+     *
+     * @return unprefixed url with database and query parameters appended.
+     */
+    public String getUnprefixedURL() {
+        return getURLWithFixes(DATABASE_NAME | QUERY_PARAMS);
+    }
+
+    /**
+     * Returns a URL with a selection of modifications.
+     *
+     * Using a binary OR, one can select which modifications should be applied
+     * to create the final URL. These modifications consist of:
+     *
+     * - PROTOCOL: "jdbc:" - SCHEME: "postgresql://" - DATABASE_NAME: The
+     * supplied database name - QUERY_PARAMS: The supplied query parameters
+     * (user, ssl, etc)
+     *
+     * @param modifications, a binary OR'd selection of PROTOCOL, SCHEME,
+     * DATABASE_NAME, QUERY_PARAMS, all of which are available as public final
+     * static integers from this class
+     * @return String version of a URL, modified according to the rules
+     * supplied.
+     */
+    public String getURLWithFixes(int modifications) {
+        try {
+            String scheme = new String(db_engine);
+            String userInfo = null;
+            int db_port = new Integer(port);
+            String db_name = "/" + database;
+            String query_params = "";
+            String fragment = null;
+
+            String result = "";
+            if ((modifications & PROTOCOL) == PROTOCOL) {
+                result += protocol + ":";
+            }
+            if ((modifications & SCHEME) != SCHEME) {
+                scheme = null;
+            }
+            if ((modifications & DATABASE_NAME) != DATABASE_NAME) {
+                db_name = null;
+            }
+
+            // Query Parameters
+            // "user=chado_user&ssl=true"
+            if ((modifications & QUERY_PARAMS) == QUERY_PARAMS) {
+                if (params.size() > 0) {
+                    /**
+                     * Handling of the query parameters. There are other ways to
+                     * do this, but it's probably never going to be more than a
+                     * "user" and an "ssl" parameter, which means that in the
+                     * grand scheme of things, joining a couple strings together
+                     * isn't a big issue
+                     */
+                    Set<String> keys = params.keySet();
+                    java.util.Iterator<String> it = keys.iterator();
+                    while (it.hasNext()) {
+                        String key = it.next();
+                        query_params += key + "=" + params.get(key) + "&";
+                    }
+                    query_params = query_params.substring(0, query_params.length() - 1);
+                }
+            }
+            URI uri_result = new URI(scheme, userInfo, host, db_port, db_name, query_params, fragment);
+//            System.out.println(uri_result.toString());
+            logger4j.debug("Pre-final URL: " + uri_result.toString());
+
+            result = result + uri_result.toString();
+            //Bugfix. Even if SCHEME is null, // is still prepended. so we remove
+            if ((modifications & SCHEME) != SCHEME && (modifications & PROTOCOL) != PROTOCOL) {
+                result = result.substring(2);
+            }
+            return result;
+        } catch (URISyntaxException ex) {
+            logger4j.error("Could not construct URL. This will likely cause an "
+                    + "SQL connection failure. ");
+        }
+        return null;
+    }
+
+    /**
+     * Checks whether SSL is enabled
+     *
+     * @return true if SSL is enabled
+     */
+    public boolean isSSLEnabled() {
+        if (params.containsKey("ssl")) {
+            return params.get("ssl").equals("true");
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Returns the hostname
+     *
+     * @return the hostname
+     */
+    public String getHost() {
+        return host;
+    }
+
+    /**
+     * Returns the database
+     *
+     * @return the database name
+     */
+    public String getDatabase() {
+        return database;
+    }
+
+    /**
+     * Returns the port number
+     *
+     * @return port number
+     */
+    public int getPort() {
+        return port;
+    }
+
+    /**
+     * Returns the username of the user connecting to the database
+     *
+     * @return username
+     */
+    public String getUsername() {
+        if (params.containsKey("user")) {
+            return params.get("user");
+        } else {
+            return "chado"; //That's the default u/n afaik
+        }
+    }
+
+    /**
+     * Returns the database engine
+     *
+     * @return database engine (usu. postgresql)
+     */
+    public String getDBEngine() {
+        return db_engine;
+    }
+
+    /**
+     * Sets the hostname
+     *
+     * @param hostname
+     */
+    public void setHost(String hostname) {
+        host = hostname.trim();
+    }
+
+    /**
+     * Sets the database name
+     *
+     * @param new_db_name
+     */
+    public void setDatabase(String new_db_name) {
+        database = new_db_name.trim();
+    }
+
+    /**
+     * Sets the port number
+     *
+     * @param new_port_number
+     */
+    public void setPort(String new_port_number) {
+        port = Integer.parseInt(new_port_number.trim());
+    }
+
+    /**
+     * Sets the port number
+     *
+     * @param new_port_number
+     */
+    public void setPort(int new_port_number) {
+        port = new_port_number;
+    }
+
+    /**
+     * Sets the username to connect with
+     *
+     * @param new_username
+     */
+    public void setUsername(String new_username) {
+        params.put("user", new_username.trim());
+    }
+
+    /**
+     * Enables or disables SSL in connection URL
+     *
+     * @param is_enabled
+     */
+    public void setSSL(boolean is_enabled) {
+        if (is_enabled) {
+            params.put("ssl", "true");
+        } else {
+            params.remove("ssl");
+        }
+    }
+
+    /**
+     * Sets the Database Engine
+     *
+     * @param new_db_engine
+     */
+    public void setDBEngine(String new_db_engine) {
+        db_engine = new_db_engine.trim();
+    }
+}