mirror of
https://git.mirrors.martin98.com/https://github.com/Ultimaker/Cura
synced 2025-05-09 13:09:09 +08:00
584a387deb
We now allow the backup to fail gracefully when partial files fail to be restored. But the user is not actively informed by these failures. Leaving him/her unaware of the state of his configuration folder. This commit show's a message windows, listing the failed files. Due to a string freeze at the moment we reuse the following i18n message: > The following error occurred while trying to restore a Cura backup: followed by a list of files that fails to be restored. Which is not ideal, but a sufficient warning in my opinion. At least better then being completely uninformed. Contributes to CURA-8313
236 lines
11 KiB
Python
236 lines
11 KiB
Python
# Copyright (c) 2018 Ultimaker B.V.
|
|
# Cura is released under the terms of the LGPLv3 or higher.
|
|
|
|
import io
|
|
import os
|
|
import re
|
|
import shutil
|
|
from copy import deepcopy
|
|
from zipfile import ZipFile, ZIP_DEFLATED, BadZipfile
|
|
from typing import Dict, Optional, TYPE_CHECKING, List, Tuple
|
|
|
|
from UM import i18nCatalog
|
|
from UM.Logger import Logger
|
|
from UM.Message import Message
|
|
from UM.Platform import Platform
|
|
from UM.Resources import Resources
|
|
from UM.Version import Version
|
|
|
|
if TYPE_CHECKING:
|
|
from cura.CuraApplication import CuraApplication
|
|
|
|
|
|
class Backup:
|
|
"""The back-up class holds all data about a back-up.
|
|
|
|
It is also responsible for reading and writing the zip file to the user data folder.
|
|
"""
|
|
|
|
IGNORED_FILES = [r"cura\.log", r"plugins\.json", r"cache", r"__pycache__", r"\.qmlc", r"\.pyc"]
|
|
"""These files should be ignored when making a backup."""
|
|
|
|
IGNORED_FOLDERS = [] # type: List[str]
|
|
|
|
SECRETS_SETTINGS = ["general/ultimaker_auth_data"]
|
|
"""Secret preferences that need to obfuscated when making a backup of Cura"""
|
|
|
|
catalog = i18nCatalog("cura")
|
|
"""Re-use translation catalog"""
|
|
|
|
def __init__(self, application: "CuraApplication", zip_file: bytes = None, meta_data: Dict[str, str] = None) -> None:
|
|
self._application = application
|
|
self.zip_file = zip_file # type: Optional[bytes]
|
|
self.meta_data = meta_data # type: Optional[Dict[str, str]]
|
|
|
|
def makeFromCurrent(self) -> None:
|
|
"""Create a back-up from the current user config folder."""
|
|
|
|
cura_release = self._application.getVersion()
|
|
version_data_dir = Resources.getDataStoragePath()
|
|
|
|
Logger.log("d", "Creating backup for Cura %s, using folder %s", cura_release, version_data_dir)
|
|
|
|
# obfuscate sensitive secrets
|
|
secrets = self._obfuscate()
|
|
|
|
# Ensure all current settings are saved.
|
|
self._application.saveSettings()
|
|
|
|
# We copy the preferences file to the user data directory in Linux as it's in a different location there.
|
|
# When restoring a backup on Linux, we move it back.
|
|
if Platform.isLinux(): #TODO: This should check for the config directory not being the same as the data directory, rather than hard-coding that to Linux systems.
|
|
preferences_file_name = self._application.getApplicationName()
|
|
preferences_file = Resources.getPath(Resources.Preferences, "{}.cfg".format(preferences_file_name))
|
|
backup_preferences_file = os.path.join(version_data_dir, "{}.cfg".format(preferences_file_name))
|
|
if os.path.exists(preferences_file) and (not os.path.exists(backup_preferences_file) or not os.path.samefile(preferences_file, backup_preferences_file)):
|
|
Logger.log("d", "Copying preferences file from %s to %s", preferences_file, backup_preferences_file)
|
|
shutil.copyfile(preferences_file, backup_preferences_file)
|
|
|
|
# Create an empty buffer and write the archive to it.
|
|
buffer = io.BytesIO()
|
|
archive = self._makeArchive(buffer, version_data_dir)
|
|
if archive is None:
|
|
return
|
|
files = archive.namelist()
|
|
|
|
# Count the metadata items. We do this in a rather naive way at the moment.
|
|
machine_count = max(len([s for s in files if "machine_instances/" in s]) - 1, 0) # If people delete their profiles but not their preferences, it can still make a backup, and report -1 profiles. Server crashes on this.
|
|
material_count = max(len([s for s in files if "materials/" in s]) - 1, 0)
|
|
profile_count = max(len([s for s in files if "quality_changes/" in s]) - 1, 0)
|
|
# We don't store plugins anymore, since if you can make backups, you have an account (and the plugins are
|
|
# on the marketplace anyway)
|
|
plugin_count = 0
|
|
# Store the archive and metadata so the BackupManager can fetch them when needed.
|
|
self.zip_file = buffer.getvalue()
|
|
self.meta_data = {
|
|
"cura_release": cura_release,
|
|
"machine_count": str(machine_count),
|
|
"material_count": str(material_count),
|
|
"profile_count": str(profile_count),
|
|
"plugin_count": str(plugin_count)
|
|
}
|
|
# Restore the obfuscated settings
|
|
self._illuminate(**secrets)
|
|
|
|
def _makeArchive(self, buffer: "io.BytesIO", root_path: str) -> Optional[ZipFile]:
|
|
"""Make a full archive from the given root path with the given name.
|
|
|
|
:param root_path: The root directory to archive recursively.
|
|
:return: The archive as bytes.
|
|
"""
|
|
ignore_string = re.compile("|".join(self.IGNORED_FILES + self.IGNORED_FOLDERS))
|
|
try:
|
|
archive = ZipFile(buffer, "w", ZIP_DEFLATED)
|
|
for root, folders, files in os.walk(root_path):
|
|
for item_name in folders + files:
|
|
absolute_path = os.path.join(root, item_name)
|
|
if ignore_string.search(absolute_path):
|
|
continue
|
|
archive.write(absolute_path, absolute_path[len(root_path) + len(os.sep):])
|
|
archive.close()
|
|
return archive
|
|
except (IOError, OSError, BadZipfile) as error:
|
|
Logger.log("e", "Could not create archive from user data directory: %s", error)
|
|
self._showMessage(
|
|
self.catalog.i18nc("@info:backup_failed",
|
|
"Could not create archive from user data directory: {}".format(error)))
|
|
return None
|
|
|
|
def _showMessage(self, message: str) -> None:
|
|
"""Show a UI message."""
|
|
|
|
Message(message, title=self.catalog.i18nc("@info:title", "Backup"), lifetime=30).show()
|
|
|
|
def restore(self) -> bool:
|
|
"""Restore this back-up.
|
|
|
|
:return: Whether we had success or not.
|
|
"""
|
|
|
|
if not self.zip_file or not self.meta_data or not self.meta_data.get("cura_release", None):
|
|
# We can restore without the minimum required information.
|
|
Logger.log("w", "Tried to restore a Cura backup without having proper data or meta data.")
|
|
self._showMessage(
|
|
self.catalog.i18nc("@info:backup_failed",
|
|
"Tried to restore a Cura backup without having proper data or meta data."))
|
|
return False
|
|
|
|
current_version = Version(self._application.getVersion())
|
|
version_to_restore = Version(self.meta_data.get("cura_release", "master"))
|
|
|
|
if current_version < version_to_restore:
|
|
# Cannot restore version newer than current because settings might have changed.
|
|
Logger.log("d", "Tried to restore a Cura backup of version {version_to_restore} with cura version {current_version}".format(version_to_restore = version_to_restore, current_version = current_version))
|
|
self._showMessage(
|
|
self.catalog.i18nc("@info:backup_failed",
|
|
"Tried to restore a Cura backup that is higher than the current version."))
|
|
return False
|
|
|
|
# Get the current secrets and store since the back-up doesn't contain those
|
|
secrets = self._obfuscate()
|
|
|
|
version_data_dir = Resources.getDataStoragePath()
|
|
try:
|
|
archive = ZipFile(io.BytesIO(self.zip_file), "r")
|
|
except LookupError as e:
|
|
Logger.log("d", f"The following error occurred while trying to restore a Cura backup: {str(e)}")
|
|
self._showMessage(self.catalog.i18nc("@info:backup_failed", "The following error occurred while trying to restore a Cura backup:") + str(e))
|
|
return False
|
|
extracted, failed_files = self._extractArchive(archive, version_data_dir)
|
|
self._showMessage(
|
|
self.catalog.i18nc("@info:backup_failed",
|
|
"The following error occurred while trying to restore a Cura backup:" + "\n{}".format("\n".join(failed_files))))
|
|
|
|
# Under Linux, preferences are stored elsewhere, so we copy the file to there.
|
|
if Platform.isLinux():
|
|
preferences_file_name = self._application.getApplicationName()
|
|
preferences_file = Resources.getPath(Resources.Preferences, "{}.cfg".format(preferences_file_name))
|
|
backup_preferences_file = os.path.join(version_data_dir, "{}.cfg".format(preferences_file_name))
|
|
Logger.log("d", "Moving preferences file from %s to %s", backup_preferences_file, preferences_file)
|
|
shutil.move(backup_preferences_file, preferences_file)
|
|
|
|
# Read the preferences from the newly restored configuration (or else the cached Preferences will override the restored ones)
|
|
self._application.readPreferencesFromConfiguration()
|
|
|
|
# Restore the obfuscated settings
|
|
self._illuminate(**secrets)
|
|
|
|
return extracted
|
|
|
|
@staticmethod
|
|
def _extractArchive(archive: "ZipFile", target_path: str) -> Tuple[bool, List[str]]:
|
|
"""Extract the whole archive to the given target path.
|
|
|
|
:param archive: The archive as ZipFile.
|
|
:param target_path: The target path.
|
|
:return: Whether we had success or not.
|
|
"""
|
|
|
|
# Implement security recommendations: Sanity check on zip files will make it harder to spoof.
|
|
from cura.CuraApplication import CuraApplication
|
|
config_filename = CuraApplication.getInstance().getApplicationName() + ".cfg" # Should be there if valid.
|
|
if config_filename not in [file.filename for file in archive.filelist]:
|
|
Logger.logException("e", "Unable to extract the backup due to corruption of compressed file(s).")
|
|
return False, []
|
|
|
|
Logger.log("d", "Removing current data in location: %s", target_path)
|
|
Resources.factoryReset()
|
|
Logger.log("d", "Extracting backup to location: %s", target_path)
|
|
name_list = archive.namelist()
|
|
failed_files = []
|
|
full_restore = True
|
|
for archive_filename in name_list:
|
|
try:
|
|
archive.extract(archive_filename, target_path)
|
|
except (PermissionError, EnvironmentError):
|
|
Logger.logException("e", f"Unable to extract the file {archive_filename} from the backup due to permission or file system errors.")
|
|
failed_files.append(archive_filename)
|
|
full_restore = False
|
|
CuraApplication.getInstance().processEvents()
|
|
return full_restore, failed_files
|
|
|
|
def _obfuscate(self) -> Dict[str, str]:
|
|
"""
|
|
Obfuscate and remove the secret preferences that are specified in SECRETS_SETTINGS
|
|
|
|
:return: a dictionary of the removed secrets. Note: the '/' is replaced by '__'
|
|
"""
|
|
preferences = self._application.getPreferences()
|
|
secrets = {}
|
|
for secret in self.SECRETS_SETTINGS:
|
|
secrets[secret.replace("/", "__")] = deepcopy(preferences.getValue(secret))
|
|
preferences.setValue(secret, None)
|
|
self._application.savePreferences()
|
|
return secrets
|
|
|
|
def _illuminate(self, **kwargs) -> None:
|
|
"""
|
|
Restore the obfuscated settings
|
|
|
|
:param kwargs: a dict of obscured preferences. Note: the '__' of the keys will be replaced by '/'
|
|
"""
|
|
preferences = self._application.getPreferences()
|
|
for key, value in kwargs.items():
|
|
preferences.setValue(key.replace("__", "/"), value)
|
|
self._application.savePreferences()
|