Package muntjac :: Package terminal :: Package gwt :: Package server :: Module paste_wsgi_servlet
[hide private]
[frames] | no frames]

Source Code for Module muntjac.terminal.gwt.server.paste_wsgi_servlet

  1   
  2  import logging 
  3   
  4  from urlparse import urlparse 
  5   
  6  from os.path import join, dirname, normpath 
  7   
  8  try: 
  9      from cPickle import UnpicklingError 
 10  except ImportError: 
 11      from pickle import UnpicklingError 
 12   
 13  from paste.httpheaders import \ 
 14      (ACCEPT_LANGUAGE, SCRIPT_NAME, PATH_INFO, IF_MODIFIED_SINCE, 
 15       USER_AGENT, CONTENT_LENGTH, CONTENT_TYPE) 
 16   
 17  from babel.core import Locale, UnknownLocaleError 
 18   
 19  import muntjac 
 20   
 21  from muntjac.util import sys_path_install, defaultLocale 
 22  # Add 'FakeWebware' to sys path 
 23  sys_path_install() 
 24   
 25  #from paste.webkit.wkservlet import HTTPServlet 
 26  from WebKit.HTTPServlet import HTTPServlet 
 27   
 28   
 29  logger = logging.getLogger(__name__) 
 30   
 31   
