def _statusCallback(self, reply: QNetworkReply, error: QNetworkReply.NetworkError = None):
url = reply.request().url().toString()
prev_statuses = self._statuses.copy()
self._statuses[url] = HttpRequestManager.replyIndicatesSuccess(reply, error)
if any(self._statuses.values()) != any(prev_statuses.values()):
self.internetReachableChanged.emit()
def _load_icon_and_cache(self, http_response: QNetworkReply):
icon_url = http_response.request().url().toString()
icon_data = self.icon_cache.get(icon_url)
icon_was_cached = True
if not icon_data:
icon_bytes = http_response.readAll()
if not icon_bytes:
return
icon_was_cached = False
pixmap = QPixmap()
pixmap.loadFromData(icon_bytes)
if not pixmap.isNull():
icon = QIcon(pixmap)
icon_data = {'icon': icon, 'bytes': icon_bytes}
self.icon_cache.add(icon_url, icon_data)
if icon_data:
for idx, app in enumerate(self.window.pkgs):
if app.model.icon_url == icon_url:
col_name = self.item(idx, 0)
col_name.setIcon(icon_data['icon'])
if app.model.supports_disk_cache(
) and app.model.get_disk_icon_path():
if not icon_was_cached or not os.path.exists(
app.model.get_disk_icon_path()):
self.window.manager.cache_to_disk(
pkg=app.model,
icon_bytes=icon_data['bytes'],
only_icon=True)
def handleNetworkData(self, reply: QNetworkReply) -> None:
img = QImage()
tp = reply.request().attribute(QNetworkRequest.User)
if not reply.error():
if not img.load(reply, ""):
img = QImage()
reply.deleteLater()
self.m_tilePixmaps[QPointH(tp)] = (
self.m_emptyTile if img.isNull() else QPixmap.fromImage(img)
)
self.updated.emit(self.tileRect(tp))
# purge unused spaces
bound = self.m_tilesRect.adjusted(-2, -2, 2, 2)
self.m_tilePixmaps = {
tp: pixmap
for tp, pixmap in self.m_tilePixmaps.items()
if bound.contains(tp)
}
self.download()
def _onRequestFinished(self, reply: QNetworkReply) -> None:
http_status_code = reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
if not http_status_code:
# Received no or empty reply
self._onRequestFailed(reply)
return
if reply.operation() == QNetworkAccessManager.PostOperation:
if "/plugin/appkeys/request" in reply.url().toString(
): # Initial AppKey request
if http_status_code == 201 or http_status_code == 202:
Logger.log("w", "Start polling for AppKeys decision")
if not self._appkey_request:
return
self._appkey_request.setUrl(
reply.header(QNetworkRequest.LocationHeader))
self._appkey_request.setRawHeader(b"Content-Type", b"")
self._appkey_poll_timer.start()
elif http_status_code == 404:
Logger.log(
"w",
"This instance of OctoPrint does not support AppKeys")
self._appkey_request = None # type: Optional[QNetworkRequest]
else:
response = bytes(reply.readAll()).decode()
Logger.log(
"w",
"Unknown response when requesting an AppKey: %d. OctoPrint said %s"
% (http_status_code, response))
self._appkey_request = None # type: Optional[QNetworkRequest]
if reply.operation() == QNetworkAccessManager.GetOperation:
if "/plugin/appkeys/probe" in reply.url().toString(
): # Probe for AppKey support
if http_status_code == 204:
self._instance_supports_appkeys = True
else:
self._instance_supports_appkeys = False
self.appKeysSupportedChanged.emit()
if "/plugin/appkeys/request" in reply.url().toString(
): # Periodic AppKey request poll
if http_status_code == 202:
self._appkey_poll_timer.start()
elif http_status_code == 200:
Logger.log("d", "AppKey granted")
self._appkey_request = None # type: Optional[QNetworkRequest]
try:
json_data = json.loads(
bytes(reply.readAll()).decode("utf-8"))
except json.decoder.JSONDecodeError:
Logger.log(
"w",
"Received invalid JSON from octoprint instance.")
return
api_key = json_data["api_key"]
self._keys_cache[self._appkey_instance_id] = api_key
global_container_stack = self._application.getGlobalContainerStack(
)
if global_container_stack:
global_container_stack.setMetaDataEntry(
"octoprint_api_key",
base64.b64encode(
api_key.encode("ascii")).decode("ascii"))
self.appKeyReceived.emit()
elif http_status_code == 404:
Logger.log("d", "AppKey denied")
self._appkey_request = None # type: Optional[QNetworkRequest]
else:
response = bytes(reply.readAll()).decode()
Logger.log(
"w",
"Unknown response when waiting for an AppKey: %d. OctoPrint said %s"
% (http_status_code, response))
self._appkey_request = None # type: Optional[QNetworkRequest]
if "api/settings" in reply.url().toString(
): # OctoPrint settings dump from /settings:
self._instance_in_error = False
if http_status_code == 200:
Logger.log("d", "API key accepted by OctoPrint.")
self._instance_api_key_accepted = True
try:
json_data = json.loads(
bytes(reply.readAll()).decode("utf-8"))
except json.decoder.JSONDecodeError:
Logger.log(
"w",
"Received invalid JSON from octoprint instance.")
json_data = {}
if "feature" in json_data and "sdSupport" in json_data[
"feature"]:
self._instance_supports_sd = json_data["feature"][
"sdSupport"]
if "webcam" in json_data and "streamUrl" in json_data[
"webcam"]:
stream_url = json_data["webcam"]["streamUrl"]
if stream_url: #not empty string or None
self._instance_supports_camera = True
if "plugins" in json_data:
self._power_plugins_manager.parsePluginData(
json_data["plugins"])
self._instance_installed_plugins = list(
json_data["plugins"].keys())
api_key = bytes(reply.request().rawHeader(
b"X-Api-Key")).decode("utf-8")
self.setApiKey(api_key) # store api key in key cache
if self._settings_instance:
self._settings_instance.setApiKey(api_key)
self._settings_instance.resetOctoPrintUserName()
self._settings_instance.getAdditionalData()
self._settings_instance.parseSettingsData(json_data)
self._settings_instance = None
elif http_status_code == 401:
Logger.log("d", "Invalid API key for OctoPrint.")
self._instance_api_key_accepted = False
elif http_status_code == 502 or http_status_code == 503:
Logger.log("d", "OctoPrint is not running.")
self._instance_api_key_accepted = False
self._instance_in_error = True
self._instance_responded = True
self.selectedInstanceSettingsChanged.emit()
