feature: "import/export" (1. iteration)

- import and export menu entry
- new shortcuts for the import and the export tool
- a new tool window (ei_tool.ui)
- import and export handler in common.py

Author: JW-CodeArt

usr/lib/webapp-manager/common.py

@@ -17,9 +17,10 @@
 import threading
 import traceback
 from typing import Optional
+import tarfile
 
 #   2. Related third party imports.
-from gi.repository import GObject
+from gi.repository import GObject, GLib
 import PIL.Image
 import requests
 # Note: BeautifulSoup is an optional import supporting another way of getting a website's favicons.
@@ -63,6 +64,19 @@ def wrapper(*args):
 ICONS_DIR = os.path.join(ICE_DIR, "icons")
 BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP, BROWSER_TYPE_LIBREWOLF_FLATPAK, BROWSER_TYPE_WATERFOX_FLATPAK, BROWSER_TYPE_FLOORP_FLATPAK, BROWSER_TYPE_CHROMIUM, BROWSER_TYPE_EPIPHANY, BROWSER_TYPE_FALKON = range(9)
 
+class ei_task:
+    def __init__(self, result_callback, update_callback, builder, webAppLauncherSelf, window, stop_event, task):
+        self.result_callback = result_callback
+        self.update_callback = update_callback
+        self.builder = builder
+        self.webAppLauncherSelf = webAppLauncherSelf
+        self.path = ""
+        self.window = window
+        self.stop_event = stop_event
+        self.task = task
+        self.include_browserdata = False
+        self.result = "error"
+
 class Browser:
 
     def __init__(self, browser_type, name, exec_path, test_path):
@@ -545,5 +559,176 @@ def download_favicon(url):
     images = sorted(images, key = lambda x: x[1].height, reverse=True)
     return images
 
