From e9bb6d9973a8c1b948619e62dc49d658845c8b64 Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 26 Jul 2023 10:09:27 +0000
Subject: [PATCH 01/14] test(backups):check that snapshot cache invalidation
 invalidates both ways.

---
 tests/test_graphql/test_backup.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index 6d12a5e..dcb4739 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -552,6 +552,34 @@ def test_snapshots_caching(backups, dummy_service):
     assert len(cached_snapshots) == 1
 
 
+def lowlevel_forget(snapshot_id):
+    Backups.provider().backupper.forget_snapshot(snapshot_id)
+
+
+# Storage
+def test_snapshots_cache_invalidation(backups, dummy_service):
+    Backups.back_up(dummy_service)
+    cached_snapshots = Storage.get_cached_snapshots()
+    assert len(cached_snapshots) == 1
+
+    Storage.invalidate_snapshot_storage()
+    cached_snapshots = Storage.get_cached_snapshots()
+    assert len(cached_snapshots) == 0
+
+    Backups.force_snapshot_cache_reload()
+    cached_snapshots = Storage.get_cached_snapshots()
+    assert len(cached_snapshots) == 1
+    snap = cached_snapshots[0]
+
+    lowlevel_forget(snap.id)
+    cached_snapshots = Storage.get_cached_snapshots()
+    assert len(cached_snapshots) == 1
+
+    Backups.force_snapshot_cache_reload()
+    cached_snapshots = Storage.get_cached_snapshots()
+    assert len(cached_snapshots) == 0
+
+
 # Storage
 def test_init_tracking_caching(backups, raw_dummy_service):
     assert Storage.has_init_mark() is False

From aa7cc7155756791a2353635fd0f8dd9ae37d107f Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 26 Jul 2023 11:54:17 +0000
Subject: [PATCH 02/14] feature(backups):add a function to set provider from
 env

---
 selfprivacy_api/backup/__init__.py | 26 ++++++++++++++++++++
 tests/test_graphql/test_backup.py  | 38 +++++++++++++++++++++++++++++-
 2 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/selfprivacy_api/backup/__init__.py b/selfprivacy_api/backup/__init__.py
index 9722b71..94d1abb 100644
--- a/selfprivacy_api/backup/__init__.py
+++ b/selfprivacy_api/backup/__init__.py
@@ -2,6 +2,7 @@
 This module contains the controller class for backups.
 """
 from datetime import datetime, timedelta
+import os
 from os import statvfs
 from typing import List, Optional
 
@@ -43,6 +44,13 @@ DEFAULT_JSON_PROVIDER = {
     "bucket": "",
 }
 
+BACKUP_PROVIDER_ENVS = {
+    "kind": "BACKUP_KIND",
+    "login": "BACKUP_LOGIN",
+    "key": "BACKUP_KEY",
+    "location": "BACKUP_LOCATION",
+}
+
 
 class NotDeadError(AssertionError):
     """
@@ -132,6 +140,24 @@ class Backups:
         Storage.store_provider(none_provider)
         return none_provider
 
