CN103678135A

CN103678135A - System and method for achieving cross-process and cross-thread debugging in large-data environment

Info

Publication number: CN103678135A
Application number: CN201310728331.2A
Authority: CN
Inventors: 马骏; 曹宗伟
Original assignee: PRIMETON INFORMATION TECHNOLOGY Co Ltd
Current assignee: PRIMETON INFORMATION TECHNOLOGY Co Ltd
Priority date: 2013-12-25
Filing date: 2013-12-25
Publication date: 2014-03-26

Abstract

The invention relates to a system and a method for achieving cross-process and cross-thread debugging in the large-data environment. The system comprises a graphical debugging platform and a debugging frame. The graphical debugging platform comprises a resource loading module, a thread management module, an interceptor interface module, an interceptor achieving module, a configuration file module and a debugging server module. The debugging frame comprises a graphical edition frame module, a debugger user interface module, a debugging command parsing module, a debugging context management module, a debugging frame interface module and a debugging frame achieving module. By means of the system and the method, the defect that cross-process and cross-thread debugging are difficult to achieve in the prior debugging technologies and tools is overcome, cross-process and cross-thread application debugging support can be achieved, and the system is simple in structure, convenient and rapid to use and maintain, stable and reliable in operation performance and wide in application range.

Description

Under large data environment, realize the System and method for of striding course and cross-thread debugging

Technical field

The present invention relates to computer software fields, relate in particular to computer distribution type application and development field, specifically refer to the System and method for of realizing striding course and cross-thread debugging under a kind of large data environment.

Background technology

Large data age arrives, for a large number of services data, network data, daily record data that the whole world is rapidly increased are stored, process, transmit, change, are analyzed, thereby excavate out the implicit value of large data, the solution of large market demand is essential.In large market demand solution, the exploitation of application is key foundation, and the debugging of application is again the key components of application and development, and the problem in a kind of good debugging technique energy effective location exploitation, has greatly improved development efficiency and the payment speed of application.Current, along with the continuous maturation of various programming languages, debug function has become IDE(Integrated Development Environment) indispensable basic function.Concerning the developer of C Plus Plus, the most frequently used exploitation debugging acid is the Visual Studio external member of Microsoft, and concerning the developer of Java language, conventional IDE instrument has Eclipse, NetBeans.In addition, the debug function of JavaScript language is mainly integrated in (as IE, Firefox, Chrome etc.) in each large browser, and in database development, conventional storing process also has corresponding exploitation debugging acid, as PL/SQL, and TOAD etc.

Large market demand comprises a plurality of processes of multiple programming language, multiple technologies realization conventionally, also often comprises a plurality of threads in process, and the concurrent execution of process, thread, asynchronous call have increased extra difficulty to the debugging of application.Debugging is divided into local debugging and remote debugging conventionally.Local debugging is comparatively simple, and general debugging acid all possesses; Remote debugging relative complex, only have and use the IDE instrument support of programming language widely, because remote debugging has very positive effect for the aspect such as quick positioning question, remote assistance in production environment, thereby remote debugging ability (being the debugging capability of striding course and thread) becomes a standard that judges that whether debugging acid is complete.Yet support the imperfection of current most of IDE instrument to multi-process, multithreading debugging, can only assist by means such as breakpoint, log recordings.So, provide good multi-process, multithreading debugging capability to become each IDE instrument problem demanding prompt solution.

General debug platform need to be realized three Core Features: the first, and at assigned address (before method, before every line code, before pel execution), suspend or continue and carry out; The second, network enabled communication, the target language of debugging must be supported and debug communicating by letter of framework; The 3rd, realize the mapping of execute file and source file, to navigate to nominated bank, to specify pel.

The debugging scheme that current all kinds of IDE instrument provides is as shown in the table:

The debugging scheme that current enterprise is used is mainly dressed to each large IDE instrument, and source (debugging) file is compiled into java class or C++ file etc., and then the debugging scheme based on each large IDE instrument designs.General Socket agreement or the communication protocol of designed, designed are used in network service.

Meanwhile, debugging efficiency also can be improved in good graphical debugging interface.In debug process, need startup interface configuration correlation parameter, need storehouse view to check stack information, need variable view to check, revise variable information, need editing machine to show, play up current commissioning content, need control desk printout information.These views have formed a complete debugging enironment.

The debugging scheme problem that current enterprise is used: first, debugging scheme is based on single language, only for corresponding similar thread, safeguard its context environmental, therefore do not support the cross-thread debugging of variety classes thread, for example in Java, call JavaScript, between Java thread and JavaScirpt thread, have cross-thread phenomenon, the scheme of now debugging just needs to consider whether to support the debugging of this type; Secondly, do not support asynchronous thread debugging, this is by debugging acid decision itself, and debugging acid itself is not also known current synchronization call or the asynchronous call of calling, can only carry out according to logical order, thereby in debug process, also need to use that the means such as breakpoint and daily record are auxiliary debugs; Finally, only have single type debugging, do not support polytype debugging, when another type file is arrived in debugging, need to change debugging acid, if will set up the complete debugging chain of multiple debug-type, need a complete feasible debugging framework that is easy to expansion.

Summary of the invention

The object of the invention is to overcome the shortcoming of above-mentioned prior art, provide that a kind of application debugging that can realize striding course and thread is supported, system architecture is simple, working service is convenient and swift, stable and reliable working performance, the scope of application realize the System and method for that striding course and cross-thread are debugged comparatively widely under large data environment.

To achieve these goals, the System and method for of realizing the debugging of striding course and cross-thread under large data environment of the present invention has following formation:

Under this large data environment, realize the system of striding course and cross-thread debugging, its principal feature is, described system comprises graphical debug platform and debugging framework, and described graphical debug platform comprises:

Resource load-on module, in order to load the various resources in debug process by debug engine;

