Mercurial > repos > borgend / file diff

--- a/backup.py	Fri Jan 19 10:41:01 2018 +0000
+++ b/backup.py	Fri Jan 19 14:42:27 2018 +0000
@@ -4,6 +4,8 @@
 
 import config
 from instance import BorgInstance
+from queue import Queue
+from threading import Thread
 
 class Backup:
 
@@ -17,6 +19,9 @@
         self.repository=config.check_string(cfg, 'repository',
                                             'Target repository', self.loc)
 
+        self.archive_prefix=config.check_string(cfg, 'archive_prefix',
+                                                'Archive prefix', self.loc)
+
         self.archive_template=config.check_string(cfg, 'archive_template',
                                                   'Archive template', self.loc)
 
@@ -30,9 +35,13 @@
 
         self.paths=config.check_nonempty_list_of_strings(cfg, 'paths', 'Paths', self.loc)
 
-        self.borg_parameters=config.check_list_of_dicts(cfg, 'borg_parameters',
-                                                        'Borg parameters', self.loc,
-                                                        default=[])
+        self.create_parameters=config.check_list_of_dicts(cfg, 'create_parameters',
+                                                         'Borg parameters', self.loc,
+                                                         default=[])
+
+        self.prune_parameters=config.check_list_of_dicts(cfg, 'prune_parameters',
+                                                         'Borg parameters', self.loc,
+                                                         default=[])
 
 
     def __init__(self, identifier, cfg):
@@ -40,20 +49,55 @@
 
         self.__decode_config(cfg)
 
-
         self.config=config
         self.lastrun=None
-        self.current_instance=None
+        self.borg_instance=None
+        self.thread=None
+
+    def __block_when_running(self):
+        assert(self.borg_instance is None and self.thread is None)
 
-    def create(self):
-        if self.current_instance is not None:
-            raise AssertionError('%s running: cannot launch' % self.loc)
+    def __listener(self):
+        for status in iter(self.borg_instance.read, None):
+            # What to do?
+            print(status)
+        # What to do on error
+            #     queue.put({'identifier': instance.identifier,
+            #                'operation': instance.operation,
+            #                'status': status})
+
+    def __launch(self, queue, operation, archive_or_repository, *args):
+
+        inst=BorgInstance(operation, archive_or_repository, *args)
+        inst.launch()
+
+        t=Thread(target=self.__listener)
+        t.daemon=True
 
-        archive="%s::%s" % (self.repository, self.archive_template)
+        self.thread=t
+        self.borg_instance=inst
+        self.queue=queue
+
+        t.start()
+
+    def create(self, queue):
+        self.__block_when_running()
 
-        inst=BorgInstance(self.identifier, 'create', self.borg_parameters, 
-                          archive, self.paths)
-        print(inst.construct_cmdline())
+        archive="%s::%s%s" % (self.repository,
+                              self.archive_prefix,
+                              self.archive_template)
+
+        self.__launch(queue, 'create', archive,
+                      self.create_parameters, self.paths)
+
+    def prune(self, queue):
+        self.__block_when_running()
+        self.__launch(queue, 'prune', self.repository,
+                      [{'prefix': self.archive_prefix}] + self.prune_parameters)
+
+    def join(self):
+        if self.thread:
+            self.thread.join()