+    @staticmethod
+    def set_provider_from_envs():
+        for env in BACKUP_PROVIDER_ENVS.values():
+            if env not in os.environ.keys():
+                raise ValueError(
+                    f"Cannot set backup provider from envs, there is no {env} set"
+                )
+
+        kind_str = os.environ[BACKUP_PROVIDER_ENVS["kind"]]
+        kind_enum = BackupProviderEnum[kind_str]
+        provider = Backups._construct_provider(
+            kind=kind_enum,
+            login=os.environ[BACKUP_PROVIDER_ENVS["login"]],
+            key=os.environ[BACKUP_PROVIDER_ENVS["key"]],
+            location=os.environ[BACKUP_PROVIDER_ENVS["location"]],
+        )
+        Storage.store_provider(provider)
+
     @staticmethod
     def _construct_provider(
         kind: BackupProviderEnum,
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index dcb4739..fcb437e 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -1,4 +1,5 @@
 import pytest
+import os
 import os.path as path
 from os import makedirs
 from os import remove
@@ -18,10 +19,11 @@ from selfprivacy_api.jobs import Jobs, JobStatus
 
 from selfprivacy_api.models.backup.snapshot import Snapshot
 
-from selfprivacy_api.backup import Backups
+from selfprivacy_api.backup import Backups, BACKUP_PROVIDER_ENVS
 import selfprivacy_api.backup.providers as providers
 from selfprivacy_api.backup.providers import AbstractBackupProvider
 from selfprivacy_api.backup.providers.backblaze import Backblaze
+from selfprivacy_api.backup.providers.none import NoBackups
 from selfprivacy_api.backup.util import sync
 from selfprivacy_api.backup.backuppers.restic_backupper import ResticBackupper
 from selfprivacy_api.backup.jobs import add_backup_job, add_restore_job
@@ -129,6 +131,40 @@ def test_config_load(generic_userdata):
     assert provider.backupper.key == "KEY"
 
 
+def test_reset_sets_to_none1():
+    Backups.reset()
+    provider = Backups.provider()
+    assert provider is not None
+    assert isinstance(provider, NoBackups)
+
+
+def test_reset_sets_to_none2(backups):
+    # now with something set up first^^^
+    Backups.reset()
+    provider = Backups.provider()
+    assert provider is not None
+    assert isinstance(provider, NoBackups)
+
+
+def test_setting_from_envs(tmpdir):
+    Backups.reset()
+    os.environ[BACKUP_PROVIDER_ENVS["kind"]] = "BACKBLAZE"
+    os.environ[BACKUP_PROVIDER_ENVS["login"]] = "ID"
+    os.environ[BACKUP_PROVIDER_ENVS["key"]] = "KEY"
+    os.environ[BACKUP_PROVIDER_ENVS["location"]] = "selfprivacy"
+    Backups.set_provider_from_envs()
+    provider = Backups.provider()
+
+    assert provider is not None
+    assert isinstance(provider, Backblaze)
+    assert provider.login == "ID"
+    assert provider.key == "KEY"
+    assert provider.location == "selfprivacy"
+
+    assert provider.backupper.account == "ID"
+    assert provider.backupper.key == "KEY"
+
+
 def test_json_reset(generic_userdata):
     Backups.reset(reset_json=False)
     provider = Backups.provider()

From ffec344ba81b9b7355930c8f65e8d7bae5aa0ab8 Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 26 Jul 2023 14:26:04 +0000
Subject: [PATCH 03/14] test(backups): make the test repo overridable by envs

---
 selfprivacy_api/backup/__init__.py | 10 ++++-
 tests/test_graphql/test_backup.py  | 64 ++++++++++++++++++++++++------
 2 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/selfprivacy_api/backup/__init__.py b/selfprivacy_api/backup/__init__.py
index 94d1abb..725904e 100644
--- a/selfprivacy_api/backup/__init__.py
+++ b/selfprivacy_api/backup/__init__.py
@@ -431,10 +431,18 @@ class Backups:
 
     @staticmethod
     def forget_snapshot(snapshot: Snapshot) -> None:
-        """Deletes a snapshot from the storage"""
+        """Deletes a snapshot from the repo and from cache"""
         Backups.provider().backupper.forget_snapshot(snapshot.id)
         Storage.delete_cached_snapshot(snapshot)
 
+    @staticmethod
+    def forget_all_snapshots():
+        """deliberately erase all snapshots we made"""
+        # there is no dedicated optimized command for this,
+        # but maybe we can have a multi-erase
+        for snapshot in Backups.get_all_snapshots():
+            Backups.forget_snapshot(snapshot)
+
     @staticmethod
     def force_snapshot_cache_reload() -> None:
         """
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index fcb437e..fc42ca2 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -39,14 +39,34 @@ TESTFILE_2_BODY = "testissimo!"
 REPO_NAME = "test_backup"
 
 
-@pytest.fixture(scope="function")
-def backups(tmpdir):
-    Backups.reset()
-
-    test_repo_path = path.join(tmpdir, "totallyunrelated")
+def prepare_localfile_backups(temp_dir):
+    test_repo_path = path.join(temp_dir, "totallyunrelated")
+    assert not path.exists(test_repo_path)
     Backups.set_localfile_repo(test_repo_path)
 
+
+@pytest.fixture(scope="function")
+def backups_local(tmpdir):
+    Backups.reset()
+    prepare_localfile_backups(tmpdir)
     Jobs.reset()
+    Backups.init_repo()
+
+
+@pytest.fixture(scope="function")
+def backups(tmpdir):
+    # for those tests that are supposed to pass with any repo
+    Backups.reset()
+    if BACKUP_PROVIDER_ENVS["kind"] in os.environ.keys():
+        Backups.set_provider_from_envs()
+    else:
+        prepare_localfile_backups(tmpdir)
+    Jobs.reset()
+    # assert not repo_path
+
+    Backups.init_repo()
+    yield
+    Backups.forget_all_snapshots()
 
 
 @pytest.fixture()
@@ -82,11 +102,6 @@ def raw_dummy_service(tmpdir):
 @pytest.fixture()
 def dummy_service(tmpdir, backups, raw_dummy_service) -> Service:
     service = raw_dummy_service
-    repo_path = path.join(tmpdir, "test_repo")
-    assert not path.exists(repo_path)
-    # assert not repo_path
-
-    Backups.init_repo()
 
     # register our service
     services.services.append(service)
@@ -148,6 +163,12 @@ def test_reset_sets_to_none2(backups):
 
 def test_setting_from_envs(tmpdir):
     Backups.reset()
+    environment_stash = {}
+    if BACKUP_PROVIDER_ENVS["kind"] in os.environ.keys():
+        # we are running under special envs, stash them before rewriting them
+        for key in BACKUP_PROVIDER_ENVS.values():
+            environment_stash[key] = os.environ[key]
+
     os.environ[BACKUP_PROVIDER_ENVS["kind"]] = "BACKBLAZE"
     os.environ[BACKUP_PROVIDER_ENVS["login"]] = "ID"
     os.environ[BACKUP_PROVIDER_ENVS["key"]] = "KEY"
@@ -164,6 +185,13 @@ def test_setting_from_envs(tmpdir):
     assert provider.backupper.account == "ID"
     assert provider.backupper.key == "KEY"
 
+    if environment_stash != {}:
+        for key in BACKUP_PROVIDER_ENVS.values():
+            os.environ[key] = environment_stash[key]
+    else:
+        for key in BACKUP_PROVIDER_ENVS.values():
+            del os.environ[key]
+
 
 def test_json_reset(generic_userdata):
     Backups.reset(reset_json=False)
@@ -294,9 +322,12 @@ def test_sizing(backups, dummy_service):
     assert size > 0
 
 
-def test_init_tracking(backups, raw_dummy_service):
+def test_init_tracking(backups, tmpdir):
+    assert Backups.is_initted() is True
+    Backups.reset()
     assert Backups.is_initted() is False
-
+    separate_dir = tmpdir / "out_of_the_way"
+    prepare_localfile_backups(separate_dir)
     Backups.init_repo()
 
     assert Backups.is_initted() is True
@@ -618,6 +649,8 @@ def test_snapshots_cache_invalidation(backups, dummy_service):
 
 # Storage
 def test_init_tracking_caching(backups, raw_dummy_service):
+    assert Storage.has_init_mark() is True
+    Backups.reset()
     assert Storage.has_init_mark() is False
 
     Storage.mark_as_init()
@@ -627,7 +660,12 @@ def test_init_tracking_caching(backups, raw_dummy_service):
 
 
 # Storage
-def test_init_tracking_caching2(backups, raw_dummy_service):
+def test_init_tracking_caching2(backups, tmpdir):
+    assert Storage.has_init_mark() is True
+    Backups.reset()
+    assert Storage.has_init_mark() is False
+    separate_dir = tmpdir / "out_of_the_way"
+    prepare_localfile_backups(separate_dir)
     assert Storage.has_init_mark() is False
 
     Backups.init_repo()

From cfa7f4ae59b23a279efa597d05453fcf11ac67bf Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 26 Jul 2023 16:45:08 +0000
Subject: [PATCH 04/14] feature(backups): add full repo erasure capability

---
 selfprivacy_api/backup/__init__.py            |  8 ++++
 selfprivacy_api/backup/backuppers/__init__.py |  5 +++
 .../backup/backuppers/none_backupper.py       |  4 ++
 .../backup/backuppers/restic_backupper.py     | 44 +++++++++++++++----
 selfprivacy_api/backup/storage.py             | 13 ++++--
 tests/test_graphql/test_backup.py             | 13 ++++++
 6 files changed, 74 insertions(+), 13 deletions(-)

diff --git a/selfprivacy_api/backup/__init__.py b/selfprivacy_api/backup/__init__.py
index 725904e..c28c01f 100644
--- a/selfprivacy_api/backup/__init__.py
+++ b/selfprivacy_api/backup/__init__.py
@@ -236,6 +236,14 @@ class Backups:
         Backups.provider().backupper.init()
         Storage.mark_as_init()
 
+    @staticmethod
+    def erase_repo() -> None:
+        """
+        Completely empties the remote
+        """
+        Backups.provider().backupper.erase_repo()
+        Storage.mark_as_uninitted()
+
     @staticmethod
     def is_initted() -> bool:
         """
diff --git a/selfprivacy_api/backup/backuppers/__init__.py b/selfprivacy_api/backup/backuppers/__init__.py
index ea2350b..ccf78b9 100644
--- a/selfprivacy_api/backup/backuppers/__init__.py
+++ b/selfprivacy_api/backup/backuppers/__init__.py
@@ -36,6 +36,11 @@ class AbstractBackupper(ABC):
         """Initialize the repository"""
         raise NotImplementedError
 
+    @abstractmethod
+    def erase_repo(self) -> None:
+        """Completely empties the remote"""
+        raise NotImplementedError
+
     @abstractmethod
     def restore_from_backup(
         self,
diff --git a/selfprivacy_api/backup/backuppers/none_backupper.py b/selfprivacy_api/backup/backuppers/none_backupper.py
index d9edaeb..87e43c5 100644
--- a/selfprivacy_api/backup/backuppers/none_backupper.py
+++ b/selfprivacy_api/backup/backuppers/none_backupper.py
@@ -23,6 +23,10 @@ class NoneBackupper(AbstractBackupper):
     def init(self):
         raise NotImplementedError
 
+    def erase_repo(self) -> None:
+        """Completely empties the remote"""
+        raise NotImplementedError
+
     def restore_from_backup(self, snapshot_id: str, folders: List[str], verify=True):
         """Restore a target folder using a snapshot"""
         raise NotImplementedError
diff --git a/selfprivacy_api/backup/backuppers/restic_backupper.py b/selfprivacy_api/backup/backuppers/restic_backupper.py
index e98c4c3..816bebf 100644
--- a/selfprivacy_api/backup/backuppers/restic_backupper.py
+++ b/selfprivacy_api/backup/backuppers/restic_backupper.py
@@ -40,20 +40,25 @@ class ResticBackupper(AbstractBackupper):
     def restic_repo(self) -> str:
         # https://restic.readthedocs.io/en/latest/030_preparing_a_new_repo.html#other-services-via-rclone
         # https://forum.rclone.org/t/can-rclone-be-run-solely-with-command-line-options-no-config-no-env-vars/6314/5
-        return f"rclone:{self.storage_type}{self.repo}"
+        return f"rclone:{self.rclone_repo()}"
+
+    def rclone_repo(self) -> str:
+        return f"{self.storage_type}{self.repo}"
 
     def rclone_args(self):
-        return "rclone.args=serve restic --stdio " + self.backend_rclone_args()
+        return "rclone.args=serve restic --stdio " + " ".join(
+            self.backend_rclone_args()
+        )
 
-    def backend_rclone_args(self) -> str:
-        acc_arg = ""
-        key_arg = ""
+    def backend_rclone_args(self) -> list[str]:
+        args = []
         if self.account != "":
-            acc_arg = f"{self.login_flag} {self.account}"
+            acc_args = [self.login_flag, self.account]
+            args.extend(acc_args)
         if self.key != "":
-            key_arg = f"{self.key_flag} {self.key}"
-
-        return f"{acc_arg} {key_arg}"
+            key_args = [self.key_flag, self.key]
+            args.extend(key_args)
+        return args
 
     def _password_command(self):
         return f"echo {LocalBackupSecret.get()}"
@@ -79,6 +84,27 @@ class ResticBackupper(AbstractBackupper):
             command.extend(ResticBackupper.__flatten_list(args))
         return command
 
+    def erase_repo(self) -> None:
+        """Fully erases repo on remote, can be reinitted again"""
+        command = [
+            "rclone",
+            "purge",
+            self.rclone_repo(),
+        ]
+        backend_args = self.backend_rclone_args()
+        if backend_args:
+            command.extend(backend_args)
+
+        with subprocess.Popen(command, stdout=subprocess.PIPE, shell=False) as handle:
+            output = handle.communicate()[0].decode("utf-8")
+            if handle.returncode != 0:
+                raise ValueError(
+                    "purge exited with errorcode",
+                    handle.returncode,
+                    ":",
+                    output,
+                )
+
     def mount_repo(self, mount_directory):
         mount_command = self.restic_command("mount", mount_directory)
         mount_command.insert(0, "nohup")
diff --git a/selfprivacy_api/backup/storage.py b/selfprivacy_api/backup/storage.py
index f7384a0..d46f584 100644
--- a/selfprivacy_api/backup/storage.py
+++ b/selfprivacy_api/backup/storage.py
@@ -21,7 +21,7 @@ REDIS_SNAPSHOT_CACHE_EXPIRE_SECONDS = 24 * 60 * 60  # one day
 
 REDIS_SNAPSHOTS_PREFIX = "backups:snapshots:"
 REDIS_LAST_BACKUP_PREFIX = "backups:last-backed-up:"
-REDIS_INITTED_CACHE_PREFIX = "backups:initted_services:"
+REDIS_INITTED_CACHE = "backups:repo_initted"
 
 REDIS_PROVIDER_KEY = "backups:provider"
 REDIS_AUTOBACKUP_PERIOD_KEY = "backups:autobackup_period"
@@ -38,9 +38,9 @@ class Storage:
         """Deletes all backup related data from redis"""
         redis.delete(REDIS_PROVIDER_KEY)
         redis.delete(REDIS_AUTOBACKUP_PERIOD_KEY)
+        redis.delete(REDIS_INITTED_CACHE)
 
         prefixes_to_clean = [
-            REDIS_INITTED_CACHE_PREFIX,
             REDIS_SNAPSHOTS_PREFIX,
             REDIS_LAST_BACKUP_PREFIX,
         ]
@@ -162,11 +162,16 @@ class Storage:
     @staticmethod
     def has_init_mark() -> bool:
         """Returns True if the repository was initialized"""
-        if redis.exists(REDIS_INITTED_CACHE_PREFIX):
+        if redis.exists(REDIS_INITTED_CACHE):
             return True
         return False
 
     @staticmethod
     def mark_as_init():
         """Marks the repository as initialized"""
-        redis.set(REDIS_INITTED_CACHE_PREFIX, 1)
+        redis.set(REDIS_INITTED_CACHE, 1)
+
+    @staticmethod
+    def mark_as_uninitted():
+        """Marks the repository as initialized"""
+        redis.delete(REDIS_INITTED_CACHE)
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index fc42ca2..e85d1de 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -222,6 +222,19 @@ def test_file_backend_init(file_backup):
     file_backup.backupper.init()
 
 
+def test_reinit_after_purge(backups):
+    assert Backups.is_initted() is True
+
+    Backups.erase_repo()
+    assert Backups.is_initted() is False
+    with pytest.raises(ValueError):
+        Backups.get_all_snapshots()
+
+    Backups.init_repo()
+    assert Backups.is_initted() is True
+    assert len(Backups.get_all_snapshots()) == 0
+
+
 def test_backup_simple_file(raw_dummy_service, file_backup):
     # temporarily incomplete
     service = raw_dummy_service

From 00317cc7e4f0fcab6f385ad1be8bf3830211f30b Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 26 Jul 2023 16:52:58 +0000
Subject: [PATCH 05/14] test(backups): erase repos between tests

---
 selfprivacy_api/backup/backuppers/none_backupper.py | 3 ++-
 tests/test_graphql/test_backup.py                   | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/selfprivacy_api/backup/backuppers/none_backupper.py b/selfprivacy_api/backup/backuppers/none_backupper.py
index 87e43c5..3f9f7fd 100644
--- a/selfprivacy_api/backup/backuppers/none_backupper.py
+++ b/selfprivacy_api/backup/backuppers/none_backupper.py
@@ -25,7 +25,8 @@ class NoneBackupper(AbstractBackupper):
 
     def erase_repo(self) -> None:
         """Completely empties the remote"""
-        raise NotImplementedError
+        # this one is already empty
+        pass
 
     def restore_from_backup(self, snapshot_id: str, folders: List[str], verify=True):
         """Restore a target folder using a snapshot"""
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index e85d1de..da81c60 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -66,7 +66,7 @@ def backups(tmpdir):
 
     Backups.init_repo()
     yield
-    Backups.forget_all_snapshots()
+    Backups.erase_repo()
 
 
 @pytest.fixture()

From bba837530afe2d776f4620b84473ea1d67c9b2ce Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Fri, 28 Jul 2023 10:40:40 +0000
Subject: [PATCH 06/14] feature(backups): expose forget to API

---
 .../graphql/mutations/backup_mutations.py     | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/selfprivacy_api/graphql/mutations/backup_mutations.py b/selfprivacy_api/graphql/mutations/backup_mutations.py
index b92af4a..f6dc282 100644
--- a/selfprivacy_api/graphql/mutations/backup_mutations.py
+++ b/selfprivacy_api/graphql/mutations/backup_mutations.py
@@ -157,6 +157,35 @@ class BackupMutations:
             job=job_to_api_job(job),
         )
 
+    @strawberry.mutation(permission_classes=[IsAuthenticated])
+    def forget_snapshot(self, snapshot_id: str) -> GenericMutationReturn:
+        """Forget a snapshot. 
+        Makes it inaccessible from the server. 
+        After some time, the data (encrypted) will not be recoverable
+        from the backup server too, but not immediately"""
+
+        snap = Backups.get_snapshot_by_id(snapshot_id)
+        if snap is None:
+            return GenericMutationReturn(
+                success=False,
+                code=404,
+                message=f"snapshot {snapshot_id} not found",
+            )
+            
+        try:
+            Backups.forget_snapshot(snap)
+            return GenericMutationReturn(
+                success=True,
+                code=200,
+                message="",
+            )
+        except Exception as error:
+            return GenericMutationReturn(
+                success=False,
+                code=400,
+                message=str(error),
+            )
+
     @strawberry.mutation(permission_classes=[IsAuthenticated])
     def force_snapshots_reload(self) -> GenericMutationReturn:
         """Force snapshots reload"""

From 2934e2becac0d7f86ad79736e6d002ecc7f62941 Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Fri, 28 Jul 2023 11:32:48 +0000
Subject: [PATCH 07/14] test(backups): test forgetting via API

---
 tests/test_graphql/test_api_backup.py | 50 +++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/tests/test_graphql/test_api_backup.py b/tests/test_graphql/test_api_backup.py
index bfa315b..e53ce2a 100644
--- a/tests/test_graphql/test_api_backup.py
+++ b/tests/test_graphql/test_api_backup.py
@@ -94,6 +94,18 @@ mutation TestRestoreService($snapshot_id: String!) {
 }
 """
 
+API_FORGET_MUTATION = """
+mutation TestForgetSnapshot($snapshot_id: String!) {
+    backup {
+        forgetSnapshot(snapshotId: $snapshot_id) {
+            success
+            message
+            code
+        }
+    }
+}
+"""
+
 API_SNAPSHOTS_QUERY = """
 allSnapshots {
     id
@@ -143,6 +155,17 @@ def api_backup(authorized_client, service):
     return response
 
 
+def api_forget(authorized_client, snapshot_id):
+    response = authorized_client.post(
+        "/graphql",
+        json={
+            "query": API_FORGET_MUTATION,
+            "variables": {"snapshot_id": snapshot_id},
+        },
+    )
+    return response
+
+
 def api_set_period(authorized_client, period):
     response = authorized_client.post(
         "/graphql",
@@ -370,3 +393,30 @@ def test_reload_snapshots(authorized_client, dummy_service):
 
     snaps = api_snapshots(authorized_client)
     assert len(snaps) == 1
+
+
+def test_forget_snapshot(authorized_client, dummy_service):
+    response = api_backup(authorized_client, dummy_service)
+    data = get_data(response)["backup"]["startBackup"]
+
+    snaps = api_snapshots(authorized_client)
+    assert len(snaps) == 1
+
+    response = api_forget(authorized_client, snaps[0]["id"])
+    data = get_data(response)["backup"]["forgetSnapshot"]
+    assert_ok(data)
+
+    snaps = api_snapshots(authorized_client)
+    assert len(snaps) == 0
+
+
+def test_forget_nonexistent_snapshot(authorized_client, dummy_service):
+    snaps = api_snapshots(authorized_client)
+    assert len(snaps) == 0
+    response = api_forget(authorized_client, "898798uekiodpjoiweoiwuoeirueor")
+    data = get_data(response)["backup"]["forgetSnapshot"]
+    assert data["code"] == 404
+    assert data["success"] is False
+
+    snaps = api_snapshots(authorized_client)
+    assert len(snaps) == 0

From ff70a3588e6a8b447d87341eb576851e1f213043 Mon Sep 17 00:00:00 2001
From: Inex Code <inex.code@selfprivacy.org>
Date: Fri, 4 Aug 2023 12:57:31 +0300
Subject: [PATCH 08/14] chore: bump version

---
 selfprivacy_api/dependencies.py                       | 2 +-
 selfprivacy_api/graphql/mutations/backup_mutations.py | 6 +++---
 setup.py                                              | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/selfprivacy_api/dependencies.py b/selfprivacy_api/dependencies.py
index 6f6f5a5..fb974e8 100644
--- a/selfprivacy_api/dependencies.py
+++ b/selfprivacy_api/dependencies.py
@@ -27,4 +27,4 @@ async def get_token_header(
 
 def get_api_version() -> str:
     """Get API version"""
-    return "2.2.1"
+    return "2.3.0"
diff --git a/selfprivacy_api/graphql/mutations/backup_mutations.py b/selfprivacy_api/graphql/mutations/backup_mutations.py
index f6dc282..c022d57 100644
--- a/selfprivacy_api/graphql/mutations/backup_mutations.py
+++ b/selfprivacy_api/graphql/mutations/backup_mutations.py
@@ -159,8 +159,8 @@ class BackupMutations:
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])
     def forget_snapshot(self, snapshot_id: str) -> GenericMutationReturn:
-        """Forget a snapshot. 
-        Makes it inaccessible from the server. 
+        """Forget a snapshot.
+        Makes it inaccessible from the server.
         After some time, the data (encrypted) will not be recoverable
         from the backup server too, but not immediately"""
 
@@ -171,7 +171,7 @@ class BackupMutations:
                 code=404,
                 message=f"snapshot {snapshot_id} not found",
             )
-            
+
         try:
             Backups.forget_snapshot(snap)
             return GenericMutationReturn(
diff --git a/setup.py b/setup.py
index dea4568..684f54f 100755
--- a/setup.py
+++ b/setup.py
@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="selfprivacy_api",
-    version="2.2.1",
+    version="2.3.0",
     packages=find_packages(),
     scripts=[
         "selfprivacy_api/app.py",

From 52336b885dfc804e93d4df4e3ad4fa0498d045d7 Mon Sep 17 00:00:00 2001
From: Inex Code <inex.code@selfprivacy.org>
Date: Fri, 4 Aug 2023 14:08:23 +0300
Subject: [PATCH 09/14] fix: check if repo is initted by checking retcode

---
 selfprivacy_api/backup/backuppers/restic_backupper.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/selfprivacy_api/backup/backuppers/restic_backupper.py b/selfprivacy_api/backup/backuppers/restic_backupper.py
index 816bebf..37ae06b 100644
--- a/selfprivacy_api/backup/backuppers/restic_backupper.py
+++ b/selfprivacy_api/backup/backuppers/restic_backupper.py
@@ -228,8 +228,7 @@ class ResticBackupper(AbstractBackupper):
 
     def is_initted(self) -> bool:
         command = self.restic_command(
-            "check",
-            "--json",
+            "unlock",
         )
 
         with subprocess.Popen(
@@ -237,10 +236,8 @@ class ResticBackupper(AbstractBackupper):
             stdout=subprocess.PIPE,
             shell=False,
         ) as handle:
-            output = handle.communicate()[0].decode("utf-8")
-            if not ResticBackupper.has_json(output):
+            if handle.returncode != 0:
                 return False
-            # raise NotImplementedError("error(big): " + output)
             return True
 
     def restored_size(self, snapshot_id: str) -> int:

From 752a0b807e7cc0133f4818f6c11ff4df7761a855 Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Mon, 7 Aug 2023 13:33:10 +0000
Subject: [PATCH 10/14] feature(backups): lock and unlock at will

---
 .../backup/backuppers/restic_backupper.py     | 53 ++++++++++++++++++-
 selfprivacy_api/backup/util.py                | 16 ++++--
 tests/test_graphql/test_backup.py             | 15 ++++++
 3 files changed, 78 insertions(+), 6 deletions(-)

diff --git a/selfprivacy_api/backup/backuppers/restic_backupper.py b/selfprivacy_api/backup/backuppers/restic_backupper.py
index 37ae06b..a359f98 100644
--- a/selfprivacy_api/backup/backuppers/restic_backupper.py
+++ b/selfprivacy_api/backup/backuppers/restic_backupper.py
@@ -227,6 +227,24 @@ class ResticBackupper(AbstractBackupper):
                 raise ValueError("cannot init a repo: " + output)
 
     def is_initted(self) -> bool:
+        command = self.restic_command(
+            "check",
+        )
+
+        with subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            shell=False,
+            stderr=subprocess.STDOUT,
+        ) as handle:
+            # communication forces to complete and for returncode to get defined
+            output = handle.communicate()[0].decode("utf-8")
+            if handle.returncode != 0:
+                return False
+            return True
+
+    def unlock(self) -> None:
+        """Remove stale locks."""
         command = self.restic_command(
             "unlock",
         )
@@ -235,10 +253,41 @@ class ResticBackupper(AbstractBackupper):
             command,
             stdout=subprocess.PIPE,
             shell=False,
+            stderr=subprocess.STDOUT,
         ) as handle:
+            # communication forces to complete and for returncode to get defined
+            output = handle.communicate()[0].decode("utf-8")
             if handle.returncode != 0:
-                return False
-            return True
+                raise ValueError("cannot unlock the backup repository: ", output)
+
+    def lock(self) -> None:
+        """
+        Introduce a stale lock.
+        Mainly for testing purposes.
+        Double lock is supposed to fail
+        """
+        command = self.restic_command(
+            "check",
+        )
+
+        # using temporary cache in /run/user/1000/restic-check-cache-817079729
+        # repository 9639c714 opened (repository version 2) successfully, password is correct
+        # created new cache in /run/user/1000/restic-check-cache-817079729
+        # create exclusive lock for repository
+        # load indexes
+        # check all packs
+        # check snapshots, trees and blobs
+        # [0:00] 100.00%  1 / 1 snapshots
+        # no errors were found
+
+        try:
+            for line in output_yielder(command):
+                if "indexes" in line:
+                    break
+                if "unable" in line:
+                    raise ValueError(line)
+        except Exception as e:
+            raise ValueError("could not lock repository") from e
 
     def restored_size(self, snapshot_id: str) -> int:
         """
diff --git a/selfprivacy_api/backup/util.py b/selfprivacy_api/backup/util.py
index bda421e..41d926c 100644
--- a/selfprivacy_api/backup/util.py
+++ b/selfprivacy_api/backup/util.py
@@ -1,8 +1,10 @@
 import subprocess
 from os.path import exists
+from typing import Generator
 
 
-def output_yielder(command):
+def output_yielder(command) -> Generator[str, None, None]:
+    """Note: If you break during iteration, it kills the process"""
     with subprocess.Popen(
         command,
         shell=False,
@@ -10,9 +12,15 @@ def output_yielder(command):
         stderr=subprocess.STDOUT,
         universal_newlines=True,
     ) as handle:
-        for line in iter(handle.stdout.readline, ""):
-            if "NOTICE:" not in line:
-                yield line
+        if handle is None or handle.stdout is None:
+            raise ValueError("could not run command: ", command)
+
+        try:
+            for line in iter(handle.stdout.readline, ""):
+                if "NOTICE:" not in line:
+                    yield line
+        except GeneratorExit:
+            handle.kill()
 
 
 def sync(src_path: str, dest_path: str):
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index da81c60..9743567 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -758,3 +758,18 @@ def test_move_blocks_backups(backups, dummy_service, restore_strategy):
 
     with pytest.raises(ValueError):
         Backups.restore_snapshot(snap, restore_strategy)
+
+
+def test_double_lock_unlock(backups, dummy_service):
+    # notice that introducing stale locks is only safe for other tests if we erase repo in between
+    # which we do at the time of writing this test
+
+    Backups.provider().backupper.lock()
+    with pytest.raises(ValueError):
+        Backups.provider().backupper.lock()
+
+    Backups.provider().backupper.unlock()
+    Backups.provider().backupper.lock()
+
+    Backups.provider().backupper.unlock()
+    Backups.provider().backupper.unlock()

From eca4b26a3171c018cb5a658f6eb996772726b5be Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 9 Aug 2023 13:47:18 +0000
Subject: [PATCH 11/14] fix(backups): robustness against stale locks: backing
 up

---
 .../backup/backuppers/restic_backupper.py     | 34 +++++++++++++++++--
 tests/test_graphql/test_backup.py             |  6 ++++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/selfprivacy_api/backup/backuppers/restic_backupper.py b/selfprivacy_api/backup/backuppers/restic_backupper.py
index a359f98..6c3dbcc 100644
--- a/selfprivacy_api/backup/backuppers/restic_backupper.py
+++ b/selfprivacy_api/backup/backuppers/restic_backupper.py
@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 import subprocess
 import json
 import datetime
 import tempfile
 
-from typing import List
+from typing import List, TypeVar, Callable
 from collections.abc import Iterable
 from json.decoder import JSONDecodeError
 from os.path import exists, join
@@ -21,6 +23,25 @@ from selfprivacy_api.backup.local_secret import LocalBackupSecret
 
 SHORT_ID_LEN = 8
 
+T = TypeVar("T", bound=Callable)
+
+
+def unlocked_repo(func: T) -> T:
+    """unlock repo and retry if it appears to be locked"""
+
+    def inner(self: ResticBackupper, *args, **kwargs):
+        try:
+            return func(self, *args, **kwargs)
+        except Exception as e:
+            if "unable to create lock" in str(e):
+                self.unlock()
+                return func(self, *args, **kwargs)
+            else:
+                raise e
+
+    # Above, we manually guarantee that the type returned is compatible.
+    return inner  # type: ignore
+
 
 class ResticBackupper(AbstractBackupper):
     def __init__(self, login_flag: str, key_flag: str, storage_type: str) -> None:
@@ -142,6 +163,7 @@ class ResticBackupper(AbstractBackupper):
             result.append(item)
         return result
 
+    @unlocked_repo
     def start_backup(self, folders: List[str], tag: str) -> Snapshot:
         """
         Start backup with restic
@@ -165,8 +187,10 @@ class ResticBackupper(AbstractBackupper):
             raise ValueError("No service with id ", tag)
 
         job = get_backup_job(service)
+        output = []
         try:
             for raw_message in output_yielder(backup_command):
+                output.append(raw_message)
                 message = self.parse_message(
                     raw_message,
                     job,
@@ -177,7 +201,13 @@ class ResticBackupper(AbstractBackupper):
                 tag,
             )
         except ValueError as error:
-            raise ValueError("Could not create a snapshot: ", messages) from error
+            raise ValueError(
+                "Could not create a snapshot: ",
+                str(error),
+                output,
+                "parsed messages:",
+                messages,
+            ) from error
 
     @staticmethod
     def _snapshot_from_backup_messages(messages, repo_name) -> Snapshot:
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index 9743567..b575b5b 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -773,3 +773,9 @@ def test_double_lock_unlock(backups, dummy_service):
 
     Backups.provider().backupper.unlock()
     Backups.provider().backupper.unlock()
+
+
+def test_operations_while_locked(backups, dummy_service):
+    Backups.provider().backupper.lock()
+    snap = Backups.back_up(dummy_service)
+    assert snap is not None

From 26ab7b4d7b9b9f7670a5bb9d085044e664160200 Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 9 Aug 2023 13:58:53 +0000
Subject: [PATCH 12/14] fix(backups): robustness against stale locks:
 is_initted

---
 .../backup/backuppers/restic_backupper.py         |  5 ++++-
 tests/test_graphql/test_backup.py                 | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/selfprivacy_api/backup/backuppers/restic_backupper.py b/selfprivacy_api/backup/backuppers/restic_backupper.py
index 6c3dbcc..022bda7 100644
--- a/selfprivacy_api/backup/backuppers/restic_backupper.py
+++ b/selfprivacy_api/backup/backuppers/restic_backupper.py
@@ -256,6 +256,7 @@ class ResticBackupper(AbstractBackupper):
             if "created restic repository" not in output:
                 raise ValueError("cannot init a repo: " + output)
 
+    @unlocked_repo
     def is_initted(self) -> bool:
         command = self.restic_command(
             "check",
@@ -267,9 +268,10 @@ class ResticBackupper(AbstractBackupper):
             shell=False,
             stderr=subprocess.STDOUT,
         ) as handle:
-            # communication forces to complete and for returncode to get defined
             output = handle.communicate()[0].decode("utf-8")
             if handle.returncode != 0:
+                if "unable to create lock" in output:
+                    raise ValueError("Stale lock detected: ", output)
                 return False
             return True
 
@@ -319,6 +321,7 @@ class ResticBackupper(AbstractBackupper):
         except Exception as e:
             raise ValueError("could not lock repository") from e
 
+    @unlocked_repo
     def restored_size(self, snapshot_id: str) -> int:
         """
         Size of a snapshot
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index b575b5b..da4da7a 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -776,6 +776,21 @@ def test_double_lock_unlock(backups, dummy_service):
 
 
 def test_operations_while_locked(backups, dummy_service):
+    # Stale lock prevention test
+
+    # consider making it fully at the level of backupper?
+    # because this is where prevention lives?
+    # Backups singleton is here only so that we can run this against B2, S3 and whatever
+    # But maybe it is not necessary (if restic treats them uniformly enough)
+
     Backups.provider().backupper.lock()
     snap = Backups.back_up(dummy_service)
     assert snap is not None
+
+    Backups.provider().backupper.lock()
+    # using lowlevel to make sure no caching interferes
+    assert Backups.provider().backupper.is_initted() is True
+
+    # check that no locks were left
+    Backups.provider().backupper.lock()
+    Backups.provider().backupper.unlock()

From 0eb70e1551f530853ea9a99b41a9d37efa033768 Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 9 Aug 2023 14:46:27 +0000
Subject: [PATCH 13/14] fix(backups): robustness against stale locks: snapshot
 sizing

---
 selfprivacy_api/backup/backuppers/restic_backupper.py | 6 +++++-
 tests/test_graphql/test_backup.py                     | 3 +++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/selfprivacy_api/backup/backuppers/restic_backupper.py b/selfprivacy_api/backup/backuppers/restic_backupper.py
index 022bda7..5db9f11 100644
--- a/selfprivacy_api/backup/backuppers/restic_backupper.py
+++ b/selfprivacy_api/backup/backuppers/restic_backupper.py
@@ -335,6 +335,7 @@ class ResticBackupper(AbstractBackupper):
         with subprocess.Popen(
             command,
             stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
             shell=False,
         ) as handle:
             output = handle.communicate()[0].decode("utf-8")
@@ -382,7 +383,10 @@ class ResticBackupper(AbstractBackupper):
         )
 
         with subprocess.Popen(
-            restore_command, stdout=subprocess.PIPE, shell=False
+            restore_command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            shell=False,
         ) as handle:
 
             # for some reason restore does not support
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index da4da7a..556b72b 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -791,6 +791,9 @@ def test_operations_while_locked(backups, dummy_service):
     # using lowlevel to make sure no caching interferes
     assert Backups.provider().backupper.is_initted() is True
 
+    Backups.provider().backupper.lock()
+    assert Backups.snapshot_restored_size(snap.id) > 0
+
     # check that no locks were left
     Backups.provider().backupper.lock()
     Backups.provider().backupper.unlock()

From 2c9011cc87f5fb3c337627133d9cb6ac00bce56e Mon Sep 17 00:00:00 2001
From: Houkime <>
Date: Wed, 9 Aug 2023 15:18:20 +0000
Subject: [PATCH 14/14] fix(backups): robustness against stale locks:
 everything else

---
 selfprivacy_api/backup/backuppers/restic_backupper.py | 10 +++++-----
 tests/test_graphql/test_backup.py                     |  9 +++++++++
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/selfprivacy_api/backup/backuppers/restic_backupper.py b/selfprivacy_api/backup/backuppers/restic_backupper.py
index 5db9f11..3a5fc49 100644
--- a/selfprivacy_api/backup/backuppers/restic_backupper.py
+++ b/selfprivacy_api/backup/backuppers/restic_backupper.py
@@ -345,6 +345,7 @@ class ResticBackupper(AbstractBackupper):
             except ValueError as error:
                 raise ValueError("cannot restore a snapshot: " + output) from error
 
+    @unlocked_repo
     def restore_from_backup(
         self,
         snapshot_id,
@@ -406,6 +407,7 @@ class ResticBackupper(AbstractBackupper):
                     output,
                 )
 
+    @unlocked_repo
     def forget_snapshot(self, snapshot_id) -> None:
         """
         Either removes snapshot or marks it for deletion later,
@@ -441,10 +443,7 @@ class ResticBackupper(AbstractBackupper):
             )  # none should be impossible after communicate
             if handle.returncode != 0:
                 raise ValueError(
-                    "forget exited with errorcode",
-                    handle.returncode,
-                    ":",
-                    output,
+                    "forget exited with errorcode", handle.returncode, ":", output, err
                 )
 
     def _load_snapshots(self) -> object:
@@ -470,8 +469,9 @@ class ResticBackupper(AbstractBackupper):
         try:
             return ResticBackupper.parse_json_output(output)
         except ValueError as error:
-            raise ValueError("Cannot load snapshots: ") from error
+            raise ValueError("Cannot load snapshots: ", output) from error
 
+    @unlocked_repo
     def get_snapshots(self) -> List[Snapshot]:
         """Get all snapshots from the repo"""
         snapshots = []
diff --git a/tests/test_graphql/test_backup.py b/tests/test_graphql/test_backup.py
index 556b72b..1990ef7 100644
--- a/tests/test_graphql/test_backup.py
+++ b/tests/test_graphql/test_backup.py
@@ -794,6 +794,15 @@ def test_operations_while_locked(backups, dummy_service):
     Backups.provider().backupper.lock()
     assert Backups.snapshot_restored_size(snap.id) > 0
 
+    Backups.provider().backupper.lock()
+    Backups.restore_snapshot(snap)
+
+    Backups.provider().backupper.lock()
+    Backups.forget_snapshot(snap)
+
+    Backups.provider().backupper.lock()
+    assert Backups.provider().backupper.get_snapshots() == []
+
     # check that no locks were left
     Backups.provider().backupper.lock()
     Backups.provider().backupper.unlock()