def _process(self, method): assert isinstance(method, str), 'Invalid method %s' % method proc = self.server.processing assert isinstance(proc, Processing), 'Invalid processing %s' % proc request, requestCnt = proc.ctx.request(), proc.ctx.requestCnt() assert isinstance(request, RequestHTTP), 'Invalid request %s' % request assert isinstance( requestCnt, RequestContentHTTP), 'Invalid request content %s' % requestCnt if RequestHTTP.clientIP in request: request.clientIP = self.client_address[0] url = urlparse(self.path) request.scheme, request.method = HTTP, method.upper() request.headers = dict(self.headers) request.uri = url.path.lstrip('/') request.parameters = parse_qsl(url.query, True, False) requestCnt.source = self.rfile chain = Chain(proc) chain.process( **proc.fillIn(request=request, requestCnt=requestCnt, response=proc.ctx.response(), responseCnt=proc.ctx.responseCnt())).doAll() response, responseCnt = chain.arg.response, chain.arg.responseCnt assert isinstance(response, ResponseHTTP), 'Invalid response %s' % response assert isinstance( responseCnt, ResponseContentHTTP), 'Invalid response content %s' % responseCnt if ResponseHTTP.headers in response and response.headers is not None: for name, value in response.headers.items(): self.send_header(name, value) assert isinstance( response.status, int), 'Invalid response status code %s' % response.status if ResponseHTTP.text in response and response.text: text = response.text elif ResponseHTTP.code in response and response.code: text = response.code else: text = None self.send_response(response.status, text) self.end_headers() if ResponseContentHTTP.source in responseCnt and responseCnt.source is not None: if isinstance(responseCnt.source, IInputStream): source = readGenerator(responseCnt.source) else: source = responseCnt.source for bytes in source: self.wfile.write(bytes)
def __call__(self, context, respond): ''' Process the WSGI call. ''' assert isinstance(context, dict), 'Invalid context %s' % context assert callable(respond), 'Invalid respond callable %s' % respond responseHeaders = dict(self.defaultHeaders) path, scheme = context['PATH_INFO'], context['wsgi.url_scheme'] if path.startswith('/'): path = path[1:] for regex, processing in self.pathProcessing: match = regex.match(path) if match: uriRoot = path[:match.end()] if not uriRoot.endswith('/'): uriRoot += '/' assert isinstance(processing, Processing), 'Invalid processing %s' % processing req, reqCnt = processing.contexts['request'](), processing.contexts['requestCnt']() rsp, rspCnt = processing.contexts['response'](), processing.contexts['responseCnt']() assert isinstance(req, RequestHTTP), 'Invalid request %s' % req assert isinstance(reqCnt, RequestContentHTTP), 'Invalid request content %s' % reqCnt assert isinstance(rsp, ResponseHTTP), 'Invalid response %s' % rsp assert isinstance(rspCnt, ResponseContentHTTP), 'Invalid response content %s' % rspCnt req.scheme, req.uriRoot, req.uri = scheme, uriRoot, path[match.end():] break else: respond('404 Not Found', list(responseHeaders.items())) return () req.method = self.methods.get(context['REQUEST_METHOD'], self.methodUnknown) req.parameters = parse_qsl(context['QUERY_STRING'], True, False) prefix, prefixLen = self.headerPrefix, len(self.headerPrefix,) req.headers = {hname[prefixLen:].replace('_', '-'):hvalue for hname, hvalue in context.items() if hname.startswith(prefix)} req.headers.update({hname.replace('_', '-'):hvalue for hname, hvalue in context.items() if hname in self.headers}) reqCnt.source = context.get('wsgi.input') Chain(processing).process(request=req, requestCnt=reqCnt, response=rsp, responseCnt=rspCnt).doAll() assert isinstance(rsp.code, Code), 'Invalid response code %s' % rsp.code responseHeaders.update(rsp.headers) if ResponseHTTP.text in rsp: status = '%s %s' % (rsp.code.code, rsp.text) else: text = self.responses.get(rsp.code.code) if text is not None: status = '%s %s' % (rsp.code.code, text[0]) else: status = str(rsp.code.code) respond(status, list(responseHeaders.items())) if rspCnt.source is not None: if isinstance(rspCnt.source, IOutputStream): return readGenerator(rspCnt.source) return rspCnt.source return ()
def _process(self, method): url = urlparse(self.path) path = url.path.lstrip("/") for regex, processing in self.pathProcessing: match = regex.match(path) if match: uriRoot = path[: match.end()] if not uriRoot.endswith("/"): uriRoot += "/" assert isinstance(processing, Processing), "Invalid processing %s" % processing req, reqCnt = processing.contexts["request"](), processing.contexts["requestCnt"]() rsp, rspCnt = processing.contexts["response"](), processing.contexts["responseCnt"]() chain = processing.newChain() assert isinstance(chain, Chain), "Invalid chain %s" % chain assert isinstance(req, RequestHTTP), "Invalid request %s" % req assert isinstance(reqCnt, RequestContentHTTP), "Invalid request content %s" % reqCnt assert isinstance(rsp, ResponseHTTP), "Invalid response %s" % rsp assert isinstance(rspCnt, ResponseContentHTTP), "Invalid response content %s" % rspCnt req.scheme, req.uriRoot, req.uri = "http", uriRoot, path[match.end() :] req.parameters = parse_qsl(url.query, True, False) break else: self.send_response(404) self.end_headers() return req.method = method req.headers = dict(self.headers) reqCnt.source = self.rfile chain.process(request=req, requestCnt=reqCnt, response=rsp, responseCnt=rspCnt) assert isinstance(rsp.code, Code), "Invalid response code %s" % rsp.code if ResponseHTTP.headers in rsp: for name, value in rsp.headers.items(): self.send_header(name, value) if ResponseHTTP.text in rsp: self.send_response(rsp.code.code, rsp.text) else: self.send_response(rsp.code.code) self.end_headers() if rspCnt.source is not None: if isinstance(rspCnt.source, IOutputStream): source = readGenerator(rspCnt.source) else: source = rspCnt.source for bytes in source: self.wfile.write(bytes)
def process(self, chain, request:Request, response:Response, responseCnt:ResponseContent, **keyargs): ''' @see: HandlerProcessor.process Provide the file content as a response. ''' assert isinstance(chain, Chain), 'Invalid processors chain %s' % chain assert isinstance(request, Request), 'Invalid request %s' % request assert isinstance(response, Response), 'Invalid response %s' % response assert isinstance(responseCnt, ResponseContent), 'Invalid response content %s' % responseCnt if request.method != GET: response.allows |= GET response.code, response.text = METHOD_NOT_AVAILABLE, 'Path only available for GET' chain.proceed() return # Make sure the given path points inside the repository entryPath = normOSPath(join(self.repositoryPath, normZipPath(unquote(request.uri)))) if not entryPath.startswith(self.repositoryPath): response.code, response.text = RESOURCE_NOT_FOUND, 'Out of repository path' chain.proceed() return # Initialize the read file handler with None value # This will be set upon successful file open rf = None if isfile(entryPath): rf = open(entryPath, 'rb') else: linkPath = entryPath while len(linkPath) > len(self.repositoryPath): if isfile(linkPath + self._linkExt): with open(linkPath + self._linkExt) as f: links = json.load(f) subPath = normOSPath(entryPath[len(linkPath):]).lstrip(sep) for linkType, *data in links: if linkType in self._linkTypes: # make sure the subpath is normalized and uses the OS separator if not self._isPathDeleted(join(linkPath, subPath)): rf = self._linkTypes[linkType](subPath, *data) if rf is not None: break break subLinkPath = dirname(linkPath) if subLinkPath == linkPath: break linkPath = subLinkPath if rf is None: response.code, response.text = METHOD_NOT_AVAILABLE, 'Invalid content resource' chain.proceed() return response.code = RESOURCE_FOUND responseCnt.source = readGenerator(rf)
def __call__(self, context, respond): ''' Process the WSGI call. ''' assert isinstance(context, dict), 'Invalid context %s' % context assert callable(respond), 'Invalid respond callable %s' % respond proc = self.processing assert isinstance(proc, Processing), 'Invalid processing %s' % proc request, requestCnt = proc.ctx.request(), proc.ctx.requestCnt() assert isinstance(request, RequestHTTP), 'Invalid request %s' % request assert isinstance(requestCnt, RequestContentHTTP), 'Invalid request content %s' % requestCnt if RequestHTTP.clientIP in request: request.clientIP = context.get('HTTP_X_FORWARDED_FOR') if request.clientIP: request.clientIP = request.clientIP.split(',')[-1].strip() else: request.clientIP = context.get('REMOTE_ADDR') request.scheme, request.method = context.get('wsgi.url_scheme', '').upper(), context.get('REQUEST_METHOD', '').upper() request.uri = context.get('PATH_INFO', '').lstrip('/') if RequestHTTP.headers in request: request.headers = {} for hname, hvalue in context.items(): if hname.startswith(self.headerPrefix): request.headers[hname[self.headerPrefixLen:].replace('_', '-')] = hvalue elif hname in self.headers: request.headers[hname.replace('_', '-')] = hvalue if RequestHTTP.parameters in request: request.parameters = parse_qsl(context.get('QUERY_STRING', ''), True, False) if RequestContentHTTP.source in requestCnt: requestCnt.source = context.get('wsgi.input') arg = proc.execute(FILL_ALL, request=request, requestCnt=requestCnt) response, responseCnt = arg.response, arg.responseCnt assert isinstance(response, ResponseHTTP), 'Invalid response %s' % response assert isinstance(responseCnt, ResponseContentHTTP), 'Invalid response content %s' % responseCnt responseHeaders = dict(self.defaultHeaders) if ResponseHTTP.headers in response and response.headers is not None: responseHeaders.update(response.headers) assert isinstance(response.status, int), 'Invalid response status code %s' % response.status if ResponseHTTP.text in response and response.text: status = '%s %s' % (response.status, response.text) elif ResponseHTTP.code in response and response.code: status = '%s %s' % (response.status, response.code) else: status = str(response.status) respond(status, list(responseHeaders.items())) if ResponseContentHTTP.source in responseCnt and responseCnt.source is not None: if isinstance(responseCnt.source, IInputStream): return readGenerator(responseCnt.source) return responseCnt.source return ()
def default(self, *vpath, **params): request, response = cherrypy.request, cherrypy.response path = '/'.join(vpath) for regex, processing in self.pathProcessing: match = regex.match(path) if match: uriRoot = path[:match.end()] if not uriRoot.endswith('/'): uriRoot += '/' assert isinstance(processing, Processing), 'Invalid processing %s' % processing req, reqCnt = processing.contexts['request'](), processing.contexts['requestCnt']() rsp, rspCnt = processing.contexts['response'](), processing.contexts['responseCnt']() chain = processing.newChain() assert isinstance(chain, Chain), 'Invalid chain %s' % chain assert isinstance(req, RequestHTTP), 'Invalid request %s' % req assert isinstance(reqCnt, RequestContentHTTP), 'Invalid request content %s' % reqCnt assert isinstance(rsp, ResponseHTTP), 'Invalid response %s' % rsp assert isinstance(rspCnt, ResponseContentHTTP), 'Invalid response content %s' % rspCnt req.scheme, req.uriRoot, req.uri = 'http', uriRoot, path[match.end():] break else: raise cherrypy.HTTPError(404) req.method = self.methods.get(request.method, self.methodUnknown) req.headers = request.headers reqCnt.source = request.rfile parameters = [] for name, value in params.items(): if isinstance(value, list): parameters.extend([(name, v) for v in value]) else: parameters.append((name, value)) req.parameters = parameters chain.process(request=req, requestCnt=reqCnt, response=rsp, responseCnt=rspCnt) assert isinstance(rsp.code, Code), 'Invalid response code %s' % rsp.code response.headers.pop('Content-Type', None) response.headers['Server'] = self.serverVersion response.headers.update(rsp.headers) if ResponseHTTP.text in rsp: response.status = '%s %s' % (rsp.code.code, rsp.text) else: response.status = str(rsp.code.code) if isinstance(rsp.source, IOutputStream): return readGenerator(rsp.source) return rspCnt.source
def processGet(pathProcessing, headers, url): ''' @see: process Process the GET and reads the response stream. ''' _req, _reqCnt, rsp, rspCnt = process(pathProcessing, GET, headers, url, None) assert isinstance(rsp, ResponseHTTP), 'Invalid response %s' % rsp assert isinstance(rspCnt, ResponseContentHTTP), 'Invalid response content %s' % rspCnt assert isinstance(rsp.code, Code), 'Invalid response code %s' % rsp.code if not rsp.code.isSuccess: raise Exception('Bad response \'%s\' %s' % (rsp.code.code, rsp.text)) if rspCnt.source is not None: if isinstance(rspCnt.source, IInputStream): source = readGenerator(rspCnt.source) else: source = rspCnt.source for bytes in source: pass # Just the consume the stream
def respond(): assert isinstance(rsp.code, int), 'Invalid response code %s' % rsp.code if ResponseHTTP.headers in rsp: for name, value in rsp.headers.items(): self.send_header(name, value) if ResponseHTTP.text in rsp: self.send_response(rsp.code, rsp.text) else: self.send_response(rsp.code) self.end_headers() if rspCnt.source is not None: if isinstance(rspCnt.source, IInputStream): source = readGenerator(rspCnt.source, self.bufferSize) else: source = rspCnt.source self._writeq.append((WRITE_ITER, iter(source))) self._writeq.append((WRITE_CLOSE, None))
def _process(self, method): url = urlparse(self.path) path = url.path.lstrip('/') for regex, processing in self.server.pathProcessing: match = regex.match(path) if match: uriRoot = path[:match.end()] if not uriRoot.endswith('/'): uriRoot += '/' assert isinstance(processing, Processing), 'Invalid processing %s' % processing req, reqCnt = processing.contexts['request'](), processing.contexts['requestCnt']() rsp, rspCnt = processing.contexts['response'](), processing.contexts['responseCnt']() assert isinstance(req, RequestHTTP), 'Invalid request %s' % req assert isinstance(reqCnt, RequestContentHTTP), 'Invalid request content %s' % reqCnt assert isinstance(rsp, ResponseHTTP), 'Invalid response %s' % rsp assert isinstance(rspCnt, ResponseContentHTTP), 'Invalid response content %s' % rspCnt req.scheme, req.uriRoot, req.uri = 'http', uriRoot, path[match.end():] req.parameters = parse_qsl(url.query, True, False) break else: self.send_response(404) self.end_headers() return req.methodName = method req.headers = dict(self.headers) reqCnt.source = self.rfile Chain(processing).process(request=req, requestCnt=reqCnt, response=rsp, responseCnt=rspCnt).doAll() assert isinstance(rsp.code, int), 'Invalid response code %s' % rsp.code if ResponseHTTP.headers in rsp: for name, value in rsp.headers.items(): self.send_header(name, value) if ResponseHTTP.text in rsp: self.send_response(rsp.code, rsp.text) else: self.send_response(rsp.code) self.end_headers() if rspCnt.source is not None: if isinstance(rspCnt.source, IInputStream): source = readGenerator(rspCnt.source) else: source = rspCnt.source for bytes in source: self.wfile.write(bytes)
def process(self, chain, response:HeadersDefines, responseCnt:ResponseContent, **keyargs): ''' @see: HandlerProcessor.process Encodes the content length. ''' assert isinstance(responseCnt, ResponseContent), 'Invalid response content %s' % responseCnt if responseCnt.source is None: return # No content to chunck. CONTENT_LENGTH.remove(response) # We make sure that no content length is not on the headers since this will create a conflict. TRANSFER_ENCODING.put(response, TRANSFER_ENCODING_CHUNKED) if isinstance(responseCnt.source, IInputStream): responseCnt.source = self.chuncks(readGenerator(responseCnt.source, self.maximumChunkSize)) else: assert isinstance(responseCnt.source, Iterable), 'Invalid source %s' % responseCnt.source responseCnt.source = self.chuncks(responseCnt.source)
def process(self, chain, response:Response, responseCnt:ResponseContent, **keyargs): ''' @see: HandlerProcessor.process Provides the additional arguments by type to be populated. ''' assert isinstance(chain, Chain), 'Invalid processors chain %s' % chain assert isinstance(response, Response), 'Invalid response %s' % response assert isinstance(responseCnt, ResponseContent), 'Invalid response content %s' % responseCnt error = None try: try: chain.process(response=response, responseCnt=responseCnt, **keyargs) # We process the chain internally so we might cache any exception. except DevelError as e: response.code, response.text, response.errorMessage = BAD_CONTENT, 'Development error', str(e) chain.process(response=response, responseCnt=responseCnt, **keyargs) # We try to process now the chain (where it left of) with the exception set. except: log.exception('Exception occurred while processing the chain') error = StringIO() traceback.print_exc(file=error) else: if __debug__ and isinstance(responseCnt.source, Iterable): # If in debug mode and the response content has a source generator then we will try to read that # in order to catch any exception before the actual streaming. content = BytesIO() try: for bytes in responseCnt.source: content.write(bytes) except: log.exception('Exception occurred while processing the chain') error = StringIO() traceback.print_exc(file=error) else: content.seek(0) responseCnt.source = readGenerator(content) if error is not None: response.code = INTERNAL_ERROR response.text = 'Upps, please consult the server logs' response.headers = self.errorHeaders responseCnt.source = convertToBytes(self.errorResponse(error), 'utf8', 'backslashreplace')
def _process(self, method): assert isinstance(method, str), 'Invalid method %s' % method proc = self.server.processing assert isinstance(proc, Processing), 'Invalid processing %s' % proc request, requestCnt = proc.ctx.request(), proc.ctx.requestCnt() assert isinstance(request, RequestHTTP), 'Invalid request %s' % request assert isinstance(requestCnt, RequestContentHTTP), 'Invalid request content %s' % requestCnt if RequestHTTP.clientIP in request: request.clientIP = self.client_address[0] url = urlparse(self.path) request.scheme, request.method = HTTP, method.upper() request.headers = dict(self.headers) request.uri = url.path.lstrip('/') request.parameters = parse_qsl(url.query, True, False) requestCnt.source = self.rfile chain = Chain(proc) chain.process(**proc.fillIn(request=request, requestCnt=requestCnt, response=proc.ctx.response(), responseCnt=proc.ctx.responseCnt())).doAll() response, responseCnt = chain.arg.response, chain.arg.responseCnt assert isinstance(response, ResponseHTTP), 'Invalid response %s' % response assert isinstance(responseCnt, ResponseContentHTTP), 'Invalid response content %s' % responseCnt if ResponseHTTP.headers in response and response.headers is not None: for name, value in response.headers.items(): self.send_header(name, value) assert isinstance(response.status, int), 'Invalid response status code %s' % response.status if ResponseHTTP.text in response and response.text: text = response.text elif ResponseHTTP.code in response and response.code: text = response.code else: text = None self.send_response(response.status, text) self.end_headers() if ResponseContentHTTP.source in responseCnt and responseCnt.source is not None: if isinstance(responseCnt.source, IInputStream): source = readGenerator(responseCnt.source) else: source = responseCnt.source for bytes in source: self.wfile.write(bytes)
def respond(): response, responseCnt = chain.arg.response, chain.arg.responseCnt assert isinstance(response, ResponseHTTP), 'Invalid response %s' % response assert isinstance(responseCnt, ResponseContentHTTP), 'Invalid response content %s' % responseCnt if ResponseHTTP.headers in response and response.headers is not None: for name, value in response.headers.items(): self.send_header(name, value) assert isinstance(response.status, int), 'Invalid response status code %s' % response.status if ResponseHTTP.text in response and response.text: text = response.text elif ResponseHTTP.code in response and response.code: text = response.code else: text = None self.send_response(response.status, text) self.end_headers() if ResponseContentHTTP.source in responseCnt and responseCnt.source is not None: if isinstance(responseCnt.source, IInputStream): source = readGenerator(responseCnt.source, self.bufferSize) else: source = responseCnt.source self._writeq.append((WRITE_ITER, iter(source))) self._writeq.append((WRITE_CLOSE, None))
def processGet(pathProcessing, headers, url): ''' @see: process Process the GET and reads the response stream. ''' _req, _reqCnt, rsp, rspCnt = process(pathProcessing, GET, headers, url, None) assert isinstance(rsp, ResponseHTTP), 'Invalid response %s' % rsp assert isinstance( rspCnt, ResponseContentHTTP), 'Invalid response content %s' % rspCnt assert isinstance(rsp.code, Code), 'Invalid response code %s' % rsp.code if not rsp.code.isSuccess: raise Exception('Bad response \'%s\' %s' % (rsp.code.code, rsp.text)) if rspCnt.source is not None: if isinstance(rspCnt.source, IOutputStream): source = readGenerator(rspCnt.source) else: source = rspCnt.source for bytes in source: pass # Just the consume the stream
def __call__(self, context, respond): """ Process the WSGI call. """ assert isinstance(context, dict), "Invalid context %s" % context assert callable(respond), "Invalid respond callable %s" % respond responseHeaders = dict(self.defaultHeaders) path, scheme = context["PATH_INFO"], context["wsgi.url_scheme"] if path.startswith("/"): path = path[1:] for regex, processing in self.pathProcessing: match = regex.match(path) if match: uriRoot = path[: match.end()] if not uriRoot.endswith("/"): uriRoot += "/" assert isinstance(processing, Processing), "Invalid processing %s" % processing req, reqCnt = processing.contexts["request"](), processing.contexts["requestCnt"]() rsp, rspCnt = processing.contexts["response"](), processing.contexts["responseCnt"]() assert isinstance(req, RequestHTTP), "Invalid request %s" % req assert isinstance(reqCnt, RequestContentHTTP), "Invalid request content %s" % reqCnt assert isinstance(rsp, ResponseHTTP), "Invalid response %s" % rsp assert isinstance(rspCnt, ResponseContentHTTP), "Invalid response content %s" % rspCnt req.scheme, req.uriRoot, req.uri = scheme, uriRoot, path[match.end() :] break else: respond("404 Not Found", list(responseHeaders.items())) return () method = context["REQUEST_METHOD"] if method: method = method.upper() if method not in METHODS: method = METHOD_UNKNOWN else: method = METHOD_UNKNOWN req.methodName = method req.parameters = parse_qsl(context["QUERY_STRING"], True, False) prefix, prefixLen = self.headerPrefix, len(self.headerPrefix) req.headers = { hname[prefixLen:].replace("_", "-"): hvalue for hname, hvalue in context.items() if hname.startswith(prefix) } req.headers.update( {hname.replace("_", "-"): hvalue for hname, hvalue in context.items() if hname in self.headers} ) reqCnt.source = context.get("wsgi.input") Chain(processing).process(request=req, requestCnt=reqCnt, response=rsp, responseCnt=rspCnt).doAll() assert isinstance(rsp.code, int), "Invalid response code %s" % rsp.code responseHeaders.update(rsp.headers) if ResponseHTTP.text in rsp: status = "%s %s" % (rsp.code, rsp.text) else: text = self.responses.get(rsp.code) if text is not None: status = "%s %s" % (rsp.code, text[0]) else: status = str(rsp.code) respond(status, list(responseHeaders.items())) if rspCnt.source is not None: if isinstance(rspCnt.source, IInputStream): return readGenerator(rspCnt.source) return rspCnt.source return ()
def __call__(self, context, respond): ''' Process the WSGI call. ''' assert isinstance(context, dict), 'Invalid context %s' % context assert callable(respond), 'Invalid respond callable %s' % respond proc = self.processing assert isinstance(proc, Processing), 'Invalid processing %s' % proc request, requestCnt = proc.ctx.request(), proc.ctx.requestCnt() assert isinstance(request, RequestHTTP), 'Invalid request %s' % request assert isinstance( requestCnt, RequestContentHTTP), 'Invalid request content %s' % requestCnt if RequestHTTP.clientIP in request: request.clientIP = context.get('HTTP_X_FORWARDED_FOR') if request.clientIP: request.clientIP = request.clientIP.split(',')[-1].strip() else: request.clientIP = context.get('REMOTE_ADDR') request.scheme, request.method = context.get('wsgi.url_scheme', '').upper(), context.get( 'REQUEST_METHOD', '').upper() request.uri = context.get('PATH_INFO', '').lstrip('/') if RequestHTTP.headers in request: request.headers = {} for hname, hvalue in context.items(): if hname.startswith(self.headerPrefix): request.headers[hname[self.headerPrefixLen:].replace( '_', '-')] = hvalue elif hname in self.headers: request.headers[hname.replace('_', '-')] = hvalue if RequestHTTP.parameters in request: request.parameters = parse_qsl(context.get('QUERY_STRING', ''), True, False) if RequestContentHTTP.source in requestCnt: requestCnt.source = context.get('wsgi.input') arg = proc.execute(FILL_ALL, request=request, requestCnt=requestCnt) response, responseCnt = arg.response, arg.responseCnt assert isinstance(response, ResponseHTTP), 'Invalid response %s' % response assert isinstance( responseCnt, ResponseContentHTTP), 'Invalid response content %s' % responseCnt responseHeaders = dict(self.defaultHeaders) if ResponseHTTP.headers in response and response.headers is not None: responseHeaders.update(response.headers) assert isinstance( response.status, int), 'Invalid response status code %s' % response.status if ResponseHTTP.text in response and response.text: status = '%s %s' % (response.status, response.text) elif ResponseHTTP.code in response and response.code: status = '%s %s' % (response.status, response.code) else: status = str(response.status) respond(status, list(responseHeaders.items())) if ResponseContentHTTP.source in responseCnt and responseCnt.source is not None: if isinstance(responseCnt.source, IInputStream): return readGenerator(responseCnt.source) return responseCnt.source return ()