+def export_config(ei_task_info: ei_task):
+    # The export process in the background.
+    try:
+        # Collect all files
+        webapps = get_all_desktop_files()
+        if ei_task_info.include_browserdata:
+            ice_files = get_all_files(ICE_DIR)
+        else:
+            ice_files = get_all_files(ICONS_DIR)
+        files = webapps + ice_files
+        total = len(files)
+        update_interval = 1 if int(total / 100) < 1 else int(total / 100)
+
+        # Write the .tar.gz file
+        with tarfile.open(ei_task_info.path, "w:gz") as tar:
+            counter = 0
+            for file in files:
+                tar.add(file["full_path"], arcname=file["arcname"])
+                if counter % update_interval == 0:
+                    progress = round(counter / total, 2)
+                    GLib.idle_add(ei_task_info.update_callback, ei_task_info, progress)
+
+                if ei_task_info.stop_event.is_set():
+                    # The user aborts the process.
+                    tar.close()
+                    clean_up_export(ei_task_info)
+                    return "cancelled"
+                counter += 1
+
+        ei_task_info.result = "ok"
+    except Exception as e:
+        print(e)
+        ei_task_info.result = "error"
+    
+    GLib.idle_add(ei_task_info.result_callback, ei_task_info)
+
+def clean_up_export(ei_task_info: ei_task):
+    # Remove the rest of the exported file when the user aborts the process.
+    if os.path.exists(ei_task_info.path):
+        os.remove(ei_task_info.path)
+    GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
+
+def import_config(ei_task_info: ei_task):
+    # The import process in the background.
+    try:
+        # Make a list of the files beforehand so that the file structure can be restored 
+        # if the user aborts the import process.
+        files_before = get_files_dirs(ICE_DIR) + get_files_dirs(APPS_DIR)
+
+        with tarfile.open(ei_task_info.path, "r:gz") as tar:
+            files = tar.getnames()
+            total = len(files)
+            base_dir = os.path.dirname(ICE_DIR)
+            update_interval = 1 if int(total / 100) < 1 else int(total / 100)
+            counter = 0
+            for file in files:
+                # Exclude the file if it belongs to the browser data.
+                no_browserdata = ei_task_info.include_browserdata == False
+                is_ice_dir = file.startswith("ice/")
+                is_no_icon = not file.startswith("ice/icons")
+                if not(no_browserdata and is_ice_dir and is_no_icon):
+                    tar.extract(file, base_dir)
+                
+                if file.startswith("applications/"):
+                    # Redefine the "Exec" section. This is necessary if the username or browser path differs.
+                    path = os.path.join(base_dir, file)
+                    update_exec_path(path)
+                
+                if counter % update_interval == 0:
+                    progress = round(counter / total, 2)
+                    GLib.idle_add(ei_task_info.update_callback, ei_task_info, progress)
+                
+                if ei_task_info.stop_event.is_set():
+                    tar.close()
+                    clean_up_import(ei_task_info, files_before)
+                    return "cancelled"
+                counter += 1
+        ei_task_info.result = "ok"
+    except Exception as e:
+        print(e)
+        ei_task_info.result = "error"
+
+    GLib.idle_add(ei_task_info.result_callback, ei_task_info)
+
+def clean_up_import(ei_task_info: ei_task, files_before):
+    # Delete all imported files if the import process is aborted.
+    try:
+        # Search all new files
+        files_now = get_files_dirs(ICE_DIR) + get_files_dirs(APPS_DIR)
+        new_files = list(set(files_now) - set(files_before))
+        for file in new_files:
+            if os.path.exists(file):
+                if os.path.isdir(file):
+                    shutil.rmtree(file)
+                else:
+                    os.remove(file)
+        
+        GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
+    except Exception as e:
+        print(e)
+
+def check_browser_directories_tar(path):
+    # Check if the archive contains browser data.
+    try:
+        with tarfile.open(path, "r:gz") as tar:
+            for member in tar:
+                parts = member.name.strip("/").split("/")
+                if parts[0] == "ice" and parts[1] != "icons":
+                    tar.close()
+                    return True
+            tar.close()
+            return False
+    except:
+        return False
+
+def get_all_desktop_files():
+    # Search all web apps and desktop files.
+    files = []
+    for filename in os.listdir(APPS_DIR):
+        if filename.lower().startswith("webapp-") and filename.endswith(".desktop"):
+            full_path = os.path.join(APPS_DIR, filename)
+            arcname = os.path.relpath(full_path, os.path.dirname(APPS_DIR))
+            files.append({"full_path":full_path, "arcname":arcname})
+    return files
+
+def get_all_files(base_dir):
+    # List all the files in a directory.
+    files = []
+    for root, dirs, filenames in os.walk(base_dir):
+        for filename in filenames:
+            full_path = os.path.join(root, filename)
+            arcname = ""
+            if base_dir == ICONS_DIR:
+                arcname += "ice/"
+            arcname += os.path.relpath(full_path, os.path.dirname(base_dir))
+            files.append({"full_path":full_path, "arcname":arcname})
+    return files
+
+def get_files_dirs(base_dir):
+    # List all the files and subdirectories within a directory.
+    paths = []
+    for dirpath, dirnames, filenames in os.walk(base_dir):
+        paths.append(dirpath)
+        for name in filenames:
+            paths.append(os.path.join(dirpath, name))
+    return paths
+
+def update_exec_path(path):
+    # This updates the 'exec' section of an imported web application or creates the browser directory for it.
+    config = configparser.RawConfigParser()
+    config.optionxform = str
+    config.read(path)
+    codename = os.path.basename(path)
+    codename = codename.replace(".desktop", "")
+    codename = codename.replace("WebApp-", "")
+    codename = codename.replace("webapp-", "")
+    webapp = WebAppLauncher(path, codename)
+    browsers = WebAppManager.get_supported_browsers()
+    if "/" in webapp.icon:
+        # Update Icon Path
+        iconpath = ICONS_DIR + "/" + os.path.basename(webapp.icon)
+        config.set("Desktop Entry", "Icon", iconpath)
+    else:
+        iconpath = webapp.icon
+
+    browser = next((browser for browser in browsers if browser.name == webapp.web_browser), None)
+    new_exec_line = WebAppManager.get_exec_string(None, browser, webapp.codename, webapp.custom_parameters, iconpath, webapp.isolate_profile, webapp.navbar, webapp.privatewindow, webapp.url)
+    config.set("Desktop Entry", "Exec", new_exec_line)
+    with open(path, 'w') as configfile:
+        config.write(configfile, space_around_delimiters=False)
+
 if __name__ == "__main__":
     download_favicon(sys.argv[1])

