package org.opends.server.plugins.profiler;

import org.opends.messages.Message;

import java.awt.BorderLayout;

import java.awt.Container;

import java.awt.Font;

import java.io.FileInputStream;

import java.io.IOException;

import java.util.Arrays;

import java.util.HashMap;

import javax.swing.JEditorPane;

import javax.swing.JFrame;

import javax.swing.JScrollPane;

import javax.swing.JSplitPane;

import javax.swing.JTree;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.DefaultTreeSelectionModel;

import javax.swing.tree.TreePath;

import javax.swing.tree.TreeSelectionModel;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import org.opends.server.protocols.asn1.*;

import org.opends.server.util.args.ArgumentException;

import org.opends.server.util.args.ArgumentParser;

import org.opends.server.util.args.BooleanArgument;

import org.opends.server.util.args.StringArgument;

import static org.opends.messages.PluginMessages.*;

import static org.opends.messages.ToolMessages.*;

import static org.opends.server.util.StaticUtils.*;

public class ProfileViewer

implements TreeSelectionListener

{

// The root stack frames for the profile information that has been captured.

private HashMap<ProfileStackFrame,ProfileStackFrame> rootFrames;

// A set of stack traces indexed by class and method name.

private HashMap<String,HashMap<ProfileStack,Long>> stacksByMethod;

// The editor pane that will provide detailed information about the selected

// stack frame.

private JEditorPane frameInfoPane;

// The GUI tree that will be used to hold stack frame information;

private JTree profileTree;

// The total length of time in milliseconds for which data is available.

private long totalDuration;

// The total number of profile intervals for which data is available.

private long totalIntervals;

/**

public static void main(String[] args)

{

// Define the command-line arguments that may be used with this program.

BooleanArgument displayUsage;

BooleanArgument useGUI = null;

StringArgument fileNames = null;

// Create the command-line argument parser for use with this program.

Message toolDescription = INFO_PROFILEVIEWER_TOOL_DESCRIPTION.get();

ArgumentParser argParser =

new ArgumentParser("org.opends.server.plugins.profiler.ProfileViewer",

toolDescription, false);

// Initialize all the command-line argument types and register them with the

// parser.

try

{

fileNames =

new StringArgument("filenames", 'f', "fileName", true, true, true,

INFO_FILE_PLACEHOLDER.get(), null, null,

INFO_PROFILEVIEWER_DESCRIPTION_FILENAMES.get());

argParser.addArgument(fileNames);

useGUI = new BooleanArgument(

"usegui", 'g', "useGUI",

INFO_PROFILEVIEWER_DESCRIPTION_USE_GUI.get());

argParser.addArgument(useGUI);

displayUsage = new BooleanArgument(

"help", 'H', "help",

INFO_PROFILEVIEWER_DESCRIPTION_USAGE.get());

argParser.addArgument(displayUsage);

argParser.setUsageArgument(displayUsage);

}

catch (ArgumentException ae)

{

Message message =

ERR_PROFILEVIEWER_CANNOT_INITIALIZE_ARGS.get(ae.getMessage());

System.err.println(message);

System.exit(1);

}

// Parse the command-line arguments provided to this program.

try

{

argParser.parseArguments(args);

}

catch (ArgumentException ae)

{

Message message =

ERR_PROFILEVIEWER_ERROR_PARSING_ARGS.get(ae.getMessage());

System.err.println(message);

System.err.println(argParser.getUsage());

System.exit(1);

}

// If we should just display usage or versionn information,

// then print it and exit.

if (argParser.usageOrVersionDisplayed())

{

System.exit(0);

}

// Create the profile viewer and read in the data files.

ProfileViewer viewer = new ProfileViewer();

for (String filename : fileNames.getValues())

{

try

{

viewer.processDataFile(filename);

}

catch (Exception e)

{

Message message =

ERR_PROFILEVIEWER_CANNOT_PROCESS_DATA_FILE.get(filename,

stackTraceToSingleLineString(e));

System.err.println(message);

}

}

// Write the captured information to standard output or display it in a GUI.

if (useGUI.isPresent())

{

viewer.displayGUI();

}

else

{

viewer.printProfileData();

}

}

/**

public ProfileViewer()

{

rootFrames = new HashMap<ProfileStackFrame,ProfileStackFrame>();

stacksByMethod = new HashMap<String,HashMap<ProfileStack,Long>>();

totalDuration = 0;

totalIntervals = 0;

}

/**

public void processDataFile(String filename)

throws IOException, ASN1Exception

{

// Try to open the file for reading.

ASN1Reader reader = ASN1.getReader(new FileInputStream(filename));

try

{

// The first element in the file must be a sequence with the header

// information.

reader.readStartSequence();

totalIntervals += reader.readInteger();

long startTime = reader.readInteger();

long stopTime = reader.readInteger();

totalDuration += (stopTime - startTime);

reader.readEndSequence();

// The remaining elements will contain the stack frames.

while (reader.hasNextElement())

{

ProfileStack stack = ProfileStack.decode(reader);

long count = reader.readInteger();

int pos = stack.getNumFrames() - 1;

if (pos < 0)

{

continue;

}

String[] classNames = stack.getClassNames();

String[] methodNames = stack.getMethodNames();

int[] lineNumbers = stack.getLineNumbers();

ProfileStackFrame frame = new ProfileStackFrame(classNames[pos],

methodNames[pos]);

ProfileStackFrame existingFrame = rootFrames.get(frame);

if (existingFrame == null)

{

existingFrame = frame;

}

String classAndMethod = classNames[pos] + "." + methodNames[pos];

HashMap<ProfileStack,Long> stackMap =

stacksByMethod.get(classAndMethod);

if (stackMap == null)

{

stackMap = new HashMap<ProfileStack,Long>();

stacksByMethod.put(classAndMethod, stackMap);

}

stackMap.put(stack, count);

existingFrame.updateLineNumberCount(lineNumbers[pos], count);

rootFrames.put(existingFrame, existingFrame);

existingFrame.recurseSubFrames(stack, pos-1, count, stacksByMethod);

}

}

finally

{

try

{

reader.close();

} catch (Exception e) {}

}

}

/**

public ProfileStackFrame[] getRootFrames()

{

ProfileStackFrame[] frames = new ProfileStackFrame[0];

frames = rootFrames.values().toArray(frames);

Arrays.sort(frames);

return frames;

}

/**

public long getTotalIntervals()

{

return totalIntervals;

}

/**

public long getTotalDuration()

{

return totalDuration;

}

/**

public void printProfileData()

{

System.out.println("Total Intervals: " + totalIntervals);

System.out.println("Total Duration: " + totalDuration);

System.out.println();

System.out.println();

for (ProfileStackFrame frame : getRootFrames())

{

printFrame(frame, 0);

}

}

/**

private static void printFrame(ProfileStackFrame frame, int indent)

{

for (int i=0; i < indent; i++)

{

System.out.print("\t");

}

System.out.print(frame.getTotalCount());

System.out.print("\t");

System.out.print(frame.getClassName());

System.out.print(".");

System.out.println(frame.getMethodName());

if (frame.hasSubFrames())

{

for (ProfileStackFrame f : frame.getSubordinateFrames())

{

printFrame(f, indent+1);

}

}

}

/**

public void displayGUI()

{

JFrame appWindow = new JFrame("Directory Server Profile Data");

appWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);

Container contentPane = appWindow.getContentPane();

contentPane.setLayout(new BorderLayout());

contentPane.setFont(new Font("Monospaced", Font.PLAIN, 12));

String blankHTML = "<HTML><BODY><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR>" +

"</BODY></HTML>";

frameInfoPane = new JEditorPane("text/html", blankHTML);

splitPane.setBottomComponent(new JScrollPane(frameInfoPane));

String label = "Profile Data: " + totalIntervals + " sample intervals " +

"captured over " + totalDuration + " milliseconds";

DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(label, true);

ProfileStackFrame[] theRootFrames = getRootFrames();

if (theRootFrames.length == 0)

{

System.err.println("ERROR: No data available for viewing.");

return;

}

for (ProfileStackFrame frame : getRootFrames())

{

boolean hasChildren = frame.hasSubFrames();

DefaultMutableTreeNode frameNode =

new DefaultMutableTreeNode(frame, hasChildren);

recurseTreeNodes(frame, frameNode);

rootNode.add(frameNode);

}

profileTree = new JTree(new DefaultTreeModel(rootNode, true));

profileTree.setFont(new Font("Monospaced", Font.PLAIN, 12));

DefaultTreeSelectionModel selectionModel = new DefaultTreeSelectionModel();

selectionModel.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);

profileTree.setSelectionModel(selectionModel);

profileTree.addTreeSelectionListener(this);

profileTree.setSelectionPath(new TreePath(rootNode.getFirstChild()));

valueChanged(null);

splitPane.setTopComponent(new JScrollPane(profileTree));

splitPane.setResizeWeight(0.5);

splitPane.setOneTouchExpandable(true);

contentPane.add(splitPane, BorderLayout.CENTER);

appWindow.pack();

appWindow.setVisible(true);

}

/**

private void recurseTreeNodes(ProfileStackFrame parentFrame,

DefaultMutableTreeNode parentNode)

{

ProfileStackFrame[] subFrames = parentFrame.getSubordinateFrames();

if (subFrames.length == 0)

{

return;

}

for (ProfileStackFrame subFrame : subFrames)

{

boolean hasChildren = parentFrame.hasSubFrames();

DefaultMutableTreeNode subNode =

new DefaultMutableTreeNode(subFrame, hasChildren);

if (hasChildren)

{

recurseTreeNodes(subFrame, subNode);

}

parentNode.add(subNode);

}

}

/**

private String formatCount(long count, int length)

{

StringBuilder buffer = new StringBuilder(length);

buffer.append(count);

while (buffer.length() < length)

{

buffer.insert(0, ' ');

}

return buffer.toString();

}

/**

@Override

public void valueChanged(TreeSelectionEvent tse)

{

try

{

TreePath path = profileTree.getSelectionPath();

if (path == null)

{

// Nothing is selected, so we'll use use an empty panel.

frameInfoPane.setText("");

return;

}

DefaultMutableTreeNode selectedNode =

(DefaultMutableTreeNode) path.getLastPathComponent();

if (selectedNode == null)

{

// No tree node is selected, so we'll just use an empty panel.

frameInfoPane.setText("");

return;

}

// It is possible that this is the root node, in which case we'll empty

// the info pane.

Object selectedObject = selectedNode.getUserObject();

if (! (selectedObject instanceof ProfileStackFrame))

{

frameInfoPane.setText("");

return;

}

// There is a tree node selected, so we should convert it to a stack

// frame and display information about it.

ProfileStackFrame frame = (ProfileStackFrame) selectedObject;

StringBuilder html = new StringBuilder();

html.append("<HTML><BODY><PRE>");

html.append("Information for stack frame <B>");

html.append(frame.getClassName());

html.append(".");

html.append(frame.getHTMLSafeMethodName());

html.append("</B><BR><BR>Occurrences by Source Line Number:<BR>");

HashMap<Integer,Long> lineNumbers = frame.getLineNumbers();

for (Integer lineNumber : lineNumbers.keySet())

{

html.append(" ");

long count = lineNumbers.get(lineNumber);

if (lineNumber == ProfileStack.LINE_NUMBER_NATIVE)

{

html.append("&lt;native&gt;");

}

else if (lineNumber == ProfileStack.LINE_NUMBER_UNKNOWN)

{

html.append("&lt;unknown&gt;");

}

else

{

html.append("Line ");

html.append(lineNumber);

}

html.append(": ");

html.append(count);

if (count == 1)

{

html.append(" occurrence<BR>");

}

else

{

html.append(" occurrences<BR>");

}

}

html.append("<BR><BR>");

html.append("<HR>Stack Traces Including this Method:");

String classAndMethod = frame.getClassName() + "." +

frame.getMethodName();

HashMap<ProfileStack,Long> stacks = stacksByMethod.get(classAndMethod);

for (ProfileStack stack : stacks.keySet())

{

html.append("<BR><BR>");

html.append(stacks.get(stack));

html.append(" occurrence(s):");

appendHTMLStack(stack, html, classAndMethod);

}

html.append("</PRE></BODY></HTML>");

frameInfoPane.setText(html.toString());

frameInfoPane.setSelectionStart(0);

frameInfoPane.setSelectionEnd(0);

}

catch (Exception e)

{

e.printStackTrace();

frameInfoPane.setText("");

}

}

/**

private void appendHTMLStack(ProfileStack stack, StringBuilder html,

String highlightClassAndMethod)

{

int numFrames = stack.getNumFrames();

for (int i=(numFrames-1); i >= 0; i--)

{

html.append("<BR> ");

String className = stack.getClassName(i);

String methodName = stack.getMethodName(i);

int lineNumber = stack.getLineNumber(i);

String safeMethod =

(methodName.equals("<init>") ? "&lt;init&gt;" : methodName);

String classAndMethod = className + "." + methodName;

if (classAndMethod.equals(highlightClassAndMethod))

{

html.append("<B>");

html.append(className);

html.append(".");

html.append(safeMethod);

html.append(":");

if (lineNumber == ProfileStack.LINE_NUMBER_NATIVE)

{

html.append("&lt;native&gt;");

}

else if (lineNumber == ProfileStack.LINE_NUMBER_UNKNOWN)

{

html.append("&lt;unknown&gt;");

}

else

{

html.append(lineNumber);

}

html.append("</B>");

}

else

{

html.append(className);

html.append(".");

html.append(safeMethod);

html.append(":");

if (lineNumber == ProfileStack.LINE_NUMBER_NATIVE)

{

html.append("&lt;native&gt;");

}

else if (lineNumber == ProfileStack.LINE_NUMBER_UNKNOWN)

{

html.append("&lt;unknown&gt;");

}

else

{

html.append(lineNumber);

}

}

}

}

}