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
