cubicweb: comparison etwist/server.py

equal deleted inserted replaced

-:7ff24154351d
+:25c13e5b12bd
 from twisted.internet.defer import maybeDeferred
 from twisted.web2 import channel, http, server, iweb
 from twisted.web2 import static, resource, responsecode
 from cubicweb import ObjectNotFound
 from cubicweb.web import (AuthenticationError, NotFound, Redirect,
 RemoteCallFailed, DirectResponse, StatusResponse,
 ExplicitLogin)
 from cubicweb.web.application import CubicWebPublisher
 from cubicweb.etwist.request import CubicWebTwistedRequestAdapter
 except:
 repo.exception('error in looping task')
 start_task(interval, catch_error_func)
 # ensure no tasks will be further added
 repo._looping_tasks = ()
 class LongTimeExpiringFile(static.File):
 """overrides static.File and sets a far futre ``Expires`` date
 on the resouce.
 return d.addCallback(setExpireHeader)
 class CubicWebRootResource(resource.PostableResource):
 addSlash = False
 def __init__(self, config, debug=None):
 self.appli = CubicWebPublisher(config, debug=debug)
 self.debugmode = debug
 self.config = config
 self.base_url = config['base-url'] or config.default_base_url()
 except ObjectNotFound:
 self.url_rewriter = None
 interval = min(config['cleanup-session-time'] or 120,
 config['cleanup-anonymous-session-time'] or 720) / 2.
 start_task(interval, self.appli.session_handler.clean_sessions)
 def shutdown_event(self):
 """callback fired when the server is shutting down to properly
 clean opened sessions
 """
 self.appli.repo.shutdown()
 """listen for pyro events"""
 try:
 self.pyro_daemon.handleRequests(self.pyro_listen_timeout)
 except select.error:
 return
 def locateChild(self, request, segments):
 """Indicate which resource to use to process down the URL's path"""
 if segments:
 if segments[0] == 'https':
 segments = segments[1:]
 elif segments[0] == 'fckeditor':
 fckeditordir = self.config.ext_resources['FCKEDITOR_PATH']
 return static.File(fckeditordir), segments[1:]
 # Otherwise we use this single resource
 return self, ()
 def render(self, request):
 """Render a page from the root resource"""
 # reload modified files (only in development or debug mode)
 if self.config.mode == 'dev' or self.debugmode:
 self.appli.vreg.register_objects(self.config.vregistry_path())
 if self.config['profile']: # default profiler don't trace threads
 return self.render_request(request)
 else:
 return threads.deferToThread(self.render_request, request)
 def render_request(self, request):
 origpath = request.path
 host = request.host
 # dual http/https access handling: expect a rewrite rule to prepend
 # 'https' to the path to detect https access
 if origpath.split('/', 2)[1] == 'https':
 origpath = origpath[6:]
 request.uri = request.uri[6:]
 https = True
 baseurl = self.https_url or self.base_url
 else:
 https = False
 baseurl = self.base_url
 req = CubicWebTwistedRequestAdapter(request, self.appli.vreg, https, baseurl)
 if req.authmode == 'http':
 return self.request_auth(req)
 except Redirect, ex:
 return self.redirect(req, ex.location)
 if https and req.cnx.anonymous_connection:
 # don't allow anonymous on https connection
 return self.request_auth(req)
 if self.url_rewriter is not None:
 # XXX should occur before authentication?
 try:
 path = self.url_rewriter.rewrite(host, origpath)
 except Redirect, ex:
 # in http we have to request auth to flush current http auth
 # information
 return self.request_auth(req, loggedout=True)
 except Redirect, ex:
 return self.redirect(req, ex.location)
-if not result:
-# no result, something went wrong...
-self.error('no data (%s)', req)
-# 500 Internal server error
-return self.redirect(req, req.build_url('error'))
 # request may be referenced by "onetime callback", so clear its entity
 # cache to avoid memory usage
 req.drop_entity_cache()
 return http.Response(stream=result, code=responsecode.OK,
 headers=req.headers_out or None)
 def redirect(self, req, location):
 req.headers_out.setHeader('location', str(location))
 self.debug('redirecting to %s', location)
 # 303 See other
 return http.Response(code=303, headers=req.headers_out)
 def request_auth(self, req, loggedout=False):
 if self.https_url and req.base_url() != self.https_url:
 req.headers_out.setHeader('location', self.https_url + 'login')
 return http.Response(code=303, headers=req.headers_out)
 if self.config['auth-mode'] == 'http':
 code = responsecode.UNAUTHORIZED
 else:
 code = responsecode.FORBIDDEN
 if loggedout:
 content = self.appli.loggedout_content(req)
 else:
 content = self.appli.need_login_content(req)
 return http.Response(code, req.headers_out, content)
 # This part gets run when you run this file via: "twistd -noy demo.py"
 def main(appid, cfgname):
 """Starts an cubicweb  twisted server for an application
 appid: application's identifier
 from twisted.internet import defer
 from twisted.web2 import fileupload
 # XXX set max file size to 100Mo: put max upload size in the configuration
 # line below for twisted >= 8.0, default param value for earlier version
 resource.PostableResource.maxSize = 100*1024*1024
 def parsePOSTData(request, maxMem=100*1024, maxFields=1024,
 maxSize=100*1024*1024):
 if request.stream.length == 0:
 return defer.succeed(None)
 ctype = request.headers.getHeader('content-type')
 if ctype is None:
 return defer.succeed(None)
 request.files.update(files)
 def error(f):
 f.trap(fileupload.MimeFormatError)
 raise http.HTTPError(responsecode.BAD_REQUEST)
 if ctype.mediaType == 'application' and ctype.mediaSubtype == 'x-www-form-urlencoded':
 d = fileupload.parse_urlencoded(request.stream, keep_blank_values=True)
 d.addCallbacks(updateArgs, error)
 return d
 elif ctype.mediaType == 'multipart' and ctype.mediaSubtype == 'form-data':

branch	tls-sprint
changeset 1420	25c13e5b12bd
parent 1263	01152fffd593
child 1520	b097057e629d