Abstract:
A debugging proxy can be used to manage communication between a client and a debugger or debugging component. A debugging protocol can be used by the debugging proxy to facilitate communication management. A debugging protocol can provide for asynchronous messaging, and can allow for the communication of large grain messages. A debugging protocol can also implement a priority scheme that can be used to process messages between a client and a debugger based upon a priority assigned to each message.

Description:
CLAIM TO PRIORITY  
       [0001]     The present application claims the benefit of priority under 35 U.S.C. §119(e) to U.S. Provisional Patent Application entitled “SYSTEMS AND METHODS UTILIZING A DEBUGGING PROXY”, Application No. 60/450,383, filed on Feb. 27, 2003, which application is incorporated herein by reference. 
     
    
     COPYRIGHT NOTICE  
       [0002]     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document of the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.  
       FIELD OF THE INVENTION  
       [0003]     The present invention relates to the debugging and/or editing of software code.  
       BACKGROUND  
       [0004]     Remote debugging systems are becoming evermore important for the growing Web application and Web services industry. These systems allow a developer to monitor, inspect, and control the execution of software running on a remote server. This is especially critical for diagnosing problems that show up after deploying the software, but cannot be reproduced in the local development environment.  
         [0005]     Unfortunately, most remote debugging protocols (e.g., the Java Debugging Interface (JDI)) are inefficient and resource intensive. These protocols are implemented by sending a constant stream of fine-grained information about debugging requests, state information, and events. This results in a slow and unproductive experience for developers and requires more effective communications bandwidth than is otherwise necessary. Bandwidth utilization problems are exacerbated by the fact that fine grain debugging messages may use only a small portion of the fixed size network packets used to transmit them, increasing communications overhead by transmitting many packets that are largely empty.  
         [0006]     To make matters worse, debugging protocols are designed to be synchronous, meaning a debugging client must stop and wait for the results from each request it sends before the client can send another request or continue processing. This “blocking and waiting” behavior often means the end user cannot enter their next command until the remote debugging system responds. Consequently, the user interface becomes sluggish and frustrating for the developer. This is true for both local and remote debugging.  
         [0007]     Often, the user isn&#39;t even interested in the result returned by the debugger, which immediately gets thrown away when the user enters their next command. For example, users often want to step rapidly through each line of the code to see which instructions are executed under certain conditions. With a synchronous debugging protocol, the user must wait after each step command for the debugger to return information about the new line. However, that information is discarded without being examined as soon as the user enters the next step command.  
         [0008]     These problems are more pronounced when the debugging client is a visual Integrated Development Environment (IDE). This IDE will usually generate many requests for debugging information automatically on behalf of the user, based on assumptions about the information the developer will “likely” want to inspect. Thus, when the IDE&#39;s assumptions are correct, the IDE can answer the user&#39;s most “likely” questions quickly from results cached in memory.  
         [0009]     Unfortunately, this eager method for collecting debugging information does not come without a cost, but results in more requests being sent to the debugger and ultimately more waiting for more results that never get used. Some IDEs attempt to reduce the amount of information they request. However, when the user requests a piece of information the IDE did not anticipate, the user must wait longer for the IDE to request that information from the debugger. At a minimum, the IDE may request debugging information about running application state that is immediately visible to the programmer in the IDE. For example,  FIG. 1  illustrates an IDE with the current local variables and current call stack visible. In this case, the IDE may request only information about each variable displayed in the local variables window and each frame of the call stack shown in the call stack window. However, if the user is just stepping through the executed instructions rapidly, she may never even look at these windows. Therefore, the information collected at each step is never actually used and the time and resources spent collecting this information is wasted.  
       BRIEF SUMMARY  
       [0010]     Methods in accordance with embodiments of the present inventions can improve upon existing debugging approaches by utilizing a debugging proxy. A debugging proxy can be used to manage communication between a client and a debugger or debugging component. A debugging protocol can be used by the debugging proxy to facilitate communication management. A debugging protocol can provide for asynchronous messaging, and can allow for the communication of large grain messages. A debugging protocol can also implement a priority scheme that can be used to process messages between a client and a debugger based upon a priority assigned to each message.  
         [0011]     Other features, aspects, and objects of the invention can be obtained from a review of the specification, the figures, and the claims.  
     
    
     BRIEF DESCRIPTION OF DRAWINGS  
       [0012]      FIG. 1  is an illustration of an IDE system in accordance with the prior art.  
         [0013]      FIG. 2  is an illustration of a debug proxy architecture in accordance with one embodiment of the present invention.  
     
    
     DETAILED DESCRIPTION  
       [0014]     Methods in accordance with embodiments of the present invention overcome problems with existing debugging approaches by utilizing an efficient, responsive debugging proxy. The debugging proxy manages communication between the client and the debugger. Communication with the debugger is handled using the debugger&#39;s native interfaces (e.g., JDI) allowing the debugger to be used in any context where a standard debugger exists. The proxy may be located on the same machine or even in the same process as the debugger ensuring potentially inefficient communications are completed locally without requiring network resources.  
         [0015]     Communication with a client can be handled using a new asynchronous debugging protocol that uses large grain messages. Such a protocol can also implement a priority scheme for ensuring high priority requests get answered quickly, and allowing lower priority requests to get automatically overridden (i.e., canceled) if the associated results are no longer needed by the client.  
         [0016]     A large grain, asynchronous debugging protocol can be used to manage communication between the client and the debugging proxy. Instead of sending a constant stream of fine-grained debugging messages, a client can send larger debugging messages, and can send them less frequently than would otherwise be necessary. This can result in lower overall communication requirements and more efficient use of available bandwidth. Consequently, the results of debugging requests can be available to the client faster, especially for remote debugging sessions.  
         [0017]     In addition, communications between a client and a debugging proxy can be asynchronous. Therefore, the client need not block and wait for the results of each debugging result it sends. Instead, a client can send a request and return control to the user, allowing the user to continue interacting with the client and sending commands. Therefore, the client can send several commands (e.g., step) without waiting for the results from the previous command to be returned and displayed. Results can be returned to the client asynchronously, allowing the client to update its display with the new information as that information becomes available, without disrupting the responsiveness of the debugging client to the user.  
         [0018]     In addition to implementing a course grained and asynchronous protocol, a debugging proxy can implement a priority scheme that allows faster processing of higher priority commands. Thus, commands most likely to require a fast response to the user can bypass commands that don&#39;t require as fast a response.  
         [0019]     Some higher priority debugging requests can also override, or effectively cancel, lower priority requests if there is no longer any need to complete them. For example, when a user steps into a new function, a debugging client may send a “step into” request followed by several lower priority requests, to get the values of variables in the new function scope. If the user immediately steps into another function before the values of variables are returned, the requests for those variables can be cancelled. The variables requested during the first step operation may no longer be visible in the new function scope after the second step operation. Therefore it can be safe to cancel the request instead of waiting for and ultimately discarding the results.  
         [heading-0020]     Architecture  
         [0021]      FIG. 2  depicts a system in accordance with one embodiment of the present invention. In this embodiment, the client generates requests to the debug proxy in response to the user&#39;s interaction with the user interface. Debug requests are sent from the client to the proxy using a course grained debugging protocol. The debugging proxy examines each message, determines its priority and places it on a priority queue or, for an immediate priority message, sends it directly to a worker thread. If the message is an override message, the debug proxy removes all pending requests from the priority queue that have a lower priority than the override message.  
         [0022]     In one embodiment, when the worker threads are not processing immediate priority requests, they dequeue and processes requests from the priority queue starting with the highest priority items first and working through the remaining items in reverse priority order (i.e., highest to lowest priority). For each course grained request, the proxy object creates a new worker thread, which generates the corresponding series of fine grained requests to the server conforming to the server&#39;s standard (but less efficient) debugging protocol and waits for the corresponding results. The debug proxy may create a separate worker thread for each course grained request so it can continue processing additional requests without waiting for results from previous requests.  
         [0023]     The debugging proxy may be located on the same machine as the server or even in the same process as the debugger on the server. Therefore, potentially inefficient communications governed by the server&#39;s standard debugging protocol may execute locally without requiring unnecessary communication overhead or consuming network resources.  
         [0024]     When a worker thread has all the required responses back from the server, it will aggregate the results into a single course grained message and place it in the response queue. The debugging proxy removes items from the response queue in order and sends them asynchronously to the client.  
         [0025]     The debug listener in the client listens for asynchronous results from the server and notifies the UI as it receives them. The UI may then update its display based on the new information.  
         [0026]     Some debugging requests sent to the server may result in one or more asynchronous response messages (a.k.a. events). For example, after the server receives a “set breakpoint” request it may generate an asynchronous response every time that breakpoint is encountered while running the code. The worker threads listen for asynchronous events from the server, package them into course grained messages and send them to the client in much the same way synchronous messages from the server are processed.  
         [heading-0027]     Debugging Protocol  
         [0028]     In one embodiment, the course grained, asynchronous debugging protocol consists of a series of request and response messages. In one embodiment, the messages implemented by serialized Java objects. Each of these objects contains the information needed to represent the associate request or response. Standard Java serialization rules are used to transmit the Java object over the wire. Using serialized Java objects makes it easy to add new message types to the protocol relatively quickly without having to define new wire formats for each message.  
         [heading-0029]     Debugging Message Base Class  
         [0030]     In one embodiment, each Java object representing a particular message is derived from a common base class. Therefore, each message shares some common behavior and may inherit default behavior from the base class. One such common base class is described below.  
                                                                                                                               public abstract class weblogic.debugging.packet.DebugPacket           implements           java.io.Serializable            Base class for all debugger communication packets.            Constructors   public DebugPacket( )       Methods   public int getPriority( )                Subclasses should override to specify a different           priority           Returns                Default priority for all DebugPackets,                MEDIUM_PRIORITY           public boolean overridesLowerPriorityPackets( )           Subclasses should override this method if they           override lower priority packets that may be           queued for sending.           Returns                Default - false            Fields   public static final IMMEDIATE_PRIORITY                public static final HIGH_PRIORITY           public static final MEDIUM_PRIORITY           public static final LOW_PRIORITY                      
 
         [0031]     Debugging Message Summary  
         [0032]     The following is a list of messages included in the debugging protocol in one embodiment. In one embodiment, each message includes a name, a priority (listed under “Pri”), a yes or no value indicating whether this message overrides lower priority messages previously sent (listed under “Ov”) and optional comments.  
                                           Debugging Messages   Pri   Ov   Comments                   BreakpointHitPacket   High   Yes   Sent from proxy to IDE to tell it the VM being                   debugged hit a breakpoint.       ClearAllBreakpointsRequestPacket   Immediate   No   Sent from the IDE to the proxy to remove all                   currently set breakpoints       ClearAllBreakpointsResponsePacket   Immediate   No       ClearBreakpointRequestPacket   Immediate   No   Sent from IDE to proxy to ask to remove an                   already set breakpoint       ClearBreakpointResponsePacket   Immediate   No       ClearMethodBreakpointPacket   Medium   No   Sent from the IDE to the proxy to tell it to                   remove a method breakpoint       DisconnectReconnectPacket   High   No       DisconnectRequestPacket   Immediate   Yes       DisconnectResponsePacket   High   No       DoneStartSetupPacket   High   No       DoneStopSetupPacket   High   No       ExceptionPacket   Medium   No       ExitPacket   Medium   No       GetBreakpointsRequestPacket   Medium   No       GetBreakpointsResponsePacket   Medium   No       GetFieldsRequestPacket   Medium   No       GetFieldsResponsePacket   Medium   No       GetStackFramesRequestPacket   Medium   No       GetStackFramesResponsePacket   Medium   No       GetThreadsRequestPacket   Medium   No       GetThreadsResponsePacket   Medium   No       GetValueRequestPacket   Medium   No       GetValueResponsePacket   Medium   No       GetVisibleVariablesRequestPacket   Medium   No       GetVisibleVariablesResponsePacket   Medium   No       GoRequestPacket   High   Yes       GoResponsePacket   High   Yes       InitPacket   High   Yes       PausePacket   Immediate   No       ProcessDonePacket   Low   No       SetBreakpointRequestPacket   Immediate   No   Sent from IDE to proxy to tell it to set a                   breakpoint       SetBreakpointResponsePacket   Immediate   No   Sent from the proxy in response to a                   SetBreakPointRequestPacket from the IDE.       SetConditionalBreakpointRequestPacket   Immediate   No   Request to set a conditional breakpoint, sent                   from IDE to proxy.       SetExceptionBreakpointRequestPacket   Immediate   No       SetMethodBreakpointRequestPacket   Medium   No   Sent from IDE to proxy to request a breakpoint                   be set on a method       SetMethodBreakpointResponsePacket   Medium   No   Sent from the proxy to the IDE in response to a                   SetMethodBreakpointRequestPacket       SetPropertiesRequestPacket   Immediate   No       SetPropertiesResponsePacket   Immediate   No       SetSmartDebuggingRequestPacket   High   No       SetSmartDebuggingResponsePacket   High   No       SetupPacket   Medium   No       SetValueRequestPacket   Medium   No       SetValueResponsePacket   Medium   No       StepInPacket   High   Yes       StepOutPacket   High   Yes       StepOverPacket   High   Yes                  
 
         [0033]     Debugging Message Details  
         [0034]     This section provides a detailed description of Java classes that could be used to define each of the messages above in one embodiment. Information available in each message is reflected by the fields and methods defined on each class (and its super classes) for accessing that information.  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 public class weblogic.debugging.packet.ValueResponse implements           java.io.Serializable            Constructors   public ValueResponse(                String variable,           String value,           String valueType,           boolean complex,           boolean editable)                public ValueResponse(                String variable,           String value,           String valueType,           boolean complex,           boolean editable,           int arrayLength)            Methods   public void setInterfaces(                Value val)            Fields   public_variable                public_value           public_valueType           public_complex           public_editable           public_static           public_synthetic           public_arrayLength           public_interfaces                public   class   weblogic.debugging.packet.StepOverPacket           extends                weblogic.debugging.packet.DebugPacket            Constructors   public StepOverPacket(                long threadId)            Methods   public long getThreadId( )                public int getPriority( )           public boolean overridesLowerPriorityPackets( )                public class weblogic.debugging.packet.StepOutPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public StepOutPacket(                long threadId)            Methods   public long getThreadId( )                public int getPriority( )           public boolean overridesLowerPriorityPackets( )                public class weblogic.debugging.packet.StepInPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public StepInPacket(                long threadId)            Methods   public long getThreadId( )                public int getPriority( )           public boolean overridesLowerPriorityPackets( )                public class weblogic.debugging.packet.SetValueResponsePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public SetValueResponsePacket(                String variable,           boolean success,           String currentValue)            Methods   public java.lang.String getVariable( )                public boolean wasSuccessful( )           public java.lang.String getCurrentValue( )                public class weblogic.debugging.packet.SetValueRequestPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public SetValueRequestPacket(                int frame,           long threadId,           String variable,           String newValue)            Methods   public int getFrame( )                public long getThreadId( )           public java.lang.String getVariable( )           public java.lang.String getNewValue( )                public class weblogic.debugging.packet.SetupPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public SetupPacket( )                public class weblogic.debugging.packet.SetSmartDebuggingResponsePacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public SetSmartDebuggingResponsePacket(                boolean enabled)            Methods   public boolean isEnabled( )                public int getPriority( )                public class weblogic.debugging.packet.SetSmartDebuggingRequestPacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public SetSmartDebuggingRequestPacket(                boolean enabled)            Methods   public boolean isEnabled( )                public int getPriority( )                public class weblogic.debugging.packet.SetPropertiesResponsePacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public SetPropertiesResponsePacket(                String name,           String value)            Methods   public java.lang.String getName( )                public java.lang.String getValue( )           public int getPriority( )                public class weblogic.debugging.packet.SetPropertiesRequestPacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public SetPropertiesRequestPacket(                String name,           String value)            Methods   public java.lang.String getName( )                public java.lang.String getValue( )           public int getPriority( )            public class       weblogic.debugging.packet.SetMethodBreakpointResponsePacket extends       weblogic.debugging.packet.DebugPacket                  
 
         [0035]     Sent from the proxy to the IDE in response to a SetMethodBreakpointRequestPacket  
                                                                               Constructors   public SetMethodBreakpointResponsePacket(                String className,           String method,           String[ ] params,           String status)            Methods   public java.lang.String getClassName( )                public java.lang.String getMethod( )           public java.lang.String[ ] getParams( )           public java.lang.String getStatus( )                public class           weblogic.debugging.packet.SetMethodBreakpointRequestPacket           extends weblogic.debugging.packet.DebugPacket                      
 
         [0036]     Sent from IDE to proxy to request a breakpoint be set on a method  
                                                                                                                                           Constructors   public SetMethodBreakpointRequestPacket(                String clazz,           String method,           String[ ] params,           int id,           String langExt)            Methods   public java.lang.String getClazz( )                public java.lang.String getMethod( )           public java.lang.String[ ] getParams( )           public int getId( )           public java.lang.String getLangExt( )                public class           weblogic.debugging.packet.SetExceptionBreakpointRequestPacket           extends           weblogic.debugging.packet.DebugPacket            Constructors   public                SetExceptionBreakpointRequestPacket(                String exceptionClass,           boolean caught,           boolean uncaught,           int id,           String langExt)            Methods   public java.lang.String                getExceptionClass( )           public boolean isCaught( )           public boolean isUncaught( )           public int getId( )           public java.lang.String getLangExt( )           public int getPriority( )           public java.lang.String toString( )                public class           weblogic.debugging.packet.SetConditionalBreakpointRequestPacket           extends           weblogic.debugging.packet.DebugPacket                      
 
         [0037]     Request to set a conditional breakpoint, sent from IDE to proxy. Response comes back as a SetBreakpointResponsePacket, NOT a SetConditionalBreakpointResponsePacket  
                                                                                                             Constructors   public                SetConditionalBreakpointRequestPacket(                String name,           int lineNumber,           int id,           String condition)                Methods   public java.lang.String getName( )                public int getLineNumber( )           public int getId( )           public java.lang.String getCondition( )           public int getPriority( )                public class           weblogic.debugging.packet.SetBreakpointResponsePacket           extends weblogic.debugging.packet.DebugPacket                      
 
         [0038]     Sent from the proxy in response to a SetBreakPointRequestPacket from the IDE. Contains information about success/failure to set the breakpoint.  
                                                                               Constructors   public SetBreakpointResponsePacket(                String className,           int origLine,           int actualLine,           String status,           int id)            Methods   public java.lang.String getClassName( )                public int getOriginalLine( )           public int getActualLine( )           public java.lang.String getStatus( )           public int getId( )           public int getPriority( )                public class weblogic.debugging.packet.SetBreakpointRequestPacket           extends weblogic.debugging.packet.DebugPacket                      
 
         [0039]     Sent from IDE to proxy to tell it to set a breakpoint  
                                                                                                                                 Constructors   public SetBreakpointRequestPacket(                String name,           int lineNumber,           Map props,           int id,           String langExt)            Methods   public java.lang.String getName( )                public int getLineNumber( )           public int getId( )           public java.lang.String getLangExt( )           public java.util.Map getProperties( )           public int getPriority( )           public java.lang.String toString( )                public class weblogic.debugging.packet.ProcessDonePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public ProcessDonePacket( )       Methods   public int getPriority( )                public class weblogic.debugging.packet.PausePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public PausePacket( )       Methods   public int getPriority( )                public java.lang.String toString( )                public class weblogic.debugging.packet.NetworkMap implements           java.io.Serializable                      
 
         [0040]     This class holds a map, and makes sure it serializes to a form that makes sense  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             Constructors   public NetworkMap(                Map m)            Methods   public java.util.Map getMap( )                public void setMap(                Map m)                public class weblogic.debugging.packet.InitPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public InitPacket(                int lineNumber,           String className,           String sourceFile,           int id)            Methods   public int getLineNumber( )                public java.lang.String getClassName( )           public java.lang.String getSourceFile( )           public int getId( )           public int getPriority( )           public boolean overridesLowerPriorityPackets( )                public class weblogic.debugging.packet.GoResponsePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GoResponsePacket( )       Methods   public int getPriority( )                public boolean overridesLowerPriorityPackets( )                public class weblogic.debugging.packet.GoRequestPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GoRequestPacket(                long threadId)            Methods   public long getThreadId( )                public int getPriority( )           public boolean overridesLowerPriorityPackets( )                public class           weblogic.debugging.packet.GetVisibleVariablesResponsePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GetVisibleVariablesResponsePacket(                String[ ] variables,           ValueResponse[ ] values)            Methods   public java.lang.String[ ] getVariables( )                public weblogic.debugging.packet.ValueResponse[ ] getValues( )                public class weblogic.debugging.packet.GetVisibleVariablesRequestPacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public GetVisibleVariablesRequestPacket(                int frame,           long threadId)            Methods   public int getFrame( )                public long getThreadId( )                public class weblogic.debugging.packet.GetValueResponsePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GetValueResponsePacket(                ValueResponse val)                public GetValueResponsePacket(                String variable,           String value,           String valueType,           boolean complex,           boolean editable)                public GetValueResponsePacket(                String variable,           String value,           String valueType,           boolean complex,           boolean editable,           int arrayLength)            Methods   public java.lang.String getVariable( )                public java.lang.String getValue( )           public java.lang.String getValueType( )           public boolean isComplex( )           public boolean isEditable( )           public boolean isArray( )           public int getArrayLength( )           public java.lang.String toString( )           public weblogic.debugging.packet.ValueResponse getValueResponse( )                public class weblogic.debugging.packet.GetValueRequestPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GetValueRequestPacket(                int frame,           long threadId,           String variable)            Methods   public int getFrame( )                public long getThreadId( )           public java.lang.String getVariable( )           public java.lang.String toString( )                public class weblogic.debugging.packet.GetThreadsResponsePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GetThreadsResponsePacket(                long[ ] ids,           String[ ] names,           StackFrameInfo[ ][ ] callStacks)            Methods   public long[ ] getIds( )                public java.lang.String[ ] getNames( )           public weblogic.debugging.comm.StackFrameInfo[ ][ ] getCallStacks( )                public class weblogic.debugging.packet.GetThreadsRequestPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GetThreadsRequestPacket( )                public class weblogic.debugging.packet.GetStackFramesResponsePacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public GetStackFramesResponsePacket(                StackFrameInfo[ ] stackFrames,           long threadId)            Methods   public weblogic.debugging.comm.StackFrameInfo[ ] getStackFrames( )                public long getThreadId( )                public class weblogic.debugging.packet.GetStackFramesRequestPacket           extend weblogic.debugging.packet.DebugPacket            Constructors   public GetStackFramesRequestPacket( )                public class weblogic.debugging.packet.GetFieldsResponsePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GetFieldsResponsePacket(                String variable,           String[ ] fields,           ValueResponse[ ] fieldValues)            Methods   public java.lang.String getVariable( )                public java.lang.String[ ] getFields( )           public weblogic.debugging.packet.ValueResponse[ ] getValues( )                public class weblogic.debugging.packet.GetFieldsRequestPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public GetFieldsRequestPacket(                int frame,           long threadId,           String variable)            Methods   public int getFrame( )                public long getThreadId( )           public java.lang.String getVariable( )                public class weblogic.debugging.packet.GetBreakpointsResponsePacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public GetBreakpointsResponsePacket(                String[ ] breakpoints)            Methods   public java.lang.String[ ] getBreakpoints( )                public class weblogic.debugging.packet.GetBreakpointsRequestPacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public GetBreakpointsRequestPacket( )                public class weblogic.debugging.packet.ExitPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public ExitPacket( )                public class weblogic.debugging.packet.ExceptionPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public ExceptionPacket(                int lineNumber,           String methodName,           String fileName,           String message,           String[ ] stackFrames)            Methods   public int getLineNumber( )                public java.lang.String getMethodName( )           public java.lang.String getFileName( )           public java.lang.String getMessage( )           public java.lang.String[ ] getStackFrames( )                public class weblogic.debugging.packet.DoneStopSetupPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public DoneStopSetupPacket( )       Methods   public int getPriority( )                public class weblogic.debugging.packet.DoneStartSetupPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public DoneStartSetupPacket( )       Methods   public int getPriority( )                public class weblogic.debugging.packet.DisconnectResponsePacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public DisconnectResponsePacket( )       Methods   public int getPriority( )                public class weblogic.debugging.packet.DisconnectRequestPacket extends           weblogic.debugging.packet.DebugPacket            Constructors   public DisconnectRequestPacket( )       Methods   public int getPriority( )                public boolean overridesLowerPriorityPackets( )                public class weblogic.debugging.packet.DisconnectReconnectPacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public DisconnectReconnectPacket( )       Methods   public int getPriority( )                public abstract class weblogic.debugging.packet.DebugPacket implements           java.io.Serializable            Base class for all   debugger communication packets.       Constructors   public DebugPacket( )       Methods   public int getPriority( )                Subclasses should override to specify a different priority           Returns                Default priority for all DebugPackets, MEDIUM_PRIORITY                public boolean overridesLowerPriorityPackets( )           Subclasses should override if they invalidate old           data that may be queued for sending.           Returns                Default - false            Fields   public static final IMMEDIATE_PRIORITY                public static final HIGH_PRIORITY           public static final MEDIUM_PRIORITY           public static final LOW_PRIORITY                public   class   weblogic.debugging.packet.ClearMethodBreakpointPacket                extends weblogic.debugging.packet.DebugPacket                      
 
         [0041]     Sent from the IDE to the proxy to tell it to remove a method breakpoint  
                                                                     Constructors   public ClearMethodBreakpointPacket( )                public class           weblogic.debugging.packet.ClearBreakpointResponsePacket           extends weblogic.debugging.packet.DebugPacket            Constructors   public ClearBreakpointResponsePacket( )       Methods   public int getPriority( )                public class           weblogic.debugging.packet.ClearBreakpointRequestPacket           extends weblogic.debugging.packet.DebugPacket                      
 
         [0042]     Sent from IDE to proxy to ask to remove an already set breakpoint  
                                                                                                                       Constructors   public ClearBreakpointRequestPacket(                String className,           int line,           int id)            Methods   public int getId( )                public java.lang.String getClassName( )           public int getLine( )           public int getPriority( )            Fields   public_id                public_className           public_line                public class           weblogic.debugging.packet.ClearAllBreakpointsResponsePacket           extends           weblogic.debugging.packet.DebugPacket            Constructors   public ClearAllBreakpointsResponsePacket( )       Methods   public int getPriority( )                public class           weblogic.debugging.packet.ClearAllBreakpointsRequestPacket           extends weblogic.debugging.packet.DebugPacket                      
 
         [0043]     Sent from the IDE to the proxy to remove all currently set breakpoints  
                                                 Constructors   public ClearAllBreakpointsRequestPacket( )       Methods   public int getPriority( )                public class weblogic.debugging.packet.BreakpointHitPacket extends           weblogic.debugging.packet.DebugPacket                      
 
         [0044]     Sent from proxy to IDE to tell it the VM being debugged hit a breakpoint. Includes relevant information that will likely be displayed in the IDE.  
                                                                                         Constructors   public BreakpointHitPacket(                int lineNumber,           String className,           String sourceFile,           int id,           String message,           long threadId)                Methods   public int getLineNumber( )                public java.lang.String getClassName( )           public java.lang.String getSourceFile( )           public int getId( )           public int getPriority( )           public boolean overridesLowerPriorityPackets( )           public java.lang.String getMessage( )           public long getThreadId( )           public java.lang.String toString( )                      
 
 Priority Queue 
 
         [0046]     In one embodiment, a debugging proxy can use a priority queue. A priority queue can be implemented using several individual queues, such as one for each available priority. When a new request message arrives from the client, the debugging proxy can examine its priority and places the message on the corresponding queue. If the message is an override message, the debugging proxy can remove all the messages from each queue with a lower priority number than the override message.  
         [0047]     Worker threads can process messages with immediate priority first. Then, the threads can begin checking for messages in the queues. Worker threads can check the highest priority queue first. If there is at least one message in the highest priority queue (e.g., HIGH), the worker threads can remove and process the message on the front of that queue. If the highest priority queue is empty, the worker threads can check the next highest priority queue (e.g., MEDIUM). If there is at least one message on the next highest priority queue, the worker threads can remove the message on the front of the queue and process that message. This process can continue in reverse priority order (i.e., highest priority to lowest priority) as long as the debugging proxy is running. If all queues are empty, the worker threads can continue checking starting again with the highest priority queue and working down to the lowest.  
         [0048]     In one embodiment, message priorities are assigned statically based on message type. In another embodiment, message priorities may be assigned dynamically based on information that changes at run-time. For example, messages requesting information currently visible in the IDE or that the user has examined frequently may be given higher priority than messages requesting information that is not currently visible or has been accessed less frequently. In this embodiment, the client may be given an API for adjusting the default priorities of some messages.  
         [heading-0049]     Debugging Communication Infrastructure  
         [0050]     This section contains details of an exemplary communication infrastructure that can be used to send and receive debugging messages in one embodiment. A client can use a AsyncSocketComm class to send requests to and accept responses from the proxy. The proxy may use the PriorityComm class to accept requests from and generate responses back to the client. Requests accepted by PriorityComm may implement the priority scheme described above.  
         [0051]     If the proxy is located in the same process space as the debugger on the server, it may use the InProcComm to send requests to and receive responses from the debugger on the server without incurring the cost of network communications. If the proxy is not located on the server, it may use ServerSocketComm to communicate with the server. It may also use ServerSocketCommAsync to communicate with the server e.g. for receiving asynchronous events from the server such as “Hit breakpoint” messages.  
         [0052]     Communications Package Summary  
                                         Interface Summary                                CommTransport   This interface defines           the communication           methods used.       DebugCommands   The DebugCommands           interface is the           interface that defines           the debugging commands           going from the UI           portion of the debugger,           to the debug proxy.       DebugConstants   The DebugConstants           interface is an           interface that           DebugCommands and           DebugEvents derive           from.       DebugEvents   The DebugEvents           interface is the           interface that           defines the debugging           events that come from           the proxy to the IDE.       IDebuggableLanguage   A scripting engine           must implement this           interface in order           to be able to set           itself up to debug           in the KNEX framework.       IDebuggableLanguage.IBreakpointInfo       IDebuggableLanguage.IComplexScriptValue       IDebuggableLanguage.IJavaValue       IDebuggableLanguage.IOtherLanguageValue       IDebuggableLanguage.IScriptArrayValue       IDebuggableLanguage.IScriptFrame       IDebuggableLanguage.IScriptValue       IDebuggableLanguage.ISimpleScriptValue       IScriptContextHolder   This interface is used           to get a context object           for a given frame.       IScriptController   The script controller           will be an object that           interoperates with the           scripting languages to           bring you script debugging.       ServerCommands   The ServerCommands           interface is the           interface that defines           the debugging commands           going from the KNEX           Server to the proxy.       ServerEvents   The ServerEvents           interface is the           interface that defines           the debugging events           that come from the           KNEX Server to the Proxy.                  
 
 Communications Package Details 
 
         [0054]     This section describes details of the classes, interfaces and exceptions listed above.  
                                                                                                                   public class weblogic.debugging.comm.TransportTimeoutException extends                weblogic.debugging.comm.TransportException            Constructors   public TransportTimeoutException( )                public TransportTimeoutException(                String str)                public TransportTimeoutException(                Exception e)            public   class   weblogic.debugging.comm.TransportException       extends            java.io.IOException                  
 
         [0055]     This is the root exception thrown for transport errors  
                                                                                                   Constructors   public TransportException( )                public TransportException(                String str)                public TransportException(                Exception e)            Methods   public java.lang.Exception getPreviousException( )       Fields   protected_e                public class weblogic.debugging.comm.StackFrameInfo implements           java.io.Serializable                      
 
         [0056]     Simple data holder for a stack frame in the VM that&#39;s being debugged  
                                                                                                                                                                                                               Constructors   public StackFrameInfo(                String className,           String sourceName,           String methodName,           int lineNumber,           int frameIndex)            Methods   public java.lang.String getClassName( )                public java.lang.String getSourceName( )           public java.lang.String getMethodName( )           public int getLineNumber( )           public int getFrameIndex( )           public java.lang.String[ ] getVariables(                ThreadReference tr,           Object sfh)                public ObjectReference getThis(                ThreadReference tr,           Object sfh)            Fields   protected_className                protected_sourceName           protected_methodName           protected_lineNumber           protected_javaFrameIndex                public class weblogic.debugging.comm.SocketCommException           extends           weblogic.debugging.comm.TransportException            Constructors   public SocketCommException( )                public SocketCommException(                String s)                public SocketCommException(                Exception e)                public   class   weblogic.debugging.comm.SocketComm                implements           weblogic.debugging.comm.CommTransport                      
 
         [0057]     SocketComm is Transport class that will transport over TCP  
                                                                                                                                           Constructors   public SocketComm( )       Methods   public void accept(                ServerSocket ss)                If this SocketComm is being used on a server           socket, this method will wait until a           client opens           a connection with it. Then it will initialize           this class to send and recive off of that socket.           public void attach(                String serverName,           int socketNum)                If this SocketComm is initiating communication with           another process, this method will attach           to the other process and initialize the SocketComm           to start to send a recieve off that socket.           protected boolean isPacketAvailable( )           public weblogic.debugging.packet.DebugPacket           getPacket( )           public weblogic.debugging.packet.DebugPacket           getPacket(                int timeout)                public void sendPacket(                DebugPacket packet)                public void close( )           public java.net.Socket getSocket( )           protected final boolean Log(                String str)                public class           weblogic.debugging.comm.ServerSocketCommAsync           implements           weblogic.debugging.comm.CommTransport, java.lang.Runnable                      
 
         [0058]     ServerSocketCommAsync is a class that will use a SocketComm for sending and receiving requests, but has another thread that is doing the actual sends/receives and queuing them to a buffer. This other thread will hang out and wait on a ServerSocket, until it can party on that socket.  
                                                                                                                                         Constructors   public ServerSocketCommAsync( )       Methods   public void setServerSocket(                ServerSocket ssT)                If this SocketComm is being used on a server           socket, this method will wait until a client           opens           a connection with it. Then it will initialize this           class to send and recive off of that socket.           public weblogic.debugging.packet.DebugPacket           getPacket(                int timeout)                public void sendPacket(                DebugPacket packet)                public void reset( )           public void close( )           public void run( )           public weblogic.debugging.packet.DebugPacket           getPacket( )                public   class                weblogic.debugging.comm.ServerSocketComm   implements                weblogic.debugging.comm.CommTransport                      
 
         [0059]     ServerSocketCommAsync is a class that will use a SocketComm for sending and reciving requests, but has another thread that is doing the actual sends/recieves and queuing them to a buffer. This other thread will hang out and wait on a ServerSocket, until it can party on that socekt.  
                                                                                                                                 Constructors   public ServerSocketComm( )       Methods   public void setServerSocket(                ServerSocket ssT)                If this SocketComm is being used on a server socket,           this method will wait until a client opens           a connection with it. Then it will initialize this           class to send and recive off of that socket.           public weblogic.debugging.comm.SocketComm           getSocketComm( )           public void accept( )           public weblogic.debugging.packet.DebugPacket           getPacket(                int timeout)                public void sendPacket(                DebugPacket packet)                public void reset(                boolean fClose)                public void close( )           public weblogic.debugging.packet.DebugPacket           getPacket( )                public interface weblogic.debugging.comm.ServerEvents                      
 
         [0060]     The ServerEvents interface is the interface that defines the debugging events that come from the KNEX Server to the Proxy. This will also define the events that come from the different languages to the Proxy. These same interfaces will be used to talk from the Proxy to the different languages.  
                                                                             Methods   public void initDone( )                public void requestLanguagePacket( )           requests information about the languages currently           loaded on the server.           public void pushRequestDone( )           sends a message to the script engine saying we&#39;ve           processed it&#39;s request.                public   class   weblogic.debugging.comm.ServerController                implements           weblogic.debugging.comm.ServerCommands,           weblogic.debugging.comm.ServerEvents                      
 
         [0061]     The ServerController is the major piece of code that goes between the proxy and the KNEX server. This code will be shared by the  
                                                                                                                                                                                                                                                                                           Constructors   public ServerController(                CommTransport transport)            Methods   public weblogic.debugging.comm.CommTransport setTransport(                CommTransport transport)                public void close( )           public void processNextEvent(                ServerEvents serverEvents)                public void init(                String serverName,           boolean fNeedsResponse)                public void operationDone( )           public void shutdown( )           public void scriptStart( )           public void scriptStop( )           public void processNextCommand(                ServerCommands serverCommands)                processNextCommand will get the next command from the           CommTransport, and call into the           appropriate function in the Server&#39;s DebugCommands interface.           This is called by the Debug           Engine code.           public static void processCommand(                DebugPacket packet,           ServerCommands serverCommands)                public void initDone( )           public void pushRequestDone( )           public void requestLanguagePacket( )           requests information about the languages currently loaded on the server.                public   class   weblogic.debugging.comm.ServerConnectInfo           extends                weblogic.debugging.comm.ConnectInfo            groks all the info about creating a connection from the proxy to the KNEX Server.            Constructors   public ServerConnectInfo( )       Methods   public void processCmdLineArgs(                String[ ] args)                public weblogic.debugging.comm.CommTransport createTransport( )           public weblogic.debugging.comm.CommTransport createClientTransport( )           public void printUsage1(                StringBuffer buff)                Prints the Commandline params we understand here. This will           only print the usage that           should appear on the first line of the usage. param buff --           This is the string buffer to append           usage info into.           public void printUsage2(                StringBuffer buff)                Prints the Commandline params we understand here. This will           only print the usage that           should appear in the body of the usage. param buff --           This is the string buffer to append           usage info into.            Fields   public static final default Port                public interface weblogic.debugging.comm.ServerCommands implements           weblogic.debugging.comm.DebugConstants                      
 
         [0062]     The ServerCommands interface is the interface that defines the debugging commands going from the KNEX Server to the proxy. These same interfaces will be used to talk from the Proxy to the different languages.  
                                                                                                 Methods   public void init(                String serverName,           boolean fNeedsResponse)                Sends an initialization packet to the proxy.           public void operationDone( )           Sends a message telling the proxy the current web operation           has completed. There may very           possibly be another operation in the process of           completing at this point.           public void shutdown( )           Sends a message to the proxy telling it to shut itself down.           This is not the same thing as           detaching for the Server, this will actually close the process.           public void scriptStart( )           public void scriptStop( )                public   class                weblogic.debugging.comm.ScriptStackFrameInfo   extends                weblogic.debugging.comm.StackFrameInfo                      
 
         [0063]     This holds the proper stack information for a stack that is translated from script  
                                                                                                                                                                                                                                                                         Constructors   public ScriptStackFrameInfo(                String className,           String sourceName,           String methodName,           int lineNumber,           String langExt,           ObjectReference contextObject,           int stackIndex,           int javaStackIndex,           ProxyScriptEngine pse)            Methods   public ObjectReference getContextObject( )                public java.lang.String getLanguageExtension( )           public int getStackIndex( )           public void setServerInfo(                ArrayReference a)                public java.lang.String[ ] getVariables(                ThreadReference tr,           Object sfhObj)                public ObjectReference getThis(                ThreadReference tr,           Object sfhObj)                public Value getLocalVariable(                String name,           ThreadReference tr)                public Value setVariable(                String name,           String strNewVal,           ThreadReference tr)                public   class   weblogic.debugging.comm.PriorityQueue           extends                weblogic.debugging.utils.SynchQueue            Methods   public synchronized java.lang.Object getObject(                int timeout)                public synchronized void putObject(                Object o,           int priority,           boolean clearLesser)                public synchronized java.lang.Object[ ] getAllObjects( )           This gets all the Objects in the array that are not           already promised to a waiter and returns           them in an Array. Note, that this will take the           highest priority bunch, which means that if you           call this while other threads are using the Queue,           this call will tend to get the high priority           items rather than the other threads.                public   class   weblogic.debugging.comm.PriorityComm           extends                weblogic.debugging.comm.AsyncCommBase                      
 
         [0064]     This class wraps other CommTransports, then when a message comes in off another transport, this will check it&#39;s priority, and if the priority is the highest, it will execute it immediately. Otherwise, it will pass it along like normal. NOTE: Although this extends AsyncSocketComm, it does not have to communicate via Sockets  
                                                                                                                                                           Methods   protected void processInput(                DebugPacket packet)                public   class                weblogic.debugging.comm.JspStackFrameInfo   extends           weblogic.debugging.comm.JavaStackFrameInfo            Constructors   public JspStackFrameInfo(                String className,           String methodName,           int lineNumber,           int javaFrameIndex,           Notify notify,           ThreadReference thread)            Methods   public java.lang.String getSourceName( )                public void setCorrectedFrameIndex(           int i)                public   class                weblogic.debugging.comm.JavaStackFrameInfo   extends                weblogic.debugging.comm.StackFrameInfo                      
 
         [0065]     Simple data holder for a stack frame in the VM that&#39;s being debugged  
                                                                                                   Constructors   public JavaStackFrameInfo(                String className,           String sourceName,           String methodName,           int lineNumber,           int javaFrameIndex)            Methods   public java.lang.String[ ] getVariables(                ThreadReference tr,           Object sfh)                public ObjectReference getThis(                ThreadReference tr,           Object sfh)                public interface weblogic.debugging.comm.IScriptController                      
 
         [0066]     The script controller will be an object that interoperates with the scripting languages to bring you script debugging. The way this will work is each language engine will have an instance of the IScriptController, and the IScriptController will have list of all the IDebuggableLanguage interfaces.  
                                                                                                                                                                                                                                                                                                                                                   Methods   public weblogic.debugging.comm.IScriptController.LanguageInfo[ ] getLanguages( )                returns a list that contains LanguageInfo. There will be one for each language.           public int Break( )           This is what a running script will call when it wants to break. This is a waiting call, that will not           return until the thread has been told to continue. The frames parameter should be a list of           IDebuggableLanguage$IScriptFrame .           Parameters                frames - - should be the frame list for the current script context.                Returns                the return value tells the scripting engine what command resumed the break.                public int Pause(                int pauseID)                this is what the scripting lanuguage calls when it&#39;s time to pause itself.           Returns                the return value tells the scripting engine what command resumed the pause.                public boolean StartScript( )           This is what a script engine must call when starting execution. This is how the engine will           know if the thread is currently in the middle of a step or not.           Returns                the return value tells the scripting engine what kind of execution we are in the middle                of.           public boolean ResumeScript( )           This is what a script engine must call when resuming execution. This is how the engine will           know if the thread is currently in the middle of a step or not.           Returns                the return value tells the scripting engine what kind of execution we are in the middle                of.           public weblogic.debugging.comm.IDebuggableLanguage.IScriptValue           processScriptValue(                IDebuggableLanguage.IScriptValue value)                processes an IScriptValue by passingit off to the script engine that knows about it, then it will           return a new IScritpValue that knows more about that value.           public void breakpointProcessed(                IDebuggableLanguage.IBreakpointInfo bpi)                This tells the script controller that a breakpoint that was previously un-resolvable has now           been resolved.           public weblogic.debugging.comm.IDebuggableLanguage.IScriptFrame[ ] getStack(                String langExt,           Object context)                This gets the stack frames for the script language specified, using the context specified.           Parameters                langExt - -- This is the language extension for the language we are inspecting.           context - -- This is the language context we are investigating.                Returns                an array of the stackframes this yeilds.            Fields   public static final RESUME_CONTINUE                public static final RESUME_STEP_IN           public static final RESUME_STEP_OUT           public static final RESUME_STEP_OVER           public static final RESUME_STOP                public static class           weblogic.debugging.comm.IScriptController.LanguageInfo implements           java.io.Serializable            Constructors   public IScriptController.LanguageInfo(                String languageName,           String[ ] languageExtensions,           String[ ] languageFilters,           String[ ] contextHolders)            Fields   public final_languageName                public final_languageExtensions           public final_languageFilters           public final_contextHolders           public transient_lang                public interface weblogic.debugging.comm.IScriptContextHolder                      
 
         [0067]     This interface is used to get a context object for a given frame. The way this will work is that the Proxy will go down the stack frame, looking for objects that derive from IScriptContextHolder. When it comes across such a class, it will get the context from the frame and pass it to the DebugScriptController. It is possible for many script frames to all have the same context. In this case, the frame will only get passed to the DebugScriptController once.  
                                                                                                                                                                                       Methods   public java.lang.Object getContext( )            public class weblogic.debugging.comm.InProcMedium            Constructors   public InProcMedium( )       Methods   public void close( )                public   class   weblogic.debugging.comm.InProcComm                implements           weblogic.debugging.comm.CommTransport            Constructors   public InProcComm(                SynchQueue in,           SynchQueue out)            Methods   public weblogic.debugging.packetDebug.Packet                getPacket(                int timeout)                public void sendPacket(                DebugPacket packet)                public void close( )           public weblogic.debugging.packetDebug.Packet           getPacket( )           protected final boolean Log(                String str)                public interface weblogic.debugging.comm.IDebuggableLanguage                      
 
         [0068]     A scripting engine must implement this interface in order to be able to set itself up to debug in the KNEX framework.  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             Methods   public void exit( )                This will be called when we are ending.           Problem is that this will not get called in the case of           system crashes, etc.           public java.lang.String[ ] LanguageFilters( )           This is a list of the classes we should filter to prevent           from showing up in the stack. You will           be able to use wild cards, such as org.mozilla.rhino.*           public java.lang.String[ ] ContextHolders( )           This is a list of the class instances that we can get a           script context from.           public java.lang.String LanguageName( )           This is a list of the class instances that we can call into           to get variable information, etc. When           walking through a stack trace, we will go to each of these           to ask it to spit out it&#39;s stack. We will           furthermore. When a user inspects this part of the stack,           we will also ask these objects for           variable values, etc.           public java.lang.String[ ] LanguageExtensions( )           This is a list of the class instances that we can call into           to get variable information, etc. When           walking through a stack trace, we will go to each of these           to ask it to spit out it&#39;s stack. We will           furthermore. When a user inspects this part of the stack,           we will also ask these objects for           variable values, etc.           public boolean featureEnabled(                String feature)                This function is used for determining what features this           debug engine supports.           public boolean pause(                Object context,           int pauseID)                When pause is called, it is up to the script engine to break           at the next possible place. This           method can be called while the engine is in teh middle of           processing, so should be treated as           a synchronized.           public weblogic.debugging.comm.IDebuggableLanguage.IScriptValue getVariable(                Object context,           String strVar,           int stackFrame)                public void setVariable(                Object context,           String strVar,           IDebuggableLanguage.IScriptValue value,           int stackFrame)                public weblogic.debugging.comm.IDebuggableLanguage.IScriptValue processValue(                IDebuggableLanguage.IScriptValue value)                public   weblogic.debugging.comm.IDebuggableLanguage.IScriptValue           processExpression(                Object context,           String strExpr,           int stackFrame)                public weblogic.debugging.comm.IDebuggableLanguage.IScriptFrame[ ] getStack(                Object context)                public   weblogic.debugging.comm.IDebuggableLanguage.IBreakpointInfo                setSourceBreakpoint(                String clazz,           int line,           int id)                public   weblogic.debugging.comm.IDebuggableLanguage.IBreakpointInfo                setMethodBreakpoint(                String clazz,           String method,           String[ ] params,           int id)                public   weblogic.debugging.comm.IDebuggableLanguage.IBreakpointInfo           setWatchpoint(                String clazz,           String varName,           boolean fStopOnRead,           boolean fStopOnWrite,           int id)                public void clearBreakpoint(                int id)                public void clearAllBreakpoints( )            Fields   public static final EXPRESSION_SUPPORT                public static final SOURCE_BREAKPOINT_SUPPORT           public static final METHOD_BREAKPOINT_SUPPORT           public static final WATCH_POINT_SUPPORT           public static final INVALID_PAUSEID                public static interface           weblogic.debugging.comm.IDebuggableLanguage.IScriptValue            Methods   public java.lang.String getValue( )                This gets the value we should display to the user.           public java.lang.String getTypeName( )           If this is a language that supports types, this should return the type name of this variable.           public void setValue(                String val)                This is the value the user typed in, it&#39;s up to the script           engine to turn this into a value.           public int getAbstractType( )           This determines if the variable is a complex type, simple type or other languagy type.            Fields   public static final SIMPLE_TYPE                public static final COMPLEX_TYPE           public static final SCRIPT_ARRAY_TYPE           public static final OTHER_LANGUAGE_TYPE           public static final JAVA_LANGUAGE_TYPE                public static interface           weblogic.debugging.comm.IDebuggableLanguage.ISimpleScriptValue           implements weblogic.debugging.comm.IDebuggableLanguage.IScriptValue            Methods   public int getPrimativeType( )                public boolean getBoolean( )           public byte getByte( )           public char getChar( )           public double getDouble( )           public float getFloat( )           public int getInt( )           public long getLong( )           public short getShort( )           public java.lang.String getString( )            Fields   public static final TYPE_BOOLEAN                public static final TYPE_BYTE           public static final TYPE_CHAR           public static final TYPE_DOUBLE           public static final TYPE_FLOAT           public static final TYPE_INT           public static final TYPE_LONG           public static final TYPE_SHORT           public static final TYPE_STRING           public static final TYPE_NULL                public static interface           weblogic.debugging.comm.IDebuggableLanguage.IScriptArrayValue           implements weblogic.debugging.comm.IDebuggableLanguage.IScriptValue            Methods   public int getLength( )                public weblogic.debugging.comm.IDebuggableLanguage.IScriptValue getElement(                int i)                public static interface           weblogic.debugging.comm.IDebuggableLanguage.IComplexScriptValue           implements weblogic.debugging.comm.IDebuggableLanguage.IScriptValue            Methods   public java.util.List getMembers( )                if this is a complex type, this will return a list of all it&#39;s members.           public weblogic.debugging.comm.IDebuggableLanguage.IScriptValue getMember(                String name)                if this is a complex type, this will return a member of it.           public void setMember(                String name,           IDebuggableLanguage. IScriptValue val)                if this is a complex type, this will return a member of it.           public weblogic.debugging.comm.IDebuggableLanguage.IScriptValue callMethod(                String name,           IDebuggableLanguage.IScriptValue[ ] values)                calls a method on the comlex type. If the method is a void           method, it should return a null.           Otherwise, callMethod should return a scriptValue representing           the returned value. If that           value is null, this will be a ScriptValue with the value null.                public static interface           weblogic.debugging.comm.IDebuggableLanguage.IOtherLanguageValue           implements weblogic.debugging.comm.IDebuggableLanguage.IScriptValue            Methods   public java.lang.String getScriptExtension( )                script extension for this variable.           public java.lang.Object getValueObject( )           gets the underlying value object. The other scripting language should be able to figure out           what this is to be able to create one of the other Script values from this.                public static interface                weblogic.debugging.comm.IDebuggableLanguage.IJavaValue   implements           weblogic.debugging.comm.IDebuggableLanguage.IScriptValue            Methods   public java.lang.Object getValueObject( )                gets the underlying java object. The proxy will be able to disect this and keep values, etc for           this.                public static interface           weblogic.debugging.comm.IDebuggableLanguage.IScriptFrame            Methods   public java.lang.String getLanguageExtension( )                This will get the file extension specifying what language this is. If a language supports more           than one file extension, this will just be one.           public java.lang.String getFunctionName( )           If this returns non-null, this string will be used to display the stack frame to the user.           public java.lang.String getClassName( )           This is the class name that we will derive the file from. This will be put through the document           resolution process on the ide.           public java.lang.String getFileName( )           This is the class name that we will derive the file from. This will be put through the document           resolution process on the ide.           public int getLine( )           This is the line of execution the current frame is on.           public java.util.List getFrameVariables( )           This function will return an array of all the values visible from the current stack. All the values           in the list that are returned will be of type Strong. To get a value, you will want to call           IDebuggableLanguage.getVariable           public weblogic.debugging.comm.IDebuggableLanguage.IScriptValue getThis( )           This function will return an IScriptValue if there is a this object, otherwise it will return null.                public static interface           weblogic.debugging.comm.IDebuggableLanguage.IBreakpointInfo            Methods   public java.lang.String getStatus( )                public int getOrigLine( )           public int getCurrLine( )           public int getId( )            Fields   public static final BREAKPOINT_RESOLVED                public static final BREAKPOINT_UNRESOLVED           public static final BREAKPOINT_ERROR                public class weblogic.debugging.comm.DisconnectReconnectException           extends weblogic.debugging.comm.TransportException            Constructors   public DisconnectReconnectException( )                public   class   weblogic.debugging.comm.DebugKillException   extends                java.lang.Throwable                      
 
         [0069]     This is an exception that can be used to kill threads in Weblogic  
                                                                 Constructors   public DebugKillException( )                public class weblogic.debugging.comm.DebugInfo                      
 
         [0070]     This class keeps track of the info we need to be able to attach to JDI on another process.  
                                                                                                                                                                                                                 Constructors   public DebugInfo(                String server,           int port)                public DebugInfo(                String MapName)                public DebugInfo(                ListeningConnector listener,           String address)            Methods   public void processCmdLineArgs(                String[ ] args)                public void printUsage1(                StringBuffer buff)                Prints the Commandline params we understand here.           This will only print the usage that           should appear on the first line of the usage. param           buff -- This is the string buffer to append           usage info into.           public void printUsage2(                StringBuffer buff)                Prints the Commandline params we understand here.           This will only print the usage that           should appear in the body of the usage. param           buff -- This is the string buffer to append           usage info into.           public void setMaxRetries(                int retries)                public static synchronized java.lang.String           getNewMapName( )           public static synchronized int getNewPort( )           public java.lang.String getTransportType( )           public int getPort( )           public java.lang.String getMapName( )           public java.lang.String getDebugArguments( )           This function will get the Debug Commandline           arguements needed to start a Java VM           public VirtualMachine AttachToVm( )            Fields   public static final KEY                public static final DefaultServer           public static final DefaultPort           public static SharedMemory           public static Sockets           public static ListeningConnector           public static PassedVM           protected static baseTemp           protected static baseCounter           protected static lastPort           protected transportType           protected port           protected server           protected listener           protected vm                public interface weblogic.debugging.comm.DebugEvents                      
 
         [0071]     The DebugEvents interface is the interface that defines the debugging events that come from the proxy to the IDE. This will also define the events that come from the different languages to the Proxy. These same interfaces will be used to talk from the Proxy to the different languages  
                                                                                                                                                                                                                                                                                                                     Methods   public void setup( )                public void exit( )           public void breakHit(                int lineNumber,           String className,           String sourceFile,           int id,           String message,           long threadId)                public void processDone( )           public void getValueDone(                ValueResponse value)                public void setValueDone(                String variable,           boolean success,           String currentValue)                public void requestFieldsDone(                String variable,           String[ ] fields,           ValueResponse[ ] fieldValues)                public void requestBreakpointsDone(                String[ ] breakpoints)                public void requestStackFramesDone(                StackFrameInfo[ ] frames,           long threadId)                public void requestVisibleVariablesDone(                String[ ] variables,           ValueResponse[ ] values)                public void goDone( )           public void setBreakpointDone(                String className,           int origLine,           int actualLine,           String status,           int id)                public void breakMethodResolved(                String className,           String method,           String[ ] params,           String status)                public void clearBreakpointDone( )           public void smartDebuggingDone(                boolean fOn)                public void clearAllBreakpointsDone( )           public void disconnectDone( )           public void disconnectReconnect( )           public void getThreadsDone(                long[ ] ids,           String[ ] names,           StackFrameInfo[ ][ ] callStacks)                public void setPropertyDone(                String prop,           String value)            Fields   public static final NOT_ARRAY                Array length value to indicate that the value is not an array                public class weblogic.debugging.comm.DebugController implements           weblogic.debugging.comm.DebugCommands,           weblogic.debugging.comm.DebugEvents                      
 
         [0072]     A DebugController is a major piece of code that can go between the client and the server. Both sides can go through the DebugController to send debugging messages. The DebugController will then pass the appropriate commands to the appropriate DebugController via the CommTransport that is provided.  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Constructors   public DebugController(                CommTransport transport)            Methods   public weblogic.debugging.comm.CommTransport                setTransport(                CommTransport transport)                public void close( )           public void processNextEvent(                DebugEvents debugEvents)                public void clearAllBreakpoints( )           public void clearBreakpoint(                String className,           int line,           int id)                public void disconnect( )           public void doneStartSetup( )           public void doneStopSetup( )           public void getValue(                int frame,           long threadId,           String variable)                public void requestBreakpoints( )           public void requestFields(                int frame,           long threadId,           String variable)                public void requestStackFrames( )           public void requestThreads( )           public void requestVisibleVariables(                int frame,           long threadId)                public void run(                long threadId)                public void setBreakpoint(                String name,           int lineNumber,           Map props,           int id,           String langExt)                public void set Method Breakpoint(                String clazz,           String method,           String[ ] params,           int id,           String langExt)                public void setExceptionBreakpoint(                String exceptionClass,           boolean caught,           boolean uncaught,           int id,           String langExt)                public void setValue(                int frame,           long threadId,           String variable,           String newValue)                public void smartDebugging(                boolean fOn)                public void stepIn(                long threadId)                public void stepOut(                long threadId)                public void stepOver(                long threadId)                public void pause( )           public void setProperty(                String prop,           String value)                public boolean processNextCommand(                DebugCommands debugCommands,           int timeout)                processNextCommand will get the next command from           the CommTransport, and call into the           appropriate function in the Server&#39;s DebugCommands           interface. This is called by the Debug           Engine code.           Returns                true if there was a JDI event to process,           false if there wasn&#39;t anything. Useful so the                caller can avoid busy waiting by doing a sleep if           there wasn&#39;t anything waiting on any of the           queues from which it consumes           public static void processCommand(                DebugPacket packet,           DebugCommands debugCommands)                public void init(                int lineNumber,           String className,           String sourceFile,           int id)                public void breakHit(                int lineNumber,           String className,           String sourceFile,           int id,           String message,           long threadId)                public void exit( )           public void setup( )           public void breakMethodResolved(                String className,           String method,           String[ ] params,           String status)                public void clearAllBreakpointsDone( )           public void clearBreakpointDone( )           public void disconnectDone( )           public void disconnectReconnect( )           public void getValueDone(                ValueResponse value)                public void goDone( )           public void processDone( )           public void requestBreakpointsDone(                String[ ] breakpoints)                public void requestFieldsDone(                String variable,           String[ ] fields,           ValueResponse[ ] fieldValues)                public void requestStackFramesDone(                StackFrameInfo[ ] frames,           long threadId)                public void requestVisibleVariablesDone(                String[ ] variables,           ValueResponse[ ] values)                public void setBreakpointDone(                String className,           int origLine,           int actualLine,           String status,           int id)                public void setValueDone(                String variable,           boolean success,           String currentValue)                public void smartDebuggingDone(                boolean fOn)                public void getThreadsDone(                long[ ] ids,           String[ ] names,           StackFrameInfo[ ][ ] callStacks)                public void setPropertyDone(                String prop,           String value)            public interface weblogic.debugging.comm.DebugConstants                  
 
         [0073]     The DebugConstants interface is an interface that DebugCommands and DebugEvents derive from. This interface only defines constants that are used for defining the commands.  
                                                           Fields   public static final PAUSE                public static final KILL           public static final BREAKPOINT_RESOLVED           public static final BREAKPOINT_UNRESOLVED           public static final BREAKPOINT_ERROR           public static final DebugSocket           public static final DebugInteruptSocket           public static final JWS_DEBUGCONTEXT           public static final JWS_STARTCONTEXT           public static final JWS_ENDCONTEXT           public static final BP_PROP_CONDITION                public interface weblogic.debugging.comm.DebugCommands           implements           weblogic.debugging.comm.DebugConstants                      
 
         [0074]     The DebugCommands interface is the interface that defines the debugging commands going from the UI portion of the debugger, to the debug proxy. The second half of this is the DebugEvents interface, which defines all the events that are sent from the debugger, to the IDE. These same interfaces will be used to talk from the Proxy to the different languages.  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         Methods   public void doneStartSetup( )                public void doneStopSetup( )           public void disconnect( )           public void run(                long threadId)                public void stepIn(                long threadId)                public void stepOver(                long threadId)                public void stepOut(                long threadId)                public void setBreakpoint(                String name,           int lineNumber,           Map properties,           int id,           String langExt)                public void setMethodBreakpoint(                String clazz,           String method,           String[ ] params,           int id,           String langExt)                public void setExceptionBreakpoint(                String exceptionClass,           boolean caught,           boolean uncaught,           int id,           String langExt)                public void clearBreakpoint(                String className,           int line,           int id)                public void clearAllBreakpoints( )           public void requestBreakpoints( )           public void getValue(                int frame,           long threadId,           String variable)                public void setValue(                int frame,           long threadId,           String variable,           String newValue)                public void requestStackFrames( )           public void requestThreads( )           public void requestVisibleVariables(                int frame,           long threadId)                public void requestFields(                int frame,           long threadId,           String variable)                public void smartDebugging(                boolean fOn)                public void pause( )           public void setProperty(                String prop,           String value)                public   class                weblogic.debugging.comm.DbgCtrlSocketException   extends           weblogic.debugging.comm.TransportException            Constructors   public DbgCtrlSocketException( )                public DbgCtrlSocketException(                String s)                public DbgCtrlSocketException(                Exception e)            Methods   public java.lang.Exception getPreviousException( )                public class weblogic.debugging.comm.ConnectInfo            Constructors   public ConnectInfo(                String server,           int port,           int connectType)                public ConnectInfo(                InProcMedium medium,           int connectType)                public ConnectInfo(                ServerSocket ss,           int connectType)            Methods   public void setWrap(                int wrapType,           Object wrapObj)                public weblogic.debugging.comm.CommTransport           createTransport( )           public void close( )            Fields   protected_connectType                protected_wrapType           protected_port           protected_obj           protected_wrapobj           public static final connectSocket           public static final connectSocketAsync           public static final connectServerSocketAsync           public static final connectSameProcessServer           public static final connectSameProcessClient           public static final connectServerSocket           public static final noWrap           public static final asyncWrap           public static final priorityWrap                public interface weblogic.debugging.comm.CommTransport                      
 
         [0075]     This interface defines the communication methods used.  
                                                                                                                                     Methods   public void sendPacket(                DebugPacket packet)                public weblogic.debugging.packet.DebugPacket           getPacket( )           public weblogic.debugging.packet.DebugPacket           getPacket(                int timeout)                public void close( )                public   class                weblogic.debugging.comm.AsyncSocketComm   extends                weblogic.debugging.comm.AsyncCommBase                      
 
         [0076]     AsyncSocketComm is a class that will use a SocketComm for sending and recievine requests, but has another thread that is doing the actual sends/receives and queuing them to a buffer.  
                                                                             Constructors   public AsyncSocketComm( )                public   class                weblogic.debugging.comm.AsyncCommBase   implements                weblogic.debugging.comm.CommTransport                      
 
         [0077]     This class wraps a CommTransport, and adds a level of indirection to make the network communications non-dependant on the message processing.  
                                                                                                                                                               Constructors   protected AsyncCommBase(                CommTransport transport)            Methods   public weblogic.debugging.comm.CommTransport                getTransport( )           public weblogic.debugging.packet.DebugPacket           getPacket(                int timeout)                public weblogic.debugging.packet.DebugPacket           getPacket( )           public void sendPacket(                DebugPacket packet)                public void close( )           protected void processInput(                DebugPacket packet)                protected void processOutput(                DebugPacket packet)            Fields   protected_transport                protected volatile_error           protected_worker           protected_worker2           protected_inputQueue           protected_outputQueue                      
 
         [0078]     The foregoing description of preferred embodiments of the present invention has been provided for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise forms disclosed. Many modifications and variations will be apparent to one of ordinary skill in the art. The embodiments were chosen and described in order to best explain the principles of the invention and its practical application, thereby enabling others skilled in the art to understand the invention for various embodiments and with various modifications that are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the following claims and their equivalence.