Debugged, improved, refactored code (catchers, dispatching, starting…).

src/fr/devinsy/kiss4web/BuildInformation.java

@@ -0,0 +1,146 @@
+/**
+ * Copyright (C) 2013-2016 Christian Pierre MOMON
+ * 
+ * This file is part of Kiss4web.
+ * 
+ * Kiss4web is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * Kiss4web 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 Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Kiss4web.  If not, see <http://www.gnu.org/licenses/>
+ */
+package fr.devinsy.kiss4web;
+
+import java.io.IOException;
+import java.util.Properties;
+
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 
+ * 
+ * @author Christian P. Momon
+ */
+public class BuildInformation
+{
+    private static final Logger logger = LoggerFactory.getLogger(BuildInformation.class);
+
+    private String productName;
+    private String majorRevision;
+    private String minorRevision;
+    private String buildNumber;
+    private String buildDate;
+    private String generator;
+    private String author;
+
+    /**
+	 * 
+	 */
+    public BuildInformation()
+    {
+        Properties build = new Properties();
+
+        try
+        {
+            //
+            build.load(BuildInformation.class.getResource("/build_information.properties").openStream());
+
+            //
+            this.productName = build.getProperty("product.name", "n/a");
+            this.majorRevision = build.getProperty("product.revision.major", "n/a");
+            this.minorRevision = build.getProperty("product.revision.minor", "n/a");
+            this.buildNumber = build.getProperty("product.revision.build", "n/a");
+            this.buildDate = build.getProperty("product.revision.date", "n/a");
+            this.generator = build.getProperty("product.revision.generator", "n/a");
+            this.author = build.getProperty("product.revision.author", "n/a");
+
+        }
+        catch (IOException exception)
+        {
+            //
+            logger.error("Error loading the build.properties file: " + exception.getMessage());
+            logger.error(ExceptionUtils.getStackTrace(exception));
+
+            //
+            this.productName = "n/a";
+            this.majorRevision = "n/a";
+            this.minorRevision = "n/a";
+            this.buildNumber = "n/a";
+            this.buildDate = "n/a";
+            this.generator = "n/a";
+            this.author = "n/a";
+        }
+    }
+
+    public String author()
+    {
+        return this.author;
+    }
+
+    public String buildDate()
+    {
+        return this.buildDate;
+    }
+
+    public String buildNumber()
+    {
+        return this.buildNumber;
+    }
+
+    public String generator()
+    {
+        return this.generator;
+    }
+
+    public String majorRevision()
+    {
+        return this.majorRevision;
+    }
+
+    public String minorRevision()
+    {
+        return this.minorRevision;
+    }
+
+    public String productName()
+    {
+        return this.productName;
+    }
+
+    /**
+	 * 
+	 */
+    @Override
+    public String toString()
+    {
+        String result;
+
+        result = String.format("%s %s.%s.%s built on %s by %s", this.productName, this.majorRevision, this.minorRevision, this.buildNumber, this.buildDate, this.author);
+
+        //
+        return result;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    public String version()
+    {
+        String result;
+
+        result = String.format("%s.%s.%s", this.majorRevision, this.minorRevision, this.buildNumber);
+
+        //
+        return result;
+    }
+}

src/fr/devinsy/kiss4web/EnvironmentInformation.java

@@ -0,0 +1,231 @@
+/**
+ * Copyright 2013-2015 Christian Pierre MOMON, DEVINSY, UMR 7186 LESC.
+ * 
+ * christian.momon@devinsy.fr
+ * 
+ * This file is part of kiss4web. This software (Kiwa) is a computer program whose
+ * purpose is to be the Kinsources Web Application, an open interactive platform
+ * for archiving, sharing, analyzing and comparing kinship data used in
+ * scientific inquiry.
+ * 
+ * This software is governed by the CeCILL license under French law and abiding
+ * by the rules of distribution of free software. You can use, modify and/ or
+ * redistribute the software under the terms of the CeCILL license as circulated
+ * by CEA, CNRS and INRIA at the following URL "http://www.cecill.info".
+ * 
+ * As a counterpart to the access to the source code and rights to copy, modify
+ * and redistribute granted by the license, users are provided only with a
+ * limited warranty and the software's author, the holder of the economic
+ * rights, and the successive licensors have only limited liability.
+ * 
+ * In this respect, the user's attention is drawn to the risks associated with
+ * loading, using, modifying and/or developing or reproducing the software by
+ * the user in light of its specific status of free software, that may mean that
+ * it is complicated to manipulate, and that also therefore means that it is
+ * reserved for developers and experienced professionals having in-depth
+ * computer knowledge. Users are therefore encouraged to load and test the
+ * software's suitability as regards their requirements in conditions enabling
+ * the security of their systems and/or data to be ensured and, more generally,
+ * to use and operate it in the same conditions as regards security.
+ * 
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ */
+package fr.devinsy.kiss4web;
+
+import javax.mail.Session;
+import javax.naming.ConfigurationException;
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import fr.devinsy.util.strings.StringList;
+import fr.devinsy.util.strings.StringListUtils;
+
+/**
+ * 
+ * 
+ * @author Christian P. Momon
+ */
+public class EnvironmentInformation
+{
+    private static final Logger logger = LoggerFactory.getLogger(EnvironmentInformation.class);;
+
+    private String name;
+    private String websiteName;
+    private String websiteUrl;
+    private String log4jFilePathname;
+
+    /**
+     * @throws ConfigurationException
+     * 
+     */
+    public EnvironmentInformation() throws ConfigurationException
+    {
+        try
+        {
+            //
+            Context initialContext = new InitialContext();
+            Context environment = (Context) initialContext.lookup("java:comp/env");
+
+            //
+            this.name = (String) environment.lookup("kiss4web.environment.name");
+
+            //
+            this.websiteName = (String) environment.lookup("kiss4web.website.name");
+
+            //
+            this.websiteUrl = (String) environment.lookup("kiss4web.website.url");
+            if ((this.websiteUrl != null) && (!this.websiteUrl.endsWith("/")))
+            {
+                this.websiteUrl = this.websiteUrl + "/";
+            }
+
+            //
+            this.log4jFilePathname = (String) environment.lookup("kiss4web.log4j.path");
+        }
+        catch (NamingException exception)
+        {
+            logger.error("Error setting the java:comp/env context: ", exception.getMessage());
+            logger.error(ExceptionUtils.getStackTrace(exception));
+            logger.error("Environment information:");
+            logger.error("- name=[" + this.name + "]");
+            logger.error("- websiteUrl=[" + this.websiteUrl + "]");
+            logger.error("- log4jPath=[" + this.log4jFilePathname + "]");
+
+            throw new ConfigurationException("Error setting environment information: " + exception.getMessage());
+        }
+
+        // Check availability of all fields.
+        if (isNotAvailable())
+        {
+            logger.error("Environment information:");
+            logger.error("- name=[" + this.name + "]");
+            logger.error("- websiteUrl=[" + this.websiteUrl + "]");
+            logger.error("- log4jPath=[" + this.log4jFilePathname + "]");
+
+            throw new ConfigurationException("Environment information is not fully available.");
+        }
+    }
+
+    /**
+     * 
+     * @param name
+     * @return
+     */
+    public String getSessionToString(final Context environment, final String name)
+    {
+        String result;
+
+        try
+        {
+            if (environment == null)
+            {
+                result = null;
+            }
+            else
+            {
+                Session session = (Session) environment.lookup(name);
+
+                StringList buffer = new StringList();
+                for (Object key : session.getProperties().keySet().toArray())
+                {
+                    buffer.append((String) key).append("=").append(session.getProperties().getProperty((String) key)).append(",");
+                }
+                buffer.removeLast();
+                result = buffer.toString();
+            }
+        }
+        catch (NamingException exception)
+        {
+            logger.info("Error: {}", exception.getMessage());
+            result = null;
+        }
+
+        //
+        return result;
+    }
+
+    /**
+     * 
+     * @param name
+     * @return
+     */
+    public String getSessionToString(final String name)
+    {
+        String result;
+
+        try
+        {
+            Context initialContext = new InitialContext();
+
+            Context environment = (Context) initialContext.lookup("java:comp/env");
+            result = getSessionToString(environment, name);
+        }
+        catch (NamingException exception)
+        {
+            logger.info("Error: {}", exception.getMessage());
+            result = null;
+        }
+
+        return result;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    public boolean isAvailable()
+    {
+        boolean result;
+
+        if (StringListUtils.containsBlank(this.name, this.websiteName, this.websiteUrl, this.log4jFilePathname))
+        {
+            result = false;
+        }
+        else
+        {
+            result = true;
+        }
+
+        //
+        return result;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    public boolean isNotAvailable()
+    {
+        boolean result;
+
+        result = !isAvailable();
+
+        return result;
+    }
+
+    public String log4jFilePathname()
+    {
+        return this.log4jFilePathname;
+    }
+
+    public String name()
+    {
+        return this.name;
+    }
+
+    public String websiteName()
+    {
+        return this.websiteName;
+    }
+
+    public String websiteUrl()
+    {
+        return this.websiteUrl;
+    }
+}

src/fr/devinsy/kiss4web/Kiss4web.java

@@ -0,0 +1,138 @@
+/**
+ * Copyright (C) 2013-2016 Christian Pierre MOMON
+ * 
+ * This file is part of Kiss4web.
+ * 
+ * Kiss4web is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * Kiss4web 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 Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Kiss4web.  If not, see <http://www.gnu.org/licenses/>
+ */
+package fr.devinsy.kiss4web;
+
+import java.util.Date;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+
+/**
+ * 
+ * 
+ * @author Christian P. Momon
+ */
+public class Kiss4web
+{
+    private static class SingletonHolder
+    {
+        private static final Kiss4web instance = new Kiss4web();
+    }
+
+    public enum Status
+    {
+        INIT_FAILED,
+        OPENED,
+        MAINTENANCE
+    }
+
+    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(Kiss4web.class);
+
+    private BuildInformation buildInformation;
+    private Status status;
+
+    /**
+     * @throws Exception
+     * 
+     */
+    private Kiss4web()
+    {
+        //
+        String currentLog = "Kiwa";
+
+        //
+        try
+        {
+            //
+            currentLog = "Kiwa";
+            logger.info("Kiwa initializing...");
+            long startTime = new Date().getTime();
+            logInit(currentLog, "STARTING");
+
+            //
+            currentLog = "BuildInformation";
+            this.buildInformation = new BuildInformation();
+            logger.info("  build information=[" + this.buildInformation.toString() + "]");
+            logInit(currentLog, "PASSED");
+
+            //
+            currentLog = "Kiwa";
+            logInit(currentLog, "STARTED");
+            long endTime = new Date().getTime();
+            logger.info("Kiss4web initialized in {}ms.", endTime - startTime);
+
+        }
+        catch (Exception exception)
+        {
+            //
+            logInit(currentLog, "FAILED");
+
+            //
+            logger.warn("KISS4WEV INIT FAILED: " + exception.getMessage());
+
+            //
+            logger.warn(ExceptionUtils.getStackTrace(exception));
+
+            //
+            this.status = Kiss4web.Status.INIT_FAILED;
+        }
+    }
+
+    public BuildInformation buildInformation()
+    {
+        return this.buildInformation;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    public Kiss4web.Status getStatus()
+    {
+        return this.status;
+    }
+
+    /**
+     * 
+     * @param status
+     */
+    public void setStatus(final Status status)
+    {
+        this.status = status;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    public static Kiss4web instance()
+    {
+        return SingletonHolder.instance;
+    }
+
+    /**
+     * 
+     * @param currentLogItem
+     * @param status
+     */
+    private static void logInit(final String currentLogItem, final String status)
+    {
+        logger.info(String.format("%s%s%s", currentLogItem, StringUtils.repeat('.', 40 - StringUtils.length(currentLogItem)), status));
+    }
+}

src/fr/devinsy/kiss4web/KissDispatcher.java

@@ -21,11 +21,13 @@ package fr.devinsy.kiss4web;
 import java.io.IOException;
 import java.util.Date;
 
+import javax.naming.ConfigurationException;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
+import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -77,6 +79,8 @@ public class KissDispatcher extends HttpServlet
     {
         long startTime = new Date().getTime();
 
+        request.setCharacterEncoding("UTF-8");
+
         logger.info("==================================================");
         logger.info("getContextPath=[" + request.getContextPath() + "]");
         logger.info("getPathInfo=[" + request.getPathInfo() + "]");
@@ -135,12 +139,11 @@ public class KissDispatcher extends HttpServlet
          * If not specified, ISO-8859-1 will be used. 
          * 
          */
-        // String path = request.getRequestURI();
+        // String urlPath = request.getPathInfo();
-        String urlPath = request.getPathInfo();
 
         if (BlankCatcher.matches(request))
         {
-            BlankCatcher.doCatch(response, urlPath);
+            BlankCatcher.doCatch(response);
         }
         else if (RootCatcher.matches(request))
         {
@@ -164,7 +167,7 @@ public class KissDispatcher extends HttpServlet
         }
         else if (WebContentCatcher.matches(this.getServletContext(), request))
         {
-            XHTMLCatcher.doCatch(this.getServletConfig(), request, response, webClassesRootPath);
+            WebContentCatcher.doCatch(this.getServletContext(), request, response);
         }
         else if (WebInfCatcher.matches(this.getServletContext(), request, webClassesRootPath))
         {
@@ -172,7 +175,7 @@ public class KissDispatcher extends HttpServlet
         }
         else
         {
-            logger.info("Request not satisfied [" + urlPath + "]");
+            logger.info("Request not satisfied [" + request.getPathInfo() + "]");
             response.sendError(HttpServletResponse.SC_NOT_FOUND);
         }
 
@@ -224,29 +227,46 @@ public class KissDispatcher extends HttpServlet
     public void init() throws ServletException
     {
         super.init();
-        logger.info("KissDispatcher init called.");
-
-        //
-        this.webclassesRootPackage = getInitParameter("webClassesRootPackage");
-        logger.info("webClassesRootPackage loaded=[{}]", this.webclassesRootPackage);
 
         // Set logger.
-        String logFilepathname = getInitParameter("log4j-init-file");
+        String logFilePathname;
-        if (logFilepathname != null)
+        try
+        {
+            new EnvironmentInformation().toString();
+
+            logFilePathname = new EnvironmentInformation().log4jFilePathname();
+        }
+        catch (ConfigurationException exception)
+        {
+            System.err.println("Error reading the environment information.");
+            exception.printStackTrace();
+            logFilePathname = null;
+        }
+
+        if (StringUtils.isBlank(logFilePathname))
+        {
+            org.apache.log4j.BasicConfigurator.configure();
+            logger.warn("Log configuration undefined, use of the basic configurator.");
+        }
+        else
         {
             try
             {
-                System.out.println("Log configuration found (" + logFilepathname + "), will use it.");
+                System.out.println("Log configuration defined (" + logFilePathname + "), will use it.");
-                org.apache.log4j.PropertyConfigurator.configure(getServletContext().getRealPath("/") + logFilepathname);
+                org.apache.log4j.PropertyConfigurator.configure(getServletContext().getRealPath("/") + logFilePathname);
             }
             catch (Exception exception)
             {
-                System.out.println("Log configuration FILE NOT FOUND (" + logFilepathname + "), use of the basic configurator.");
+                System.out.println("Log configuration FILE NOT FOUND (" + logFilePathname + "), use of the basic configurator.");
                 org.apache.log4j.BasicConfigurator.configure();
             }
 
             logger = LoggerFactory.getLogger(this.getClass());
             logger.info("Log initialization done.");
         }
+
+        //
+        this.webclassesRootPackage = getInitParameter("webClassesRootPackage");
+        logger.info("webClassesRootPackage loaded=[{}]", this.webclassesRootPackage);
     }
 }

src/fr/devinsy/kiss4web/catchers/BlankCatcher.java

@@ -38,7 +38,7 @@ public class BlankCatcher
      * @throws IOException
      * 
      */
-    public static void doCatch(final HttpServletResponse response, final String urlPath) throws IOException
+    public static void doCatch(final HttpServletResponse response) throws IOException
     {
         logger.debug("Doing catch.");
 

src/fr/devinsy/kiss4web/catchers/FolderCatcher.java

@@ -25,7 +25,6 @@ import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
-import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -63,14 +62,15 @@ public class FolderCatcher
 
             // Note: as pathInfo starts always with a '/', the first
             // good token index is 1.
-            for (int tokenCounter = 1; tokenCounter < tokens.length - 1; tokenCounter++)
+            for (int tokenCounter = 1; tokenCounter <= tokens.length - 1; tokenCounter++)
             {
                 buffer.append(tokens[tokenCounter]);
                 buffer.append('.');
             }
 
-            String lastToken = tokens[tokens.length - 1];
+            // String lastToken = tokens[tokens.length - 1];
-            buffer.append(StringUtils.capitalize(lastToken)).append("_xhtml");
+            // buffer.append(StringUtils.capitalize(lastToken)).append("_xhtml");
+            buffer.append("Index_xhtml");
 
             className = buffer.toString();
         }

src/fr/devinsy/kiss4web/catchers/LongURLCatcher.java

@@ -50,8 +50,8 @@ public class LongURLCatcher
         String urlPath = request.getPathInfo();
 
         String rewritedURLPath = LongURLRewriter.unrewrite(urlPath);
-
+        String className = XHTMLCatcher.translateToClassName(rewritedURLPath);
-        String className = KissDispatcherUtils.concatenatePackage(webClassesRootPackage, rewritedURLPath);
+        className = KissDispatcherUtils.concatenatePackage(webClassesRootPackage, className);
         logger.info("className=[" + className + "]");
 
         KissDispatcherUtils.dispatchToServlet(servletConfig, request, response, className);

src/fr/devinsy/kiss4web/catchers/LongURLRewriter.java

@@ -87,7 +87,7 @@ public class LongURLRewriter
      * Note: "-/" is used to indicate the beginning of parameters.
      * 
      */
-    public static String rewriteLongUrl(final String path, final String... parameters)
+    public static String rewrite(final String path, final String... parameters)
     {
         String result;
 

src/fr/devinsy/kiss4web/catchers/ShortURLCatcher.java

@@ -51,7 +51,9 @@ public class ShortURLCatcher
 
         String rewritedURLPath = ShortURLRewriter.unrewrite(urlPath);
 
-        String className = KissDispatcherUtils.concatenatePackage(webClassesRootPackage, rewritedURLPath);
+        String className = XHTMLCatcher.translateToClassName(rewritedURLPath);
+        className = KissDispatcherUtils.concatenatePackage(webClassesRootPackage, className);
+
         logger.info("className=[" + className + "]");
 
         KissDispatcherUtils.dispatchToServlet(servletConfig, request, response, className);

src/fr/devinsy/kiss4web/catchers/WebContentCatcher.java

@@ -43,8 +43,7 @@ public class WebContentCatcher
      * @throws ServletException
      * 
      */
-    public static void doCatch(final ServletContext servletContext, final HttpServletRequest request, final HttpServletResponse response, final String webClassesRootPackage) throws IOException,
+    public static void doCatch(final ServletContext servletContext, final HttpServletRequest request, final HttpServletResponse response) throws IOException, ServletException
-            ServletException
     {
         logger.debug("Doing catch.");
 

src/fr/devinsy/kiss4web/catchers/XHTMLCatcher.java

@@ -50,30 +50,7 @@ public class XHTMLCatcher
 
         String urlPath = request.getPathInfo();
 
-        String className;
+        String className = translateToClassName(urlPath);
-        String[] tokens = urlPath.split("/");
-        if (tokens.length == 1)
-        {
-            className = "Index_xhtml";
-        }
-        else
-        {
-            StringList buffer = new StringList();
-
-            // Note: as pathInfo starts always with a '/', the first
-            // good token index is 1.
-            for (int tokenCounter = 1; tokenCounter < tokens.length - 1; tokenCounter++)
-            {
-                buffer.append(tokens[tokenCounter]);
-                buffer.append('.');
-            }
-
-            String lastToken = tokens[tokens.length - 1];
-            buffer.append(StringUtils.capitalize(lastToken).replace('.', '_')).append("_xhtml");
-
-            className = buffer.toString();
-        }
-
         className = KissDispatcherUtils.concatenatePackage(webClassesRootPackage, className);
         logger.info("className=[" + className + "]");
 
@@ -103,4 +80,40 @@ public class XHTMLCatcher
         //
         return result;
     }
+
+    /**
+     * 
+     * @param urlPath
+     * @return
+     */
+    public static String translateToClassName(final String urlPath)
+    {
+        String result;
+
+        String[] tokens = urlPath.split("/");
+        if (tokens.length == 1)
+        {
+            result = "Index_xhtml";
+        }
+        else
+        {
+            StringList buffer = new StringList();
+
+            // Note: as pathInfo starts always with a '/', the first
+            // good token index is 1.
+            for (int tokenCounter = 1; tokenCounter < tokens.length - 1; tokenCounter++)
+            {
+                buffer.append(tokens[tokenCounter]);
+                buffer.append('.');
+            }
+
+            String lastToken = tokens[tokens.length - 1];
+            buffer.append(StringUtils.capitalize(lastToken).replace('.', '_'));
+
+            result = buffer.toString();
+        }
+
+        //
+        return result;
+    }
 }