def get_zope_request(webob_request):
outstream = StringIO()
response = ZServerHTTPResponse(stdout=outstream, stderr=sys.stderr)
environ = webob_request.environ
zope_request = Request(environ['wsgi.input'], environ, response)
zope_request.processInputs()
return zope_request
def get_zope_request(webob_request):
outstream = StringIO()
response = ZServerHTTPResponse(stdout=outstream, stderr=sys.stderr)
environ = webob_request.environ
zope_request = Request(environ['wsgi.input'], environ, response)
zope_request.processInputs()
return zope_request
def __init__(self):
env = {
'SERVER_NAME': 'nohost',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET'
}
Request.__init__(self, None, env, Response())
def makerequest(app, stdout=sys.stdout, environ={}):
'''Wraps the app into a fresh REQUEST.'''
from ZPublisher.BaseRequest import RequestContainer
from ZPublisher.Request import Request
from ZPublisher.Response import Response
response = Response(stdout=stdout)
new_environ = {}
new_environ['SERVER_NAME'] = _Z2HOST or 'nohost'
new_environ['SERVER_PORT'] = '%d' % (_Z2PORT or 80)
new_environ['REQUEST_METHOD'] = 'GET'
new_environ.update(environ)
request = Request(sys.stdin, new_environ, response)
request._steps = ['noobject'] # Fake a published object
request['ACTUAL_URL'] = request.get('URL') # Zope 2.7.4
return app.__of__(RequestContainer(REQUEST=request))
def publish(self,
path,
basic=None,
env=None,
extra=None,
request_method='GET',
stdin=None,
handle_errors=True):
'''Publishes the object at 'path' returning a response object.'''
from StringIO import StringIO
from ZPublisher.Request import Request
from ZPublisher.Response import Response
from ZPublisher.Publish import publish_module
# Commit the sandbox for good measure
transaction.commit()
if env is None:
env = {}
if extra is None:
extra = {}
request = self.app.REQUEST
env['SERVER_NAME'] = request['SERVER_NAME']
env['SERVER_PORT'] = request['SERVER_PORT']
env['REQUEST_METHOD'] = request_method
p = path.split('?')
if len(p) == 1:
env['PATH_INFO'] = p[0]
elif len(p) == 2:
[env['PATH_INFO'], env['QUERY_STRING']] = p
else:
raise TypeError, ''
if basic:
env['HTTP_AUTHORIZATION'] = "Basic %s" % base64.encodestring(basic)
if stdin is None:
stdin = StringIO()
outstream = StringIO()
response = Response(stdout=outstream, stderr=sys.stderr)
request = Request(stdin, env, response)
for k, v in extra.items():
request[k] = v
publish_module(
'Zope2',
debug=not handle_errors,
request=request,
response=response,
)
return ResponseWrapper(response, outstream, path)
def publish(self,
path,
basic=None,
env=None,
extra=None,
request_method='GET',
stdin=None,
handle_errors=True):
"""
Mostly pulled from Testing.functional
"""
from ZPublisher.Request import Request
from ZPublisher.Response import Response
from ZPublisher.Publish import publish_module
transaction.commit()
if env is None:
env = {}
if extra is None:
extra = {}
env['SERVER_NAME'] = self.request['SERVER_NAME']
env['SERVER_PORT'] = self.request['SERVER_PORT']
env['REQUEST_METHOD'] = request_method
p = path.split('?')
if len(p) == 1:
env['PATH_INFO'] = p[0]
elif len(p) == 2:
[env['PATH_INFO'], env['QUERY_STRING']] = p
else:
raise TypeError('')
if basic:
env['HTTP_AUTHORIZATION'] = "Basic %s" % base64.encodestring(basic)
if stdin is None:
stdin = StringIO()
outstream = StringIO()
response = Response(stdout=outstream, stderr=sys.stderr)
request = Request(stdin, env, response)
if extra:
# Needed on Plone 3 when adding things to the path in a querystring
# is not enough.
for key, value in extra.items():
request[key] = value
publish_module('Zope2',
debug=not handle_errors,
request=request,
response=response)
return ResponseWrapper(response, outstream, path)
def makerequest(app, stdout=sys.stdout):
'''Wraps the app into a fresh REQUEST.'''
from ZPublisher.BaseRequest import RequestContainer
from ZPublisher.Request import Request
from ZPublisher.Response import Response
response = Response(stdout=stdout)
environ = {}
environ['SERVER_NAME'] = _Z2HOST or 'nohost'
environ['SERVER_PORT'] = '%d' % (_Z2PORT or 80)
environ['REQUEST_METHOD'] = 'GET'
request = Request(sys.stdin, environ, response)
request._steps = ['noobject'] # Fake a published object
request['ACTUAL_URL'] = request.get('URL') # Zope 2.7.4
# set Zope3-style default skin so that the request is usable for
# Zope3-style view look-ups
from zope.app.publication.browser import setDefaultSkin
setDefaultSkin(request)
return app.__of__(RequestContainer(REQUEST=request))
def publish(
self,
path,
basic=None,
env=None,
extra=None,
request_method="GET",
stdin=None,
handle_errors=True,
):
"""
Mostly pulled from Testing.functional
"""
from ZPublisher.Request import Request
from ZPublisher.Response import Response
# Note: the next import fail in Python 3, because it needs ZServer.
from ZPublisher.Publish import publish_module
transaction.commit()
if env is None:
env = {}
env["SERVER_NAME"] = self.request["SERVER_NAME"]
env["SERVER_PORT"] = self.request["SERVER_PORT"]
env["REQUEST_METHOD"] = request_method
p = path.split("?")
if len(p) == 1:
env["PATH_INFO"] = p[0]
elif len(p) == 2:
[env["PATH_INFO"], env["QUERY_STRING"]] = p
else:
raise TypeError("")
if basic:
env["HTTP_AUTHORIZATION"] = "Basic %s" % base64.encodestring(basic)
if stdin is None:
stdin = BytesIO()
outstream = BytesIO()
response = Response(stdout=outstream, stderr=sys.stderr)
request = Request(stdin, env, response)
publish_module("Zope2",
debug=not handle_errors,
request=request,
response=response)
return ResponseWrapper(response, outstream, path)
def __init__(self):
env = {'SERVER_NAME': 'nohost',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET'}
Request.__init__(self, None, env, Response())
def publish_module(module_name,
stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr,
environ=os.environ, debug=0, request=None, response=None,
extra={}):
""" Adapted from from ZPublisher.Test.publish_module:
but we handle the response status like given from response.getStatus(),
otherwise plone internal links will return status=200 for status=404 links,
which will not throw an error.
"""
must_die = 0
status = 200
after_list = [None]
from ZPublisher.Response import Response
from ZPublisher.Request import Request
from ZPublisher.Publish import publish
from zope.publisher.interfaces import ISkinnable
from zope.publisher.skinnable import setDefaultSkin
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)
# 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)
for k, v in extra.items():
request[k] = v
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 Unauthorized:
# Handle Unauthorized separately, otherwise it will be displayed as
# a redirect to the login form
status = 200
response = None
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:
# this is our change: otherwise 404 will return 200
# but we only want "real" 404 - otherwise the list will get full
# of internal links with edit-links stuff that will return 5xx
# codes.
if response.getStatus() in (301, 302, 404):
status = response.getStatus()
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()
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:
raise must_die[0], must_die[1], must_die[2]
finally:
must_die = None
return status, response
def __init__(self, *args, **kwargs):
Request.__init__(self, *args, **kwargs)
self.__plugins = {interfaces.IRequest.__identifier__: self}