X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=source%2FMir.java;h=011b1f98efda5bd3205d37f5544ba3b3307a7963;hb=c7b5042f921185615b471a2c01ce3db157b427f9;hp=88183f482ef9707a8fbd47be598b334beda6c452;hpb=303c010339cb8afb3bbce24ea1fd8b9dcf729cb2;p=mir.git

diff --git a/source/Mir.java b/source/Mir.java
index 88183f48..011b1f98 100755
--- a/source/Mir.java
+++ b/source/Mir.java
@@ -1,219 +1,358 @@
-import java.io.*;
-import java.util.*;
-import java.net.*;
-import java.lang.reflect.*;
-import javax.servlet.*;
-import javax.servlet.http.*;
-import java.sql.*;
-
-import freemarker.template.*;
-
-import mir.misc.*;
-import mir.servlet.*;
-
-import mircoders.servlet.*;
-import mircoders.module.*;
-import mircoders.entity.*;
-import mircoders.storage.*;
-
-/**
- *  Mir.java - main servlet, that dispatches to servletmodules
+/*
+ * Copyright (C) 2001-2006 The Mir-coders group
  *
- *  @author RK 1999-2001
+ * This file is part of Mir.
  *
+ * Mir 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.
+ *
+ * Mir 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 Mir; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * In addition, as a special exception, The Mir-coders gives permission to link
+ * the code of this program with  any library licensed under the Apache Software License,
+ * and distribute linked combinations including the two.  You must obey the
+ * GNU General Public License in all respects for all of the code used other than
+ * the above mentioned libraries.  If you modify this file, you may extend this
+ * exception to your version of the file, but you are not obligated to do so.
+ * If you do not wish to do so, delete this exception statement from your version.
  */
 
+import mir.bundle.Bundle;
+import mir.config.MirPropertiesConfiguration;
+import mir.servlet.AbstractServlet;
+import mir.servlet.AdminServletModule;
+import mir.servlet.ServletModuleExc;
+import mir.servlet.ServletModuleUserExc;
+import mir.util.ExceptionRoutines;
+import mir.util.StringRoutines;
+import mircoders.entity.EntityUsers;
+import mircoders.global.MirGlobal;
+import mircoders.module.ModuleUsers;
+import mircoders.servlet.ServletHelper;
+import multex.Failure;
 
