New Addon

Google BK

hassio-google-drive-backup/backup/model/simulatedsource.py

@@ -0,0 +1,129 @@
+from .model import CreateOptions, BackupDestination
+from .backups import Backup
+from .dummybackupsource import DummyBackupSource
+from typing import Dict
+from io import IOBase
+from ..ha import BackupName
+from ..logger import getLogger
+
+logger = getLogger(__name__)
+
+
+class SimulatedSource(BackupDestination):
+    def __init__(self, name, is_destination=False):
+        self._name = name
+        self.current: Dict[str, DummyBackupSource] = {}
+        self.saved = []
+        self.deleted = []
+        self.created = []
+        self._enabled = True
+        self._upload = True
+        self.index = 0
+        self.max = 0
+        self.backup_name = BackupName()
+        self.host_info = {}
+        self.backup_type = "Full"
+        self.working = False
+        self.needConfig = None
+        self.is_destination = is_destination
+
+    def isDestination(self):
+        return self.is_destination
+
+    def setEnabled(self, value):
+        self._enabled = value
+        return self
+
+    def needsConfiguration(self) -> bool:
+        if self.needConfig is not None:
+            return self.needConfig
+        return super().needsConfiguration()
+
+    def setNeedsConfiguration(self, value: bool):
+        self.needConfig = value
+
+    def setUpload(self, value):
+        self._upload = value
+        return self
+
+    def upload(self):
+        return self._upload
+
+    def setMax(self, count):
+        self.max = count
+        return self
+
+    def isWorking(self):
+        return self.working
+
+    def setIsWorking(self, value):
+        self.working = value
+
+    def maxCount(self) -> None:
+        return self.max
+
+    def insert(self, name, date, slug=None, retain=False):
+        if slug is None:
+            slug = name
+        new_backup = DummyBackupSource(
+            name,
+            date,
+            self._name,
+            slug)
+        self.current[new_backup.slug()] = new_backup
+        return new_backup
+
+    def name(self) -> str:
+        return self._name
+
+    def enabled(self) -> bool:
+        return self._enabled
+
+    def nameSetup(self, type, host_info):
+        self.backup_type = type
+        self.host_info = host_info
+
+    async def create(self, options: CreateOptions) -> DummyBackupSource:
+        assert self.enabled
+        new_backup = DummyBackupSource(
+            self.backup_name.resolve(
+                self.backup_type, options.name_template, options.when, self.host_info),
+            options.when,
+            self._name,
+            "{0}slug{1}".format(self._name, self.index))
+        self.index += 1
+        self.current[new_backup.slug()] = new_backup
+        self.created.append(new_backup)
+        return new_backup
+
+    async def get(self) -> Dict[str, DummyBackupSource]:
+        assert self.enabled
+        return self.current
+
+    async def delete(self, backup: Backup):
+        assert self.enabled
+        assert backup.getSource(self._name) is not None
+        assert backup.getSource(self._name).source() is self._name
+        assert backup.slug() in self.current
+        slug = backup.slug()
+        self.deleted.append(backup.getSource(self._name))
+        backup.removeSource(self._name)
+        del self.current[slug]
+
+    async def save(self, backup: Backup, bytes: IOBase = None) -> DummyBackupSource:
+        assert self.enabled
+        assert backup.slug() not in self.current
+        new_backup = DummyBackupSource(
+            backup.name(), backup.date(), self._name, backup.slug())
+        backup.addSource(new_backup)
+        self.current[new_backup.slug()] = new_backup
+        self.saved.append(new_backup)
+        return new_backup
+
+    async def read(self, backup: DummyBackupSource) -> IOBase:
+        assert self.enabled
+        return None
+
+    async def retain(self, backup: DummyBackupSource, retain: bool) -> None:
+        assert self.enabled
+        backup.getSource(self.name()).setRetained(retain)