~blamar/+junk/openstack-api-arrrg

<?xml version="1.0" encoding="utf-8"?><!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><html lang="en" xmlns="http://www.w3.org/1999/xhtml">

<head>

<title>Twisted Documentation: Asynchronous Responses</title>

</head>

<h1 class="title">Asynchronous Responses</h1>

In all of the previous examples, the resource examples presented generated

responses immediately. One of the features of prime interest of Twisted Web,

though, is the ability to generate a response over a longer period of time while

leaving the server free to respond to other requests. In other words,

asynchronously. In this installment, we'll write a resource like this.

A resource that generates a response asynchronously looks like one that

generates a response synchronously in many ways. The same base class, <code class="API"><a href="http://twistedmatrix.com/documents/10.0.0/api/twisted.web.resource.Resource.html" title="twisted.web.resource.Resource">Resource</a></code>, is used either way; the

same render methods are used. There are three basic differences, though.

First, instead of returning the string which will be used as the body of the

response, the resource uses <code class="API"><a href="http://twistedmatrix.com/documents/10.0.0/api/twisted.web.http.Request.write.html" title="twisted.web.http.Request.write">Request.write</a></code>. This method can be called

repeatedly. Each call appends another string to the response body. Second, when

the entire response body has been passed to <code>Request.write</code>, the

application must call <code class="API"><a href="http://twistedmatrix.com/documents/10.0.0/api/twisted.web.http.Request.finish.html" title="twisted.web.http.Request.finish">Request.finish</a></code>. As you might expect from the

name, this ends the response. Finally, in order to make Twisted Web not end the

response as soon as the render method returns, the render method must return

<code>NOT_DONE_YET</code>. Consider this example:

<pre class="python"> 1

from twisted.web.resource import Resource

from twisted.web.server import NOT_DONE_YET

from twisted.internet import reactor

class DelayedResource(Resource):

def _delayedRender(self, request):

request.write("Sorry to keep you waiting.")

request.finish()

def render_GET(self, request):

reactor.callLater(5, self._delayedRender, request)

return NOT_DONE_YET

</pre>

If you're not familiar with reactor.<code class="API"><a href="http://twistedmatrix.com/documents/10.0.0/api/twisted.internet.interfaces.IReactorTime.callLater.html" title="twisted.internet.interfaces.IReactorTime.callLater">callLater</a></code>, all you really

need to know about it to understand this example is that the above usage of it

arranges to have <code>self._delayedRender(request)</code> run about 5 seconds

after <code>callLater</code> is invoked from this render method and that it

returns immediately.

All three of the elements mentioned earlier can be seen in this example. The

resource uses <code>Request.write</code> to set the response body. It uses

<code>Request.finish</code> after the entire body has been specified (all with

just one call to write in this case). Lastly, it returns

<code>NOT_DONE_YET</code> from its render method. So there you have it,

asynchronous rendering with Twisted Web.

Here's a complete rpy script based on this resource class (see the <a href="rpy-scripts.html" shape="rect">previous example</a> if you need a reminder about rpy

scripts):

<pre class="python"> 1

class DelayedResource(Resource):

def _delayedRender(self, request):

request.write("Sorry to keep you waiting.")

request.finish()

def render_GET(self, request):

return NOT_DONE_YET

100

101

resource = DelayedResource()

102

</pre>

103

104

Drop this source into a <code>.rpy</code> file and fire up a server using

105

<code>twistd -n web --path /directory/containing/script/.</code> You'll see that

106

loading the page takes 5 seconds. If you try to load a second before the first

107

completes, it will also take 5 seconds from the time you request it (but it

108

won't be delayed by any other outstanding requests).

109

110

Something else to consider when generating responses asynchronously is that

111

the client may not wait around to get the response to its

112

request. A <a href="interrupted.html" shape="rect">subsequent example</a> demonstrates how

113

to detect that the client has abandoned the request and that the server

114

shouldn't bother to finish generating its response.

115

116

</div>

117

118

<a href="../index.html">Index</a>

119

Version: 10.0.0

120

</body>

121

</html>

b'\\ No newline at end of file'

Older »