diff options
Diffstat (limited to 'plugins/DigitalLibrary/src/DFFileUploader.py')
| -rw-r--r-- | plugins/DigitalLibrary/src/DFFileUploader.py | 147 |
1 files changed, 147 insertions, 0 deletions
diff --git a/plugins/DigitalLibrary/src/DFFileUploader.py b/plugins/DigitalLibrary/src/DFFileUploader.py new file mode 100644 index 0000000000..9c5356255e --- /dev/null +++ b/plugins/DigitalLibrary/src/DFFileUploader.py @@ -0,0 +1,147 @@ +# Copyright (c) 2021 Ultimaker B.V. +# Cura is released under the terms of the LGPLv3 or higher. + +from PyQt5.QtNetwork import QNetworkRequest, QNetworkReply +from typing import Callable, Any, cast, Optional, Union + +from UM.Logger import Logger +from UM.TaskManagement.HttpRequestManager import HttpRequestManager +from .DFLibraryFileUploadResponse import DFLibraryFileUploadResponse +from .DFPrintJobUploadResponse import DFPrintJobUploadResponse + + +class DFFileUploader: + """Class responsible for uploading meshes to the the digital factory library in separate requests.""" + + # The maximum amount of times to retry if the server returns one of the RETRY_HTTP_CODES + MAX_RETRIES = 10 + + # The HTTP codes that should trigger a retry. + RETRY_HTTP_CODES = {500, 502, 503, 504} + + def __init__(self, + http: HttpRequestManager, + df_file: Union[DFLibraryFileUploadResponse, DFPrintJobUploadResponse], + data: bytes, + on_finished: Callable[[str], Any], + on_success: Callable[[str], Any], + on_progress: Callable[[str, int], Any], + on_error: Callable[[str, "QNetworkReply", "QNetworkReply.NetworkError"], Any] + ) -> None: + """Creates a mesh upload object. + + :param http: The network access manager that will handle the HTTP requests. + :param df_file: The file response that was received by the Digital Factory after registering the upload. + :param data: The mesh bytes to be uploaded. + :param on_finished: The method to be called when done. + :param on_success: The method to be called when the upload is successful. + :param on_progress: The method to be called when the progress changes (receives a percentage 0-100). + :param on_error: The method to be called when an error occurs. + """ + + self._http = http # type: HttpRequestManager + self._df_file = df_file # type: Union[DFLibraryFileUploadResponse, DFPrintJobUploadResponse] + self._file_name = "" + if isinstance(self._df_file, DFLibraryFileUploadResponse): + self._file_name = self._df_file.file_name + elif isinstance(self._df_file, DFPrintJobUploadResponse): + if self._df_file.job_name is not None: + self._file_name = self._df_file.job_name + else: + self._file_name = "" + else: + raise TypeError("Incorrect input type") + self._data = data # type: bytes + + self._on_finished = on_finished + self._on_success = on_success + self._on_progress = on_progress + self._on_error = on_error + + self._retries = 0 + self._finished = False + + def start(self) -> None: + """Starts uploading the mesh.""" + + if self._finished: + # reset state. + self._retries = 0 + self._finished = False + self._upload() + + def stop(self): + """Stops uploading the mesh, marking it as finished.""" + + Logger.log("i", "Finished uploading") + self._finished = True # Signal to any ongoing retries that we should stop retrying. + self._on_finished(self._file_name) + + def _upload(self) -> None: + """ + Uploads the file to the Digital Factory Library project + """ + if self._finished: + raise ValueError("The upload is already finished") + + Logger.log("i", "Uploading DF file to project '{library_project_id}' via link '{upload_url}'".format(library_project_id = self._df_file.library_project_id, upload_url = self._df_file.upload_url)) + self._http.put( + url = cast(str, self._df_file.upload_url), + headers_dict = {"Content-Type": cast(str, self._df_file.content_type)}, + data = self._data, + callback = self._onUploadFinished, + error_callback = self._onUploadError, + upload_progress_callback = self._onUploadProgressChanged + ) + + def _onUploadProgressChanged(self, bytes_sent: int, bytes_total: int) -> None: + """Handles an update to the upload progress + + :param bytes_sent: The amount of bytes sent in the current request. + :param bytes_total: The amount of bytes to send in the current request. + """ + Logger.debug("Cloud upload progress %s / %s", bytes_sent, bytes_total) + if bytes_total: + self._on_progress(self._file_name, int(bytes_sent / len(self._data) * 100)) + + def _onUploadError(self, reply: QNetworkReply, error: QNetworkReply.NetworkError) -> None: + """Handles an error uploading.""" + + body = bytes(reply.peek(reply.bytesAvailable())).decode() + Logger.log("e", "Received error while uploading: %s", body) + self._on_error(self._file_name, reply, error) + self.stop() + + def _onUploadFinished(self, reply: QNetworkReply) -> None: + """ + Checks whether a chunk of data was uploaded successfully, starting the next chunk if needed. + """ + + Logger.log("i", "Finished callback %s %s", + reply.attribute(QNetworkRequest.HttpStatusCodeAttribute), reply.url().toString()) + + status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) # type: Optional[int] + if not status_code: + Logger.log("e", "Reply contained no status code.") + self._onUploadError(reply, None) + return + + # check if we should retry the last chunk + if self._retries < self.MAX_RETRIES and status_code in self.RETRY_HTTP_CODES: + self._retries += 1 + Logger.log("i", "Retrying %s/%s request %s", self._retries, self.MAX_RETRIES, reply.url().toString()) + try: + self._upload() + except ValueError: # Asynchronously it could have completed in the meanwhile. + pass + return + + # Http codes that are not to be retried are assumed to be errors. + if status_code > 308: + self._onUploadError(reply, None) + return + + Logger.log("d", "status_code: %s, Headers: %s, body: %s", status_code, + [bytes(header).decode() for header in reply.rawHeaderList()], bytes(reply.readAll()).decode()) + self._on_success(self._file_name) + self.stop() |