Unify saving/importing/syncing configuration

Author: vikdevelop

src/core/archive.py

@@ -1,38 +1,52 @@
 import os, sys, shutil, subprocess, argparse, re
 from savedesktop.globals import *
+from savedesktop.core.password_store import PasswordStore
 
 parser = argparse.ArgumentParser()
 parser.add_argument("-c", "--create", help="Create archive", type=str)
 parser.add_argument("-u", "--unpack", help="Unpack archive", type=str)
 args = parser.parse_args()
 
+TEMP_CACHE = f"{CACHE}/workspace"
+
+# Cleanup the cache dir before saving
+def cleanup_cache_dir():
+    print("Cleaning up the cache directory")
+    try:
+        shutil.rmtree(TEMP_CACHE)
+    except:
+        pass
+    os.makedirs(TEMP_CACHE, exist_ok=True)
+    os.chdir(TEMP_CACHE)
+
 # Get password entered in the "Create a new password" dialog from the temporary file
 def get_password():
     temp_file = f"{CACHE}/temp_file"
     if os.path.exists(temp_file):
         with open(temp_file) as tmp:
             return tmp.read().strip()
     else:
-        return None
+        p = PasswordStore()
+        return p.password
 
 # Remove above temporary file
 def remove_temp_file():
-    try:
+    if os.path.exists(f"{CACHE}/temp_file"):
         os.remove(f"{CACHE}/temp_file")
-    except FileNotFoundError:
-        pass
 
 class Create:
     def __init__(self):
         self.start_saving()
 
     def start_saving(self):
-        self._cleanup_cache_dir()
+        cleanup_cache_dir()
         subprocess.run([sys.executable, "-m", "savedesktop.core.config", "--save"], check=True, env={**os.environ, "PYTHONPATH": f"{app_prefix}"})
 
         print("Creating and moving the configuration archive or folder to the user-defined directory")
 
-        if settings["save-without-archive"]:
+        # In the periodic saving mode, it's not allowed to save the
+        # configuration without creating the archive
+        if settings["save-without-archive"] and not args.create == settings["periodic-saving-folder"]:
             self._copy_config_to_folder()
         else:
             self._create_archive()
@@ -41,25 +55,14 @@ def start_saving(self):
         print("Configuration saved successfully.")
         remove_temp_file()
 
-    # Cleanup the cache dir before saving
-    def _cleanup_cache_dir(self):
-        print("Cleaning up the cache directory")
-        save_cache_dir = f"{CACHE}/save_config"
-        try:
-            shutil.rmtree(save_cache_dir)
-        except:
-            pass
-        os.makedirs(save_cache_dir, exist_ok=True)
-        os.chdir(save_cache_dir)
-
     # Copy the configuration folder to the user-defined directory
     def _copy_config_to_folder(self):
-        open(f"{CACHE}/save_config/.folder.sd", "w").close()
+        open(f".folder.sd", "w").close()
 
         if os.path.exists(args.create):
             shutil.rmtree(args.create)
 
-        shutil.move(f"{CACHE}/save_config", f"{args.create}")
+        shutil.move(TEMP_CACHE, f"{args.create}")
 
     # Create a new ZIP archive with 7-Zip
     def _create_archive(self):
@@ -85,31 +88,15 @@ def start_importing(self):
         self.import_file = args.unpack
         self.import_folder = args.unpack
 
-        self._cleanup_cache_dir()
+        cleanup_cache_dir()
         self._check_config_type()
 
         self._replace_home_in_files(".", home)
         subprocess.run([sys.executable, "-m", "savedesktop.core.config", "--import_"], check=True, env={**os.environ, "PYTHONPATH": f"{app_prefix}"})
 
-        self._remove_status_file()
-
         print("Configuration imported successfully.")
         remove_temp_file()
 
-    def _cleanup_cache_dir(self):
-        # Cleanup the cache dir before importing
-        print("Cleaning up the cache directory")
-        imp_cache_dir = f"{CACHE}/import_config"
-        try:
-            shutil.rmtree(imp_cache_dir)
-        except:
-            pass
-        os.makedirs(imp_cache_dir, exist_ok=True)
-        os.chdir(imp_cache_dir)
-
-        # Create a txt file to prevent removing the cache's content after closing the app window
-        open("import_status", "w").close()
-
     # Check, if the input is archive or folder
     def _check_config_type(self):
         if self.import_file.endswith(".sd.zip") or self.import_file.endswith(".sd.tar.gz"):
@@ -130,7 +117,7 @@ def _check_config_type(self):
 
     # Copy the user-defined folder to the cache directory
     def _copy_folder_to_cache(self):
-        shutil.copytree(self.import_folder, f"{CACHE}/import_config", dirs_exist_ok=True, ignore_dangling_symlinks=True)
+        shutil.copytree(self.import_folder, TEMP_CACHE, dirs_exist_ok=True, ignore_dangling_symlinks=True)
 
     # Unpack the ZIP archive with 7-Zip
     def _unpack_zip_archive(self):
