~justin-fathomdb/nova/justinsb-openstack-api-volumes

<?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: Storing Objects in the Session</title>

</head>

<h1 class="title">Storing Objects in the Session</h1>

This example shows you how you can persist objects across requests in the

session object.

As was discussed <a href="session-basics.html" shape="rect">previously</a>, instances

of <code class="API"><a href="http://twistedmatrix.com/documents/10.0.0/api/twisted.web.server.Session.html" title="twisted.web.server.Session">Session</a></code> last as long as

the notional session itself does. Each time <code class="API"><a href="http://twistedmatrix.com/documents/10.0.0/api/twisted.web.server.Request.getSession.html" title="twisted.web.server.Request.getSession">Request.getSession</a></code> is called, if the session

for the request is still active, then the same <code>Session</code> instance is

returned as was returned previously. Because of this, <code>Session</code>

instances can be used to keep other objects around for as long as the session

exists.

It's easier to demonstrate how this works than explain it, so here's an

example:

>>> from zope.interface import Interface, Attribute, implements

>>> from twisted.python.components import registerAdapter

>>> from twisted.web.server import Session

>>> class ICounter(Interface):

... value = Attribute("An int value which counts up once per page view.")

...

>>> class Counter(object):

... implements(ICounter)

... def __init__(self, session):

... self.value = 0

...

>>> registerAdapter(Counter, Session, ICounter)

>>> ses = Session(None, None)

>>> data = ICounter(ses)

>>> print data

<__main__.Counter object at 0x8d535ec>

>>> print data is ICounter(ses)

True

>>>

</pre>

What?, I hear you say.

What's shown in this example is the interface and adaption-based API which

<code>Session</code> exposes for persisting state. There are several critical

pieces interacting here:

<ul>

<li><code>ICounter</code> is an interface which serves several purposes. Like

all interfaces, it documents the API of some class of objects (in this case,

just the <code>value</code> attribute). It also serves as a key into what is

basically a dictionary within the session object: the interface is used to

store or retrieve a value on the session (the <code>Counter</code> instance,

in this case).</li>

<li><code>Counter</code> is the class which actually holds the session data in

this example. It implements <code>ICounter</code> (again, mostly for

documentation purposes). It also has a <code>value</code> attribute, as the

interface declared.</li>

<li>The <code class="API"><a href="http://twistedmatrix.com/documents/10.0.0/api/twisted.python.components.registerAdapter.html" title="twisted.python.components.registerAdapter">registerAdapter</a></code> call sets up the

relationship between its three arguments so that adaption will do what we

want in this case.</li>

<li>Adaption is performed by the expression <code>ICounter(ses)</code>. This

is read as adapt <code>ses</code> to <code>ICounter</code>. Because

of the <code>registerAdapter</code> call, it is roughly equivalent

to <code>Counter(ses)</code>. However (because of certain

things <code>Session</code> does), it also saves the <code>Counter</code>

instance created so that it will be returned the next time this adaption is

done. This is why the last statement produces <code>True</code>.</li>

</ul>

If you're still not clear on some of the details there, don't worry about it

and just remember this: <code>ICounter(ses)</code> gives you an object you can

persist state on. It can be as much or as little state as you want, and you can

use as few or as many different <code>Interface</code> classes as you want on a

single <code>Session</code> instance.

With those conceptual dependencies out of the way, it's a very short step to

actually getting persistent state into a Twisted Web application. Here's an

example which implements a simple counter, re-using the definitions from the

example above:

<pre class="python">1

from twisted.web.resource import Resource

class CounterResource(Resource):

100

def render_GET(self, request):

101

session = request.getSession()

102

counter = ICounter(session)

103

counter.value += 1

104

return "Visit #%d for you!" % (counter.value,)

105

</pre>

106

107

Pretty simple from this side, eh? All this does is

108

use <code>Request.getSession</code> and the adaption from above, plus some

109

integer math to give you a session-based visit counter.

110

111

Here's the complete source for an <a href="rpy-scripts.html" shape="rect">rpy script</a>

112

based on this example:

113

114

<pre class="python"> 1

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

cache()

140

141

from zope.interface import Interface, Attribute, implements

142

from twisted.python.components import registerAdapter

143

from twisted.web.server import Session

144

from twisted.web.resource import Resource

145

146

class ICounter(Interface):

147

value = Attribute("An int value which counts up once per page view.")

148

149

class Counter(object):

150

implements(ICounter)

151

def __init__(self, session):

152

self.value = 0

153

154

registerAdapter(Counter, Session, ICounter)

155

156

class CounterResource(Resource):

157

def render_GET(self, request):

158

session = request.getSession()

159

counter = ICounter(session)

160

counter.value += 1

161

return "Visit #%d for you!" % (counter.value,)

162

163

resource = CounterResource()

164

</pre>

165

166

One more thing to note is the <code>cache()</code> call at the top of this

167

example. As with the <a href="http-auth.html" shape="rect">previous example</a> where this

168

came up, this rpy script is stateful. This time, it's the <code>ICounter</code>

169

definition and the

170

<code>registerAdapter</code> call that need to be executed only once. If we

171

didn't use <code>cache</code>, every request would define a new, different

172

interface named <code>ICounter</code>. Each of these would be a different key in

173

the session, so the counter would never get past one.

174

175

</div>

176

177

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

178

Version: 10.0.0

179

</body>

180

</html>

b'\\ No newline at end of file'

Older »