Thread management module, in order to manage the life cycle of each debugger thread by debug engine;

Blocker interface module, in order to define blocker interface and to carry out event blocker concurrent and call each debug-type when event is concurrent by debug engine and move;

Blocker is realized module, in order to be called the blocker interface of each debug-type by debug engine management;

Profile module, in order to configure parameter and the selection in debug process;

Debugging server module, in order to receive and to resolve the Debugging message of described debugging framework transmission and to send debug command to described debugging framework;

Described debugging framework comprises:

Graphical editing frame module, with thinking that operation flow and service logic exploitation provide patterned support;

Debugger subscriber interface module, in order to provide the function with user interactions;

Debug command parsing module, in order to receive and to resolve the debug command of described graphical debug platform transmission and to provide essential Debugging message to described graphical debug platform;

Debugging context management module, in order to safeguard the contextual information of each debugging request and to provide indispensable basis for asynchronous debugging and multithreading debugging;

Debugging framework interface module, in order to define debugging interface and various debug-type;

Debugging framework is realized module, uses so that various debug-type is realized respectively corresponding debugging framework interface.

Preferably, described graphical debug platform and debugging framework communicate by Socket agreement.

The invention still further relates to the method that realizes striding course and cross-thread debugging under the large data environment of a kind of system based on described, its principal feature is that described method comprises the following steps:

(1) described graphical debug platform and debugging framework carry out pretreatment operation;

(2) breakpoint information that described debugging framework obtains user according to described debugging framework is carried out the breakpoint configuration of debug engine;

(3) described debug engine and graphical debug platform are carried out debugging interrupt operation according to user's interruption debug command.

Preferably, described graphical debug platform and debugging framework carry out pretreatment operation, comprise the following steps:

(11) described profile module is carried out to initialization;

(12) start the application server at described graphical debug platform place;

(13) the resource load-on module in described graphical debug platform, thread management module and debugging server module are carried out to initialization;

(14) in the server boxes of described debugging framework, fill in server address and Service-Port;

(15) the debug command parsing module in described debugging framework is carried out to initialization;

(16) described graphical debug platform receives and calls debug engine after debugging request and process and build debug command and send to described debugging framework;

(17) the debugging framework described in is accepted debug command and is carried out pattern exhibiting and play up.

More preferably, described carries out initialization to described profile module, comprises the following steps:

(111) in described profile module, configure and whether debug;

(112) the configuration debugging max-timeout time in described profile module;

(113) in described profile module, configure the port of debugging server;

(114) the IP section of configuration permission connection debugging server in described profile module;

(115) in described profile module, configuration needs the resource loading classes using;

(116) in described profile module, configuration needs the execution container and the thread pool that use;

(117) blocker of the debug-type that configuration need to be used in described profile module.

More preferably, described carries out initialization to the resource load-on module in described graphical debug platform, thread management module and debugging server module, comprises the following steps:

(131) debug engine module loads relevant configuration by resource in profile module and is written into buffer memory;

(132) All Files in debug engine scan item, distinguishes and transfers to resource loading classes to process resource file by suffix;

(133) resource loading classes converts resource file to model;

(134) according to the configuration of carrying out container and thread pool in profile module, initialization container and thread pool;

(135) container is registered blocker event when initialization, by debug engine, is distributed;

(136) carrying out container starts to accept request;

(137) if configuration is not debugged in profile module, do not carry out following operation;

(138) if configuration is debugged in profile module, according to the debugging max-timeout time configuring in profile module, the port of debugging server, permission connects the IP section of debugging server, sets up network service;

(139) network service starts to monitor, and waits for debugging framework and communicating by letter.

More preferably, the described debug command parsing module in described debugging framework carries out initialization, comprises the following steps:

(151) the debug command parsing module in debugging framework obtains server address and the Service-Port that user fills in;

(152) the debug command parsing module in debugging framework starts network service;

(153) the debug command parsing module in debugging framework connects with graphical debug platform.

Preferably, the breakpoint information that described debugging framework obtains user according to described debugging framework is carried out the breakpoint configuration of debug engine, comprises the following steps:

(21) user arranges breakpoint mark by described debugger subscriber interface module in debug source file;

(22) described debugger subscriber interface module adds breakpoint mark to the breakpoint management device in debugging framework;

(23) described graphical debug platform periodically sent request and obtains breakpoint information to debugging framework every the systemic presupposition time interval;

(24) described debug command parsing module reads all breakpoint informations in described breakpoint management device and returns to debug engine;

(25) breakpoint information that described debug engine is resolved according to described debug command parsing module is upgraded the breakpoint information of holding.

More preferably, described user arranges breakpoint mark by described debugger subscriber interface module in debug source file, comprises the following steps:

(211) described debugger subscriber interface module imports resource path and the content of text of debug source file into;

(212) user adds breakpoint in resource editor;

(213) can described debugger subscriber interface module judgement current line descend breakpoint, if so, continues step (214), otherwise continue step (215);

(214) debugger subscriber interface module adds a breakpoint and notifies breakpoint view to show breakpoint in breakpoint management device;

(215) it is invalid that the debugger subscriber interface module prompting active user described in operates.

Preferably, described debug engine and graphical debug platform are carried out debugging interrupt operation according to user's interruption debug command, comprise the following steps:

(31) user carries out debug command operation and related commissioning instruction is sent to graphical debug platform at described debugging framework after sending debugging request by browser;

(32) described debugging framework is realized module and is debugged context management module and judges according to current debug command and breakpoint information whether current line needs to interrupt, and if not, continues step (33), if it is continues step (34);

(33) do not carry out interrupt operation and continue to carry out debugging;

(34) described debugging framework notifies graphical debug platform interrupt and to graphical debug platform, call debug engine and obtain current storehouse and current variable;