@@ -148,13 +135,13 @@ def _unpack_zip_archive(self):
             print("Checking password is completed.")
 
         subprocess.run(
-            ['7z', 'x', '-y', f'-p{password}', self.import_file, f'-o{CACHE}/import_config'],
+            ['7z', 'x', '-y', f'-p{password}', self.import_file, f'-o{TEMP_CACHE}'],
             capture_output=False, text=True, check=True
         )
 
     # Unpack a legacy archive with Tarball (for backward compatibility)
     def _unpack_tar_archive(self):
-        subprocess.run(["tar", "-xzf", self.import_file, "-C", f"{CACHE}/import_config"],capture_output=True, text=True, check=True)
+        subprocess.run(["tar", "-xzf", self.import_file, "-C", f"{TEMP_CACHE}"],capture_output=True, text=True, check=True)
 
     # Replace original /home/$USER path with actual path in the dconf-settings.ini file and other XML files
     def _replace_home_in_files(self, root, home, patterns=(".xml", ".ini")):
@@ -171,15 +158,6 @@ def _replace_home_in_files(self, root, home, patterns=(".xml", ".ini")):
                             f.write(new_text)
                         print(f"Updated /home/$USER path in: {path}")
 
-    # Remove the "import_status" file if the condition is met
-    def _remove_status_file(self):
-        if all(not os.path.exists(p) for p in [
-            f"{CACHE}/import_config/app",
-            f"{CACHE}/import_config/installed_flatpaks.sh",
-            f"{CACHE}/import_config/installed_user_flatpaks.sh"
-        ]):
-            os.remove("import_status")
-
 if args.create:
     Create()
 elif args.unpack:

src/core/config.py

@@ -147,13 +147,8 @@ def save_flatpak_data(self):
         gsettings = settings["disabled-flatpak-apps-data"]
         black_list = gsettings # convert GSettings property to a list
 
-        # set destination dir
-        if os.path.exists(f"{CACHE}/periodic_saving/saving_status"):
-            os.makedirs(f"{CACHE}/periodic_saving/app", exist_ok=True)
-            destdir = f"{CACHE}/periodic_saving/app"
-        else:
-            os.makedirs(f"{CACHE}/save_config/app", exist_ok=True)
-            destdir = f"{CACHE}/save_config/app"
+        os.makedirs(f"{CACHE}/workspace/app", exist_ok=True)
+        destdir = f"{CACHE}/workspace/app"
 
         # copy Flatpak apps data
         for item in os.listdir(f"{home}/.var/app"):

src/core/flatpaks_installer.py

@@ -18,10 +18,8 @@
         os.system("gsettings set org.gnome.shell disable-user-extensions false")
 
 # Check if the required directories exist in the cache directory
-if os.path.exists(f"{CACHE_FLATPAK}/import_config"):
-    dest_dir = f"{CACHE_FLATPAK}/import_config"
-elif os.path.exists(f"{CACHE_FLATPAK}/syncing"):
-    dest_dir = f"{CACHE_FLATPAK}/syncing"
+if os.path.exists(f"{CACHE_FLATPAK}/workspace"):
+    dest_dir = f"{CACHE_FLATPAK}/workspace"
 else:
     dest_dir = None
 

src/core/periodic_saving.py

@@ -72,39 +72,25 @@ def backup(self):
         else:
             self.filename = settings["filename-format"]
 
-        os.makedirs(f"{CACHE}/periodic_saving", exist_ok=True)
-        os.chdir(f"{CACHE}/periodic_saving")
-        os.system("echo > saving_status")
-        subprocess.run([sys.executable, "-m", "savedesktop.core.config", "--save"], check=True, env={**os.environ, "PYTHONPATH": f"{app_prefix}"})
-
-        print("creating the configuration archive")
-        print("moving the configuration archive to the user-defined directory")
-        self.get_password_from_file()
+        print("MODE: Periodic saving")
+        self.call_archive_command()
 
         self.save_last_backup_date()
         self.config_saved()
 
-    # Get an encrypted password from the {DATA}/password file
-    def get_password_from_file(self):
-        try:
-            ps = PasswordStore()
-            self.password = ps.password
-        except:
-            self.password = None
-        if self.password != None:
-           subprocess.run(['7z', 'a', '-tzip', '-mx=6', f'-p{self.password}', '-mem=AES256', '-x!*.zip', '-x!saving_status', 'cfg.sd.zip', '.'], check=True)
-        else:
-           subprocess.run(['7z', 'a', '-tzip', '-mx=6', '-x!*.zip', '-x!saving_status', 'cfg.sd.zip', '.'], check=True)
-        shutil.copyfile('cfg.sd.zip', f'{self.pbfolder}/{self.filename}.sd.zip')
+    # Call the command for making the archive
+    def call_archive_command(self):
+        self.archive_mode = "--create"
+        self.archive_name = f"{self.pbfolder}/{self.filename}"
+
+        subprocess.run([sys.executable, "-m", "savedesktop.core.archive", self.archive_mode, self.archive_name], env={**os.environ, "PYTHONPATH": f"{app_prefix}"})
 
     # Save today's date to the {DATA}/periodic-saving.json file
     def save_last_backup_date(self):
         with open(f"{DATA}/periodic-saving.json", "w") as pb:
             json.dump({"last-saved": date.today().isoformat()}, pb)
 
     def config_saved(self):
