src/org/objectweb/cjdbc/controller/core/ReportManager.java

説明を見る。

package org.objectweb.cjdbc.controller.core;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;

import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.RollingFileAppender;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.util.Constants;
import org.objectweb.cjdbc.common.util.ReadWrite;
import org.objectweb.cjdbc.common.xml.ControllerXmlTags;

public class ReportManager
{

  static Trace             logger             = Trace
                                                  .getLogger(ReportManager.class
                                                      .getName());

  boolean                  reportEnabled      = false;
  boolean                  hideSensitiveData  = true;
  boolean                  generateOnShutdown = true;
  boolean                  generateOnFatal    = true;
  boolean                  enableFileLogging  = true;
  boolean                  showLogsOnly       = false;
  String                   reportLocation = ControllerConstants.REPORT_LOCATION;

  private Controller       controller;
  private StringBuffer     buffer;
  private FileOutputStream fos;

  public ReportManager(Controller controller)
  {
    this.controller = controller;
    buffer = new StringBuffer();
    //listLoggers();
  }

  public void startReport()
  {
    writeTitle("CJDBC (version:" + Constants.VERSION + ") REPORT generated on "
        + new Date().toString());
    writeJavaProperties();
    writeControllerSettings();
    writeControllerInfo();
  }

  public ReportManager(Controller controller, boolean showLogsOnly)
  {
    this(controller);
    this.showLogsOnly = showLogsOnly;
  }

  public ReportManager(Controller controller, Exception e)
  {
    this(controller);
    writeException(e);
  }