(35) described graphical debug platform sends debug command to debugging framework;

(36) the debugger subscriber interface module of described debugging framework is received described debug command and is found the debug source file in project according to resource path;

(37) the debugger subscriber interface module of described debugging framework is opened debug source file and is navigated to current pel or current interruption row graphically playing up in current pel or current interruption row;

(38) the debugger subscriber interface module of described debugging framework receives graphical debug platform allocating stack at storehouse view demonstration stack information;

(39) the debugger subscriber interface module of the debugging framework described in receives graphical debug platform variable information and show variable information in variable view.

More preferably, described debugging framework is realized module and debugs context management module to judge according to current debug command and breakpoint information whether current line needs to interrupt, and comprises the following steps:

(321) described debugging framework is realized module and debugging context management module and is judged that whether current pel exists breakpoint, if so, continues step (34), otherwise, continue step (322);

(322) judge current debug command type, if being single step, current debug command skips, continue step (323), if being single step, current debug command returns, continue step (326), if current debug command is single step, enter, continue step (328), if current debug command, for carrying out, continues step (33);

(323) judge that current context whether in the contextual single step storehouse of debugging, if do not existed, continues execution step (33), if, execution step (324);

(324) be switched to self-defined debugging skeleton view and current thread and carry out interruption;

(325) the step number of debugging contextual single step storehouse is greater than at 0 o'clock, carries out out stack operation;

(326) judge that current context whether in the contextual single step storehouse of debugging, if do not existed, continues execution step (33), if, execution step (327);

(327) be switched to self-defined debugging skeleton view and current thread and carry out interruption;

(328) be switched to self-defined debugging skeleton view and current thread and carry out interruption.

More preferably, described debugging framework notifies graphical debug platform interrupt and to graphical debug platform, call debug engine and obtain current storehouse and current variable, comprises the following steps:

(341) the debug command parsing module of debugging framework sends interruptive command to graphical debug platform;

(342) the debugging server module of graphical debug platform receives interrupt instruction;

(343) debug engine invokes thread administration module interrupts given thread;

(344) debug engine obtains the storehouse of given thread;

(345) debug engine obtains the variable of given thread.

More preferably, the debugger subscriber interface module of described debugging framework is received described debug command root, comprises the following steps:

(361) the debug command parsing module in debugging framework receives debug command;

(362) the debug command parsing module in debugging framework is resolved debug command;

(363) the debug command parsing module in debugging framework returns to resource, line number, allocating stack and variant content.

More preferably, described finds the debug source file in project according to resource path, comprises the following steps:

(364) the debugger subscriber interface module in debugging framework gets resource path;

(365) whether the debugger subscriber interface module detection in debugging framework is consistent with resource path when resource file corresponding to the graphical editing machine of front opening, is if it is directly targeted to current editing machine, otherwise continues step (366);

(366) the debugger subscriber interface module in debugging framework, by the file under index search all items, if can find, is opened corresponding editing machine, otherwise, return to sky.

Preferably, described step (3) is afterwards, further comprising the steps of:

(4) the debugging framework described in enters debug command fill order stepping according to user's single step and enters operation;

Described debugging framework enters debug command fill order stepping according to user's single step and enters operation and comprise the following steps:

(41) user selects single step to enter debug command;

(42) whether the debugger thread of graphical debug platform judgement and debugging framework operation is same thread, exits if not finishing, otherwise continues step (43);

(43) graphical debug platform engine loads resource, and thread management module is responsible for that debugger thread is carried out to first pel place of respective file or Java method the first row code place hangs up;

(44) whether the debugger thread of debugging framework judgement and debugging framework operation is same thread, if it is current debugging pel is played up, and then continues step (45), exits if not finishing;

(45) debugging framework judgement primitive types, enters respective file;

(46) debugging framework storehouse view update stack information;

(47) debugging framework variable view update variable information.

Preferably, described step (3) is afterwards, further comprising the steps of:

(5) described debugging framework is skipped debug command according to user's single step and is carried out single step skip operations;

Described debugging framework is skipped debug command execution single step skip operations according to user's single step and is comprised the following steps:

(51) user selects single step to skip debug command;

(52) whether the debugger thread of graphical debug platform judgement and debugging framework operation is same thread, if so, continues step (53), exits if not finishing;

(53) graphical debug platform thread management module judges that current context ID is whether in stack, if, continue step (54), if do not existed, hang up and finish and exit;

(54) whether the debugger thread of debugging framework judgement and debugging framework operation is same thread, if it is current debugging pel is played up, and then continues step (55), exits if not finishing;

(55) debugging framework storehouse view update stack information;

(56) debugging framework variable view update variable information.

Preferably, described step (3) is afterwards, further comprising the steps of:

(6) described debugging framework returns to debug command execution single step according to user's single step and returns to operation;

Described debugging framework returns to debug command according to user's single step and carries out single step and return to operation and comprise the following steps:

(61) user selects single step to return to debug command;

(62) whether the debugger thread of graphical debug platform judgement and debugging framework operation is same thread, if so, continues step (63), exits if not finishing;

(63) graphical debug platform thread management module goes out stack operation to debugging storehouse;

(64) graphical debug platform thread management module judge that current context ID is whether in stack, if, continue step (65), if do not existed, hang up end and exit;

(65) whether the debugger thread of debugging framework judgement and debugging framework operation is same thread, if current debugging pel is played up, then continues step (66), exits if not finishing;

(66) debugging framework storehouse view update stack information;

(67) debugging framework variable view update variable information.

Adopt the System and method for of realizing striding course and cross-thread debugging under the large data environment in this invention, there is following beneficial effect:

The object of the invention is to overcome the shortcoming that is difficult to realize striding course and thread debugging in above-mentioned existing debugging technique, instrument, the system and the method thereof that provide that a kind of application debugging that realizes striding course and thread is supported, system architecture is simple, working service is convenient and swift, stable and reliable working performance, the scope of application realize striding course and cross-thread debugging comparatively widely under large data environment, specifically tool has the following advantages:

(1) striding course cross-thread

Debugging framework carries out striding course with graphical debug platform communicates by letter, while needing cross-thread access in debug process, can make across thread in debug also and normally return, when initiating a plurality of debugging request simultaneously, for each debugger thread, safeguard context environmental separately, it is not interfere with each other.

(2) be easy to expansion

While increasing new debug-type, only need realize concrete debug-type, without revising core code, make to debug framework and there is portability and extendability.

(3) can set up integrated debugging link

By operation flow debugging related in exploitation, service logic debugging, class debugging, method debugging, script debugging is together in series, and sets up integrated debugging link, and developer is debugged each process, thereby orientation problem dealing with problems, improves the ability that solves actual production problem under large data environment rapidly.

Accompanying drawing explanation

Fig. 1 is the structural representation of realizing the system of striding course and cross-thread debugging under large data environment of the present invention.

Fig. 2 is that single step of the present invention enters the process flow diagram of debugging framework under debug command.

Fig. 3 is the process flow diagram that single step of the present invention enters graphical debug platform under debug command.

Fig. 4 is that the process flow diagram of debugging framework under debug command is skipped in single step of the present invention.

Fig. 5 is the process flow diagram that graphical debug platform under debug command is skipped in single step of the present invention.

Fig. 6 is that the process flow diagram of debugging framework under debug command is returned in single step of the present invention.

Fig. 7 is the process flow diagram that graphical debug platform under debug command is returned in single step of the present invention.

Embodiment

In order more clearly to describe technology contents of the present invention, below in conjunction with specific embodiment, conduct further description.

In order to realize object of the present invention, the System and method for of realizing striding course and cross-thread debugging under large data environment of the present invention is as follows:

Under this large data environment, realize the system of striding course and cross-thread debugging, comprise graphical debug platform and debugging framework, its principal feature is that described graphical debug platform comprises: debug engine, thread management, blocker interface, blocker realization, configuration file, resource load and debugging server module.

Resource load-on module: load the various resources in debug process by debug engine, comprise debugging file, configuration file.

Thread management module: manage the life cycle of each debugger thread by debug engine, key is to guarantee each debugger thread independent operating, and the ability that allows given thread suspend (continuing to carry out) is provided.

Blocker interface module: define a set of blocker interface, each debug-type is realized, and carries out case distribution by engine, when event (import/export business flow process, import/export business flow process pel etc.) occurs, calls the blocker action that each debug-type is realized.

Blocker is realized module: each debug-type is realized respectively defined blocker interface, by engine, is managed and is called.

Profile module: mainly comprise whether enabling debug function, the debugging max-timeout time, the port of debugging server, allows the IP section of connection debugging server etc.

Debugging server module: main being responsible for receives and resolve the Debugging message that debugging framework sends, and Parallel debugging framework sends debug command.

Described debugging framework comprises: graphical editing frame, debugger UI(user interface), debugging context management, debug command management, debugging framework interface and debugging framework realize;

Graphical editing frame module: for operation flow, service logic exploitation provide patterned support, an editing area and a palette are provided, user selects the pel needing in palette, in the mode that drags or click, pel or connection is placed on to editing area; User can check and revise most of attribute of certain pel or connection; Context menu and keyboard commands are provided; The zoom function of figure is provided; An outline view is provided, shows the thumbnail of editing area, or tree shaped model structure; Support undo/redo function etc.

Debugger UI(user interface) module: provide breakpoint management, source file location, debugging to start, check the function of variable, debugging action (single step enters, single step is skipped, single step is returned, carry out, stop) etc. and user interactions.

Debug command parsing module: be responsible for receiving and resolve the debug command that graphical debug platform sends, and provide essential Debugging message to graphical debug platform.

Debugging context management module: for its contextual information is safeguarded in each request, for the debugging of asynchronous debugging and multithreading provides indispensable basis.

Debugging framework interface module: define a set of debugging interface, each debug-type is realized, and distributes management by whole framework docking port and realization.If it is Business Stream that interface mainly comprises handleEntry(debug-type, define before and after import/export business flow process, action before and after import/export business flow process pel), handleStepInto(definition single step enters action), handleStepOver(definition single step skip action), handleStepReturn(definition single step return action), action is submitted in handleResume(definition to), whether canHandleStepInto(can single step enters), whether canHandleStepOver(can single step skips), whether canHandleStepReturn(can single step returns), the content that getLabel(definition current stack view stack top shows), displaySource(resource location, show current debugging position: editing machine+pel).

Debugging framework is realized module: each debug-type is realized respectively defined debugging framework interface, by whole framework, is managed.

Debugging framework communicates by Socket agreement (or other procotol) with graphical debug platform.

The Debugging message of realizing under this large data environment in the system of striding course and cross-thread debugging comprises debug command, resource path, stack information, variable information, the line number at breakpoint place or ID.

Under this large data environment, realize debugging action in the system of striding course and cross-thread debugging and comprise that single step enters that (stepOver) skipped in (stepInto), single step, single step is returned to (stepReturn), continued to carry out (resume) and termination (terminate).

Under this large data environment, realize debug command in the system of striding course and cross-thread debugging and comprise that single step enters that (stepOver) skipped in (stepInto), single step, single step is returned to (stepReturn), continued to carry out (resume) and termination (terminate).

Should the system based on above-mentioned realize the System and method for of realizing striding course and cross-thread debugging under large data environment, its principal feature is, described method comprises pretreatment operation, breakpoint configuration operation and the debugging interrupt operation of graphical debug platform, the pretreatment operation of described graphical debug platform, comprises the following steps:

(1) initialization operation of profile module.

(2) start the application server at graphical debug platform place.

(3) the resource load-on module in graphical debug platform carries out initialization.

(4) thread management module in graphical debug platform carries out initialization.

(5) the debugging server module in graphical debug platform is carried out initialization.

(6) at debugging framework, open connection server dialog box, fill in server address and Service-Port, click and determine.

(7) the debug command parsing module in debugging framework carries out initialization.

(8) browser sends request to graphical debug platform, and address is http: // [IP at server end]: [debug port]/[filename].

(9) graphically debug platform receives debugging request, calls debug engine and processes, and build debug command to the transmission of debugging framework.

(10) debugging framework is accepted debug command, carries out pattern exhibiting and plays up.

Described breakpoint configuration operation, comprises the following steps:

(1) user arranges breakpoint mark in debug source file by debugger subscriber interface module.

(2) debugger subscriber interface module adds breakpoint mark to the breakpoint management device in debugging framework.

(3) graphical debug platform periodically sent request and obtains breakpoint information to debugging framework every the time interval of systemic presupposition.

(4) debug command parsing module reads all breakpoint informations in this breakpoint management device.

(5) debug command parsing module returns to debug engine by all breakpoint informations that obtain.

(6) debug engine calls the breakpoint information that debugging server module parses obtains.

(7) debug engine upgrades the breakpoint information of holding.

Described user arranges breakpoint mark in debug source file by debugger subscriber interface module, comprise the following steps:

(1) described debugger subscriber interface module imports resource path and the content of text of debug source file into.

(2) user adds breakpoint in resource editor.

(3) described debugger subscriber interface module judges whether current line can descend breakpoint, and carries out respectively following steps according to judged result:

(a), if current line can descend breakpoint, debugger UI adds a breakpoint and notifies breakpoint view to show breakpoint in breakpoint management device.

(b), if current line can not descend breakpoint, user's operation is invalid.

The time interval of realizing the systemic presupposition in the System and method for of striding course and cross-thread debugging under this large data environment is 500ms.

Under this large data environment, realizing debugging server module in the System and method for of striding course and cross-thread debugging sends request the request form that obtains breakpoint information and is:

[COMMAND]: [debug events].

Under this large data environment, realizing the form that debug command parsing module in the System and method for of striding course and cross-thread debugging returns to the breakpoint information data of graphical debug platform is:

[COMMAND]: [debug events] [breakpoint]: [[breakpoint 1:[resource path] [line number or ID]] [breakpoint 2:[resource path] [line number or ID]]].

Described debugging interrupt operation comprises the following steps:

(1) user sends debugging request by browser, or in " Start-up and Adjustment " of graphical editing machine click right menu, Start-up and Adjustment.

(2) user adds/deletes breakpoint at debugging framework, and single-step debug is submitted to, the operations such as interruption, and dependent instruction is sent to graphical debug platform.

(3) debugging framework is realized module and debugging context management module and judge according to present instruction (single step enters, single step is skipped, single step is returned, carry out, termination etc.), breakpoint information whether current line needs interruption.

(4) if current line does not need to interrupt, continue to carry out.

(5), if current line need to interrupt, debug framework and notify graphical debug platform to interrupt, and to graphical debug platform, call engine and obtain current storehouse and current variable.

(6) graphical debug platform sends debug command to debugging framework.

The data layout that debugging code API sends is as follows:

[order]: [command type]

[request ID]: [current request number]

[context ID]: [current context ID]

[resource path]: [resource file URL]

[pel numbering]: [current pel numbering]

[line number]: [current Java or Javascript line number] (if the non-Java pel of current pel or Javascript pel are empty)

[allocating stack]: [allocating stack and variable]

(7) the debugger command analysis module of debugging in framework received the contents such as debug command and relevant resource, line number, allocating stack, variable.

(8) the debugger UI in debugging framework finds the debug source file in project according to the path of resource.

(9) the debugger UI in debugging framework opens debug source file and navigates to current pel or current interruption row, and graphically play up at current pel or current interruption row, to distinguish debugging pel (debugging code) and non-debugging pel (non-debugging code).

(10) the debugger UI in debugging framework receives graphical debug platform allocating stack at storehouse view demonstration stack information.

(11) the debugger UI of debugging in framework receives graphical debug platform variable information show variable information in variable view.

Described profile module initialization operation comprises the steps:

(1) whether configuration debugs.

(2) the configuration debugging max-timeout time.

(3) port of configuration debugging server.

(4) configuration allows to connect the IP section of debugging server.

(5) configuration needs the resource loading classes using.

(6) configuration needs the execution container and the thread pool that use.

(7) configuration needs the blocker of the debug-type of use.

The application server at the graphical debug platform of described startup place comprises the steps:

(1) user clicks the start button of graphical debug platform application server.

(2) startup of application server has two kinds of modes: a kind of is directly to call the main method that starts class; Another kind is in application, to configure web.xml, by application server, is loaded.

(3) if adopt, directly call the mode that starts class, call its main method and start.

(4) if adopt the mode of configuration web.xml, by application server, load the Servlet registering in web.xml.

(5) Servlet carries out initialization.

Resource management module in described graphical debug platform carries out initialization operation and comprises the steps:

(1) debug engine module loads relevant configuration by resource in profile module and is written into buffer memory.

(2) All Files in debug engine scan item, distinguishes and transfers to resource loading classes to process resource file by suffix.

(3) resource loading classes converts resource file to model.

Thread management module in described graphical debug platform carries out initialization operation and comprises the steps:

(1) according to the configuration of carrying out container and thread pool in profile module, initialization container and thread pool.

(2) container is registered blocker event when initialization, by debug engine, is distributed.

(3) carrying out container starts to accept request.

Debugging server module in described graphical debug platform is carried out initial configuration and is comprised the steps:

(1) if configuration is not debugged in profile module, do not carry out following operation.

(2) if configuration is debugged in profile module, according to the debugging max-timeout time configuring in profile module, the port of debugging server, permission connects the IP section of debugging server, sets up network service.

(3) network service starts to monitor, and waits for debugging framework and communicating by letter.

Debug command parsing module in described debugging framework carries out initialization operation and comprises the steps:

(1) the debug command parsing module in debugging framework obtains server address and the Service-Port that user fills in.

(2) the debug command parsing module in debugging framework starts network service.

(3) the debug command parsing module in debugging framework connects with graphical debug platform.

Described debugging framework is realized module and debugging context management module and judge according to present instruction (single step enters, single step is skipped, single step is returned, carry out, termination etc.), breakpoint information whether current line needs interruption to comprise the steps:

(1) if current pel exists breakpoint, carry out interrupt operation; Otherwise, carry out following steps.

(2) judge current debug command type.

(3) if current debug command is single step skips,

A) judge contextID(current context) whether at commandContext(debugging context) stepStack(single step storehouse) in, if do not carry out continuing, if, carry out following steps.

B) be switched to self-defined debugging skeleton view.

C) current thread is carried out and is interrupted.

(4) if current debug command is single step to be returned,

A) stepStack(single step storehouse commandContext(debugging context)) if step number be greater than 0, carry out pop(and pop) operation

B) judge contextID(current context) whether at commandContext(debugging context) stepStack(single step storehouse) in, if do not carry out continuing, if, carry out following steps.

C) be switched to self-defined debugging skeleton view.

D) current thread is carried out and is interrupted.

(5) if current debug command is single step to enter, be directly switch to self-defined debugging skeleton view, current thread is carried out and is interrupted.

(6) if current debug command for carrying out, continues to carry out.

If described current line need to interrupt, debug framework and notify graphical debug platform to interrupt, and to graphical debug platform, call that engine obtains current storehouse and current variable comprises the following steps:

(1) the debug command parsing module of debugging framework sends interruptive command to graphical debug platform.

(2) the debugging server module of graphical debug platform receives interrupt instruction.

(3) debug engine invokes thread administration module interrupts given thread.

(4) debug engine obtains the storehouse of given thread.

(5) debug engine obtains the variable of given thread.

Debug command parsing module in described debugging framework receives that the contents such as debug command and relevant resource, line number, allocating stack, variable comprise the steps:

(1) the debug command parsing module in debugging framework receives debug command.

(2) the debug command parsing module in debugging framework is resolved debug command.

(3) the debug command parsing module in debugging framework returns to the contents such as resource, line number, allocating stack, variable.

Debugger UI in described debugging framework finds the debug source file in project to comprise the steps: according to the path of resource

(1) the debugger UI in debugging framework gets resource path.

(2) whether the debugger UI detection of debugging in framework is consistent with resource path when resource file corresponding to the graphical editing machine of front opening, if be directly targeted to current editing machine, if not execution is following, operates.

(3) the debugger UI in debugging framework, by the file under index search all items, if can find, opens corresponding editing machine, if can not find, returns to sky.

The operation that described debugging framework single step enters comprises the following steps (as Fig. 2, shown in 3):

(1) user clicks Step Into(single step and enters) button.

(2) whether the debugger thread of graphical debug platform judgement and debugging framework operation is same thread, if not exit.

(3) graphical debug platform engine loads resource, and thread management module is responsible for that debugger thread is carried out to first pel place of respective file (or Java method the first row code place) and is hung up.

(4) whether the debugger thread of the judgement of debugging framework and debugging framework operation is same thread, if current debugging pel is played up, if not exit.

(5) debugging framework judgement primitive types, enters respective file

(6) debugging framework storehouse view update stack information.

(7) debugging framework variable view update variable information.

The operation that described debugging framework single step is skipped comprises the following steps (as Fig. 4, shown in 5):

(1) user clicks Step Over(single step and skips) button.

(3) graphical debug platform thread management module judges current contextID(context ID) whether in stack (stepStack), if carried out continuing, if do not existed, hang up.

(4) whether the debugger thread of the judgement of debugging framework and debugging framework operation is same thread, if current debugging pel is played up, if not exit

(5) debugging framework storehouse view update stack information.

(6) debugging framework variable view update variable information.

The operation that described debugging framework single step is returned comprises the following steps (as Fig. 6, shown in 7):

(1) user clicks Step Return(single step and returns) button.

(3) graphical debug platform thread management module is debugged storehouse to debugStack() go out stack operation.

(4) graphical debug platform thread management module judges current contextID(context ID) whether in stack (stepStack), if carried out continuing, if do not existed, hang up.

(5) whether the debugger thread of the judgement of debugging framework and debugging framework operation is same thread, if current debugging pel is played up, if not exit.

(6) debugging framework storehouse view update stack information.

Debugging framework variable view update variable information.

Below lift a specific embodiment the present invention be described:

Graphical editing frame: the major function of graphical editing frame is to provide patterned support for operation flow, service logic exploitation.Graphical editing frame provides an editing area and a palette, and user selects the pel needing in palette, in the mode that drags or click, pel or connection is placed on to editing area; User can check and revise most of attribute of certain pel or connection; Context menu and keyboard commands are provided; The zoom function of figure is provided; An outline view is provided, shows the thumbnail of editing area, or tree shaped model structure; Support undo/redo function etc.

Graphical editing machine framework adopts Eclipse GEF framework (the graphical editing machine framework of Eclipse), and its operation steps is as follows:

(1) by the newly-built graphical editing machine file of guide, as operation flow file, take .flow as suffix, service logic be take .biz as suffix.

(2) after document creation success, in Eclipse, open graph of a correspondence editing machine.