-public class Mir extends AbstractServlet
-{
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletException;
+import javax.servlet.UnavailableException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import javax.servlet.http.HttpSessionBindingEvent;
+import javax.servlet.http.HttpSessionBindingListener;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
 
-  private static ModuleUsers usersModule=null;
-  private static ModuleMessage messageModule=null;
-  private static boolean confed=false;
+public class Mir extends AbstractServlet {
+  private static ModuleUsers usersModule = null;
+  private static Locale fallbackLocale = null;
 
+  private static List loginLanguages = null;
 
-  public void doGet(HttpServletRequest req, HttpServletResponse res)
-    throws ServletException, IOException {
-    doPost(req,res);
-  }
+  private List getLoginLanguages() throws Failure {
+    synchronized (Mir.class) {
+      try {
+        if (loginLanguages == null) {
+          List languages =
+            StringRoutines.splitString(MirGlobal.config().getString("Mir.Login.Languages", "en"), ";");
 
-  public void doPost(HttpServletRequest req, HttpServletResponse res)
-    throws ServletException, IOException {
+          loginLanguages = new ArrayList();
 
-    long            startTime = (new java.util.Date()).getTime();
-    Class           theServletModule;
-    ServletModule   smod;
-    long            sessionConnectTime=0;
-    String          http="";
+          Iterator i = languages.iterator();
 
-    // get the configration
-    if (!confed){
-      confed = getConfig(req);
-    }
+          while (i.hasNext()) {
+            String code = (String) i.next();
 
+            Bundle bundle =
+                MirGlobal.getBundleFactory().getBundle("etc/bundles/adminlocal", new String[] { code });
+            Bundle defaultBundle =
+                MirGlobal.getBundleFactory().getBundle("bundles/admin", new String[] { code });
 
-    if (req.getServerPort() == 443) http="https"; else http="http";
-    res.setContentType("text/html");
-    String moduleName = req.getParameter("module");
-    HttpSession session = req.getSession(true);
+            String name = bundle.getValue("languagename", Collections.EMPTY_LIST);
 
-    if(session.getAttribute("Language")==null){
-      setLanguage(req,getAcceptLanguage(req));
-    }
-
-    // Authentifizierung
-    if (moduleName!=null && moduleName.equals("login")) {
-      String user=req.getParameter("login");
-      String passwd= req.getParameter("password");
-      String lang = req.getParameter("lang");
-      theLog.printDebugInfo("--login: evaluating for user: "+user);
-      EntityUsers userEntity = allowedUser(user,passwd);
-      if (userEntity==null) {
-        // login failed: redirecting to login
-        theLog.printWarning("--login: failed!");
-        _sendLoginPage(req,res.getWriter());
-        return;
-      } else {
-        // login successful
+            if (name == null) {
+              name = defaultBundle.getValue("languagename", Collections.EMPTY_LIST);
+            }
 
-        //if accept-language!=selected language change language
-        if(!getLanguage(req).equals(lang)){
-          setLanguage(req,lang);
-        }
+            if (name == null) {
+              name = code;
+            }
 
-        theLog.printInfo("--login: successful! setting uid: " + userEntity.getId());
-        session.setAttribute("login.uid", userEntity);
-        theLog.printDebugInfo("--login: trying to retrieve login.target");
-        String target = (String)session.getAttribute("login.target");
-        if (target != null) {
-          theLog.printDebugInfo("Redirect: "+target);
-          int serverPort = req.getServerPort();
-          String redirect = "";
-          if(serverPort==80){
-            redirect = "<html><head><meta http-equiv=refresh content=\0421;URL="
-                    + res.encodeURL(http +"://" + req.getServerName() + target)
-                    + "\"></head><body>going " + target + "</body></html>";
-          } else {
-            redirect = "<html><head><meta http-equiv=refresh content=\0421;URL="
-                    + res.encodeURL(http +"://" + req.getServerName() +":"+ serverPort + target)
-                    + "\"></head><body>going " + target + "</body></html>";
+            Map record = new HashMap();
+            record.put("name", name);
+            record.put("code", code);
+            loginLanguages.add(record);
           }
-          res.getWriter().println(redirect);
-        } else {
-          // redirecting to default target
-          //theLog.printDebugInfo("--login: no target - redirecting to default");
-          _sendStartPage(req, res.getWriter(),userEntity);
         }
-        return;
-      } // if login succesful
-    } // if login
 
-    if (moduleName!=null && moduleName.equals("logout")) {
-      theLog.printDebugInfo("--logout");
-      session.invalidate();
-      _sendLoginPage(req,res.getWriter());
-      return;
+        return loginLanguages;
+      }
+      catch (Throwable t) {
+        throw new Failure("Error while retrieving the available login languages", t);
+      }
     }
+  }
+
+  public void init(ServletConfig config) throws ServletException {
+    super.init(config);
+
+    usersModule = new ModuleUsers();
+  }
+
+  protected String getDefaultLanguage(HttpServletRequest aRequest) {
+    String defaultlanguage =
+      MirGlobal.config().getString("Mir.Login.DefaultLanguage", "");
 
-    // Check if authed!
-    EntityUsers userEntity = (EntityUsers)session.getAttribute("login.uid");
-    if (userEntity == null) {
-      // redirect to loginpage
-      String redirectString = req.getRequestURI();
-      if (req.getQueryString()!=null) redirectString += "?" + req.getQueryString();
-      theLog.printDebugInfo("STORING: " + redirectString);
-      session.setAttribute("login.target", redirectString);
-      _sendLoginPage(req,res.getWriter());
-      return;
+    if (defaultlanguage.length() == 0) {
+      Locale locale = aRequest.getLocale();
+      defaultlanguage = locale.getLanguage();
     }
 
-    // Bei blossem Serveltaufruf redirect auf Standardstarttemplate
-    if (moduleName == null || moduleName.equals("")) {
-      _sendStartPage(req, res.getWriter(),userEntity);
-      return;
+    return defaultlanguage;
+  }
+
+  protected synchronized Locale getFallbackLocale() throws ServletException {
+    try {
+      if (fallbackLocale == null) {
+        fallbackLocale = new Locale(MirPropertiesConfiguration.instance().getString("Mir.Admin.FallbackLanguage", "en"), "");
+      }
+    }
+    catch (Throwable t) {
+      throw new ServletException(t.getMessage());
     }
 
-    //From now on normal Dispatching...
+    return fallbackLocale;
+  }
+
+  public EntityUsers checkCredentials(HttpServletRequest aRequest) throws ServletException {
     try {
-      try {
-        theServletModule = Class.forName("mircoders.servlet.ServletModule" + moduleName);
-      } catch (ClassNotFoundException e) {
-        // searching Servlet webdb.servlet-classes
-        theServletModule = Class.forName("mir.servlet.ServletModule" + moduleName);
+      EntityUsers user = ServletHelper.getUser(aRequest);
+
+      String username = aRequest.getParameter("login");
+      String password = aRequest.getParameter("password");
+
+      if (username != null && password != null) {
+        user = usersModule.getUserForLogin(username, password);
+
+        if (user!=null) {
+          ServletHelper.setUser(aRequest, user);
+          usersModule.recordLogin(user);
+          aRequest.getSession().setAttribute("sessiontracker", new SessionTracker(username, user.getId()));
+        }
       }
-      //Instanciate the ServletModule
-      Method m = theServletModule.getMethod("getInstance",null);
-      smod = (ServletModule)m.invoke(null,null);
-      ServletModuleDispatch.dispatch(smod,req,res);
-    }
-    catch (NoSuchMethodException e) { handleError( res.getWriter(), "ServletModule" + moduleName + " getInstance() nicht gefunden."); }
-    catch (InvocationTargetException e) { handleError( res.getWriter(), "ServletModule" + moduleName + " target nicht gefunden."); }
-    catch (ClassNotFoundException e) { handleError( res.getWriter(), "ServletModule" + moduleName + " nicht gefunden."); }
-    catch (IllegalArgumentException e) { handleError( res.getWriter(), "ServletModule" + moduleName + " nicht gefunden."); }
-    catch (ServletModuleException e){ handleError(res.getWriter(), "ServletException in Module ServletModule" + moduleName + " -- " + e.toString()); }
-    catch (IllegalAccessException e){
-        handleError(res.getWriter(), "Kein Zugriff auf Klasse ServletModule" + moduleName + " -- " + e.toString()); }
-
-    // timing...
-    sessionConnectTime = new java.util.Date().getTime() - startTime;
-    theLog.printInfo("EXECTIME (" + moduleName + "): " + sessionConnectTime + " ms");
+
+      return user;
+    }
+    catch (Throwable t) {
+      throw new ServletException(t.getMessage());
+    }
   }
 
-  private void handleError(PrintWriter out, String errorString) {
+  public void process(HttpServletRequest aRequest, HttpServletResponse aResponse) throws ServletException, IOException, UnavailableException {
     try {
-      theLog.printError(errorString);
-      SimpleHash modelRoot = new SimpleHash();
-      modelRoot.put("errorstring", new SimpleScalar(errorString));
-      modelRoot.put("date", new SimpleScalar(StringUtil.date2readableDateTime(new GregorianCalendar())));
-      HTMLTemplateProcessor.process(Configuration.getProperty("Mir.ErrorTemplate"),modelRoot,out);
-      out.close();
+      long startTime = System.currentTimeMillis();
+      long sessionConnectTime = 0;
+
+      HttpSession session = aRequest.getSession(true);
+      setNoCaching(aResponse);
+      aResponse.setContentType("text/html; charset=" +
+                               configuration.
+                               getString("Mir.DefaultHTMLCharset", "UTF-8"));
+
+      EntityUsers userEntity = checkCredentials(aRequest);
+
+      if (userEntity == null) {
+        String queryString = aRequest.getQueryString();
+
+        if ( (queryString != null) && (queryString.length() != 0) && session.getAttribute("login.target") == null &&
+             (aRequest.getParameter("module")==null ||
+              (!aRequest.getParameter("module").equals("login") && !aRequest.getParameter("module").equals("logout")))) {
+          session.setAttribute("login.target", queryString);
+        }
+
+        _sendLoginPage(aResponse, aRequest);
+      }
+      else {
+        String moduleName = aRequest.getParameter("module");
+        checkLanguage(session, aRequest);
+
+        if ( ( (moduleName == null) || moduleName.equals(""))) {
+          moduleName="Admin";
+        }
+
+        if (moduleName.equals("login")) {
+          String target = (String) session.getAttribute("login.target");
+
+          if (target != null) {
+            ServletHelper.redirect(aResponse, target);
+          }
+          else {
+            ServletHelper.redirect(aResponse, "");
+          }
+        }
+        else if (moduleName.equals("logout")) {
+          logger.info(userEntity.getFieldValue("login") + " has logged out");
+          session.invalidate();
+          _sendLoginPage(aResponse, aRequest);
+          return;
+        }
+        else {
+          try {
+            AdminServletModule servletModule = getServletModuleForName(moduleName);
+            servletModule.handleRequest(aRequest, aResponse);
+
+            sessionConnectTime = System.currentTimeMillis() - startTime;
+            logger.info("EXECTIME (" + moduleName + "): " + sessionConnectTime + " ms");
+          }
+          catch (Throwable e) {
+            Throwable cause = ExceptionRoutines.traceCauseException(e);
+
+            if (cause instanceof ServletModuleUserExc)
+              handleUserError(aRequest, aResponse, (ServletModuleUserExc) cause);
+            else
+              handleError(aRequest, aResponse, cause);
+          }
+
+          if (aRequest.getParameter("killsession")!=null)
+            aRequest.getSession().invalidate();
+        }
+      }
     }
-    catch (Exception e) {
-      System.err.println("Fehler in ErrorTemplate");
+    catch (Throwable t) {
+      throw new ServletException(t.toString());
     }
   }
 
   /**
-   *  evaluate login for user / password
+   * caching routine to get a module for a module name
+   *
+   * @param aModuleName the module name
+   * @return the requested module
+   * @throws ServletModuleExc
    */
-  protected EntityUsers allowedUser(String user, String password) {
+  private static AdminServletModule getServletModuleForName(String aModuleName) throws ServletModuleExc {
+    return ServletHelper.getServletModule(aModuleName);
+  }
+
+  private void handleUserError(HttpServletRequest aRequest, HttpServletResponse aResponse, ServletModuleUserExc anException) {
     try {
-      if (usersModule == null) usersModule = new ModuleUsers(DatabaseUsers.getInstance());
-      return usersModule.getUserForLogin(user, password);
+      logger.info("user error: " + anException.getMessage());
+
+      Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, new Locale[] {getLocale(aRequest), getFallbackLocale()});
+
+      Bundle bundle =
+          MirGlobal.getBundleFactory().getBundle("etc/bundles/adminlocal", new
+              String[] { getLocale(aRequest).getLanguage() });
+      Bundle defaultBundle =
+          MirGlobal.getBundleFactory().getBundle("bundles/admin", new
+              String[] { getLocale(aRequest).getLanguage() });
+      String message =
+        bundle.getValue(anException.getMessage(), Arrays.asList(anException.getParameters()));
+
+      if (message==null) {
+        message =
+          defaultBundle.getValue(anException.getMessage(), Arrays.asList(anException.getParameters()));
+      }
+
+      responseData.put("errorstring", message);
+      responseData.put("date", new GregorianCalendar().getTime());
+
+      ServletHelper.generateResponse(aResponse.getWriter(), responseData, MirPropertiesConfiguration.instance().getString("Mir.UserErrorTemplate"));
+    }
+    catch (Throwable e) {
+      logger.error("Error handling user error" + e.toString());
     }
-    catch(Exception e) { theLog.printDebugInfo(e.toString()); return null; }
   }
 
-  // Redirect-methods
-  private void _sendLoginPage(HttpServletRequest req, PrintWriter out) {
-    String loginTemplate = "login.template";
+  private void handleError(HttpServletRequest aRequest, HttpServletResponse aResponse, Throwable anException) {
     try {
-      theLog.printDebugInfo("login: "+lang);
-      if(lang==null){
-        lang=getAcceptLanguage(req);
+      logger.error("error: " + anException);
+
+      Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, new Locale[] {getLocale(aRequest), getFallbackLocale()});
+
+      responseData.put("errorstring", anException.toString());
+      StringWriter writer = new StringWriter();
+      anException.printStackTrace(new PrintWriter(writer));
+      responseData.put("stacktrace", writer.toString());
+      responseData.put("date", new GregorianCalendar().getTime());
+
+      ServletHelper.generateResponse(aResponse.getWriter(), responseData, MirPropertiesConfiguration.instance().getString("Mir.ErrorTemplate"));
+    }
+    catch (Throwable e) {
+      logger.error("Error handling error: " + e.toString());
+
+      try {
+        Throwable rootException = ExceptionRoutines.traceCauseException(anException);
+
+        PrintWriter writer = aResponse.getWriter();
+        writer.println("<html><head><title>FATAL Error</title><body>");
+        writer.println("<h1>" + rootException.toString()+"</h1>");
+        writer.println("<code>");
+        rootException.printStackTrace(writer);
+        writer.println("</code>");
+        writer.println("</body></html>");
+        writer.close();
+      }
+      catch (Throwable t) {
+
       }
-      HTMLTemplateProcessor.process(lang+"/"+loginTemplate, new SimpleHash(), out);
-    } catch(HTMLParseException e) {
-      handleError( out, "fehler in logintemplate.");
     }
   }
 
-  private void _sendStartPage(HttpServletRequest req,PrintWriter out, EntityUsers userEntity) {
-    String startTemplate = "start_admin.template";
+  // Redirect-methods
+  private void _sendLoginPage(HttpServletResponse aResponse, HttpServletRequest aRequest) {
+    String loginTemplate = configuration.getString("Mir.LoginTemplate");
+
     try {
-      // merge with logged in user and messages
-      SimpleHash mergeData = new SimpleHash();
-      mergeData.put("login_user", HTMLTemplateProcessor.makeSimpleHash(userEntity));
-      if (messageModule == null) messageModule = new ModuleMessage(DatabaseMessages.getInstance());
-      mergeData.put("messages", HTMLTemplateProcessor.makeSimpleList(messageModule.getByWhereClause(null, "webdb_create desc",0,10)));
-      HTMLTemplateProcessor.process(getLanguage(req)+"/"+startTemplate, mergeData,out);
+      Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, new Locale[] {getLocale(aRequest), getFallbackLocale()});
+
+      responseData.put("defaultlanguage", getDefaultLanguage(aRequest));
+      responseData.put("languages", getLoginLanguages());
+
+      ServletHelper.generateResponse(aResponse.getWriter(), responseData, loginTemplate);
     }
-    catch(Exception e) {
-      handleError( out, "error while trying to send startpage. " + e.toString());
+    catch (Throwable e) {
+      handleError(aRequest, aResponse, e);
     }
   }
 
-  public String getServletInfo(){ return "Mir 1.0 rev02 multilanguage"; }
+  public String getServletInfo() {
+    return "Mir " + configuration.getString("Mir.Version");
+  }
 
-}
+  private class SessionTracker implements HttpSessionBindingListener {
+    private String name;
+    private String id;
+
+    public SessionTracker(String aUserName, String anId) {
+      name = aUserName;
+      id = anId;
+    }
 
+    public void valueBound(HttpSessionBindingEvent anEvent) {
+      MirGlobal.registerLogin(name, id);
+    }
+
+    public void valueUnbound(HttpSessionBindingEvent anEvent) {
+      MirGlobal.registerLogout(name, id);
+    }
+  }
+}