usr/lib/webapp-manager/webapp-manager.py

@@ -7,6 +7,7 @@
 import shutil
 import subprocess
 import warnings
+import threading
 
 #   2. Related third party imports.
 import gi
@@ -21,7 +22,7 @@
 from gi.repository import Gtk, Gdk, Gio, XApp, GdkPixbuf
 
 #   3. Local application/library specific imports.
-from common import _async, idle, WebAppManager, download_favicon, ICONS_DIR, BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP
+from common import _async, idle, WebAppManager, download_favicon, BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP, export_config, import_config, ei_task, check_browser_directories_tar
 
 setproctitle.setproctitle("webapp-manager")
 
@@ -124,6 +125,20 @@ def __init__(self, application):
         self.window.add_accel_group(accel_group)
         menu = self.builder.get_object("main_menu")
         item = Gtk.ImageMenuItem()
+        item.set_image(Gtk.Image.new_from_icon_name("document-send-symbolic", Gtk.IconSize.MENU))
+        item.set_label(_("Export"))
+        item.connect("activate", lambda widget: self.open_ei_tool("export"))
+        key, mod = Gtk.accelerator_parse("<Control><Shift>E")
+        item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
+        menu.append(item)
+        item = Gtk.ImageMenuItem()
+        item.set_image(Gtk.Image.new_from_icon_name("document-open-symbolic", Gtk.IconSize.MENU))
+        item.set_label(_("Import"))
+        item.connect("activate", lambda widget: self.open_ei_tool("import"))
+        key, mod = Gtk.accelerator_parse("<Control><Shift>I")
+        item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
+        menu.append(item)
+        item = Gtk.ImageMenuItem()
         item.set_image(
             Gtk.Image.new_from_icon_name("preferences-desktop-keyboard-shortcuts-symbolic", Gtk.IconSize.MENU))
         item.set_label(_("Keyboard Shortcuts"))
@@ -541,6 +556,125 @@ def load_webapps(self):
         self.stack.set_visible_child_name("main_page")
         self.headerbar.set_subtitle(_("Run websites as if they were apps"))
 