(3) user carries out business layout exploitation in graphical editing machine, and detailed process, for to select pel from option version, is dragged to appropriate location in editor zone by pel, and adds line.

(4) user uses editing machine context menu, toolbar, and shortcut operates.

(5) attribute information of properties view display editor or pel.

(6) one-piece construction of outline view display graphics editing machine.

2. debugger UI: debugger UI provides breakpoint management, source file location, debugging to start, check the function of variable, debugging action (single step enters, single step is skipped, single step is returned, carry out, stop) etc. and user interactions.

Eclipse has realized a set of debugging framework, and debugger UI is based on Eclipse platform, and improves as follows:

(1) improve storehouse view.The stack information that debugging framework storehouse view receives graphical debug platform transmission is in the demonstration of storehouse view, and displaying contents main body is debugger thread, and in debugger thread, shows debugging storehouse.

(2) custom variable view.Graphical debug platform sends the variable information of XML form to debugging framework, in variable view, with tree-like form, show.

(3) transformation breakpoint view.Debugging framework breakpoint view is transformed, after transformation, added the breakpoint view of Eclipse to carry out unified management the pel breakpoint of graphical editing machine.

(4) self-defined debugging skeleton view.Self-defined debugging view comprises storehouse view, custom variable view, graphical editing machine, outline view, control desk.

3. debug command parsing module: debugging framework debug command parsing module is mainly responsible for receiving and resolving the debug command of graphical debug platform transmission, and Parallel debugging engine provides essential Debugging message.

4. debugging context management: debugging context management is safeguarded its contextual information for each request, for asynchronous debugging and multithreading debugging provide indispensable basic.

The method for designing of debugging context management module is as follows:

(1) with single routine Model Design debugging context manager.

(2) in debugging context manager, safeguard a threadMap(thread Map), key is threadID(Thread Id), value is requestID(request ID), a thread is corresponding with a request.

(3) in debugging context manager, safeguard a commandMap(debug command Map), key is requestID(request ID), value is commandContext(debugging context), a request is corresponding with a debugging context.

(4) in debugging context, in constant mode, define debug command constant (single step enters, and single step is skipped, and single step is returned, and carries out etc.), be used for identifying current debugging action.

(5) in debugging context, safeguard a debugStack(debugging storehouse), record debug process.

(6) in debugging context, safeguard a stepStack(single step storehouse), record single-step debug process.

(7) with contextID(context ID) execution of operation flow of sign (or service logic etc.), contextID(context ID) by graphical debug platform engine, generated, pass to debugging framework, debugging framework is responsible for stacked when entering operation flow (debugStack), and (debugStack) pops when going out operation flow.

5. debug framework interface: define a set of debugging interface, each debug-type is realized, and by whole framework docking port and realization, distributes management.

If debugging framework interface mainly comprises that handleEntry(debug-type is Business Stream, define before and after import/export business flow process, action before and after import/export business flow process pel), handleStepInto(definition single step enters action), handleStepOver(definition single step skip action), handleStepReturn(definition single step return action), action is submitted in handleResume(definition to), whether canHandleStepInto(can single step enters), whether canHandleStepOver(can single step skips), whether canHandleStepReturn(can single step returns), action is submitted in handleResume(definition to), the content that getLabel(definition current stack view stack top shows), displaySource(resource location, show current debugging position: editing machine+pel).

6. debugging framework is realized: each debug-type is realized respectively defined debugging framework interface, by whole framework, is managed.

Debugging framework to the step of debugging framework interface and realization management is:

(1) debugging framework receives the debug command that graphical debug platform sends, and parses debug-type.

(2) the debugging framework realization that debugging framework is distributed to corresponding debug-type according to debug-type by current commissioning content is processed.

(3) particular type debugging framework is realized and is carried out corresponding operating or return after analog value, hands to debugging framework and processes.

(4) debugging framework builds debug command, sends to graphical debug platform.

7. resource loads: by engine, load the various resources in debug process, comprise debugging file, configuration file.

8. thread management.By the life cycle of each debugger thread of engine management, key is to guarantee each debugger thread independent operating, and the ability that allows given thread suspend (continuing to carry out) is provided.

9. blocker interface: define a set of blocker interface, each debug-type is realized, and carries out case distribution by engine, when event (import/export business flow process, import/export business flow process pel etc.) occurs, calls the blocker that each debug-type realizes and moves.

10. blocker is realized: each debug-type is realized respectively defined blocker interface, by engine, is managed and is called.

Take operation flow blocker as example, blocker before operation flow, blocker after operation flow, blocker before operation flow pel, after operation flow, blocker is achieved as follows.

Before operation flow, blocker is realized, and comprises the following steps:

(1) obtain trade context object.

(2) resolve trade context object, obtain transaction id.

(3) resolve trade context object, obtain transaction pel ID.

(4) resolve trade context object, obtain request ID.

(5) call UUID and generate unique ID, sign is one whole transaction from start to end.

(6) newly-built stack object, by the unique ID maker of UUID() unique ID of generating is pressed in stack.

(7) stack object is put into trade context object;

(8) by All Activity information, be configured to Url;

Blocker after operation flow, comprises the following steps:

(1) obtain trade context object;

(2) resolve trade context object, obtain transaction id;

(3) resolve trade context object, obtain transaction pel ID;

(4) resolve trade context object, obtain request ID;

(5) from trade context object, obtain stack object;

(6) the top layer ID of stack object pops;

(7) by All Activity information, be configured to Url;

Before operation flow pel, blocker is realized, and comprises the following steps:

(1) obtain trade context object;

(2) resolve trade context object, obtain transaction id;

(3) resolve trade context object, obtain transaction pel ID;

(4) resolve trade context object, obtain request ID;

(5) from trade context object, obtain stack object;

(6) from stack object, obtain the ID of whole transaction of sign one;

