Exemplo n.º 1
0
 public static void log(String str) {
   AEDiagnosticsLogger diag_logger = AEDiagnostics.getLogger("v3.MD");
   diag_logger.log(str);
   if (DEBUG_CACHING) {
     System.out.println(
         Thread.currentThread().getName() + "|" + System.currentTimeMillis() + "] " + str);
   }
 }
Exemplo n.º 2
0
 static {
   AEDiagnostics.addEvidenceGenerator(
       new AEDiagnosticsEvidenceGenerator() {
         public void generate(IndentWriter writer) {
           generateEvidence(writer);
         }
       });
 }
  protected void initialise() {

    // ConfigurationChecker.migrateConfig();  //removed 2201

    ConfigurationChecker.checkConfiguration();

    ConfigurationChecker.setSystemProperties();

    loadExportedParameters();

    AEDiagnostics.addEvidenceGenerator(this);
  }
Exemplo n.º 4
0
/** Debug-assisting class. */
public class Debug {

  private static AEDiagnosticsLogger diag_logger = AEDiagnostics.getLogger("debug");

  private static boolean STOP_AT_INITIALIZER =
      System.getProperty("debug.stacktrace.full", "0").equals("0");

  static {
    diag_logger.setForced(true);
  }

  /**
   * Prints out the given debug message to System.out, prefixed by the calling class name, method
   * and line number.
   */
  public static void out(final String _debug_message) {
    out(_debug_message, null);
  }

  /**
   * Prints out the given exception stacktrace to System.out, prefixed by the calling class name,
   * method and line number.
   */
  public static void out(final Throwable _exception) {
    out("", _exception);
  }

  public static void outNoStack(String str) {
    outNoStack(str, false);
  }

  public static void outNoStack(String str, boolean stderr) {
    diagLoggerLogAndOut(
        "DEBUG::" + new Date(SystemTime.getCurrentTime()).toString() + "  " + str, stderr);
  }

  public static void outDiagLoggerOnly(String str) {
    diagLoggerLog(str);
  }

  /**
   * Prints out the given debug message to System.out, prefixed by the calling class name, method
   * and line number, appending the stacktrace of the given exception.
   */
  public static void out(final String _debug_msg, final Throwable _exception) {
    String header = "DEBUG::";
    header = header + new Date(SystemTime.getCurrentTime()).toString() + "::";
    String className;
    String methodName;
    int lineNumber;
    String trace_trace_tail = null;

    try {
      throw new Exception();
    } catch (Exception e) {
      StackTraceElement[] st = e.getStackTrace();

      StackTraceElement first_line = st[2];
      className = first_line.getClassName() + "::";
      methodName = first_line.getMethodName() + "::";
      lineNumber = first_line.getLineNumber();

      trace_trace_tail = getCompressedStackTrace(e, 3, 200, false);
    }

    diagLoggerLogAndOut(header + className + (methodName) + lineNumber + ":", true);
    if (_debug_msg.length() > 0) {
      diagLoggerLogAndOut("  " + _debug_msg, true);
    }
    if (trace_trace_tail != null) {
      diagLoggerLogAndOut("    " + trace_trace_tail, true);
    }
    if (_exception != null) {
      diagLoggerLogAndOut(_exception);
    }
  }

  public static String getLastCaller() {
    return getLastCaller(0);
  }

  public static String getLastCaller(int numToGoBackFurther) {
    try {
      throw new Exception();
    } catch (Exception e) {
      // [0] = our throw
      // [1] = the line that called getLastCaller
      // [2] = the line that called the function that has getLastCaller
      StackTraceElement st[] = e.getStackTrace();
      if (st == null || st.length == 0) return "??";
      if (st.length > 3 + numToGoBackFurther) return st[3 + numToGoBackFurther].toString();

      return st[st.length - 1].toString();
    }
  }

  public static void outStackTrace() {
    // skip the last, since they'll most likely be main
    diagLoggerLogAndOut(getStackTrace(1), false);
  }

  private static String getStackTrace(int endNumToSkip) {
    String sStackTrace = "";
    try {
      throw new Exception();
    } catch (Exception e) {
      StackTraceElement st[] = e.getStackTrace();
      for (int i = 1; i < st.length - endNumToSkip; i++) {
        if (!st[i].getMethodName().endsWith("StackTrace")) sStackTrace += st[i].toString() + "\n";
      }
      if (e.getCause() != null) sStackTrace += "\tCaused By: " + getStackTrace(e.getCause()) + "\n";
    }
    return sStackTrace;
  }

  public static void killAWTThreads() {
    ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();

    killAWTThreads(threadGroup);
  }

  private static String getCompressedStackTrace(Throwable t, int frames_to_skip) {
    return getCompressedStackTrace(t, frames_to_skip, 200);
  }

