def to_png(image):
""" Get as PNG
"""
imgbuf = QBuffer()
imgbuf.open(QIODevice.ReadWrite)
image.save(imgbuf, "PNG")
# Return a QByteArray
return imgbuf.data()
def writeTile(self, tile, image, fileFormat, quality):
data = QByteArray()
buff = QBuffer(data)
image.save(buff, fileFormat, quality)
self.cursor.execute('''INSERT INTO tiles(zoom_level, tile_column, tile_row, tile_data) VALUES (?, ?, ?, ?);''', (tile.z, tile.x, tile.y, sqlite3.Binary(buff.data())))
buff.close()
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()