(7) by All Activity information, be configured to Url;

After operation flow, blocker is realized, and comprises the following steps:

(1) obtain trade context object;

(2) resolve trade context object, obtain transaction id;

(3) resolve trade context object, obtain transaction pel ID;

(4) resolve trade context object, obtain request ID;

(5) from trade context object, obtain stack object;

(6) from stack object, obtain the ID of whole transaction of sign one;

(7) by All Activity information, be configured to Url;

11. configuration files: mainly comprise whether enabling debug function, the debugging max-timeout time, the port of debugging server, allows the IP section of connection debugging server etc.

Below the relevant setting of debugging:

#--------is relevant setting----------------------# of debugging below

Whether # enables debug function

enableDebug=true

# debugs max-timeout time, unit millisecond

debugTimeOut=10000

The port of # debugging server

debugPort=9999

# allows to connect the IP section (support regular expression) of debugging server

validConnectingIpPattern=.*

# can trigger the IP section (support regular expression) of breakpoint

enabledBreakpointIpPattern=127.0.0.1

Below blocker relevant configuration:

12. debugging server modules (graphical debug platform): graphical debug platform debugging server module is mainly responsible for receiving and resolve the Debugging message that debugging framework sends, and Parallel debugging framework sends debug command.

(1) striding course cross-thread

(2) be easy to expansion

(3) can set up integrated debugging link

In this instructions, the present invention is described with reference to its specific embodiment.But, still can make various modifications and conversion obviously and not deviate from the spirit and scope of the present invention.Therefore, instructions and accompanying drawing are regarded in an illustrative, rather than a restrictive.

Claims

1. a system that realizes striding course and cross-thread debugging under large data environment, is characterized in that, described system comprises graphical debug platform and debugging framework, and described graphical debug platform comprises:

Described debugging framework comprises:

2. the system that realizes striding course and cross-thread debugging under large data environment according to claim 1, is characterized in that, described graphical debug platform and debugging framework communicate by Socket agreement.

3. a method that realizes striding course and cross-thread debugging under the large data environment of the system based on described in claim 1 or 2, is characterized in that, described method comprises the following steps:

4. the method that realizes striding course and cross-thread debugging under large data environment according to claim 3, is characterized in that, described graphical debug platform and debugging framework carry out pretreatment operation, comprise the following steps:

(11) described profile module is carried out to initialization;

(12) start the application server at described graphical debug platform place;

5. the method that realizes striding course and cross-thread debugging under large data environment according to claim 4, is characterized in that, described carries out initialization to described profile module, comprises the following steps:

(111) in described profile module, configure and whether debug;

(112) the configuration debugging max-timeout time in described profile module;

(113) in described profile module, configure the port of debugging server;

6. under large data environment according to claim 4, realize the method for striding course and cross-thread debugging, it is characterized in that, described carries out initialization to the resource load-on module in described graphical debug platform, thread management module and debugging server module, comprises the following steps:

(133) resource loading classes converts resource file to model;

(136) carrying out container starts to accept request;

7. the method that realizes striding course and cross-thread debugging under large data environment according to claim 4, is characterized in that, the described debug command parsing module in described debugging framework carries out initialization, comprises the following steps:

8. under large data environment according to claim 3, realize the method for striding course and cross-thread debugging, it is characterized in that, the breakpoint information that described debugging framework obtains user according to described debugging framework is carried out the breakpoint configuration of debug engine, comprises the following steps:

9. the method that realizes striding course and cross-thread debugging under large data environment according to claim 8, is characterized in that, described user arranges breakpoint mark by described debugger subscriber interface module in debug source file, comprises the following steps:

(212) user adds breakpoint in resource editor;

10. the method that realizes striding course and cross-thread debugging under large data environment according to claim 3, is characterized in that, described debug engine and graphical debug platform are carried out debugging interrupt operation according to user's interruption debug command, comprise the following steps:

(33) do not carry out interrupt operation and continue to carry out debugging;

Under 11. large data environments according to claim 10, realize the method for striding course and cross-thread debugging, it is characterized in that, described debugging framework realizes module and debugging context management module judges according to current debug command and breakpoint information whether current line needs to interrupt, and comprises the following steps:

Under 12. large data environments according to claim 10, realize the method for striding course and cross-thread debugging, it is characterized in that, described debugging framework notifies graphical debug platform interrupt and to graphical debug platform, call debug engine and obtain current storehouse and current variable, comprises the following steps:

(344) debug engine obtains the storehouse of given thread;

(345) debug engine obtains the variable of given thread.

The method that realizes striding course and cross-thread debugging under 13. large data environments according to claim 10, is characterized in that, the debugger subscriber interface module of described debugging framework is received described debug command root, comprises the following steps:

The method that realizes striding course and cross-thread debugging under 14. large data environments according to claim 10, is characterized in that, described finds the debug source file in project according to resource path, comprises the following steps:

The method that realizes striding course and cross-thread debugging under 15. large data environments according to claim 3, is characterized in that, described step (3) is afterwards, further comprising the steps of:

(41) user selects single step to enter debug command;

(45) debugging framework judgement primitive types, enters respective file;

(46) debugging framework storehouse view update stack information;

(47) debugging framework variable view update variable information.

The method that realizes striding course and cross-thread debugging under 16. large data environments according to claim 3, is characterized in that, described step (3) is afterwards, further comprising the steps of:

(51) user selects single step to skip debug command;

(55) debugging framework storehouse view update stack information;

(56) debugging framework variable view update variable information.

The method that realizes striding course and cross-thread debugging under 17. large data environments according to claim 3, is characterized in that, described step (3) is afterwards, further comprising the steps of:

(61) user selects single step to return to debug command;

(66) debugging framework storehouse view update stack information;

(67) debugging framework variable view update variable information.