def render(self, request): self._session_id = request.getHeader('x-apple-session-id') if self._session_id == None: self._session_id = 'dummy' else: self._protocolHandler.sessionID = self._session_id request.responseHeaders.removeHeader('Content-Type') request.responseHeaders.removeHeader('Server') Resource.render(self, request) return 1
def render(self, request): self._session_id = request.getHeader('x-apple-session-id') if self._session_id == None: self._session_id = 'dummy' else: self._protocolHandler.sessionID = self._session_id request.responseHeaders.removeHeader('Content-Type') request.responseHeaders.removeHeader('Server') Resource.render(self, request) return 1
def render(self, request): # For proxied requests, we have to override getClientIP to return # the proper IP address. if request.requestHeaders.hasHeader(b'x-forwarded-for'): client_ip = request.requestHeaders.getRawHeaders( b"x-forwarded-for", [b"-"])[0].split(b",")[0].strip() request.getClientIP = lambda: client_ip # Add a few properties to the request object that are used to # return additional information for the request_buffer debugging # tool request._zaction = { "metrics": [], "maps": [], "events": [] } result = TwistedResource.render(self, request) # log any requests that generated error responses # this will only get us the code, but the detailed response bodies # will be in the /health logs. if request.code >= 400: timestamp = datetimeToLogString(reactor.seconds()) log.error(combinedLogFormatter(timestamp, request)) if not request.uri.startswith("/health"): self.site.request_buffer.store_request(request, result) return result
def render(self, request): try: return Resource.render(self, request) except UnsupportedMethod, e: Logr.debug("(%s) unhandled method %s", self.service.serviceType, request.method) raise e
def render(self, request): try: return Resource.render(self, request) except BadOption as e: self._write_error(request, 400, e) self._log_stats(request, {}, error=self._format_error(400, e)) return b"\n"
def render(self, request): session = get_current_session(request) authresponse = self._checkAuth(request) if authresponse != None: return authresponse else: return Resource.render(self, request)
def render(self, request): "Disable cache of renderable resources" request.setHeader('Expires', 'Fri, 25 Nov 1966 08:22:00 EST') request.setHeader("Cache-Control", "no-store, no-cache, must-revalidate") request.setHeader("Pragma", "no-cache") request.setHeader("X-XSS-Protection", "0") return Resource.render(self, request)
def render(self, request): try: return Resource.render(self, request) except UnsupportedMethod, e: Logr.debug("(%s) unhandled method %s", self.service.serviceType, request.method) raise e
def render(self, request): request.setHeader('Content-Type', 'application/json; charset=utf8') user = request.getUser() passwd = request.getPassword() m = hashlib.sha256() m.update(passwd) if m.hexdigest() != settings.ADMIN_PASSWORD_SHA256: request.setResponseCode(401) return '"Authorisation required!"' links = [] for c in self.children: if isinstance(self.children[c], RestResource) and c != '': links.append('</%s>; rel="%s"' % (c, c)) if len(links) > 0: request.setHeader('Link', ", ".join(links)) self.path_or_id = self.get_path_id(request) if request.method == 'POST' and self.path_or_id != '': request.setResponseCode(405) return '"Cannot call POST on a resource with an identifier"' if (request.method == 'PUT' or request.method == 'DELETE') and self.path_or_id == '': request.setResponseCode(405) return '"Cannot call PUT or DELETE without an identifier"' return Resource.render(self, request)
def render(self, request): try: return Resource.render(self, request) except: log.err() return """{"message": "We were unable to handle your api request.", "success": false}"""
def render(self, request): request.initialize(self) result = Resource.render(self, request) if result == NOT_DONE_YET: return result request.finalize() return result.encode("UTF-8")
def render(self, request): "Disable cache of renderable resources" request.setHeader('Expires', 'Fri, 25 Nov 1966 08:22:00 EST') request.setHeader("Cache-Control", "no-store, no-cache, must-revalidate") request.setHeader("Pragma", "no-cache") request.setHeader("X-XSS-Protection", "0") return Resource.render(self, request)
def render(self, *args, **kwargs): ret = Resource.render(self, *args, **kwargs) if ret is not NOT_DONE_YET: ret = json.dumps(ret, indent=2) if not isinstance(ret, basestring) else ret if not ret.endswith('\n'): ret += '\n' return ret
def render(self, request): """ Invoke appropriate handler function. This is where the incoming HTTP request first lands. Dispatch the request to corresponding handler function based on the request method (get/put/post/...). """ methodname, method = self._getMethod(request) try: if method: d = defer.maybeDeferred( self._executeHandler, methodname, method, request) d.addCallback(self._createResponse, request) d.addErrback(self._errorResponse) d.addCallback(self._prepareResponse, request) return NOT_DONE_YET else: # let the base class handle 405 return ResourceBase.render(self, request) finally: self.log.info('"%s %s" %d' % ( request.method, request.path, request.code if method else 501))
def render(self, request): try: return Resource.render(self, request) except BadOption as e: self._write_error(request, 400, e) self._log_stats(request, {}, error=self._format_error(400, e)) return b"\n"
def render(self, request): request.setHeader('Content-Type', 'application/json; charset=utf8') user = request.getUser() passwd = request.getPassword() m = hashlib.sha256() m.update(passwd) if m.hexdigest() != settings.ADMIN_PASSWORD_SHA256: request.setResponseCode(401) return '"Authorisation required!"' links = [] for c in self.children: if isinstance(self.children[c], RestResource) and c != '': links.append('</%s>; rel="%s"' % (c, c)) if len(links) > 0: request.setHeader('Link', ", ".join(links)) self.path_or_id = self.get_path_id(request) if request.method == 'POST' and self.path_or_id != '': request.setResponseCode(405) return '"Cannot call POST on a resource with an identifier"' if (request.method == 'PUT' or request.method == 'DELETE') and self.path_or_id == '': request.setResponseCode(405) return '"Cannot call PUT or DELETE without an identifier"' return Resource.render(self, request)
def render(self, *args, **kwargs): ret = Resource.render(self, *args, **kwargs) if ret is not NOT_DONE_YET: ret = json.dumps( ret, indent=2) if not isinstance(ret, basestring) else ret if not ret.endswith('\n'): ret += '\n' return ret
def render(self, request): start = time.time() try: return Resource.render(self, request) except Exception, e: log.err(e) request.content.reset() log.err('Error: input: %s' % request.content.read())
def render(self, request): self.request = request user = self.request.getUser() password = self.request.getPassword() if user == self.root.api.username and password == self.root.api.password: return Resource.render(self, request) else: request.setResponseCode(http.UNAUTHORIZED) return json.dumps({'status': 'Unauthorized'})
def render(self, request): session = get_current_session(request) redirect_uri = self._authredirect(request) if redirect_uri != None: session.return_uri = request.uri return redirect(request, redirect_uri) else: return Resource.render(self, request)
def render(self, request): session = get_current_session(request) redirect_uri = self._authredirect(request) if redirect_uri != None: session.return_uri = request.uri return redirect(request, redirect_uri) else: return Resource.render(self, request)
def render(self, request): try: request.setHeader('Content-Type', 'text/xml') return Resource.render(self, request) except UnsupportedMethod, e: log.msg("unsupported: (%s) %s" % (self.service.serviceType, request.method), loglevel=logging.DEBUG) raise e
def render(self, request): try: request.setHeader('Content-Type', 'text/xml') return Resource.render(self, request) except UnsupportedMethod, e: log.msg("unsupported: (%s) %s" % ( self.service.serviceType, request.method), loglevel=logging.DEBUG) raise e
def render(self, request): if self.cors: request.setHeader('Access-Control-Allow-Origin', '*') request.setHeader('Access-Control-Allow-Methods', 'PUT, GET, POST, DELETE, OPTIONS') request.setHeader('Access-Control-Allow-Headers', 'authorization, content-type') if request.method != "OPTIONS" or not self.cors: return Resource.render(self, request) else: return ""
def render(self, request): # assert(isinstance(request, (server.Request))) # assert(isinstance(request.site, AuthenticatedSite)) self.request = request request.user = request.site.check_authentication(request) request.user = None if not self.check_permissions(): return self.access_forbidden(request) return Resource.render(self, request)
def render(self, request): request.setResponseCode(200) request.setHeader('Content-Type', 'application/json') try: return Resource.render(self, request) except IOError as ex: if ex.errno == errno.ENOENT: return NoResource().render(request) else: raise except ErrorPage as ex: return ex.render(request)
def make_real_webserver(self): """ Construct a real webserver to test actual connectivity. """ root = Resource() root.isLeaf = True root.render = lambda r: self._render_request(r) site_factory = Site(root) webserver = yield reactor.listenTCP( 0, site_factory, interface='127.0.0.1') self.add_cleanup(webserver.loseConnection) addr = webserver.getHost() url = "http://%s:%s/" % (addr.host, addr.port) returnValue(url)
def make_real_webserver(self): """ Construct a real webserver to test actual connectivity. """ root = Resource() root.isLeaf = True root.render = lambda r: self._render_request(r) site_factory = Site(root) webserver = yield reactor.listenTCP( 0, site_factory, interface='127.0.0.1') self.add_cleanup(webserver.loseConnection) addr = webserver.getHost() url = "http://%s:%s/" % (addr.host, addr.port) returnValue(url)
def render(self, request): """Process request @type request: twisted.web.http.Request""" # Import here to prevent circular import from management_portal.auth.decorators import NotAllowed, NotLoggedIn try: return Resource.render(self, request) except NotLoggedIn: myTmp = self.redirectRelative(request, '/login?next=' + request.path) request.setResponseCode(http.UNAUTHORIZED) return myTmp except NotAllowed: return self.redirectRelative(request, '/')
def render(self, request): # type: (Request) -> Union[int, bytes] """ Before we render this request as normal, parse parameters, and add them to the request! Also, catch any errors during parameter parsing, and show them appropriately. :param request: Twisted request object :return: Byte string or NOT_DONE_YET - see IResource.render """ try: request.url_args = self.parse_args(request) except Exception: self.handle_exception(request) return NOT_DONE_YET else: return Resource.render(self, request)
def render(self, request): from twisted.web2 import http_headers head = http_headers.Headers(handler=http_headers.DefaultHTTPHandler) head.setRawHeaders('Accept', (request.getHeader('Accept'),)) accept = head.getHeader('Accept') accept = sorted([(mime, prio) for mime, prio in accept.iteritems()], key=lambda x: -x[1]) if self.plugin.flat_urls.hasURL('/'): urls = self.plugin.flat_urls.getURL('/') for ctype, weight in accept: ctype = '%s/%s' % (ctype.mediaType, ctype.mediaSubtype) if ctype in urls: request.raw_content_type = ctype return self.plugin.flat_urls[('/', ctype)].render(request) return Resource.render(self, request)
def render(self, request): request.setResponseCode(200) request.setHeader('Content-Type', 'application/json') try: return Resource.render(self, request) except IOError as ex: if ex.errno == errno.ENOENT: if request.is_ajax(): return SlydJsonNoResource().render(request) else: return NoResource().render(request) else: raise except ErrorPage as ex: if request.is_ajax(): ex = SlydJsonErrorPage(ex.code, ex.brief, ex.detail) return ex.render(request)
def render(self, request): request.setResponseCode(200) request.setHeader('Content-Type', 'application/json') try: return Resource.render(self, request) except IOError as ex: if ex.errno == errno.ENOENT: if request.is_ajax(): return SlydJsonNoResource().render(request) else: return NoResource().render(request) else: raise except ErrorPage as ex: if request.is_ajax(): ex = SlydJsonErrorPage(ex.code, ex.brief, ex.detail) return ex.render(request)
def render(self, request): request.setHeader(b"content-type", b"application/json") token = request.args.get('access_token') if token: token = token[0] if not token: log.info("No access token") request.setResponseCode(401) return '{"errcode": "twisted.unauthorized"}' elif token != self.api.token_hs: log.info("Wrong token: {got!r} != {expected!r}", got=token, expected=self.api.token_hs) request.setResponseCode(403) return '{"errcode": "M_FORBIDDEN"}' else: return Resource.render(self, request)
def render(self, request): """ Check for HTTP basic auth, and pass to normal rendering if accepted """ try: self.projectName = request.site.buildbot_service.parent.projectName except: self.projectName = "" if self.userpass is not None: if request.getUser() != self.userpass[0] or request.getPassword() != self.userpass[1]: realm = "%s buildbot tryserver" % self.projectName request.setHeader('WWW-Authenticate', 'Basic Realm="%s"' % realm) errpage = ErrorPage(http.UNAUTHORIZED, "Unauthorized", "401 Authentication required") return errpage.render(request) return Resource.render(self, request)
def render(self, request): self.request = request user = self.request.getUser().decode() password = self.request.getPassword().decode() if user == self.root.api.username and password == self.root.api.password: if self.require_init and (not self.root.api.initialized): request.setResponseCode( http.SERVICE_UNAVAILABLE, message='Gateway not Initialized'.encode()) return json.dumps(False).encode() else: try: return Resource.render(self, request) except Exception as exc: traceback.print_exc() self.root.api.check_exception_halt(exc, self) else: request.setResponseCode(http.UNAUTHORIZED) return json.dumps({'status': 'Unauthorized'}).encode()
def render(self, request): try: id = getPlatypusCookie(request) except CookieError: print "There was a cookie issue" try: redirect_number = int(request.args["redirect"][0]) except: redirect_number = 1 print "Redirect number ", print int(redirect_number) if redirect_number < 6: print "Setting cookie" setPlatypusCookie(request) url = str(request.uri) url = self.appendToURL(url, {"redirect":str(redirect_number)}) print "Redirect url is ", print str(url) redirectTo(url, request) request.finish() return NOT_DONE_YET # though we are else: request.write("<h2> You're request couldn't be completed.") request.finish() return NOT_DONE_YET# though we are else: try: return Resource.render(self, request) except: log.err() return "<html> <body><h2>Sorry we could not process your request.</h2></body> </html>" '''
def render(self, request): request.setHeader('Server', self.factory.banner) return Resource.render(self, request)
def render(self, request): log.msg('control ressource: %s' % request) return Resource.render(self, request)
def render(self, *args, **kwargs): self.startTime = time.time() return Resource.render(self, *args, **kwargs)
def render(self, request): request.setHeader('Server', self.factory.banner) return Resource.render(self, request)
def render(self,request): request.setHeader('Access-Control-Allow-Origin', '*') request.setHeader("Access-Control-Allow-Methods","*") request.setHeader("Access-Control-Allow-Headers","Content-Type,*") return Resource.render(self,request)
def render(self, request): try: return Resource.render(self, request) except BadRequest as e: request.setResponseCode(400) return str(e) + "\n"
def render(self, request): request.setHeader('Server', self.factory.banner) request.setResponseCode(int(self.error_code)) return Resource.render(self, request)
def render(self, request): request.setHeader('access-control-allow-origin', request.getHeader('origin')) request.setHeader('access-control-allow-credentials', 'true') return Resource.render(self, request)
def render(self, request): log.msg('control ressource: %s' % request) return Resource.render(self, request)
def render(self, *args, **kwargs): self.startTime = time.time() return Resource.render(self, *args, **kwargs)
def render(self, request): try: return Resource.render(self, request) except BadOption as e: return self._write_error(request, 400, e)
def do_render(info): Resource.render(self, request)
def render(self, request): request.setHeader('Server', self.factory.banner) request.setResponseCode(int(self.error_code)) return Resource.render(self, request)
def render(self, request): result = Resource.render(self, request) result.addCallback(self.finishRequest, request) return NOT_DONE_YET
def render(self, request): try: return Resource.render(self, request) except BadOption as e: request.setResponseCode(400) return str(e) + "\n"
def render(self, request): try: return Resource.render(self, request) except BadOption as e: return self._write_error(request, 400, e)