def _getHigherLevelUser(self, request, roles=None): if roles: accessed = self._getPAS()._getObjectContext( request["PUBLISHED"], request)[1] req_roles = request.roles auth = request._auth # save response and install new one to prevent side effects saved_response = request.response try: request.response = Response() for uf in self._generateHigherLevelUserFolders(): if req_roles is UNSPECIFIED_ROLES: u = uf.validate(request, auth) else: u = uf.validate(request, auth, req_roles) if u is None or u is nobody: continue # this user folder has authenticated a user able to perform # the request if roles: # check in addition that is has one of *roles* if not u.allowed(accessed, roles): # reject this user continue return u finally: request.response = saved_response
def render_object(obj, path, where, append_html=True, output_root='', raise_errors=False): path = path.strip('/') assert '..' not in path outputfile = os.path.join(where, path) outputdir = os.path.dirname(outputfile) environ = {'SERVER_NAME': 'localhost', 'SERVER_PORT': '80'} stdin = StringIO() response = Response(stdout=sys.stdout, stderr=sys.stderr) request = Request(stdin, environ, response) if output_root: request['SERVER_URL'] = relpath(output_root, outputdir) setDefaultSkin(request) app = Application().__of__(RequestContainer(REQUEST=request)) obj = obj.__of__(app) request.other['VirtualRootPhysicalPath'] = obj.getPhysicalPath() obj = obj.unrestrictedTraverse(path) if getattr(obj, 'index_html', None) is not None: obj = obj.index_html try: result = mapply(obj, request.args, request) except Exception, e: print >> sys.stderr, "cannot render %s: %s: %s" % ( path, e.__class__.__name__, e) if raise_errors: raise
def __init__(self): env = { 'SERVER_NAME': 'nohost', 'SERVER_PORT': '80', 'REQUEST_METHOD': 'GET' } Request.__init__(self, None, env, Response())
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 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 __call__(self): request = BaseRequest() site = self.context.getSite() request['PARENTS'] = [site] request.steps = list(self.context.getPhysicalPath()) request['URL'] = site.absolute_url() request.response = Response() import pdb pdb.set_trace() request.traverse('who-who') return
def setBody(self, body, title='', is_error=0, **kw): if IStreamIterator.providedBy(body): body = ''.join(body) Response.setBody(self, body, title, is_error, **kw)
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.Response import Response from ZPublisher.Test import publish_module from AccessControl.SecurityManagement import getSecurityManager from AccessControl.SecurityManagement import setSecurityManager # Save current Security Manager old_sm = getSecurityManager() # 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('?') 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 env.has_key('HTTP_AUTHORIZATION'): 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.appendResponseHeaders(response._cookie_list()) header_output.appendResponseHeaders(response.accumulated_headers.splitlines()) # Restore previous security manager, which may have been changed # by calling the publish method above setSecurityManager(old_sm) # Sync connection sync() return DocResponseWrapper(response, outstream, path, header_output)
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 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.Response import Response from 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 env.has_key('HTTP_AUTHORIZATION'): 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 run(self, *args, **kwargs): self.payload = kwargs['payload'] self.template = kwargs['template'] self.rec_id = kwargs['rec_id'] site = getSite() user = getSecurityManager().getUser() acl_users = site.acl_users user = user.__of__(acl_users) user_id = kwargs['user_id'] request = BaseRequest() request.response = Response() request.AUTHENTICATED_USER = user request['PARENTS'] = [site] request['URL'] = kwargs['url'] request.steps = [] request.cookies = {} request.form = {} import_location = site.unrestrictedTraverse(kwargs['import_path']) import_location.REQUEST = request site.REQUEST = request geo_fields = kwargs['geo_fields'] self.prop_map = kwargs['properties'] meta_type = kwargs['meta_type'] header = self.template row = self.payload record_number = self.rec_id content_type = import_location.getSite().get_pluggable_item(meta_type) add_object = content_type['add_method'] properties = {} extra_properties = {} address = None for column, value in zip(header, row): if value == '': continue if column not in self.prop_map: extra_properties[column] = value continue key = self.prop_map[column]['column'] widget = self.prop_map[column]['widget'] widget = widget.__of__(import_location) convert = widget.convert_from_user_string properties[key] = convert(value) try: properties = do_geocoding(geo_fields, properties) except GeocoderServiceError, e: msg = ( 'Warnings: could not find a valid address ' 'for row ${record_number}: ${error}', { 'record_number': record_number + 1, # account for header 'error': str(e) }) self.warnings.append(msg) address = properties.pop(geo_fields['address'])