Electrical computers and digital processing systems: multicomput – Computer-to-computer session/connection establishing
Reexamination Certificate
2000-03-14
2004-03-02
Voeltz, Emanuel Todd (Department: 2154)
Electrical computers and digital processing systems: multicomput
Computer-to-computer session/connection establishing
C709S228000
Reexamination Certificate
active
06701367
ABSTRACT:
BACKGROUND
This invention relates generally to computer systems, and more particularly to a mechanism for enabling a customized session manager to interact with a network server.
On the Internet or World Wide Web, information is generally communicated on a request-response basis. That is, a client (typically running a browser program) submits a service request to a server. The service request may simply ask for a static page (usually in HTML format), or it may request that a particular application or program be executed to generate a return page. In response to the service request, the server performs whatever tasks are necessary to service the request, and provides a return page to the client. This request-response sequence, referred to as a “roundtrip”, is carried out for each request.
Generally, the Internet is a stateless environment. That is, each service request is treated as its own individual request, and there is no “memory” of prior requests. Put another way, the server makes no association between a current request and a previous request, even if the requests are from the same client, and even if the requests have some common nexus. For simple applications in which every task that needs to be performed can be carried out in a single roundtrip, this statelessness is not a problem. However, for exchanges (such as transactions) that require multiple roundtrips, the lack of state presents a significant impediment.
An example of an application in which it is necessary to maintain state across multiple roundtrips is that of an “electronic shopping cart” application. More specifically, a user visits a merchant's website using a particular client machine. As the user peruses the website, he sees an item that he wishes to purchase, and puts that item into his “shopping cart”. As some point, the user invokes a link to another page of the website, and at that point, a request is sent to the server which requests the desired page and which also provides to the server all of the items currently in the shopping cart. The server responds to the request by storing information pertaining to the shopping cart items, and by providing the desired page to the client. Thereafter, the user peruses the new page and puts additional items into the shopping cart. In a subsequent request by the client, the additional items in the shopping are sent to the server. Since the subsequent request is from the same client, the server should associate the additional items with the previous items as being in the same shopping cart. To do this, though, the server needs to associate the subsequent request with the previous request, which in turn requires that the server maintain state information relating to the requests. However, as noted above, the Internet is generally a stateless environment. As a result, without further functionality on the part of the server, multiple roundtrip exchanges, such as those required by the electronic shopping cart application, cannot be implemented on the Internet.
To enable exchanges which require multiple roundtrips, some servers implement a session management functionality. Basically, this functionality maintains state information across multiple roundtrips so that associations between multiple requests can be made. Usually, state information is maintained by passing session ID information back and forth between the client and the server. For example, when a service on the server requiring state information is first invoked by a client request, a new session is created, and a new session ID is associated with the new session. The session acts as a “container” that can be used to store all of the necessary state information relating to that particular session. Once the session is created (and possibly updated to include state information relating to processing of the current request), the associated session ID is provided to the client that requested the service. If that client makes a subsequent request to the same service, the client includes in that request the session ID. Using the session ID, the server accesses the associated session, and based upon the state information stored in the associated session, the server can determine what has transpired thus far. In this manner, the server is able to associate a current request with one or more previous requests.
Typically, the session management functionality of a server is an integral part of the server. This means that in order to make any changes to the session management functionality, it is necessary to change and to recompile the core server code. While this simplifies the overall architecture of the server, it can lead to significant drawbacks, such as inflexibility and non-scalability. Both of these limit the overall effectiveness of the server. As a result, there is a need for an improved session management architecture.
SUMMARY OF THE INVENTION
In light of the shortcomings of the prior art, the present invention provides an improved session management mechanism which enables customized session managers to interact with a network server. In accordance with the present invention, there is provided a programming interface which enables customized session managers to “plug in” to and to interact with the server. In one embodiment, the programming interface takes the form of an abstract class definition, and each customized session manager is a subclass of the abstract class. Each customized session manager can provide a customized method implementation for each method defined by the abstract class.
This programming interface makes it possible to change session management functionality without having to make any changes to the core server. More specifically, to change session management functionality, all that needs to be done is to alter the code for a particular session manager and to recompile that session manager. The server code does not need to be altered or recompiled. This significantly increases the flexibility of the server. In addition, the programming interface makes it possible to incorporate multiple session managers into the server. Each session manager can be assigned to a certain set of applications, and each session manager can manage sessions in its own customized fashion. The ability to incorporate multiple session managers into the server significantly increases the flexibility and scalability of the server.
In addition to the programming interface, the present invention further provides a service engine for coordinating the interaction with the session managers. More specifically, for each client request, the service engine determines which application needs to be invoked. Then, based upon that application, the service engine determines which, if any, associated session manager needs to be invoked to manager session (i.e. state) information for that application. The service engine invokes the session manager via the programming interface. With the programming interface and the service engine, the present invention provides a flexible and scalable mechanism for implementing session management functionality in a network server.
REFERENCES:
patent: 5410698 (1995-04-01), Danneels et al.
patent: 5691973 (1997-11-01), Ramstrom et al.
patent: 5790790 (1998-08-01), Smith et al.
patent: 5793415 (1998-08-01), Gregory, III et al.
patent: 5796393 (1998-08-01), MacNaughton et al.
patent: 5809145 (1998-09-01), Slik et al.
patent: 5809248 (1998-09-01), Vidovic
patent: 5835724 (1998-11-01), Smith
patent: 5872963 (1999-02-01), Bitar et al.
patent: 5918228 (1999-06-01), Rich et al.
patent: 5928323 (1999-07-01), Gosling et al.
patent: 5961584 (1999-10-01), Wolf
patent: 5991792 (1999-11-01), Nageswaran
patent: 6012090 (2000-01-01), Chung et al.
patent: 6052711 (2000-04-01), Gish
patent: 6112196 (2000-08-01), Zimowski et al.
patent: 6182109 (2001-01-01), Sharma et al.
patent: 6374286 (2002-04-01), Gee et al.
patent: 6393477 (2002-05-01), Paxhia et al.
patent: 6418458 (2002-07-01), Maresco
Sebastian Wilhelmi, “Re: (ORBit-mt-0.5.7)g_main_iterate(): main loop already active in another thread,” Jan. 28, 200
Hickman Palermo Truong & Becker
Nicholes Christian A.
Sun Microsystems Inc.
Todd Voeltz Emanuel
Truong Bobby K.
LandOfFree
Mechanism for enabling customized session managers to... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Mechanism for enabling customized session managers to..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Mechanism for enabling customized session managers to... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3241787