class Response(QgsServerResponse): def __init__( self ): QgsServerResponse.__init__(self) self._buffer = QBuffer() self._buffer.open(QIODevice.ReadWrite) def setReturnCode( self, code ): pass def setHeader( self, key, val ): pass def clearHeader( self, key ): pass def sendError( self, code, message ): pass def io(self): return self._buffer def finish(self): pass def flush(self): pass def clear(self): pass
def getCachedImage(self, project, request, key): m = hashlib.md5() paramMap = request.parameters() urlParam = "&".join(["%s=%s" % (k, paramMap[k]) for k in paramMap.keys()]) m.update(urlParam.encode('utf8')) if not os.path.exists(os.path.join(self._tile_cache_dir, m.hexdigest() + ".png")): return QByteArray() img = QImage(m.hexdigest() + ".png") with open(os.path.join(self._tile_cache_dir, m.hexdigest() + ".png"), "rb") as f: statusOK = img.loadFromData(f.read()) if not statusOK: print("Could not read or find the contents document. Error at line %d, column %d:\n%s" % (errorLine, errorColumn, errorStr)) return QByteArray() ba = QByteArray() buff = QBuffer(ba) buff.open(QIODevice.WriteOnly) img.save(buff, 'PNG') return ba
def __init__( self ): QgsServerResponse.__init__(self) self._buffer = QBuffer() self._buffer.open(QIODevice.ReadWrite)
def __init__(self): QgsServerResponse.__init__(self) self._buffer = QBuffer() self._buffer.open(QIODevice.ReadWrite)
class Response(QgsServerResponse): """ Adaptor to handler response The data is written at 'flush()' call. """ def __init__(self, handler: RequestHandler) -> None: super().__init__() self._handler = handler self._buffer = QBuffer() self._buffer.open(QIODevice.ReadWrite) self._numbytes = 0 self._finish = False def setStatusCode(self, code: int) -> None: if not self._handler.header_written: self._handler.status_code = code else: LOGGER.error("Cannot set status code after header written") def statusCode(self) -> int: return self._handler.status_code def finish(self) -> None: """ Terminate the request """ self._finish = True self.flush() def flush(self) -> None: """ Write the data to the handler buffer and flush the socket Headers will be written at the first call to flush() """ try: self._buffer.seek(0) bytesAvail = self._buffer.bytesAvailable() LOGGER.debug("%s: Flushing response data: (%d bytes)", self._handler.identity, bytesAvail) if self._finish: self._handler.headers['Content-Length'] = bytesAvail # Take care of the logic: if finish and not handler.header_written then there is no # chunk following send_more = not self._finish or self._handler.header_written if bytesAvail: self._handler.send(bytes(self._buffer.data()), send_more) self._buffer.buffer().clear() # push the sentinel if send_more and self._finish: self._handler.send(b'', False) except: LOGGER.error("Caught Exception (worker: %s, msg: %s):\n%s", self._handler.identity, self._handler.msgid, traceback.format_exc()) del self._handler.headers['Content-Type'] self.sendError(500, "Internal server error") def header(self, key: str) -> str: return self._handler.headers.get(key) def headers(self) -> Dict[str, str]: """ Return headers as dict """ return self._handler.headers def io(self) -> QIODevice: return self._buffer def data(self) -> QByteArray: """ Return buffer data """ return self._buffer.data() def setHeader(self, key: str, value: str) -> None: if not self._handler.header_written: self._handler.headers[key] = value else: LOGGER.error("Cannot set header after header written") def removeHeader(self, key: str) -> None: self._handler.headers.pop(key, None) def sendError(self, code: int, message: str = None) -> None: try: if not self._handler.header_written: LOGGER.error("%s (%s)", message, code) self._handler.status_code = code self._handler.send(bytes(str(message).encode('ascii'))) self._finish = True else: LOGGER.error("Cannot set error after header written") except: LOGGER.critical("Unrecoverable exception:\n%s", traceback.format_exc()) def _clearHeaders(self) -> None: """ Clear headers set so far """ self._handler.headers = {} def clear(self) -> None: self._clearHeaders() self.truncate() def headersSent(self) -> bool: return self._handler.header_written def truncate(self) -> None: """ Truncate buffer """ self._buffer.seek(0) self._buffer.buffer().clear()
def make_buffer(obj): data = QByteArray(make_payload(obj)) buffer = QBuffer() buffer.setData(data) buffer.open(buffer.ReadOnly) return buffer