Separate once again the app registry and the backup apps

apps/backups/classes.py

@@ -0,0 +1,161 @@
+import logging
+import os
+
+from django.core.files.base import ContentFile
+from django.core.files.storage import FileSystemStorage
+from django.core.management.commands.dumpdata import Command
+from django.conf import settings
+from django.db import router, DEFAULT_DB_ALIAS
+from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import ugettext
+from django.utils.importlib import import_module
+
+logger = logging.getLogger(__name__)
+
+
+# Data types
+class ElementDataBase(object):
+    """
+    The basic unit of a backup, a data type
+    it is produced or consumed by the ElementBackup classes
+    """
+    def make_filename(self, id):
+        return '%s-%s' % (self.model_backup.app_backup.app.name, id)
+    
+    def save(self):
+        """
+        Must return a file like object
+        """
+        raise NotImplemented
+
+    def load(self, file_object):
+        """
+        Must read a file like object and store content
+        """
+        raise NotImplemented        
+
+
+class Fixture(ElementDataBase):
+    name = 'fixture'
+    
+    def __init__(self, model_backup, content):
+        self.model_backup = model_backup
+        self.content = content
+    
+    @property
+    def filename(self):
+        return self.make_filename(self.__class__.name)
+    
+    def save(self):
+        return ContentFile(name=self.filename, content=self.content)
+
+    #def load(self):
+
+
+# Element backup
+class ElementBackupBase(object):
+    """
+    Sub classes must provide at least:
+        info()
+        backup()
+        restore()
+    """
+
+    label = _(u'Base backup manager')
+
+    def info(self):
+        """
+        Must return at least None
+        """
+        return None
+
+    def link(self, app_backup):
+        self.app_backup = app_backup
+        return self
+
+    def __unicode__(self):
+        return unicode(self.__class__.label)
+
+
+class ModelBackup(ElementBackupBase):
+    label = _(u'Model fixtures')
+
+    def __init__(self, models=None):
+        self.model_list = models or []
+    
+    def info(self):
+        return _(u'models: %s') % (u', '.join(self.model_list) if self.model_list else _(u'All'))
+
+    def backup(self):
+        """
+        """
+        #TODO: turn into a generator
+
+        command = Command()
+        if not self.model_list:
+            result = [self.app_backup.app.name]
+        else:
+            result = [u'%s.%s' (self.app_backup.app.name, model) for model in self.model_list]
+        
+        #TODO: a single Fixture or a list of Fixtures for each model?
+        #Can't return multiple Fixture until a way to find all of an app's models is found
+        return [Fixture(
+            model_backup=self,
+            content=command.handle(u' '.join(result), format='json', indent=4, using=DEFAULT_DB_ALIAS, exclude=[], user_base_manager=False, use_natural_keys=False)
+        )]
+
+
+class FileBackup(ElementBackupBase):
+    label = _(u'File copy')
+
+    def __init__(self, storage_class, filepath=None):
+        self.storage_class = storage_class
+        self.filepath = filepath
+    
+    def info(self):
+        return _(u'%s from %s') % (self.filepath or _(u'all files'), self.storage_class)
+
+    def backup(self):
+        """
+        Fetch a file specified by filepath from the Django storage class
+        and return a file like object
+        """
+        return None
+        
+
+# App config
+class AppBackup(object):
+    _registry = {}
+ 
+    STATE_BACKING_UP = 'backing_up'
+    STATE_RESTORING = 'restoring'
+    STATE_IDLE = 'idle'
+    
+    STATE_CHOICES = (
+        (STATE_BACKING_UP, _(u'backing up')),
+        (STATE_RESTORING, _(u'restoring')),
+        (STATE_IDLE, _(u'idle')),
+    )
+
+    @classmethod
+    def get(cls, name):
+        return cls._registry[name]
+
+    @classmethod
+    def get_all(cls):
+        return cls._registry.values()
+
+    def __init__(self, app, backup_managers):
+        # app = App instance from app_registry app
+        self.app = app
+        self.backup_managers = [manager.link(self) for manager in backup_managers]
+        self.state = self.__class__.STATE_IDLE
+        self.__class__._registry[app] = self
+
+    def info(self):
+        results = []
+        for manager in self.backup_managers:
+            results.append(u'%s - %s' % (manager, manager.info() or _(u'Nothing')))
+        return u', '.join(results)
+
+