(19) United States
`(12) Patent Application Publication (10) Pub. No.: US 2004/0143645 A1
`
`
` Cheenath (43) Pub. Date: Jul. 22, 2004
`
`US 20040143645A1
`
`(54) ASYNCHRONOUS WEB SERVICE
`INVOCATION MODEL
`
`(52) US. Cl.
`
`.............................................................. 709/218
`
`(76)
`
`Inventor: Manoj Cheenath, Alameda, CA (US)
`
`(57)
`
`ABSTRACT
`
`Correspondence Address
`Sheldon R Meyer Esq.
`FLIESLEI-l DUBP: ME-YER & LOVEJOY LLP
`Fourth Floor
`Four Embarcadero Center
`San Francisco CA 94111_4156 (US)
`’
`'
`.
`-
`(21) APp1' NO"
`10/348,315
`(22) Filed:
`Jan. 21, 2003
`
`publication Classification
`
`(51)
`
`Int. Cl.7 ..................................................... G06F 15/16
`
`A system and method for asynchronously invoking a remote
`web service on a server by application code residing on a
`client. The web. serv1ee invoke request received from appli—
`cation code residing on the client, passes an invoke request
`to a web service residing on a server, receives a result from
`the web serVice, the result relating to the invoke request
`passed by the client, and transmits the result to the appli-
`cation code. Once the invoke request is passed to the web
`service by the client, the application code is freed to perform
`other tasks. The result may be transmitted to the application
`code from the client as part of a call back object passed to
`the client by the application code, as a result of application
`code polling 0f the client, or by the application code ending
`the task generated by the client.
`
`
`
`ode
`TApplicatiohiC
`Invokes Web
`
`
`
`
`
`Service, Passes
`Call Back
`
`20
`
`50
`
`60
`
`Client Passes
`Request to Web
`Service
`
`Web Service
`Recieves and
`Processes
`
` l
`
` Application Code
`
`
`
`Request
`
`
`Web Sue‘rVice
`Transmits Results
`to Client
`mt.
`Client Receives
`
`Result. Calls Back
`Application Code
`
` l
`
`Receives Call
`Back. Obtains
`Result
`
`mul—
`Gad) fl
`
`Page 1 of 12
`
`GOOGLE EXHIBIT 1014
`
`Page 1 of 12
`
`GOOGLE EXHIBIT 1014
`
`

`

`Patent Application Publication
`
`Jul. 22, 2004 Sheet 1 0f 5
`
`US 2004/0143645 A1
`
`
`
`Processor
`
`1
`
`121
`
`Bus
`
`
`
`
`
`
`
`
`
`
`Client Web
`
`Service
`
`Application
`
`1.3.5.
`
`WED Service
`
`Sewer
`
`Page 2 of 12
`
`Page 2 of 12
`
`

`

`Patent Application Publication Jul. 22, 2004 Sheet 2 0f 5
`
`US 2004/0143645 A1
`
`
`
`
`
`
`
`Client Invokes
`
`
`Web Service on Q
`
`
`
`
`Application Code
`Requests Web
`
`Web Service
`
`Receives and
`
`Processes
`
`
`
`
`
`Request
`
`
`
`
`Web Service
`
`240
`Transmits Results
`to Client _
`
`
`
`2.0—
`
`fl
`
`60
`
`
`
`Client Provides
`
`
`
`Results to
`
`
`
`Application Code
`
`
`
`Page 3 of 12
`
`
`
`FIG. 2 - Prior Art
`
`Page 3 of 12
`
`

`

`Patent Application Publication Jul. 22, 2004 Sheet 3 0f 5
`
`US 2004/0143645 A1
`
`
`
`Application Code
`Invokes Web
`
`
`
`Service, Passes
`
`Call Back
`
`
`20
`
`
`
`
`
`
`
`
`
`Client Passes
`Request to Web
`Service
`
`
`
`Web Service
`
`330
`Recieves and
`Processes _
`
`
`
`
`Request
`
`
`
`
`
`
`Web ServiCe '
`
`Transmits Results
` to Client
`
`340
`
` Application Code
`
`
`
`
`Receives Call
`
`Back, Obtains
`
`Page 4 of 12
`
`Page 4 of 12
`
`