  public void writeControllerInfo()
  {
    try
    {
      writeHeader("CONTROLLER INFO XML");
      write(controller.getXml());
      writeHeader("DATABASE INFO");
      write(controller.viewDatabases());
      writeHeader("DATABASE INFO XML");
      write(controller.viewDatabasesXml());
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  public void writeControllerSettings()
  {
    writeHeader("CONTROLLER SETTINGS");
    write(controller.getConfiguration());
  }

  public void writeJavaProperties()
  {
    writeHeader("JAVA SETTINGS");
    write(System.getProperties());
  }

  public void writeLogs()
  {
    writeHeader("LOG CONFIGURATION");
    String s = this.getClass().getResource(ControllerConstants.LOG4J_RESOURCE)
        .getFile();
    writeFile(s);
    writeHeader("LOGS");
    if (isEnableFileLogging())
    {
      Logger log = Logger.getRootLogger();
      FileAppender appender = (FileAppender) log
          .getAppender("Filetrace");
      s = appender.getFile();
      writeFile(s);
    }
  }

  public void writeException(Exception e)
  {
    writeHeader("EXCEPTION DESCRIPTION");
    write(e.getClass().toString());
    write(e.getMessage());
    write(e.toString());
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    e.printStackTrace(pw);
    write(sw.toString());
  }

  public String generate()
  {
    // Here we get all the logs before writing report
    writeLogs();
    try
    {
      File reportFile = new File(reportLocation + File.separator
          + ControllerConstants.REPORT_FILE);
      reportFile.getParentFile().mkdirs();
      fos = new FileOutputStream(reportFile);
      fos.write(buffer.toString().getBytes());
      fos.close();
      String returned = buffer.toString();
      // Reset buffer
      buffer.delete(0,buffer.length());
      return returned;
    }
    catch (Exception e)
    {
      e.printStackTrace();
      return "";
    }
  }

  public String generateJustLogs()
  {
    String s = this.getClass().getResource(ControllerConstants.LOG4J_RESOURCE)
        .getFile();
    Logger log = Logger.getRootLogger();
    try
    {
      FileAppender appender = (FileAppender) log.getAppender("Filetrace");
      s = appender.getFile();
      writeFile(s);
      return buffer.toString();
    }
    catch (Exception e)
    {
      logger
          .warn("Filetrace appender is not of type FileAppender and cannot be dumped ("
              + e + ")");
      return "";
    }
  }

  /* Write Methods */

  private void write(String string)
  {
    try
    {
      buffer.append(string.toString());
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  private void writeFile(String filename)
  {
    try
    {
      File f = new File(filename);
      FileInputStream fis = new FileInputStream(f);
      byte[] logs = new byte[(int) f.length()];
      fis.read(logs);
      write(new String(logs));
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  private void write(Hashtable table)
  {
    buffer.append(ReadWrite.write(table, true));
  }

  private void writeTitle(String title)
  {
    write("==========================================================================="
        + System.getProperty("line.separator"));
    write("==========================================================================="
        + System.getProperty("line.separator"));
    write("==== " + title + System.getProperty("line.separator"));
    write("==========================================================================="
        + System.getProperty("line.separator"));
    write("==========================================================================="
        + System.getProperty("line.separator"));
  }

  private void writeHeader(String header)
  {
    write(System.getProperty("line.separator"));
    write("############################################################"
        + System.getProperty("line.separator"));
    write("####\t\t" + header + System.getProperty("line.separator"));
    write("############################################################"
        + System.getProperty("line.separator"));
  }

  private void setLogsDeleteOnExit()
  {
    try
    {
      Logger log = Logger.getRootLogger();
      RollingFileAppender appender = (RollingFileAppender) log
          .getAppender("Filetrace");
      File logFile = new File(appender.getFile());
      logFile.deleteOnExit();
    }
    catch (Exception e)
    {
      // appender has been removed or is not defined.
      logger.debug("Failed to set deleteOnExit on log file", e);
    }
  }

  public final void setSettings(Hashtable settings)
  {
    //listLoggers();
    setLogsDeleteOnExit();
    if (settings == null)
    {
      reportEnabled = false;
    }
    else if (settings.containsKey(ControllerXmlTags.ATT_REPORT_ENABLED))
    {
      reportEnabled = new Boolean((String) settings
          .get(ControllerXmlTags.ATT_REPORT_ENABLED)).booleanValue();
    }
    if (!reportEnabled)
    {
      hideSensitiveData = false;
      generateOnShutdown = false;
      generateOnFatal = false;
      enableFileLogging = false;
      //removeFileTraceAppender();
      return;
    }
    else
    {
      if ("true".equals(settings
          .get(ControllerXmlTags.ATT_REPORT_DELETE_ON_SHUTDOWN)))
      {
        setLogsDeleteOnExit();
      }
      if (settings
          .containsKey(ControllerXmlTags.ATT_REPORT_ENABLE_FILE_LOGGING))
      {
        enableFileLogging = new Boolean((String) settings
            .get(ControllerXmlTags.ATT_REPORT_ENABLE_FILE_LOGGING))
            .booleanValue();
        if (!enableFileLogging)
        {
          //removeFileTraceAppender();
        }
      }
      if (settings.containsKey(ControllerXmlTags.ATT_REPORT_GENERATE_ON_FATAL))
      {
        generateOnFatal = new Boolean((String) settings
            .get(ControllerXmlTags.ATT_REPORT_GENERATE_ON_FATAL))
            .booleanValue();
      }
      if (settings
          .containsKey(ControllerXmlTags.ATT_REPORT_GENERATE_ON_SHUTDOWN))
      {
        generateOnShutdown = new Boolean((String) settings
            .get(ControllerXmlTags.ATT_REPORT_GENERATE_ON_SHUTDOWN))
            .booleanValue();
      }
      if (settings
          .containsKey(ControllerXmlTags.ATT_REPORT_HIDE_SENSITIVE_DATA))
      {
        hideSensitiveData = new Boolean((String) settings
            .get(ControllerXmlTags.ATT_REPORT_HIDE_SENSITIVE_DATA))
            .booleanValue();
      }
      if (settings.containsKey(ControllerXmlTags.ATT_REPORT_REPORT_LOCATION))
      {
        reportLocation = (String) settings
            .get(ControllerXmlTags.ATT_REPORT_REPORT_LOCATION);
      }
    }
  }

  void listLoggers()
  {
    Logger log = Logger.getRootLogger();
    Enumeration loggers = Logger.getDefaultHierarchy().getCurrentLoggers();
    while (loggers.hasMoreElements())
    {
      Logger logger = (Logger) loggers.nextElement();
      log.debug("Found logger:" + logger.getName());
    }
  }

  public boolean isEnableFileLogging()
  {
    return enableFileLogging;
  }

  public boolean isGenerateOnFatal()
  {
    return reportEnabled && generateOnFatal;
  }

  public boolean isGenerateOnShutdown()
  {
    return reportEnabled && generateOnShutdown;
  }

  public boolean isHideSensitiveData()
  {
    return hideSensitiveData;
  }

  public boolean isReportEnabled()
  {
    return reportEnabled;
  }

  public String getReportLocation()
  {
    return reportLocation;
  }

  public void setEnableFileLogging(boolean enableFileLogging)
  {
    this.enableFileLogging = enableFileLogging;
  }

  public void setGenerateOnFatal(boolean generateOnFatal)
  {
    this.generateOnFatal = generateOnFatal;
  }

  public void setGenerateOnShutdown(boolean generateOnShutdown)
  {
    this.generateOnShutdown = generateOnShutdown;
  }

  public void setHideSensitiveData(boolean hideSensitiveData)
  {
    this.hideSensitiveData = hideSensitiveData;
  }

  public void setReportEnabled(boolean reportEnabled)
  {
    this.reportEnabled = reportEnabled;
  }

  public void setReportLocation(String reportLocation)
  {
    this.reportLocation = reportLocation;
  }
}

---