-        os.chdir(CACHE)
-        shutil.rmtree("periodic_saving")
         print("Configuration saved.")
 
 if __name__ == "__main__":

src/core/synchronization.py

@@ -64,17 +64,14 @@ def check_manually_sync_status(self):
 
     # Download the configuration archive from the cloud drive folder
     def download_config(self):
+        print("MODE: Synchronization")
         self._send_notification_at_startup()
         if not os.path.exists(f"{settings['file-for-syncing']}/SaveDesktop.json"):
             err_str = _("An error occurred")
-            err = "SaveDesktop.json doesn't exist in the cloud drive folder!"
+            err = "SaveDesktop.json: directory or file does not exist."
             os.system(f'notify-send "{err_str}" "{err}"')
         else:
             self.get_pb_info()
-            os.makedirs(f"{CACHE}/syncing", exist_ok=True) # create the subfolder in the cache directory
-            os.chdir(f"{CACHE}/syncing")
-            os.system("echo > sync_status") # create a txt file to prevent removing the sync's folder content after closing the app window
-            print("extracting the archive")
             self.get_zip_file_status()
 
     # Send a notification about the started synchronization
@@ -114,7 +111,7 @@ def get_zip_file_status(self):
             self.get_pwd_from_file()
         else:
             self.password = None
-            self.extract_archive()
+            self.call_archive_command()
 
     # Get a password from the {DATA}/password file
     def get_pwd_from_file(self):
@@ -147,56 +144,23 @@ def try_passwordstore():
             os.system(f'notify-send "{err_occurred}" "{msg}"')
         else:
             # #5 Continue in extraction
-            self.extract_archive()
+            self.call_archive_command()
 
     # Extract the configuration archive
-    def extract_archive(self):
-        try:
-            if os.path.exists(f"{settings['file-for-syncing']}/{self.file}.sd.zip"):
-               try:
-                    result = subprocess.run(
-                        ['7z', 'x', f'-p{self.password}', f"{settings['file-for-syncing']}/{self.file}.sd.zip", f'-o{CACHE}/syncing', '-y'],
-                        capture_output=True, text=True, check=True
-                    )
-                    print("Output:", result.stdout)
-               except subprocess.CalledProcessError as e:
-                    print("Return code:", e.returncode)
-                    raise OSError(e.stderr)
-            else:
-                with tarfile.open(f"{settings['file-for-syncing']}/{self.file}.sd.tar.gz", 'r:gz') as tar:
-                    for member in tar.getmembers():
-                        try:
-                            tar.extract(member)
-                        except PermissionError as e:
-                            print(f"Permission denied for {member.name}: {e}")
-            self.password = None
-            if os.path.exists(f"{DATA}/entered-password.txt"):
-                os.remove(f"{DATA}/entered-password.txt")
-        except Exception as e:
-            err_occurred = _("An error occurred")
-            os.system(f"notify-send '{err_occurred}' '{e}' -i io.github.vikdevelop.SaveDesktop-symbolic")
-            if os.path.exists(f"{DATA}/password"):
-                os.remove(f"{DATA}/password")
-            if os.path.exists("sync_status"):
-                os.remove("sync_status")
-        else:
-            self.import_config()
-    
-    # Start importing a configuration from the configuration archive
-    def import_config(self):
-        subprocess.run([sys.executable, "-m", "savedesktop.core.config", "--save"], check=True, env={**os.environ, "PYTHONPATH": f"{app_prefix}"})
+    def call_archive_command(self):
+        self.archive_mode = "--unpack"
+        self.archive_name = f"{settings['file-for-syncing']}/{self.file}.sd.zip"
+
+        subprocess.run([sys.executable, "-m", "savedesktop.core.archive", self.archive_mode, self.archive_name], env={**os.environ, "PYTHONPATH": f"{app_prefix}"})
         self.done()
 
     def done(self):
         if not settings["manually-sync"]:
             with open(f"{DATA}/sync-info.json", "w") as s:
                 json.dump({"last-synced": date.today().isoformat()}, s)
 
-        # Remove the cache dir's content
-        os.chdir(CACHE)
-        if all(not os.path.exists(p) for p in ["app", "installed_flatpaks.sh", "installed_user_flatpaks.sh"]):
-            if os.path.exists("syncing"):
-                shutil.rmtree("syncing")
+        if os.path.exists(f"{DATA}/entered-password.txt"):
+            os.remove(f"{DATA}/entered-password.txt")
 
         # Send a notification about finished synchronization
         os.system(f"notify-send 'Save Desktop Synchronization ({self.file})' '{_('The configuration has been applied!')} {_('Changes will only take effect after the next login')}' -i io.github.vikdevelop.SaveDesktop-symbolic")