PC Online 1999 November/PCONLINE_11_99.ISO/filesbbs/OS2/APCHSSL2.ZIP/OS2HTTPD/jserv/com/bitmechanic/gsp/GspServlet.class

Java Class File | 1999-02-03 | 14.0 KB | 498 lines

package com.bitmechanic.gsp;

import com.bitmechanic.smtp.Mailer;
import com.bitmechanic.util.Scheduler;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.StringTokenizer;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class GspServlet extends HttpServlet {
   private ServletConfig config;
   private ServletContext context;
   private Properties properties;
   private Logger logger;
   private Mailer mailer;
   private TemplateFactory factory;
   private ApplicationManager appManager;
   private Scheduler scheduler;
   private Hashtable templateHash;
   private Hashtable globalHash;
   private static boolean debug;
   private boolean started = false;
   private boolean bench = false;
   private boolean alwaysRegister = false;
   private boolean keepUploadFile = false;
   private boolean checkProperties = false;
   private String uploadDir;
   private String errorMessage;
   private String indexPage;
   private String propFile;
   private long maxFileSize;
   private long requestCount;
   private long statInterval;
   private Date startTime;
   private long propLastMod;
   private long recheckProp;

   public synchronized void init(ServletConfig var1) {
      if (!this.started) {
         this.config = var1;
         this.context = var1.getServletContext();
         this.startTime = new Date();
         this.globalHash = new Hashtable();
         this.templateHash = new Hashtable();
         this.requestCount = 0L;
         this.scheduler = new Scheduler();
         this.propFile = var1.getInitParameter("propfile");
         if (this.propFile == null) {
            this.errorMessage = "GspServlet: missing init parameter 'propfile'.\n\n     Please add an initArgs attribute 'propfile' for this servlet that points to the gsp.properties file.";
            this.context.log(this.errorMessage);
         } else {
            this.properties = new Properties();

            try {
               File var2 = new File(this.propFile);
               this.properties.load(new FileInputStream(var2));
               this.propLastMod = var2.lastModified();
            } catch (IOException var16) {
               this.errorMessage = "GspServlet: cannot load properties for: " + this.propFile + "\n" + Logger.exceptionToString(var16);
               this.context.log(this.errorMessage);
               return;
            }

            String var18 = this.properties.getProperty("mailer.smtphost");
            if (var18 == null) {
               var18 = "localhost";
            }

            this.mailer = new GspMailer(var18, this);
            String var3 = this.properties.getProperty("class.logger");
            if (var3 != null) {
               try {
                  Class var4 = Class.forName(var3);
                  this.logger = (Logger)var4.newInstance();
                  this.context.log("GspServlet: using custom logger " + var3);
               } catch (Exception var15) {
                  this.errorMessage = "GspServlet: cannot instantiate class.logger: " + var3 + "\n" + Logger.exceptionToString(var15);
                  this.context.log(this.errorMessage);
                  return;
               }
            } else {
               this.logger = new Logger();
            }

            try {
               this.logger.init(this);
            } catch (Exception var14) {
               this.errorMessage = "GspServlet: cannot init() class.logger: " + var3 + "\n" + Logger.exceptionToString(var14);
               this.context.log(this.errorMessage);
               return;
            }

            try {
               String var19 = this.properties.getProperty("parser.statinterval.seconds");
               this.statInterval = Long.parseLong(var19) * 1000L;
            } catch (Exception var13) {
               this.statInterval = 5000L;
            }

            this.recheckProp = System.currentTimeMillis() + this.statInterval;
            this.checkProperties = this.properties.getProperty("parser.checkproperties") != null;

            try {
               String var20 = this.properties.getProperty("class.factory");
               if (var20 != null) {
                  try {
                     Class var5 = Class.forName(var20);
                     this.factory = (TemplateFactory)var5.newInstance();
                     this.context.log("GspServlet: using custom factory " + var20);
                  } catch (Exception var12) {
                     this.errorMessage = "GspServlet: error creating factory: " + var20 + " -- " + Logger.exceptionToString(var12);
                     this.context.log(this.errorMessage);
                     this.factory = new TemplateFactory();
                  }
               } else {
                  this.factory = new TemplateFactory();
               }

               this.factory.init(this);
               this.appManager = new ApplicationManager(this);
               String var21 = this.properties.getProperty("class.applications");
               if (var21 != null) {
                  StringTokenizer var6 = new StringTokenizer(var21);

                  while(var6.hasMoreTokens()) {
                     try {
                        String var7 = var6.nextToken();
                        Class var8 = Class.forName(var7);
                        Application var9 = (Application)var8.newInstance();
                        this.appManager.addApplication(var9);
                        this.context.log("GspServlet: adding custom Application " + var7);
                     } catch (Exception var11) {
                        this.errorMessage = "GspServlet: error creating custom Application\n" + Logger.exceptionToString(var11);
                        this.context.log(this.errorMessage);
                     }
                  }
               }

               DefaultApplication var22 = new DefaultApplication();
               this.appManager.addApplication(var22);
               this.bench = this.properties.getProperty("log.bench") != null;
               this.indexPage = this.properties.getProperty("parser.indexpage");
               if (this.indexPage == null) {
                  this.indexPage = "index.gsp";
               }

               this.uploadDir = this.properties.getProperty("upload.dir");
               if (this.uploadDir == null) {
                  if (File.separator.equals("/")) {
                     this.uploadDir = "/tmp";
                  } else {
                     this.uploadDir = "c:\\temp";
                  }

                  this.context.log("GspServlet: warning - upload.dir not set.  Using " + this.uploadDir + " by default");
               }

               this.keepUploadFile = this.properties.getProperty("upload.keeptempfile") != null;

               try {
                  this.maxFileSize = Long.parseLong(this.properties.getProperty("upload.maxfilesize"));
               } catch (Exception var10) {
                  this.maxFileSize = 1000000L;
                  this.context.log("GspServlet: warning - upload.maxfilesize not set.  Using " + this.maxFileSize + " bytes by default");
               }

               this.alwaysRegister = this.properties.getProperty("session.create_upon_request") == null;
               this.started = true;
               this.context.log("GspServlet started successfully at: " + new Date());
            } catch (Exception var17) {
               this.errorMessage = "GspServlet: Failed to start successfully: " + Logger.exceptionToString(var17);
               this.context.log(this.errorMessage);
            }
         }
      }
   }

   public void destroy() {
      if (this.started) {
         this.context.log("GspServlet: destroy() called.  shutting down applications");

         try {
            this.appManager.destroy();
         } catch (Exception var2) {
            this.logger.log(var2, "during GspServlet.destroy()");
         }

         this.context.log("GspServlet: stopping the logger");
         this.logger.destroy();
         this.context.log("GspServlet: stopping the scheduler");
         this.scheduler.stop();
         this.context.log("GspServlet: shutdown successful");
         this.started = false;
      }

   }

   public void service(HttpServletRequest var1, HttpServletResponse var2) throws IOException {
      if (this.started) {
         GspRequest var31 = null;
         long var4 = System.currentTimeMillis();

         try {
            ++this.requestCount;
            String var8 = var1.getRequestURI();
            if (var8.indexOf(63) != -1) {
               var8 = var8.substring(0, var8.indexOf(63));
            }

            String var9 = var1.getPathTranslated();
            String var10 = var1.getServletPath();
            var1.getPathInfo();
            String var11 = var8;
            if (var9 == null) {
               throw new IOException("req.getPathTranslated() is null!");
            }

            if (var8 == null) {
               throw new IOException("uri is null!");
            }

            if (File.separatorChar != '/' && var9.indexOf(var8) == -1) {
               var9 = var9 + var8;
            }

            if (debug) {
               System.err.println("getRequestURI() = " + var8);
               System.err.println("getServletPath() = " + var10);
               System.err.println("getPathTranslated() = " + var9);
               System.err.println("relativePath = " + var8);
            }

            if (var10 != null && var8.indexOf(var10) != -1 && !var8.equals(var10)) {
               var11 = var8.substring(var10.length());
            }

            if (debug) {
               System.err.println("relativePath = " + var11);
            }

            Object var13 = null;
            String var14 = null;
            String var36;
            if (!var9.endsWith(var11) && var9.indexOf(var11) != -1) {
               int var37 = var9.lastIndexOf(var11);
               var36 = var9.substring(0, var37);
               var11 = var9.substring(var36.length());
            } else if (var8.startsWith("/~")) {
               int var15 = var8.indexOf(47, 2);
               var11 = var8.substring(var15);
               var14 = var8.substring(2, var15);
               var36 = var9.substring(0, var9.length() - var11.length());
            } else {
               var36 = var9.substring(0, var9.length() - var11.length());
            }

            if (debug) {
               System.err.println("relativePath = " + var11);
            }

            if (var11.indexOf(".gsp/") != -1) {
               var11 = var11.substring(0, var11.indexOf(".gsp/") + 4);
               if (debug) {
                  System.err.println("relativePath = " + var11);
               }
            }

            if (var36.indexOf(var11) != -1) {
               var36 = var36.substring(0, var36.indexOf(var11));
            }

            if (debug) {
               System.err.println("relativePath = " + var11);
               System.err.println("docRoot = " + var36);
            }

            String var38 = System.getProperty("file.separator") + System.getProperty("file.separator");
            int var16 = var11.indexOf(var38);
            if (var16 >= 0) {
               StringBuffer var18 = new StringBuffer(var11.length());
               var18.append(var11.substring(0, var16 + 1));

               while(var16 >= 0) {
                  int var17 = var16;

                  do {
                     ++var17;
                  } while(var11.charAt(var17) == File.separatorChar);

                  var16 = var11.indexOf(System.getProperty("file.separator") + System.getProperty("file.separator"), var17 + 1);
                  if (var16 >= 0) {
                     var18.append(var11.substring(var17, var16 + 1));
                  } else {
                     var18.append(var11.substring(var17));
                  }
               }

               var11 = var18.toString();
               if (debug) {
                  System.err.println("stripped double path separators from relativePath to get " + var11);
               }
            }

            Application var39 = this.appManager.getApplication(var1.getRequestURI());
            var31 = new GspRequest(this, var1, var39, var36, var11, var14, var4);
            GspResponse var40 = new GspResponse(this, var2);
            if (this.alwaysRegister) {
               var1.getSession(true);
            }

            var2.setContentType("text/html");
            Template var19 = null;
            if (!var39.handleRequest(var31, var40)) {
               var19 = this.renderTemplate(var31, var40, var39, var31.getRelativePath());
            }

            if (var19 != null) {
               if (var19.usesPrintWriter()) {
                  PrintWriter var20 = var40.getWriter();
                  var20.flush();
               } else {
                  ServletOutputStream var41 = var40.getOutputStream();
                  ((OutputStream)var41).flush();
               }
            }

            if (this.bench) {
               long var42 = System.currentTimeMillis() - var4;
               this.logger.log("GSP BENCH: " + var42);
            }

            this.logger.flushExceptions(var4);
         } catch (Exception var29) {
            if (var31 != null) {
               this.logger.log(var29, var31);
            } else {
               this.logger.log(var29);
            }
         } finally {
            if (var31 != null && !this.keepUploadFile && var31.getUploadedFiles() != null) {
               Enumeration var32 = var31.getUploadedFiles().elements();

               while(var32.hasMoreElements()) {
                  String var34 = (String)var32.nextElement();

                  try {
                     File var35 = new File(var34);
                     var35.delete();
                  } catch (Exception var27) {
                     this.logger.log(var27, var31);
                  }
               }
            }

            if (this.checkProperties && var4 > this.recheckProp) {
               this.recheckProp = var4 + this.statInterval;
               File var33 = new File(this.propFile);
               if (var33.exists() && var33.lastModified() > this.propLastMod) {
                  this.restartServlet(var33);
               }
            }

         }

      } else {
         try {
            var2.setContentType("text/html");
            ServletOutputStream var3 = var2.getOutputStream();
            var3.println("<html><head><title>GspServlet Not Started</title>");
            var3.println("</head><body>");
            var3.println("<h1>Error: GspServlet Not Started</h1>");
            var3.println("The following error occurred while trying to start ");
            var3.println("the GspServlet: ");
            var3.println("<p><hr><p><pre>");
            var3.println(this.errorMessage);
            var3.println("</pre><p><hr><p>");
            var3.println("Please consult your Servlet runtime's error logs ");
            var3.println("for more information.  Fix the configuration ");
            var3.println("problem, and restart the Servlet runtime.");
            var3.println("</body></html>");
            ((OutputStream)var3).flush();
         } catch (Exception var28) {
            this.context.log(Logger.exceptionToString(var28));
         }
      }
   }

   public ServletConfig getServletConfig() {
      return this.config;
   }

   public Template renderTemplate(GspRequest var1, GspResponse var2, Application var3, String var4) {
      Object var5 = null;

      try {
         var5 = this.factory.getTemplate(var1.getDocumentRoot(), var4, var1.getUsername(), var1.getRequestTime());
      } catch (Throwable var8) {
         var5 = new ErrorTemplate("An internal error w/in GSP occured while trying to retrieve the template class<pre>" + Logger.exceptionToString(var8) + "</pre>");
         this.logger.log(var8, "N/A");
      }

      try {
         ((Template)var5).render(var3, var1, var2);
         return (Template)var5;
      } catch (Exception var7) {
         var3.handleException(var7, var1, var2);
         return null;
      }
   }

   public Logger getLogger() {
      return this.logger;
   }

   public Mailer getMailer() {
      return this.mailer;
   }

   public Scheduler getScheduler() {
      return this.scheduler;
   }

   public void flushCache() {
      this.factory.flushCache();
   }

   public Date getStartTime() {
      return this.startTime;
   }

   public long getRequestCount() {
      return this.requestCount;
   }

   public ServletContext getServletContext() {
      return this.context;
   }

   public String getProperty(String var1) {
      return this.properties.getProperty(var1);
   }

   public String getProperty(String var1, String var2) {
      return this.properties.getProperty(var1, var2);
   }

   public Enumeration getPropertyNames() {
      return this.properties.keys();
   }

   public Object getGlobal(String var1) {
      return this.globalHash.get(var1);
   }

   public Object setGlobal(String var1, Object var2) {
      return this.globalHash.put(var1, var2);
   }

   public Object removeGlobal(String var1) {
      return this.globalHash.remove(var1);
   }

   public long getMaxFileSize() {
      return this.maxFileSize;
   }

   public String getUploadDir() {
      return this.uploadDir;
   }

   public long getStatInterval() {
      return this.statInterval;
   }

   private synchronized void restartServlet(File var1) {
      if (var1.lastModified() > this.propLastMod) {
         this.propLastMod = var1.lastModified();
         this.context.log("GspServlet: restarting GSP to reload gsp.properties");
         this.destroy();
         this.init(this.config);
         this.context.log("GspServlet: restart successful");
      }

   }
}