Abstract:
The Asynchronous Aggregator shifts the burden of retrieving and aggregating asynchronous responses by replacing asynchronous requests in an original request thread with placcholders with a unique identifier, creating new threads for each asynchronous request, writing a script to request the asynchronous request output, and returning the original request and the script to the client. Each of the new threads run independently and when completed, place the output in the server store. The script then requests each output from the server store as the output becomes available to fill the placeholders.

Description:
FIELD OF THE INVENTION 
     The invention relates generally to computer data processing, and particularly to asynchronous execution of requests on a distributed computer system. 
     BACKGROUND OF THE INVENTION 
     Clients use distributed computer environments to perform a variety of tasks across multiple applications. For a typical task, a client sends a request to a distributed computer environment, which returns a response to the client. While this seems simple enough, there are actually several intermediate steps involved in executing such a request. First, a user or an application initiates the client request by sending the request to an application server. The application server is a computer acting as an intermediary between the client and other resources making up the distributed computer environment. The application server may perform such tasks as verifying the client&#39;s security credentials and determining which resource on the distributed computer environment is appropriate for executing the client&#39;s request. Second, the application server forwards the request to the appropriate resource on the client&#39;s behalf. Third, after the request executes on the appropriate resource, the application server sends the response to the client. 
     Certain fragment markup and assembly technologies, such as EDGE SIDE INCLUDE (ESI), DELTA ENCODING, and other fragment markup and assembly engines allow for the fragmentation of requests under certain circumstances at the application server. Often, requests can be split into multiple smaller tasks, or “fetches” and distributed across multiple resources. After all the fetches are executed, the fragmented responses are reassembled and returned to the client. Fragmentation allows for more efficient use of resources and for lower cycle-times on a distributed computer environment. Once all the fragments are executed, the responses are aggregated and returned to the client. 
     When fragments execute in sequence, there can be a long delay from the time the request is made until the fragmented responses are aggregated and returned to the client. To shorten the overall time needed to execute a set of fragments, methods have been developed to allow request fragments to execute asynchronously. With asynchronous execution, fragments can be executed simultaneously, or in any order, reducing the overall time needed to execute a fragmented request. 
     One example of dispatching asynchronous threads is disclosed in U.S. Pat. No. 7,003,570 owned by BEA Systems, Inc. The &#39;570 patent discloses a system that operates on an application server that provides for asynchronous processing of request fragments. After all the request fragments are executed and responses returned to the application server, the responses are aggregated and returned to the client from the application server. But aggregation takes place at the application server, and application server system resources are tied up. 
     In addition to tying up application server system resources, current asynchronous fragment execution systems require that the client wait until all the fragments are executed and aggregated before receiving a response. Depending on the complexity of the original request, the client may have a long wait before receiving a response. Meanwhile, the application server is tied up with the execution thread until the entire request is executed. The delay is particularly acute when executing multiple fragments and aggregating the fragmented responses before returning a response to the client. Therefore, a need exists for a way to free up the execution thread and shift the burden of retrieving and aggregating the response to the client, freeing up application server resources while preserving in a fragment any context included in the original request. 
     SUMMARY OF THE INVENTION 
     The Asynchronous Aggregator frees up an original execution thread and shifts the burden of retrieving and aggregating asynchronous responses from the server to the client. This is achieved by creating new threads for the execution of each asycnchronous request, registering the asynchronous include for each asynchronous request with a server store, replacing asynchronous request content in the response with placeholders that contain a unique identifier, writing javascript in place of each asynchronous include to enable the client to request the asynchronous include content, the returning the modified response output containing the javascript to the client. Each of the new threads run independently and, when completed, place the output in the server store. The javascript then requests each output from the server store to fill the placeholders. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         FIG. 1  depicts an exemplary computer network; 
         FIG. 2  depicts an exemplary memory on a distributed computer system containing the Asynchronous Aggregator; 
         FIG. 3  depicts a flowchart of a Java Servlet Container; 
         FIG. 4  depicts a flowchart of the Server Store Process; 
         FIG. 5  depicts a flowchart of the Javascript Process; and 
         FIG. 6  depicts a diagram of an overview of the Asynchronous Aggregator process. 
     
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     The principles of the present invention are applicable to a variety of computer hardware and software configurations. The term “computer hardware” or “hardware,” as used herein, refers to any machine or apparatus that is capable of accepting, performing logic operations on, storing, or displaying data, and includes without limitation processors and memory; the term “computer software” or “software,” refers to any set of instructions operable to cause computer hardware to perform an operation. A “computer,” as that term is used herein, includes without limitation any useful combination of hardware and software, and a “computer program” or “program” includes without limitation any software operable to cause computer hardware to accept, perform logic operations on, store, or display data. A computer program may, and often is, comprised of a plurality of smaller programming units, including without limitation subroutines, modules, functions, methods, and procedures. Thus, the functions of the present invention may be distributed among a plurality of computers and computer programs. The invention is described best, though, as a single computer program that configures and enables one or more general-purpose computers to implement the novel aspects of the invention. For illustrative purposes, the inventive computer program will be referred to as the “Asynchronous Aggregator.” 
     Additionally, the Asynchronous Aggregator is described below with reference to an exemplary network of hardware devices, as depicted in  FIG. 1 . A “network” comprises any number of hardware devices coupled to and in communication with each other through a communications medium, such as the Internet. A “communications medium” includes without limitation any physical, optical, electromagnetic, or other medium through which hardware or software can transmit data. For descriptive purposes, exemplary network  100  has only a limited number of nodes, including workstation computer  105 , workstation computer  110 , server computer  115 , and persistent storage  120 . Network connection  125  comprises all hardware, software, and communications media necessary to enable communication between network nodes  105 - 120 . Unless otherwise indicated in context below, all network nodes use publicly available protocols or messaging services to communicate with each other through network connection  125 . 
     Asynchronous Aggregator  200  typically is stored in a memory, represented schematically as memory  220  in  FIG. 2 . The term “memory,” as used herein, includes without limitation any volatile or persistent medium, such as an electrical circuit, magnetic disk, or optical disk, in which a computer can store data or software for any duration. As shown in  FIG. 2 , memory  220  is distributed across a plurality of media, namely, client  210 , application server tier  250 , and backend server tier  290 . Thus,  FIG. 2  is included merely as a descriptive expedient and does not necessarily reflect any particular physical embodiment of memory  220 . As depicted in  FIG. 2 , though, memory  220  may include additional data and programs. Of particular import to Asynchronous Aggregator  200 , memory  220  may include browser  212  on client  210  and target resource  291  on backend server tier  290 . Asynchronous Aggregator  200  has three components: Java Servlet Container  300  and generic Java Service  600  located on application server tier  250 , and JavaScript  500  on client  210 . Java Servlet  300  has four sub-components: request dispatcher  301 , filter  302 , script writer  303 , and Async Bean  304 . Generic Java Service  600  has an allocation of memory for storage, server store  601 . 
       FIG. 3  is a flowchart depicting the logic of Java Servlet Container  300 . Although Java Servlet Container  300  is described here as a single application with four sub-components (see  FIG. 2 ), Java Servlet Container  300  may be a collection of related servlets and applications that work together to perform the functions described herein. When the client sends an original request to the application server, the original request begins executing on an original thread. The original thread is a servlet/jsp received by Java Servlet Container  300  on the application server. Java Servlet Container  300  starts ( 310 ) when the original thread is received by application server tier  250  ( 312 ), and Java Servlet Container  300  determines whether the original request contains an async include ( 314 ). If not, Java Servlet Container  300  processes the request normally without utilizing any asynchronous behavior ( 315 ). If the request contains an async include, then request dispatcher  301  is called ( 316 ). 
     Request dispatcher  301  executes the request ( 318 ). When request dispatcher  301  executes the request, it executes the initial servlet/jsp resource as well as the async include that is part of the servlet/jsp. Request dispatcher  301  replaces the response output of the async include in the original request with a placeholder containing a unique identifier ( 320 ). The purpose of the placeholder is to indicate where the async include content will persist when the client receives the async include content from the generic service store (server store  601 ). When the client receives the async include content, the placeholders are replaced with the actual response output from the execution of the async include. 
     Request dispatcher  301  uses filter  302  to copy the original request and response object ( 322 ) and passes the copy to the async include ( 324 ). This is required because the request and response objects are not designed to be used on multiple threads concurrently. The request object is the representation of the request from the client to execute the resource. The response object is the representation of what is sent back to the client in the response to the request. Next, request dispatcher  301  creates a unique identifier for the async include ( 326 ) and registers the unique identifier with the server store ( 328 ). Register means a process in which the original thread registers a unique identifier (or token) with the server store prior to executing the async include to indicate that an async include is about to occur with the unique identifier (or token). 
     Request dispatcher  301  calls script writer  303  to write content and include javascript for the async include ( 330 ). The javascript contains AJAX style requests containing the unique identifier that corresponds to the async include so that the placeholder can be populated with the response at a later time. Request dispatcher  301  then uses Async Bean  304  to start a new thread for the async include ( 332 ). The new thread is sent to a specified asynchronous resource. Upon completion of writing the placeholders and javascript, any additional content from the original request is written, the original request completes, and the thread is returned. The javascript will be run transparently on the client for retrieving responses to the async include from the server store. 
     Java Servlet Container  300  then determines whether there is another async include in the original request ( 334 ). If there another async include in the original request, Java Servlet Container  300  goes to step  320 . If not, Java Servlet Container  300  sends the original request to the client ( 336 ). Java Servlet Container  300  determines whether an async include has completed processing ( 338 ). If an async include has completed processing, Java Servlet Container  300  publishes the response output from the async include with the server store ( 342 ). If not, Java Servlet Container  300  waits ( 340 ) and returns to step  338 . Java Servlet Container  300  determines whether there is an async include that has not yet completed processing ( 344 ). If so, Java Servlet Container  300  goes to step  338 . If not, Java Servlet Container stops ( 350 ). 
       FIG. 4  is a flowchart depicting the logic of Server Store Process  400 . Server Store Process starts ( 402 ) and receives a notification that an asynchronous request will occur with an associated unique identifier ( 410 ). Server store  601  (see  FIG. 2 ) receives the content of the asynchronous response output ( 412 ). Server Store Process  400  determines whether an async output request has been received from a client ( 414 ). If not, Server Store Process  400  waits ( 416 ) and returns to step  414 . If an async output request has been received, then the Server Store Process  400  releases the async request output from server store  601  ( 418 ). Server Store Process  400  determines whether there is another notification ( 420 ). If so, Server Store Process returns to step  412 , and if not, stops ( 430 ). 
       FIG. 5  is a flowchart depicting the logic of flowchart of Javascript  500 . Javascript  500  starts when received at client  210  ( 510 ) and displays on Browser  212  the placeholders for the request fragment responses ( 512 ). Javascript  500  calls Generic Java Service  600  ( 514 ) and queries for the request fragment response ( 516 ). If the request fragment response is not ready, Javascript  500  waits a predetermined period ( 520 ) and goes to step  514 . If the request fragment response is ready, Javascript  500  retrieves the response ( 522 ), replaces the placeholder with the response ( 524 ), refreshes the HTML display on browser  212  ( 526 ) and stops ( 528 ). 
       FIG. 6  depicts propagation of a request in distributed memory  700 . Numeral  701  represents an original request made by browser  212  on client  210  to Java Servlet Container  300 . Three async includes are identified in the original request, and Request Dispatcher  301  is called. The async includes are extracted and placeholders inserted into the original request. Numeral  707  represents the original request with placcholders for the async includes being returned to the client After the copies of the original request and response objects are passed to each of the async includes, numeral  702  represents the three async includes having unique identifiers created by filter  302 . The unique identifiers are registered with the server store  601 . Numeral  703  represents new threads being created by Async Bean  304 . Numeral  704  represents registration of the three new threads with Generic Java Service  600 . Numeral  705  and  706  represent request dispatcher  301  invoking script writer  303  to write content and include javascript for the new threads. Numerals  708  and  709  represent Generic Java Service  600  asynchronously accessing resources on backend server tier  290  while executing the async includes of the new threads. Responses to the three async includes are stored in server store  601 . Numeral  710  represents client requests for the responses and numeral  711  represents the async include responses being sent to javascript  500  on client  210 . 
     A preferred form of the invention has been shown in the drawings and described above, but variations in the preferred form will be apparent to those skilled in the art. The preceding description is for illustration purposes only, and the invention should not be construed as limited to the specific form shown and described. The scope of the invention should be limited only by the language of the following claims.