32 -class EndResponseException(Exception):
33 pass
34 35
36 -class PasteWsgiServlet(HTTPServlet):
37 38 EndResponse = EndResponseException 39
40 - def __init__(self, contextRoot=None, contextPath=None, timeout=1800):
41 # super(PasteWsgiServlet, self).__init__() 42 43 if contextRoot is not None: 44 self.contextRoot = contextRoot 45 else: 46 root = join(dirname(muntjac.__file__), 'public') 47 self.contextRoot = normpath(root) 48 49 self.contextPath = contextPath if contextPath is not None else '' 50 51 self._timeout = timeout
52 53 54 # def __call__(self, environ, start_response): 55 # pass 56
57 - def awake(self, transaction):
58 # super(PasteWsgiServlet, self).awake(transaction) 59 60 self.init()
61 62
63 - def respond(self, transaction):
64 # super(PasteWsgiServlet, self).respond(transaction) 65 66 self.service(transaction.request(), transaction.response())
67 68
69 - def init(self):
70 raise NotImplementedError
71 72
73 - def service(self, request, response):
74 raise NotImplementedError
75 76
77 - def getContextPath(self, request):
78 ## FIXME: implement request.contextPath() 79 return self.contextPath
80 81
82 - def originalContextPath(self, request):
83 ## FIXME: implement request.originalContextPath() 84 return self.getContextPath(request)
85 86
87 - def getServletPath(self, request):
88 ## FIXME: implement request.servletPath() 89 servletPath = SCRIPT_NAME(request.environ()) 90 # pathInfo = PATH_INFO(request.environ()) 91 # 92 # if 'REQUEST_URI' in request.environ(): 93 # uri = request.environ()['REQUEST_URI'] 94 # # correct servletPath if there was a redirection 95 # if not (uri + '/').startswith(servletPath + '/'): 96 # i = uri.find(pathInfo) 97 # servletPath = i > 0 and uri[:i] or '' 98 99 return servletPath
100 101
102 - def getUrlPath(self, url):
103 """ 104 @param url: URL of the form scheme://netloc/path;parameters?query#frag 105 @return: the path part or the url 106 """ 107 return urlparse(url)[2] # FIXME remove URL query
108 109
110 - def getResourceAsStream(self, path):
111 # FIXME: 112 path = join(self.contextRoot, path.lstrip('/')) 113 stream = open(normpath(path), 'rb') 114 return stream
115 116
117 - def getResource(self, filename):
118 # FIXME: 119 path = join(self.contextRoot, filename.lstrip('/')) 120 return path
121 122
123 - def getResourcePath(self, session, path):
124 # FIXME: 125 return join(self.contextRoot, path.lstrip('/'))
126 127 # Request 128
129 - def getParameters(self, request):
130 return request.fields()
131 132
133 - def getParameter(self, request, key, default=''):
134 return request.field(key, default)
135 136
137 - def setParameter(self, request, key, value):
138 request.setField(key, value)
139 140
141 - def getHeader(self, request, field):
142 return request.serverDictionary().get(field)
143 144
145 - def getUserAgent(self, request):
146 return USER_AGENT(request.environ())
147 148
149 - def getContentLength(self, request):
150 return CONTENT_LENGTH(request.environ())
151 152
153 - def getContentType(self, request):
154 return CONTENT_TYPE(request.environ())
155 156
157 - def getIfModifiedSince(self, request):
158 dh = IF_MODIFIED_SINCE(request.environ()) 159 return int(dh) if dh else -1
160 161
162 - def getServerPort(self, request):
163 portStr = request.environ().get('SERVER_PORT') 164 return int(portStr) if portStr is not None else None
165 166
167 - def getRequestUri(self, request):
168 """The request's URL from the protocol name up to the query string""" 169 return urlparse(request.uri())[2]
170 171
172 - def getPathInfo(self, request):
173 return PATH_INFO(request.environ())
174 175
176 - def getLocale(self, request):
177 ## FIXME: implement request.locale() 178 tags = ACCEPT_LANGUAGE.parse(request.environ()) 179 if tags: 180 try: 181 return Locale.parse(tags[0], sep='-') 182 except UnknownLocaleError, e: 183 try: 184 return Locale.parse(tags[0]) 185 except UnknownLocaleError, e: 186 logger.error('Locale parsing error: %s' % e) 187 return defaultLocale() 188 else: 189 return defaultLocale() # server default
190 191
192 - def getServerName(self, request):
193 return request.environ().get('SERVER_NAME', '')
194 195
196 - def isSecure(self, request):
197 """Check whether the request is a HTTPS connection.""" 198 return request.environ().get('HTTPS', '').lower() == 'on'
199 200
201 - def getInputStream(self, request):
202 return request.rawInput()
203 204 # Response 205
206 - def setHeader(self, response, name, value):
207 response.setHeader(name, value)
208 209
210 - def setStatus(self, response, n, msg=''):
211 response.setStatus(n, msg)
212 213
214 - def write(self, response, value):
215 response.write(value)
216 217
218 - def redirect(self, response, url):
219 response.sendRedirect(url)
220 221
222 - def getOutputStream(self, response):
223 return response
224 225 # Session 226
227 - def getSession(self, request, allowSessionCreation=True):
228 try: 229 if allowSessionCreation: 230 return request.session() 231 else: 232 if request.transaction().hasSession(): 233 return request.session() 234 else: 235 return None 236 except EOFError, e: 237 logger.exception('Session retrieval error: %s' % str(e)) 238 return None 239 except UnpicklingError, e: 240 logger.exception('Session retrieval error: %s' % str(e)) 241 return None 242 except ValueError, e: 243 logger.exception('Session retrieval error: %s' % str(e)) 244 return None
245 246
247 - def invalidateSession(self, request):
248 try: 249 request.session().invalidate() 250 except Exception, e: 251 logger.error('Session invalidation error: %s' % e)
252 253
254 - def getSessionId(self, request):
255 try: 256 return request.sessionId() 257 except Exception, e: 258 logger.error('Session ID error: %s' % e) 259 return None
260 261
262 - def getSessionAttribute(self, session, name, default=None):
263 if session is not None: 264 return session.value(name, default) 265 else: 266 return default
267 268
269 - def setSessionAttribute(self, session, name, value):
270 if session is not None: 271 session.setValue(name, value)
272 273
274 - def getMaxInactiveInterval(self, session):
275 if session is not None: 276 return session.value('timeout', self._timeout) 277 else: 278 return self._timeout
279 280
281 - def isSessionNew(self, session):
282 if session is not None: 283 return session.isNew() 284 else: 285 return True
286