+    # Export and Import feature "ei"
+    def open_ei_tool(self, action):
+        # Open the import / export window
+        gladefile = "/usr/share/webapp-manager/ei_tool.ui"
+        builder = Gtk.Builder()
+        builder.set_translation_domain(APP)
+        builder.add_from_file(gladefile)
+        window = builder.get_object("window")
+        # Translate text and prepare widgets
+        if action == "export":
+            window.set_title(_("Export Tool"))
+        else:
+            window.set_title(_("Import Tool"))
+        builder.get_object("choose_location_text").set_text(_("Choose a location"))
+        builder.get_object("include_browserdata").set_label(_("BETA: Include Browser data (Config, Cache, Extensions...)\nIt requires the same browser version on the destination computer\nIt might take some time."))
+        builder.get_object("no_browser_data").set_text(_("Browser data import not available because \nit is not included in the importet file."))
+        builder.get_object("no_browser_data").set_visible(False)
+        builder.get_object("start_button").set_label(_("Start"))
+        builder.get_object("start_button").connect("clicked", lambda button: self.ei_start_process(button, ei_task_info))
+        builder.get_object("cancel_button").set_visible(False)
+        builder.get_object("select_location_button").connect("clicked", lambda widget: self.select_location(ei_task_info))
+
+        # Prepare ei_task_info which stores all the values for the import / export
+        stop_event = threading.Event()
+        ei_task_info = ei_task(self.show_ei_result, self.update_ei_progress, builder, self, window, stop_event, action)
+        window.show()
+
+    def ei_start_process(self, button, ei_task_info: ei_task):
+        # Start the import / export process
+        buffer = ei_task_info.builder.get_object("file_path").get_buffer()
+        path = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), True)
+        if path != "":
+            ei_task_info.path = path
+            ei_task_info.include_browserdata = ei_task_info.builder.get_object("include_browserdata").get_active()
+            button.set_sensitive(False)
+            if ei_task_info.task == "export":
+                thread = threading.Thread(target=export_config, args=(ei_task_info,))
+            else:
+                thread = threading.Thread(target=import_config, args=(ei_task_info,))
+            thread.start()
+            ei_task_info.builder.get_object("cancel_button").set_visible(True)
+            ei_task_info.builder.get_object("cancel_button").connect("clicked", lambda button: self.abort_ei(button, ei_task_info, thread))
+
+
+    def select_location(self, ei_task_info: ei_task):
+        # Open the file chooser window
+        if ei_task_info.task == "export":
+            buttons = (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.OK)
+            dialog = Gtk.FileChooserDialog(_("Export Configuration - Please choose a file location"), self.window, Gtk.FileChooserAction.SAVE, buttons)
+        else:
+            buttons = (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)
+            dialog = Gtk.FileChooserDialog(_("Import Configuration - Please select the file"), self.window, Gtk.FileChooserAction.OPEN, buttons)
+        
+        filter = Gtk.FileFilter()
+        filter.set_name(".tar.gz")
+        filter.add_pattern("*.tar.gz")
+        dialog.add_filter(filter)
+        response = dialog.run()
+        if response == Gtk.ResponseType.OK:
+            path = dialog.get_filename()
+            if ei_task_info.task == "export":
+                path += ".tar.gz"
+            ei_task_info.builder.get_object("file_path").get_buffer().set_text(path)
+
+            # Check if include browser data is available 
+            include_browser_available = True
+            if ei_task_info.task == "import":
+                if not check_browser_directories_tar(path):
+                    include_browser_available = False
+            
+            ei_task_info.builder.get_object("include_browserdata").set_sensitive(include_browser_available)
+            ei_task_info.builder.get_object("no_browser_data").set_visible(not include_browser_available)
+            ei_task_info.builder.get_object("include_browserdata").set_active(include_browser_available)
+        dialog.destroy()
+
+        
+    def abort_ei(self, button, ei_task_info:ei_task, thread):
+        # Abort the export / import process
+        button.set_sensitive(False)
+        self.update_ei_progress(ei_task_info, 0)
+        # The backend function will automatically clean up after the stop flag is triggered.
+        ei_task_info.stop_event.set()
+        thread.join()
+
+    def update_ei_progress(self, ei_task_info:ei_task, progress):
+        # Update the progress bar or close the tool window by 100%.
+        try:
+            ei_task_info.builder.get_object("progress").set_fraction(progress)
+            if progress == 1:
+                ei_task_info.window.destroy()
+        except:
+            # The user closed the progress window
+            pass
+
+
+    def show_ei_result(self, ei_task_info:ei_task):
+        # Displays a success or failure message when the process is complete.
+        ei_task_info.window.destroy()
+        if ei_task_info.result == "ok":
+            message = _(ei_task_info.task.capitalize() + " completed!")
+        else:
+            message = _(ei_task_info.task.capitalize() + " failed!")
+        
+        if ei_task_info.result == "ok" and ei_task_info.task == "export":
+            # This dialog box gives users the option to open the containing directory.
+            dialog = Gtk.Dialog(message, ei_task_info.webAppLauncherSelf.window, None, (_("Open Containing Folder"), 10, Gtk.STOCK_OK, Gtk.ButtonsType.OK))
+            dialog.get_content_area().add(Gtk.Label(label=_("Configuration has been exported successfully. This is the file location:")+"\n"+ei_task_info.path))
+            dialog.show_all()
+            result = dialog.run()
+            if result == 10:
+                # Open Containing Folder
+                print("open folder")
+                os.system("xdg-open " + os.path.dirname(ei_task_info.path))
+        else:
+            dialog = Gtk.MessageDialog(text=message, message_type=Gtk.MessageType.INFO, buttons=Gtk.ButtonsType.OK)
+            dialog.run()
+
+        dialog.destroy()
+        ei_task_info.webAppLauncherSelf.load_webapps()
 
 if __name__ == "__main__":
     application = MyApplication("org.x.webapp-manager", Gio.ApplicationFlags.FLAGS_NONE)