`

`Patent Application Publication Jul. 22, 2004 Sheet 4 0f 5
`
`US 2004/0143645 A1
`
`
`
`
`
`Application Code
`lnvokes Web
`
`Service
`
`Application Code
`
`Web Service
`
`Receives and
`
`
`
`
`Client Passes
`
`
`Request to Web
`Service, Frees
`
`
`
`
`
`
`
`Processes
`Request
`
`
`
`Web Service
`Transmits Results
`
`440
`
`
`
`
`
`to Client
`
`Application Code
`Polls Client -
`
`esult Received?
`
`Application Code
`Obtains Result
`
`
`
`
`
`
`Page 5 of 12
`
`Page 5 of 12
`
`

`

`Patent Application Publication Jul. 22, 2004 Sheet 5 0f 5
`
`US 2004/0143645 A1
`
`
`
`
`
`
`
`Application Code
`invokes Web
`SerVice
`
`
`
`
`
`
`
`
`Client Passes
`
`
`Request to Web
`
`
`Service
`
`fl
`
`52
`
`5_3_Q
`
`540
`
`fig
`
`.QQ
`
` Application Code
`
`
`
`Performs Other
`
`Tasks
`
`
`
`
`
`
`
`
` Web Service
`Receives and
`Processes
`
`Request
`
`
`
`Web Service
`Transmits Results
`
`
`
`‘
`
`to Client
`
`
`
`Application Code
`calls End Q
`
`
`
`
`
`ObtainstResult
`
`A Iication Code
`pp
`
`580
`
`
`
`Page 6 of 12
`
`Page 6 of 12
`
`

`

`US 2004/0143645 A1
`
`Jul. 22, 2004
`
`ASYNCHRONOUS WEB SERVICE INVOCATION
`MODEL
`
`COPYRIGHT NOTICE
`
`[0001] A portion of the disclosure of this patent document
`contains material which is subject to copyright protection.
`The copyright owner has no objection to the facsimile
`reproduction by anyone of the patent document or the patent
`disclosure, as it appears in the Patent and Trademark Office
`patent file or records, but otherwise reserves all copyright
`rights whatsoever.
`
`FIELD OF THE INVENTION
`
`[0002] The current invention relates generally to remote
`web services, and more particularly to asynchronously
`invoking a remote web service.
`
`BACKGROUND OF THE INVENTION
`
`Java standards for web services are constantly
`[0003]
`being developed. Concurrently, businesses are building
`important applications on top of web services infrastruc-
`tures, such as that available in WebLogic Server from BEA
`Systems of San Jose, Calif. As these applications evolve,
`they become more complex with more operations to per-
`form.
`
`[0004] A system illustrating a client-server system is illus-
`trated in FIG. 1. A typical web service 135 residing on a
`server 130 may be accessed by a client 120. The client may
`be implemented as a stand alone machine that communicates
`with the server over a physical connection or a logically
`implemented client that resides on the same machine as the
`server. If implemented on a stand alone machine, the client
`includes a processor 121, RAM 122, input means 123 and
`output means 124. In either embodiment,
`the client
`is
`configured to include vendor—added application code 125 as
`well as standard JAVA objects such as client web service
`applications 126 such as client web service Runtime. The
`server 130 includes a web service 135. A user may invoke
`the web service 135 through the client 120.
`
`[0005] FIG. 2 illustrates a method 200 for invoking a web
`service in accordance with one embodiment of the present
`invention. Operation of method 200 begins with start step
`205. Application code requests a web service at step 210. In
`one embodiment, application code residing within the client
`initiates a call to the client’s runtime routine to request a web
`service residing on a server. This may be initiated by a user
`or other code within the client. Next, the client invokes the
`web service on the server in step 220. The invocation request
`initiates the generation of an application thread by runtime
`in which the request is carried out. The server receives the
`request and processes the request at step 230. Next,
`the
`server returns a result to the client at step 240. The client
`receives the result in step 250 and provides the application
`code with the result at step 260. The thread is then complete
`and operation of method 200 then ends at step 265. Through-
`out steps 220-260, the synchronized operation initiated by
`the application code is performed within a single thread.
`Thus, the synchronized operation involves the application
`code waiting for a response from the client before perform-
`ing other tasks. Thus, the thread is blocked until the web
`service invoke is complete. An Enterprise Java Bean (EJB)
`does not allow application code to create new threads. As a
`
`result, the method currently used by client server systems to
`process user requests is slow and inefficient.
`
`[0006] What is needed is a web service invocation model
`that allows a user to perform other tasks while a request is
`being processed.
`
`SUMMARY OF THE INVENTION
`
`invention provides asynchronous
`[0007] The present
`remote web service invocation. Asystem in accordance with
`one embodiment of the present invention includes a client
`and a remote server. Invocation of a web service on the
`server by the client is initiated from an application thread.
`This application thread is then freed by the client web
`service runtime to allow the application to process other
`tasks while the web service is invoked. In one embodiment,
`asynchronous web service invocation for a system in Java is
`implemented by freeing the thread used by the application to
`invoke the web service. (ok to remove?) Once the first thread
`is free, the application code may perform other tasks while
`the second thread carries out the web service invocation.
`Results from the invoked remote web service are transmitted
`to the client.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`[0008] FIG. 1 is an illustration of a system for providing
`access to a remote web service by a user in accordance with
`one embodiment of the present invention.
`
`[0009] FIG. 2 is an illustration of a prior art method for
`providing synchronous invocation of a remote web service.
`
`[0010] FIG. 3 is an illustration of a method for providing
`asynchronous invocation of a remote web service using a
`callback technique in accordance with one embodiment of
`the present invention.
`
`[0011] FIG. 4 is an illustration of a method for providing
`asynchronous invocation of a remote web service using a
`polling technique in accordance with one embodiment of the
`present invention.
`
`[0012] FIG. 5 is an illustration of a method for providing
`asynchronous invocation of a remote web service using a
`delayed end call technique in accordance with one embodi-
`ment of the present invention.
`
`DETAILED DESCRIPTION
`
`invention provides asynchronous
`[0013] The present
`remote web service invocation. Asystem in accordance with
`one embodiment of the present invention includes a client
`and a remote server. Invocation of a web service on the
`server by the client
`initiates an application thread. The
`application initiated thread is used to access the web service.
`The user generated thread is then freed to allow the appli-
`cation to process other tasks while the web service is
`invoked. In one embodiment, asynchronous web service
`invocation for a system in Java is implemented by freeing
`the thread initiated by the application to invoke the web
`service. In one embodiment, the client web service run time
`frees the first thread and uses a second thread to carry out the
`web service invocation. Once the first thread is free, the
`application code may perform other tasks while the second
`thread carries out the web service invocation. Results from
`the invoked remote web service are transmitted to the client.
`
`Page 7 of 12
`
`Page 7 of 12
`
`

`