  public static String getCompressedStackTrace(Throwable t, int frames_to_skip, int iMaxLines) {
    return getCompressedStackTrace(t, frames_to_skip, iMaxLines, true);
  }

  public static String getCompressedStackTrace(
      Throwable t, int frames_to_skip, int iMaxLines, boolean showErrString) {
    StringBuffer sbStackTrace = new StringBuffer(showErrString ? (t.toString() + "; ") : "");
    StackTraceElement[] st = t.getStackTrace();

    if (iMaxLines < 0) {
      iMaxLines = st.length + iMaxLines;
      if (iMaxLines < 0) {
        iMaxLines = 1;
      }
    }
    int iMax = Math.min(st.length, iMaxLines + frames_to_skip);
    for (int i = frames_to_skip; i < iMax; i++) {

      if (i > frames_to_skip) {
        sbStackTrace.append(", ");
      }

      String classname = st[i].getClassName();
      String cnShort = classname.substring(classname.lastIndexOf(".") + 1);

      if (Constants.IS_CVS_VERSION) {
        if (STOP_AT_INITIALIZER
            && st[i].getClassName().equals("com.aelitis.azureus.ui.swt.Initializer")) {
          sbStackTrace.append("Initializer");
          break;
        }
        // Formatted so it's clickable in eclipse
        sbStackTrace.append(st[i].getMethodName());
        sbStackTrace.append(" (");
        sbStackTrace.append(classname);
        sbStackTrace.append(".java:");
        sbStackTrace.append(st[i].getLineNumber());
        sbStackTrace.append(')');
      } else {
        sbStackTrace.append("::");
        sbStackTrace.append(st[i].getMethodName());
        sbStackTrace.append("::");
        sbStackTrace.append(st[i].getLineNumber());
      }
    }

    Throwable cause = t.getCause();

    if (cause != null) {
      sbStackTrace.append("\n\tCaused By: ");
      sbStackTrace.append(getCompressedStackTrace(cause, 0));
    }

    return sbStackTrace.toString();
  }

  public static String getStackTrace(boolean bCompressed, boolean bIncludeSelf) {
    return getStackTrace(bCompressed, bIncludeSelf, bIncludeSelf ? 0 : 1, 200);
  }

  public static String getStackTrace(
      boolean bCompressed, boolean bIncludeSelf, int iNumLinesToSkip, int iMaxLines) {
    if (bCompressed)
      return getCompressedStackTrace(
          bIncludeSelf ? 2 + iNumLinesToSkip : 3 + iNumLinesToSkip, iMaxLines);

    // bIncludeSelf not supported gor non Compressed yet
    return getStackTrace(1);
  }

  private static String getCompressedStackTrace(int frames_to_skip, int iMaxLines) {
    String trace_trace_tail = null;

    try {
      throw new Exception();
    } catch (Exception e) {
      trace_trace_tail = getCompressedStackTrace(e, frames_to_skip, iMaxLines, false);
    }

    return (trace_trace_tail);
  }

  public static void killAWTThreads(ThreadGroup threadGroup) {
    Thread[] threadList = new Thread[threadGroup.activeCount()];

    threadGroup.enumerate(threadList);

    for (int i = 0; i < threadList.length; i++) {

      Thread t = threadList[i];

      if (t != null) {

        String name = t.getName();

        if (name.startsWith("AWT")) {

          out("Interrupting thread '".concat(t.toString()).concat("'"));

          t.interrupt();
        }
      }
    }

    if (threadGroup.getParent() != null) {

      killAWTThreads(threadGroup.getParent());
    }
  }

  public static void dumpThreads(String name) {
    out(name + ":");

    ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();

    dumpThreads(threadGroup, "\t");
  }

  public static void dumpThreads(ThreadGroup threadGroup, String indent) {
    Thread[] threadList = new Thread[threadGroup.activeCount()];

    threadGroup.enumerate(threadList);

    for (int i = 0; i < threadList.length; i++) {

      Thread t = threadList[i];

      if (t != null) {

        out(
            indent
                .concat("active thread = ")
                .concat(t.toString())
                .concat(", daemon = ")
                .concat(String.valueOf(t.isDaemon())));
      }
    }

    if (threadGroup.getParent() != null) {

      dumpThreads(threadGroup.getParent(), indent + "\t");
    }
  }

  public static void dumpThreadsLoop(final String name) {
    new AEThread("Thread Dumper") {
      public void runSupport() {
        while (true) {
          Debug.dumpThreads(name);

          try {
            Thread.sleep(5000);
          } catch (Throwable e) {
            Debug.printStackTrace(e);
          }
        }
      }
    }.start();
  }

  public static void dumpSystemProperties() {
    out("System Properties:");

    Properties props = System.getProperties();

    Iterator it = props.keySet().iterator();

    while (it.hasNext()) {

      String name = (String) it.next();

      out("\t".concat(name).concat(" = '").concat(props.get(name).toString()).concat("'"));
    }
  }

