def testIfModSince(self): now = time.time() e = {'SERVER_NAME': 'foo', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET'} # not modified since t_notmod = rfc1123_date(now) e['HTTP_IF_MODIFIED_SINCE'] = t_notmod out = BytesIO() resp = HTTPResponse(stdout=out) req = HTTPRequest(sys.stdin, e, resp) data = self.file.index_html(req, resp) self.assertEqual(resp.getStatus(), 304) self.assertEqual(data, b'') # modified since t_mod = rfc1123_date(now - 100) e['HTTP_IF_MODIFIED_SINCE'] = t_mod out = BytesIO() resp = HTTPResponse(stdout=out) req = HTTPRequest(sys.stdin, e, resp) data = self.file.index_html(req, resp) self.assertEqual(resp.getStatus(), 200) self.assertEqual(data, bytes(self.file.data))
def getRenderingTemplate(self, templatename, request=None): """ """ skin = self.portal_skins.cmfplomino_templates if hasattr(skin, templatename): pt = getattr(skin, templatename) if request: pt.REQUEST = request else: request = getattr(pt, 'REQUEST', None) proper_request = request and pt.REQUEST.__class__.__name__ == 'HTTPRequest' if not proper_request: # XXX What *else* could REQUEST be here? # we are not in an actual web context, but we a need a # request object to have the template working response = HTTPResponse(stdout=sys.stdout) env = { 'SERVER_NAME': 'fake_server', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET' } pt.REQUEST = HTTPRequest(sys.stdin, env, response) # we also need a RESPONSE if not pt.REQUEST.has_key('RESPONSE'): pt.REQUEST['RESPONSE'] = HTTPResponse() return pt else: return None
def getRenderingTemplate(self, templatename, request=None): """ Look up a Plomino form or field template from portal skin layers. """ # The portal_skins machinery will look through layers in order if hasattr(self.portal_skins, templatename): pt = getattr(self.portal_skins, templatename) if request: pt.REQUEST = request else: request = getattr(pt, 'REQUEST', None) proper_request = (request and pt.REQUEST.__class__.__name__ == 'HTTPRequest') if not proper_request: # XXX What *else* could REQUEST be here? # we are not in an actual web context, but we a need a # request object to have the template working response = HTTPResponse(stdout=sys.stdout) env = { 'SERVER_NAME': 'fake_server', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET' } pt.REQUEST = HTTPRequest(sys.stdin, env, response) # we also need a RESPONSE if 'RESPONSE' not in pt.REQUEST: pt.REQUEST['RESPONSE'] = HTTPResponse() return pt
def test_setHeader_drops_LF(self): from ZPublisher.HTTPResponse import HTTPResponse response = HTTPResponse() response.setHeader('Location', 'http://www.ietf.org/rfc/\nrfc2616.txt') self.assertEqual(response.headers['location'], 'http://www.ietf.org/rfc/rfc2616.txt')
def test_no_registry(self): environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished() GZipTransform(published, request).transformUnicode(u"", "utf-8") self.assertEqual(0, response.enableHTTPCompression(query=True))
def test_no_registry(self): environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished() GZipTransform(published, request).transformUnicode(u"", "utf-8") self.assertEquals(0, response.enableHTTPCompression(query=True))
def setBody(self, body, title='', is_error=0): if isinstance(body, file) or IStreamIterator.providedBy(body): body.seek(0, 2) length = body.tell() body.seek(0) self.setHeader('Content-Length', '%d' % length) self.body = body else: HTTPResponse.setBody(self, body, title, is_error)
def testRangeSupport(self): """ functionnal test of range support """ self.loginAsPortalOwner() # Create content content_id = 'test_file' file_content = self.addFileByFileUpload(self.test_folder, content_id) # Get file field file_field = file_content.getField('file') file_content = file_field.get(file_content) # do an simple request e = { 'SERVER_NAME': 'foo', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET' } out = StringIO() resp = HTTPResponse(stdout=out) req = HTTPRequest(sys.stdin, e, resp) req.RESPONSE = resp data = file_content.index_html(req, resp) self.failUnless( len(data) == len(file_content), 'not good lenght data ') # now do an range request with one range e = { 'SERVER_NAME': 'foo', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET', 'HTTP_RANGE': 'bytes=0-10' } resp = HTTPResponse(stdout=out) req = HTTPRequest(sys.stdin, e, resp) req.RESPONSE = resp data = file_content.index_html(req, resp) read_data = '' for d in data: read_data += d self.failUnless( len(read_data) == 11, 'not good lenght data <%s>' % len(read_data)) # now mulitple range e = { 'SERVER_NAME': 'foo', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET', 'HTTP_RANGE': 'bytes=0-10, 50-80' } resp = HTTPResponse(stdout=out) req = HTTPRequest(sys.stdin, e, resp) req.RESPONSE = resp data = file_content.index_html(req, resp)
def setBody(self, body, title='', is_error=0, **kw): """ Accept either a stream iterator or a string as the body """ if IStreamIterator.isImplementedBy(body): assert(self.headers.has_key('content-length')) # wrap the iterator up in a producer that medusa can understand self._bodyproducer = iterator_producer(body) HTTPResponse.setBody(self, '', title, is_error, **kw) return self else: HTTPResponse.setBody(self, body, title, is_error, **kw)
def setBody(self, body, title='', is_error=0, **kw): """ Accept either a stream iterator or a string as the body """ if IStreamIterator.providedBy(body): assert (self.headers.has_key('content-length')) # wrap the iterator up in a producer that medusa can understand self._bodyproducer = iterator_producer(body) HTTPResponse.setBody(self, '', title, is_error, **kw) return self else: HTTPResponse.setBody(self, body, title, is_error, **kw)
def testSwordService(self): request = self.portal.REQUEST # Check that 'sword' ends up at a browser view view = self.portal.restrictedTraverse('sword') assert isinstance(view, BrowserView) # Test service-document view = self.portal.unrestrictedTraverse('sword/servicedocument') assert isinstance(view, ServiceDocument) assert "<sword:error" not in view() # Upload a zip file zipfilename = os.path.join(DIRNAME, 'data', 'multipart.txt') zipfile = open(zipfilename, 'r') env = { 'CONTENT_TYPE': 'application/zip', 'CONTENT_LENGTH': os.path.getsize(zipfilename), 'CONTENT_DISPOSITION': 'attachment; filename=multipart.txt', 'REQUEST_METHOD': 'POST', 'SERVER_NAME': 'nohost', 'SERVER_PORT': '80', 'IN_PROGRESS': 'true', } uploadresponse = HTTPResponse(stdout=StringIO()) uploadrequest = clone_request(self.app.REQUEST, uploadresponse, env) uploadrequest.set('BODYFILE', zipfile) # Fake PARENTS uploadrequest.set('PARENTS', [self.folder]) # Call the sword view on this request to perform the upload self.setRoles(('Manager',)) xml = getMultiAdapter( (self.folder, uploadrequest), Interface, 'sword')() zipfile.close() assert bool(xml), "Upload view does not return a result" assert "<sword:error" not in xml, xml # Test that we can still reach the edit-iri assert self.folder.unrestrictedTraverse('multipart-txt/sword/edit') # Test publish env = { 'CONTENT_LENGTH': '0', 'REQUEST_METHOD': 'POST', 'SERVER_NAME': 'nohost', 'SERVER_PORT': '80' } publishresponse = HTTPResponse(stdout=StringIO()) publishrequest = clone_request(self.app.REQUEST, publishresponse, env) publishrequest.set('PARENTS', [self.folder]) xml = getMultiAdapter( (self.folder['multipart-txt'], publishrequest), ISWORDEditIRI)() self.assertTrue(bool(xml), "Publish returned nothing") self.assertTrue("<sword:error" not in xml, xml)
def testStreaming(self): out = StringIO() response = HTTPResponse(stdout=out) response.write('datachunk1') response.write('datachunk2') events = self.reporter.events self.assertEqual(len(events), 1) self.assert_(isinstance(events[0], PubBeforeStreaming)) self.assertEqual(events[0].response, response) self.assertTrue('datachunk1datachunk2' in out.getvalue())
def test_disabled(self): provideUtility(Registry(), IRegistry) registry = getUtility(IRegistry) registry.registerInterface(IPloneCacheSettings) environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished() GZipTransform(published, request).transformUnicode(u"", "utf-8") self.assertEquals(0, response.enableHTTPCompression(query=True))
def test_disabled(self): provideUtility(Registry(), IRegistry) registry = getUtility(IRegistry) registry.registerInterface(IPloneCacheSettings) environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished() GZipTransform(published, request).transformUnicode(u"", "utf-8") self.assertEqual(0, response.enableHTTPCompression(query=True))
def FakeRequest(method="GET", add_auth=False, **kwargs): environ = {} environ.setdefault("SERVER_NAME", "foo") environ.setdefault("SERVER_PORT", "80") environ.setdefault("REQUEST_METHOD", method) if api.env.plone_version() < "5.2": # manually set stdout for Plone < 5.2 request = HTTPRequest(sys.stdin, environ, HTTPResponse(stdout=BytesIO())) else: request = HTTPRequest(sys.stdin, environ, HTTPResponse()) request.form = kwargs if add_auth: request.form["_authenticator"] = plone.protect.createToken() return request
def wrap_with_request(app): from StringIO import StringIO from ZPublisher.HTTPRequest import HTTPRequest from ZPublisher.HTTPResponse import HTTPResponse from Acquisition import Implicit class FakeRootObject(Implicit): pass fake_root = FakeRootObject() fake_root.app = app stdin = StringIO() environ = { 'REQUEST_METHOD': 'GET', 'SERVER_NAME': 'nohost', 'SERVER_PORT': '80' } request = HTTPRequest(stdin, environ, HTTPResponse(), clean=1) anonymous_user = fake_root.app.acl_users._nobody request.AUTHENTICATED_USER = anonymous_user fake_root.REQUEST = request return fake_root
def test_LastModified(self): from plone.app.caching.operations.etags import LastModified mod = datetime(2010, 1, 2, 3, 4, 5, 6, tzlocal()) utcStamp = time.mktime(mod.utctimetuple()) class DummyLastModified(object): implements(ILastModified) adapts(DummyPublished) def __init__(self, context): self.context = context def __call__(self): return mod provideAdapter(DummyLastModified) environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished(DummyContext()) etag = LastModified(published, request) self.assertEqual(str(utcStamp), etag())
def test_CatalogCounter(self): from plone.app.caching.operations.etags import CatalogCounter class DummyCatalog(object): def getCounter(self): return 10 class DummyTools(object): implements(Interface) adapts(DummyContext, Interface) def __init__(self, context, request): pass def catalog(self): return DummyCatalog() provideAdapter(DummyTools, name=u"plone_tools") environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished(DummyContext()) etag = CatalogCounter(published, request) self.assertEqual('10', etag())
def test_default_viewname_overrides_fti(self): response = HTTPResponse() environment = { 'URL': '', 'PARENTS': [self.site], 'REQUEST_METHOD': 'GET', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET', 'steps': [], 'SERVER_NAME': 'localhost', '_hacked_path': 0 } r = HTTPRequest(StringIO(), environment, response) r.other.update(environment) alsoProvides(r, IBrowserRequest) # we define a Zope3-style default view name for which a view # actually exists defineDefaultViewName('index.html', DummyContent) provideAdapter(DummyView, (DummyContent, IBrowserRequest), IBrowserView, 'index.html') r.traverse('foo') self.assertEqual(r.URL, '/foo/index.html') self.assertEqual(r.response.base, '/foo/')
def _getContext(app): request = HTTPRequest(None, { 'SERVER_NAME': 'localhost', 'SERVER_PORT': '8080', 'REQUEST_METHOD': 'GET' }, HTTPResponse(stdout=None)) return app.__of__(RequestContainer(REQUEST=request))
def test_Roles_member(self): from plone.app.caching.operations.etags import Roles class DummyMember(object): def getRolesInContext(self, context): return ['Member', 'Manager'] class DummyPortalState(object): implements(Interface) adapts(DummyContext, Interface) def __init__(self, context, request): pass def anonymous(self): return False def member(self): return DummyMember() provideAdapter(DummyPortalState, name=u"plone_portal_state") environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished(DummyContext()) etag = Roles(published, request) self.assertEqual('Manager;Member', etag())
def test_UserID_member(self): from plone.app.caching.operations.etags import UserID class DummyMember(object): def getId(self): return 'bob' class DummyPortalState(object): implements(Interface) adapts(DummyContext, Interface) def __init__(self, context, request): pass def member(self): return DummyMember() provideAdapter(DummyPortalState, name=u"plone_portal_state") environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished(DummyContext()) etag = UserID(published, request) self.assertEqual('bob', etag())
def test_Roles_anonymous(self): from plone.app.caching.operations.etags import Roles @implementer(Interface) @adapter(DummyContext, Interface) class DummyPortalState(object): def __init__(self, context, request): pass def anonymous(self): return True def member(self): return None provideAdapter(DummyPortalState, name=u'plone_portal_state') environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished(DummyContext()) etag = Roles(published, request) self.assertEqual('Anonymous', etag())
def test_enabled_accepted(self): provideUtility(Registry(), IRegistry) registry = getUtility(IRegistry) registry.registerInterface(IPloneCacheSettings) ploneSettings = registry.forInterface(IPloneCacheSettings) ploneSettings.enableCompression = True environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80', 'HTTP_ACCEPT_ENCODING': 'gzip'} response = HTTPResponse() request = HTTPRequest(StringIO(), environ, response) published = DummyPublished() GZipTransform(published, request).transformUnicode(u"", "utf-8") self.assertEqual(1, response.enableHTTPCompression(query=True))
def _makeRequest(self, stdin=None, environ=None, response=None, clean=1, stdout=None): from ZPublisher.HTTPRequest import HTTPRequest from ZPublisher.HTTPResponse import HTTPResponse if stdin is None: from StringIO import StringIO stdin = StringIO() if stdout is None: from StringIO import StringIO stdout = StringIO() if environ is None: environ = {} if 'SERVER_NAME' not in environ: environ['SERVER_NAME'] = 'http://localhost' if 'SERVER_PORT' not in environ: environ['SERVER_PORT'] = '8080' if response is None: response = HTTPResponse(stdout=stdout) req = HTTPRequest(stdin, environ, response, clean) setDefaultSkin(req) return req
def testMultipart(self): view = self.portal.restrictedTraverse('sword') # Upload a zip file body_content = os.path.join(DIRNAME, 'data', 'multipart.txt') file = open(body_content, 'r') env = { 'CONTENT_TYPE': 'multipart/related; boundary="===============1338623209=="', 'SLUG': 'multipart', 'CONTENT_LENGTH': os.path.getsize(body_content), 'REQUEST_METHOD': 'POST', 'SERVER_NAME': 'nohost', 'SERVER_PORT': '80' } uploadresponse = HTTPResponse(stdout=StringIO()) uploadrequest = clone_request(self.app.REQUEST, uploadresponse, env) uploadrequest.stdin = file # Fake PARENTS uploadrequest.set('PARENTS', [self.folder]) # Call the sword view on this request to perform the upload self.setRoles(('Manager',)) adapter = getMultiAdapter( (self.folder, uploadrequest), Interface, 'sword') xml = adapter() file.close() self.assertTrue(bool(xml), "Upload view does not return a result") self.assertTrue("<sword:error" not in xml, xml) self.assertTrue('multipart' in self.folder.objectIds(), "upload failed")
def listHeaders(self): result = [] if self._server_version: result.append(('Server', self._server_version)) result.append(('Date', build_http_date(_now()))) result.extend(HTTPResponse.listHeaders(self)) return result
def makeBaseRequest(self): response = HTTPResponse() environment = { 'URL': '', 'PARENTS': [self.root], 'steps': [], '_hacked_path': 0, '_test_counter': 0, 'response': response } return BaseRequest(environment)
def test_basic(self): response = HTTPResponse() self.setCookie(response, "secret", "euphorie", "123") self.assertTrue('euphorie' in response.cookies) cookie = response.cookies['euphorie'] self.assertTrue('expires' not in cookie) self.assertEqual(cookie['path'], '/') self.assertEqual(cookie['http_only'], True) self.assertEqual(cookie['value'], 's2QukE8flTyx94ketu53fjEyMw==')
def _getContext(app): resp = HTTPResponse(stdout=None) env = { "SERVER_NAME": "localhost", "SERVER_PORT": "8080", "REQUEST_METHOD": "GET", } req = HTTPRequest(None, env, resp) return app.__of__(RequestContainer(REQUEST=req))
def aputrequest(file, content_type): resp = HTTPResponse(stdout=sys.stdout) environ = {} environ['SERVER_NAME'] = 'foo' environ['SERVER_PORT'] = '80' environ['REQUEST_METHOD'] = 'PUT' environ['CONTENT_TYPE'] = content_type req = HTTPRequest(stdin=file, environ=environ, response=resp) return req
def create_request(): """ fake request """ # Create a request to work with response = HTTPResponse(stdout=sys.stdout) env = {'SERVER_NAME': 'fake_server', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET'} return HTTPRequest(sys.stdin, env, response)
def FakeRequest(method='GET', add_auth=False, **kwargs): environ = {} environ.setdefault('SERVER_NAME', 'foo') environ.setdefault('SERVER_PORT', '80') environ.setdefault('REQUEST_METHOD', method) request = HTTPRequest(sys.stdin, environ, HTTPResponse(stdout=StringIO())) request.form = kwargs if add_auth: request.form['_authenticator'] = plone.protect.createToken() return request
def _getContext(self, app): resp = HTTPResponse(stdout=None) env = { 'SERVER_NAME': 'localhost', 'SERVER_PORT': '8080', 'REQUEST_METHOD': 'GET' } req = HTTPRequest(None, env, resp) app.__of__(RequestContainer(REQUEST=req)) return app
def testCSRF(self): """ test csrf protection """ # for this test, we need a bit more serious request simulation from ZPublisher.HTTPRequest import HTTPRequest from ZPublisher.HTTPResponse import HTTPResponse environ = {} environ.setdefault('SERVER_NAME', 'foo') environ.setdefault('SERVER_PORT', '80') environ.setdefault('REQUEST_METHOD', 'POST') request = HTTPRequest(sys.stdin, environ, HTTPResponse(stdout=sys.stdout)) request.form = \ {'topic':'test subject', 'replyto':'*****@*****.**', 'comments':'test comments'} self.ff1.checkAuthenticator = True self.assertRaises(zExceptions.Forbidden, self.ff1.fgvalidate, request) # with authenticator... no error tag = AuthenticatorView('context', 'request').authenticator() token = tag.split('"')[5] request.form['_authenticator'] = token errors = self.ff1.fgvalidate(REQUEST=request) self.assertEqual( errors, {} ) # sneaky GET request environ['REQUEST_METHOD'] = 'GET' request = HTTPRequest(sys.stdin, environ, HTTPResponse(stdout=sys.stdout)) self.assertRaises(zExceptions.Forbidden, self.ff1.fgvalidate, request) # bad authenticator request.form['_authenticator'] = 'inauthentic' request = HTTPRequest(sys.stdin, environ, HTTPResponse(stdout=sys.stdout)) self.assertRaises(zExceptions.Forbidden, self.ff1.fgvalidate, request)
def setBody(self, body, title='', is_error=0, **kw): """ Accept either a stream iterator or a string as the body """ if not IStreamIterator.providedBy(body): return HTTPResponse.setBody(self, body, title, is_error, **kw) assert not self._wrote if isinstance(body, BlobStreamIterator): body = body.blob # A BlobFile if hasattr(body, 'seek') and hasattr(body, 'read') and hasattr(body, 'close'): self.stdout = body self._wrote = 1 return try: while True: chunk = body.next() self.write(chunk) except StopIteration: pass
def process_wrapper(pid, request_body, request_environ): # Sets up everything we need to run a view method in a new Zope-ish # context, then runs it and stores the result for later retrieval. _process = None def my_mapply(object, positional=(), keyword={}, debug=None, maybe=None, missing_name=None, handle_class=None, context=None, bind=0): if not isinstance(keyword, Mapping): keyword = {} keyword['process_id'] = pid args = (getattr(object, '__run__', object),) kwargs = dict(positional=positional, keyword=keyword, debug=debug, maybe=maybe, context=context, bind=bind ) if missing_name is not None: kwargs['missing_name'] = missing_name if handle_class is not None: kwargs['handle_class'] = handle_class return mapply(*args, **kwargs) response = HTTPResponse(stdout=StringIO(), stderr=StringIO()) request = HTTPRequest(StringIO(request_body), request_environ, response) request.set('process_id', pid) import Zope2 app = Zope2.bobo_application.__bobo_traverse__(request) reg = getProcessRegistry(app) _process = reg.get(pid) # Run try: try: response = publish(request, 'Zope2', [None], mapply=my_mapply) # We can't just pass the response back, as the data streams will not # be set up right. attr = (hasattr(response, 'cookies') and 'cookies') or \ (hasattr(response, '_cookies') and '_cookies') cookies = deepcopy(getattr(response, attr)) if IHTTPResponse.providedBy(response): _process['result'] = (response.getStatus(), dict(response.getHeaders()), cookies, response.consumeBody()) else: # Currently, ZPublisher.HTTPResponse doesn't implement # IHTTPResponse, even though HTTPRequest implements # IHTTPRequest. _process['result'] = (response.getStatus(), dict(response.headers), cookies, response.body) except Exception, e: # Set result to the exception raised _process['result'] = e raise else:
def http(request_string, handle_errors=True): """Execute an HTTP request string via the publisher This is used for HTTP doc tests. """ import urllib import rfc822 from cStringIO import StringIO from ZPublisher.HTTPResponse import HTTPResponse as Response from ZServer.ZPublisher.Publish import publish_module # Commit work done by previous python code. transaction.commit() # Discard leading white space to make call layout simpler request_string = request_string.lstrip() # Split off and parse the command line l = request_string.find('\n') command_line = request_string[:l].rstrip() request_string = request_string[l + 1:] method, path, protocol = command_line.split() path = urllib.unquote(path) instream = StringIO(request_string) env = {"HTTP_HOST": 'localhost', "HTTP_REFERER": 'localhost', "REQUEST_METHOD": method, "SERVER_PROTOCOL": protocol, } p = path.split('?', 1) if len(p) == 1: env['PATH_INFO'] = p[0] elif len(p) == 2: [env['PATH_INFO'], env['QUERY_STRING']] = p else: raise TypeError('') header_output = HTTPHeaderOutput( protocol, ('x-content-type-warning', 'x-powered-by', 'bobo-exception-type', 'bobo-exception-file', 'bobo-exception-value', 'bobo-exception-line')) headers = [split_header(header) for header in rfc822.Message(instream).headers] # Store request body without headers instream = StringIO(instream.read()) for name, value in headers: name = ('_'.join(name.upper().split('-'))) if name not in ('CONTENT_TYPE', 'CONTENT_LENGTH'): name = 'HTTP_' + name env[name] = value.rstrip() if 'HTTP_AUTHORIZATION' in env: env['HTTP_AUTHORIZATION'] = auth_header(env['HTTP_AUTHORIZATION']) outstream = StringIO() response = Response(stdout=outstream, stderr=sys.stderr) publish_module('Zope2', response=response, stdin=instream, environ=env, debug=not handle_errors) header_output.setResponseStatus(response.getStatus(), response.errmsg) header_output.setResponseHeaders(response.headers) header_output.headersl.extend(response._cookie_list()) header_output.appendResponseHeaders(response.accumulated_headers) sync() return DocResponseWrapper(response, outstream, path, header_output)
def publish_module_standard( module_name, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr, environ=os.environ, debug=0, request=None, response=None): must_die = 0 status = 200 after_list = [None] try: try: if response is None: response = Response(stdout=stdout, stderr=stderr) else: stdout = response.stdout # debug is just used by tests (has nothing to do with debug_mode!) response.handle_errors = not debug if request is None: request = Request(stdin, environ, response) setRequest(request) # make sure that the request we hand over has the # default layer/skin set on it; subsequent code that # wants to look up views will likely depend on it if ISkinnable.providedBy(request): setDefaultSkin(request) response = publish(request, module_name, after_list, debug=debug) except (SystemExit, ImportError): # XXX: Rendered ImportErrors were never caught here because they # were re-raised as string exceptions. Maybe we should handle # ImportErrors like all other exceptions. Currently they are not # re-raised at all, so they don't show up here. must_die = sys.exc_info() request.response.exception(1) except: # debug is just used by tests (has nothing to do with debug_mode!) if debug: raise request.response.exception() status = response.getStatus() if response: outputBody = getattr(response, 'outputBody', None) if outputBody is not None: outputBody() else: response = str(response) if response: stdout.write(response) # The module defined a post-access function, call it if after_list[0] is not None: after_list[0]() finally: if request is not None: request.close() clearRequest() if must_die: # Try to turn exception value into an exit code. try: if hasattr(must_die[1], 'code'): code = must_die[1].code else: code = int(must_die[1]) except: code = must_die[1] and 1 or 0 if hasattr(request.response, '_requestShutdown'): request.response._requestShutdown(code) try: reraise(must_die[0], must_die[1], must_die[2]) finally: must_die = None return status