`US 2004/0143645 A1
`
`Jul. 22, 2004
`
`[0014] A method 300 for providing asynchronous invoca-
`tion of a remote web service using a call back technique in
`accordance with one embodiment of the present invention is
`illustrated in FIG. 3. Operation of method 300 begins with
`start step 305. Application code invokes a web service and
`passes a call back parameter to the client in step 310. During
`the invocation of the web service by the application code,
`the client web service Runtime Routine generates a first
`thread to carry out the invocation. The application code may
`be located on a stand alone client machine or implemented
`logically as discussed above in reference to FIG. 1. In one
`embodiment, the application code creates an async context
`and passes a call back object to the client as part of asynch
`context creation. The async context may contain informa—
`tion. A start method call made subsequently by the client
`may include the asynchronous context (AC) and arguments.
`
`In step 320, the client passes a request to the web
`[0015]
`service. In one embodiment, passing a request to the web—
`service includes invoking an operation to access the remote
`web service by generating a second thread while the first
`application thread is freed. Freeing the first application
`thread allows the user to process other tasks instead of
`waiting to receive the result from the web service invoca-
`tion. In one embodiment, a call is made to the asannvoke
`method on the client stub. The operation then sends a
`message to a client dispatcher located on the client. The
`client dispatcher then creates a FutureResult object,
`the
`object
`to be sent back to the user, creates a task, and
`schedules this task to the thread pool. The created task
`includes sending a request to the web service and receiving
`a result from the web service. Scheduling a task to the thread
`pool allows a second thread to handle execution of the task.
`The task is then executed by calling a method of the web
`service. The second thread processes the call that invokes
`the task. The task uses a protocol binding to transmit the task
`request data over a network to a web service for processing.
`
`[0016] The Web service located on the server receives and
`processes the request at step 330. Processing the request
`includes invoking the requested web service and obtaining a
`result. The server will use the parameters passed by the
`client, if any, to obtain a result from the web service. Once
`the remote method of the web service has been invoked and
`a result is generated, the result is transmitted by the web
`service back to the client at step 340. In one embodiment, the
`result is received by the protocol binding. The task then sets
`the future result value to the value of the result received from
`the web service.
`
`[0017] The client receives the result and invokes a call
`back to the application code at step 350. In one embodiment,
`the call back indicates the result is available at the client for
`
`the application code to access. In one embodiment, this
`includes the web service client runtime initiating the context
`to notify any listening entities.
`
`[0018] The application code receives the call back and
`obtains the result
`from the client at step 360.
`In one
`embodiment, the application code accesses the web service
`client runtime and retrieves stored FutureResult value. In yet
`another embodiment, the client invokes the client stub. The
`client stub then retrieves the future result from the client and
`
`provides the application code with the result. Operation of
`method 300 then ends at step 355.
`
`Page 8 of 12
`
`[0019] An example of application code that may be used
`to implement the method of FIG. 3 along with client code
`(not shown) is shown below.
`
`public class Main{
`public void test ( ) throws cheption{
`SimpleTest echoService = new SimpleTestilrnpl ( );
`SinipleTestSoap echol’ort = echoService.getSinipleTestSoap ();
`[/ /callback style
`WSContext WSContext = new WSContext ( );
`wsCOntext.setResultListener( new ResultListener ( ) {
`public void onCompletion ( InvokeCompletedEvent event ) {
`SimpleTestSoap source = (SimpleTesLSoap)
`event.getSource (
`
`);
`
`try{
`
`String result = source.endEchOString(
`event. getFutureResult ( ) );
`weblogic.utils.Debug.say ( Acallback result: @ +
`
`result );
`
`gotCallback = true;
`}catch ( RemoteException e ) {
`e.printStackTrace ( Systemout :I;
`
`‘r
`
`}
`
`echoPort.startEchOString ( A94501", WSContext );
`
`}
`
`In another embodiment of the present invention, a
`[0020]
`polling technique may be used to asynchronously invoke a
`remote web service. A method 400 for providing asynchro-
`nous invocation of a remote web service using a polling
`technique in accordance with one embodiment of the present
`invention is illustrated in FIG. 4. Operation of method 400
`begins with start step 405. Application code invokes a web
`service in step 410. In one embodiment, application code
`invokes a call to remote method of a remote web service in
`step 410. In contrast to the call back technique of method
`300 in FIG. 3, no call back is passed with the remote method
`call. As in method 300,
`the web service client runtime
`generates a thread upon the invocation request by the
`application code. The web service invocation may be initi-
`ated by a user action at a console, on a graphical user
`interface, or by application code. The application code may
`be located on a remote or logically implemented client. In
`one embodiment,
`the application code creates an async
`context and calls a start method. The start method call may
`include the asynchronous context (AC) and arguments.
`
`[0021] Next, the client calls a remote method of the web
`service and passes the request to the web service in step 420.
`In this embodiment, the client invokes an operation using a
`second thread while freeing the first thread associated with
`the application code. Freeing the first thread allows the user
`to process other tasks instead of waiting to receive the result
`from the web service invocation. In one embodiment, calling
`a remote method includes calling an asannvoke operation
`on the client stub. The operation then sends a message to a
`client dispatcher located on the client. The client dispatcher
`then creates a FutureResult object, the value to be sent back
`to the user, creates a task, and schedules this task to the
`thread pool. The created task includes sending a request to
`the web service and receiving the result of the remote
`method from the web service. Scheduling a task to the thread
`pool allows a second thread to handle execution of the task.
`The task is then executed using an execute call. The second
`
`Page 8 of 12
`
`

`

`US 2004/0143645 A1
`
`Jul. 22, 2004
`
`an operation to access the remote web service in step 520.
`In this embodiment, the client invokes an operation using a
`second thread and passes arguments needed to invoke the
`web service. The arguments may have been generated from
`the application code or the client itself. Invoking an opera-
`tion may include the client stub calling an asannvoke
`operation. The operation then sends a message to a client
`dispatcher located on the client. The client dispatcher then
`creates a FutureResult value, the value to be sent back to the
`application code, creates a task, and schedules the task to the
`thread pool. The created task includes sending a request to
`the web service and receiving a result from the web service.
`Scheduling a task to the thread pool allows a second thread
`to handle execution of the task. The task is then executed
`
`using an execute command. The second thread processes the
`execute command that invokes the task. The task is then sent
`to the client binding. The binding sends the task over a
`network to a web service for processing.
`
`to the web
`[0026] After the client passes the request
`service in step 520, the application code may perform other
`tasks at step 530. These other tasks will
`include tasks
`performed by the application code that do not require a result
`from the invoked web service. Though listed as step 530 in
`method 500 of FIG. 5, the other tasks may be performed at
`any time after the start call is made in step 510 and the end
`call is made in step 570.
`
`[0027] After the application code has made a start call, the
`web service located on the server receives and processes the
`request in step 540. Processing the request includes gener-
`ating a result from the web service. The web service then
`transmits the result to the client in step 550. The client
`receives the result in step 560. In one embodiment, the result
`is received by the binding. The task created earlier then sets
`FutureResnlt to the value of the result received from the web
`service.
`
`[0028] At some point before the application code requires
`the result, the application code will invoke endXXX( ) to
`end the first thread, as shown in step 570. The end call serves
`to end the first thread. In step 580, the application code
`obtains the FutureResnlt
`from the client. Operation of
`method 500 then ends at step 585. An example of user code
`that may be used to implement the method of FIG. 5 is
`shown below.
`
`public void test ( ) throws Exception{
`SimpleTest echoService = new SimpleTestilmpl ( ):
`SimpleTestSoap echoPort = echoService.getSinipleTestSoap ( );
`[/ / sync invoke using async style
`FutureResult futureResult = echoPort.startEchoString l: A94501”,
`null i)=
`// other tasks performed by the application code here.
`String result = echoPorL.endEchoString ( futureResult );
`wcblogic.utils.chug.say (Async result:@ + result);
`
`.
`
`.
`
`In one embodiment of the invention, the systems
`[0029]
`illustrated in FIGS. 3, 4 and 5 may be a request—response
`service. In a request-response service,
`the client sends a
`request to a server and receives a response from the server
`over the same socket connection. In another embodiment of
`
`the present invention, a server may send the result back to
`the client on a second socket connection that differs from the
`
`thread processes the execute command that invokes the task.
`The task uses a protocol binding to send the result back to
`the client. The binding issued to transmit the task over a
`network to a web service for processing.
`
`[0022] The server receives and processes the request to
`obtain a result at step 430. After the server obtains a result,
`the server sends the result to the client, as shown in step 440.
`In one embodiment,
`the result is received by the client
`binding. The task then sets a future result object with the
`value received from the web service. The application code
`then polls the client Runtime to determine if the client has
`received a result from the server in step 450. If the client
`indicates it has not received a result from the server, opera-
`tion loops back to step 450 where the application code
`continues to poll the client. In one embodiment, the user will
`poll the client at some interval of time after the previous poll.
`If the client indicates it has received a result from the server,
`operation continues to step 460. In step 460, the user obtains
`the result from the client runtimc Operation of method 400
`then ends at step 465. In another embodiment, the poll of
`step 460 occurs at some other point during operation of
`method 400 than after step 450. For example, the polling
`step may occur immediately after the client passes the
`request to the web service.
`
`[0023] An example of application code that may be used
`to implement the method of FIG. 4 is shown below.
`
`public class Main{
`public void Lest ( ) throws Exception{
`SimplcTcst echoService = new SimplcTcstilrnpl ( );
`SimpleTestSoap eehoPort = echoService.getSimpleTestSoap ( );
`{ ,’ /async poll style
`FutureResult futureResult = echoPort.startEchOString( A94501”,
`null \I;
`while ( lfutureResult.isCompleted () ) {
`weblogic.utils.Debug.say (Aasync polling ...@ );
`// other tasks performed by the application code here.
`
`.
`
`.
`
`}S
`
`tring result = echoPort.endEchoString ( futureResult );
`weblogic.utils.Debug.say (Apoll result: @ + result );
`
`....
`
`In another embodiment of the present invention, a
`[0024]
`delayed end call technique may be used to asynchronously
`invoke a remote web service. In this embodiment, an end
`method may be called to obtain the result from an asyn-
`chronous invocation. A method 500 for providing asynchro-
`nous invocation of a remote web service using a static end
`technique in accordance with one embodiment of the present
`invention is illustrated in FIG. 5. Operation of method 500
`begins with start step 505. Application code invokes a
`remote web service in step 510. As in methods 300 and 400,
`the invocation request by the application code requires the
`generation of a first thread to process the request. The web
`service invocation may be initiated by a user action at a
`console, on a graphical user interface, or by application
`code. The application code may be located on the client
`computer or on some other system or machine.
`In one
`embodiment, the application code creates an async context
`and calls a start method. The start method call may include
`the asynchronous context (AC) and arguments.
`
`to the web
`the client passes the request
`[0025] Next,
`service in step 520. In one embodiment, the client invokes
`
`Page 9 of 12
`
`Page 9 of 12
`
`

`

`US 2004/0143645 A1
`
`Jul. 22, 2004
`
`line the request was received on by the server. In this
`embodiment, the thread driving the request is free when the
`client sends the request to the server. Once the request is
`processed and a result is obtained by the server, the server
`uses a new thread to drive the transmittal of the result back
`to the client. Since the first thread is freed when the client
`sends the request, the user is free to process other tasks. The
`user is not restricted from doing other tasks while waiting to
`receive the result from the web service. The systems illus-
`trated in FIGS. 3, 4 and 5 may be used to implement a
`system with a server having two one-way transmissions.
`
`In one embodiment of the present invention, asyn-
`[0030]
`chronous web service invocation is enabled when an
`
`attribute generateAsyncMethods in clientgen task is set to
`true. This will generate a client stub with asynchronous web
`invocation methods that start and stop the asynchronized
`invocation.
`
`invention provides asynchronous
`[0031] The present
`remote web service invocation. Asystem in accordance with
`one embodiment of the present invention includes a client
`and a remote server. Invocation of a web service on the
`server by the client
`initiates an application thread. The
`application initiated thread to access the web service. The
`user generated thread is then freed to allow the application
`to process other tasks while the web service is invoked. In
`one embodiment, asynchronous web service invocation for
`a system in Java is implemented by freeing the thread
`initiated by the application to invoke the web service. In one
`embodiment, the client web service run time frees the first
`thread and uses a second thread to carry out the web service
`invocation. Once the first thread is free, the application code
`may perform other tasks while the second thread carries out
`the web service invocation. Results from the invoked remote
`web service are transmitted to the client.
`
`[0032] Other features, aspects and objects of the invention
`can be obtained from a review of the figures and the claims.
`It is to be understood that other embodiments of the inven-
`
`tion can be developed and fall within the spirit and scope of
`the invention and claims.
`
`[0033] The foregoing description of preferred embodi—
`ments of the present invention has been provided for the
`purposes of illustration and description. It is not intended to
`be exhaustive or to limit the invention to the precise forms
`disclosed. Obviously, many modifications and variations
`will be apparent to the practitioner skilled in the art. The
`embodiments were chosen and described in order to best
`
`explain the principles of the invention and its practical
`application,
`thereby enabling others skilled in the art
`to
`understand the invention for various embodiments and with
`various modifications that are suited to the particular use
`contemplated. It is intended that the scope of the invention
`be defined by the following claims and their equivalence.
`
`In addition to an embodiment consisting of spe-
`[0034]
`cifically designed integrated circuits or other electronics, the
`present invention may be conveniently implemented using a
`conventional general purpose or a specialized digital com-
`puter or microprocessor programmed according to the teach-
`ings of the present disclosure, as will be apparent to those
`skilled in the computer art.
`
`[0035] Appropriate software coding can readily be pre—
`pared by skilled programmers based on the teachings of the
`
`present disclosure, as will be apparent to those skilled in the
`software art. The invention may also be implemented by the
`preparation of application specific integrated circuits or by
`interconnecting an appropriate network of conventional
`component circuits, as will be readily apparent to those
`skilled in the art.
`
`[0036] The present invention includes a computer pro-
`gram product which is a storage medium (media) having
`instructions stored thereon/in which can be used to program
`a computer to perform any of the processes of the present
`invention. The storage medium can include, but
`is not
`limited to, any type of disk including floppy disks, optical
`discs, DVD, CD-ROMs, microdrive, and magneto-optical
`disks, ROMS, RAMs, EPROMs, EEPROMs, DRAMs,
`VRAMs, flash memory devices, magnetic or optical cards,
`nanosystems (including molecular memory ICs), or any type
`of media or device suitable for storing instructions and/or
`data.
`
`readable
`[0037] Stored on any one of the computer
`medium (media), the present invention includes software for
`controlling both the hardware of the general purpose/spe-
`cialized computer or microprocessor, and for enabling the
`computer or microprocessor to interact with a human user or
`other mechanism utilizing the results of the present inven-
`tion. Such software may include, but is not limited to, device
`drivers, operating systems, and user applications. Ulti—
`mately, such computer readable media further includes soft-
`ware for performing at least one of additive model repre-
`sentation and reconstruction.
`
`Included in the programming (software) of the
`[0038]
`general/specialized computer or microprocessor are soft-
`ware modules for implementing the teachings of the present
`invention, including, but not limited to, separating planes of
`a source image, averaging at least one of foreground and
`background colors, replacing colors, and compensating for
`error introduced by color replacement
`in one plane by
`feeding error into a second plane, storage, communication of
`results, and reconstructing an image according to the pro-
`cesses of the present invention.
`
`In the claims:
`
`1. A method for asynchronously invoking a remote web
`service on a server by a client, the method comprising:
`
`receiving a web service invoke request by a client, the
`web service invoke request received from application
`code residing on the client;
`
`passing an invoke request by the client to a web service
`residing on a server;
`
`receiving a result by the client from the web service, the
`result relating to the invoke request passed by the
`client;
`
`notifying the application code that the result is available;
`
`receiving a result request from the application code by the
`client; and
`
`transmitting the result to the application code.
`2. The method of claim 1 wherein said receiving a web
`service invoke request includes:
`
`Page 10 of 12
`
`Page 10 of 12
`
`

`

`US 2004/0143645 A1
`
`Jul. 22, 2004
`
`receiving a call back object by the client from the appli-
`cation code, wherein notifying the application code
`includes returning the call back object to the applica-
`tion code from the client.
`
`3. The method of claim 2 wherein the call back object is
`contained in an asynchronous context.
`4. The method of claim 3 wherein passing an invoke
`request by the client to a web service residing on a server
`includes:
`
`passing the asynch context to the web service from the
`client.
`
`5. The method of claim 1 wherein said passing an invoke
`request by the client to a web service residing on a server
`includes:
`
`generating a second thread to process a task generated by
`the client, the task configured to handle invoking the
`web service, wherein a first thread generated from the
`web service invoke request received by the client is
`freed upon the generation of the second thread.
`6. A method for asynchronously invoking a remote web
`service on a server by a client, the method comprising:
`
`receiving a web service invoke request by a client, the
`web service invoke request received from application
`code residing on the client;
`
`passing an invoke request by the client to a web service
`residing on a server;
`
`freeing the web service invoke request by the client;
`
`receiving a result by the client from the web service, the
`result relating to the invoke request passed by the
`client;
`
`receiving a poll from the application code;
`
`notifying the application code that the result is available;
`
`receiving a result request from the application code by the
`client; and
`
`transmitting the result to the application code.
`7. The method of claim 4 wherein said passing an invoke
`request by the client to the web service residing on a server
`includes:
`
`generating a second thread to process a task generated by
`the client, the task configured to handle invoking the
`web service, wherein a first thread generated from the
`web service invoke request received by the client is
`freed upon the generation of the second thread.
`8. A method for asynchronously invoking a remote web
`service on a server by application code, the method com-
`prising:
`
`sending a web service invoke request by application code
`to a client,
`the client configured to pass the invoke
`request from the client to a remote web service, said
`sending a web service invoke request including gener—
`ating a first thread;
`
`performing a task by the application code, wherein the
`client is configured to free the first thread when passing
`on the web service invoke to a web service;
`
`polling the client by the application code to determine if
`a result has been received by the client from the web
`
`the result provided by the web service in
`service,
`response to the web service invocation; and
`
`obtaining the result from the client by the application
`code.
`
`9. The method of claim 6 further comprising:
`
`receiving a result ready signal from the client by the
`application code, the result ready signal received in
`response to the application code polling and indicating
`the