  public static String getNestedExceptionMessage(Throwable e) {
    String last_message = "";

    while (e != null) {

      String this_message;

      if (e instanceof UnknownHostException) {

        this_message = "Unknown host " + e.getMessage();

      } else if (e instanceof FileNotFoundException) {

        this_message = "File not found: " + e.getMessage();

      } else {

        this_message = e.getMessage();
      }

      // if no exception message then pick up class name. if we have a deliberate
      // zero length string then we assume that the exception can be ignored for
      // logging purposes as it is just delegating

      if (this_message == null) {

        this_message = e.getClass().getName();

        int pos = this_message.lastIndexOf(".");

        this_message = this_message.substring(pos + 1).trim();
      }

      if (this_message.length() > 0 && last_message.indexOf(this_message) == -1) {

        last_message += (last_message.length() == 0 ? "" : ", ") + this_message;
      }

      e = e.getCause();
    }

    return (last_message);
  }

  public static String getNestedExceptionMessageAndStack(Throwable e) {
    return (getNestedExceptionMessage(e) + ", " + getCompressedStackTrace(e, 0));
  }

  public static String getCompressedStackTrace() {
    return (getCompressedStackTrace(new Throwable(), 1, 200, false));
  }

  /**
   * @param iMaxLines Max # of stack lines. If < 0, chops off -MaxLines entries from end
   * @return
   */
  public static String getCompressedStackTrace(int iMaxLines) {
    return (getCompressedStackTrace(new Throwable(), 1, iMaxLines, false));
  }

  public static String getExceptionMessage(Throwable e) {
    String message = e.getMessage();

    if (message == null || message.length() == 0) {

      message = e.getClass().getName();

      int pos = message.lastIndexOf(".");

      message = message.substring(pos + 1);

    } else if (e instanceof ClassNotFoundException) {

      if (message.toLowerCase().indexOf("found") == -1) {

        message = "Class " + message + " not found";
      }
    }

    return (message);
  }

  public static void printStackTrace(Throwable e) {
    printStackTrace(e, null);
  }

  public static void printStackTrace(Throwable e, Object context) {
    String header = "DEBUG::";
    header = header + new Date(SystemTime.getCurrentTime()).toString() + "::";
    String className = "?::";
    String methodName = "?::";
    int lineNumber = -1;

    try {
      throw new Exception();
    } catch (Exception f) {
      StackTraceElement[] st = f.getStackTrace();

      for (int i = 1; i < st.length; i++) {
        StackTraceElement first_line = st[i];
        className = first_line.getClassName() + "::";
        methodName = first_line.getMethodName() + "::";
        lineNumber = first_line.getLineNumber();

        // skip stuff generated by the logger

        if (className.indexOf(".logging.") != -1 || className.endsWith(".Debug::")) {

          continue;
        }

        break;
      }
    }

    diagLoggerLogAndOut(header + className + (methodName) + lineNumber + ":", true);

    try {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();

      PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos));

      if (context != null) {
        pw.print("  ");
        pw.println(context);
      }
      pw.print("  ");
      e.printStackTrace(pw);

      pw.close();

      String stack = baos.toString();

      diagLoggerLogAndOut(stack, true);
    } catch (Throwable ignore) {

      e.printStackTrace();
    }
  }

  public static String getStackTrace(Throwable e) {
    try {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();

      PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos));

      e.printStackTrace(pw);

      pw.close();

      return baos.toString();

    } catch (Throwable ignore) {
      return "";
    }
  }

  private static void diagLoggerLog(String str) {
    diag_logger.log(str);
  }

  private static void diagLoggerLogAndOut(String str, boolean stderr) {
    // handle possible recursive initialisation problems where the init of diag-logger gets
    // back here....

    if (diag_logger == null) {
      if (stderr) {
        System.err.println(str);
      } else {
        System.out.println(str);
      }
    } else {
      diag_logger.logAndOut(str, stderr);
    }
  }

  private static void diagLoggerLogAndOut(Throwable e) {
    // handle possible recursive initialisation problems where the init of diag-logger gets
    // back here....

    if (diag_logger == null) {
      e.printStackTrace();
    } else {
      diag_logger.logAndOut(e);
    }
  }

  /**
   * @param key
   * @return
   */
  public static String secretFileName(String key) {
    if (key == null) return "";

    final String sep = File.separator;
    final String regex = "([\\" + sep + "]?[^\\" + sep + "]{0,3}+)[^\\" + sep + "]*";

    String secretName = key.replaceAll(regex, "$1");
    int iExtensionPos = key.lastIndexOf(".");
    if (iExtensionPos >= 0) secretName += key.substring(iExtensionPos);
    return secretName;
  }

  public static void main(String[] args) {
    System.out.println(secretFileName("c:\\temp\\hello there.txt"));
    System.out.println(secretFileName("hello there.txt"));
  }
}