Prevention of browser timeout

• US 8,589,946 B2
• Filed: 09/08/2008
• Issued: 11/19/2013
• Est. Priority Date: 09/08/2008
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Schneider, Elena, Zhang, Jia Ming
• Primary Examiner(s): Puente, Emerson
• Assistant Examiner(s): KIM, SISLEY NAHYUN
• Application Number:
  US12/206,476
• Publication Number:
  US 20100064298A1
• Time in Patent Office: 1,898 Days
• Field of Search: None
• US Class Current: 719/313
• CPC Class Codes: G06F 2209/541 Client-server
• CPC Class Codes: G06F 9/485 Task life-cycle, e.g. stopping, restarting, resuming execution G06F9/4881 takes precedence
• CPC Class Codes: G06F 9/54 Interprogram communication
• CPC Class Codes: H04L 67/02 based on web technology, e.g. hypertext transfer protocol [HTTP]
• CPC Class Codes: H04L 69/28 Timers or timing mechanisms used in protocols

Abstract

A method for preventing a browser timeout resulting from multiple requests sent from a client to a server is provided. In response to receiving a request from the client, an application thread is initialized on the server for submitting data to the client. The application thread is observed using a daemon observation thread. If a loading time of the application thread exceeds a timeout, the application thread is terminated. In response to terminating the application thread, an empty response is sent to the client. In response to receiving the empty response to the client, a determination is made whether to make an additional request to the server.

Claims

1. A method for preventing a browser timeout resulting from at least one of a plurality of concurrent requests sent from a client to a server, comprising:

responsive to receiving the at least one of a plurality of concurrent requests from the client, initializing an application thread on the server for submitting data to the client;

observing the application thread using a daemon observation thread;

if a loading time of the application thread exceeds a timeout, terminating the application thread;

configuring the timeout based on a number of potential requests to be received from the client;

responsive to terminating the application thread, sending an empty response to the client;

allowing a next set of the at least one of a plurality of concurrent requests from the client to wait for processing without timing out based upon the configuring;

responsive to receiving the empty response to the client, determining whether to make an additional request to the server,

implementing a maximum number of the plurality of concurrent-requests to be concurrently active in a submitting state, and

placing a plurality of concurrent remaining requests in an inactive state, wherein a first application and observation thread is initialized for a first request in the submitting state, and additional application and observation threads are initialized for additional requests in the submitting state.

2. The method of claim 1, wherein the maximum number of the plurality of concurrent requests to be concurrently active in the submitting state is two.

3. The method of claim 1, wherein implementing a maximum number of the plurality of concurrent requests to be concurrently active in a submitting state is performed by a request control framework operable on the client, the request control client adapted for defining the submitting and inactive states.

4. The method of claim 3, further including, subsequent to determining whether to make an additional request, placing the additional request in the submitting state to be resubmitted to the server.

5. A system for preventing a browser timeout resulting from at least one of a plurality of concurrent requests sent from a client to a server, comprising:

an application module operable on the server; and

a request control module operable on the client, the request control module in communication with the application module, wherein;

the application module is adapted for, responsive to receiving at least one of a plurality of concurrent requests from the client, initializing an application thread on the server for submitting data to the client,

observing the application thread using a daemon observation thread,

if a loading time of the application thread exceeds a timeout, terminating the application thread,

configuring the timeout based on a number of potential requests to be received from the client,

allowing a next set of the at least one of a plurality of concurrent requests from the client to wait for processing without timing out based upon the configuring,

responsive to terminating the application thread, sending an empty response to the client,

the request control module is adapted for, responsive to receiving the empty response to the client, determining whether to make an additional request to the server,

wherein the request control module is further adapted for;

implementing a maximum number of the plurality of concurrent requests to be concurrently active in a submitting state, and

placing a plurality of concurrent remaining requests in an inactive state, wherein a first application and observation thread is initialized for a first request in the submitting state, and additional application and observation threads are initialized for additional requests in the submitting state.

6. The system of claim 5, wherein the maximum number of the plurality of concurrent requests to be concurrently active in the submitting state is two.

7. The system of claim 5, wherein the application module is further adapted for configuring the timeout based on a number of potential requests to be received by the client.

8. The system of claim 5, wherein the request control client is further adapted for defining the submitting and inactive states.

9. The system of claim 8, wherein the request control module is further adapted for, subsequent to determining whether to make an additional request, placing the additional request in the submitting state to be resubmitted to the server.

10. A computer program product for preventing a browser timeout resulting from at least one of a plurality of concurrent requests sent from a client to a server, the computer program product comprising a non-transitory computer-readable storage medium having computer-readable program code portions stored therein, the computer-readable program code portions comprising:

a first executable portion for, responsive to receiving at least one of a plurality of concurrent requests from the client, initializing an application thread on the server for submitting data to the client;

a second executable portion for observing the application thread using a daemon observation thread;

a third executable portion for, if a loading time of the application thread exceeds a timeout, terminating the application thread;

a fourth executable portion for, responsive to terminating the application thread, sending an empty response to the client;

a fifth executable portion for, responsive to receiving the empty response to the client, determining whether to make an additional request to the server;

a sixth executable portion for allowing a next set of the at least one of a plurality of concurrent requests from the client to wait for processing without timing out based upon the configuring;

a seventh executable portion for configuring the timeout based on a number of potential requests to be received from the client,

an eighth executable portion for implementing a maximum number of the plurality of concurrent requests to be concurrently active in a submitting state, and

a ninth executable portion for placing a plurality of currently remaining requests in an inactive state, wherein a first application and observation thread is initialized for a first request in the submitting state, and additional application and observation threads are initialized for additional requests in the submitting state.

11. The computer program product of claim 10, wherein the maximum number of the plurality of concurrent requests to be concurrently active in the submitting state is two.

12. The computer program product of claim 10, further including a tenth executable portion for defining the submitting and inactive states.

13. The computer program product of claim 12, further including an eleventh executable portion, subsequent to determining whether to make an additional request, placing the additional request in the submitting state to be resubmitted to the server.