X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=src%2Fbackup%2Fpcsbackupmanager.py;fp=src%2Fbackup%2Fpcsbackupmanager.py;h=92a5cc7e1b6fd61d3a89ecad3c60d5ff76affb9a;hb=256d6db84797e58f32185f042154a7c0fc54163e;hp=0000000000000000000000000000000000000000;hpb=7d8224c9f08712280a22af40325d59a19f4fb1e1;p=tablet-suite

diff --git a/src/backup/pcsbackupmanager.py b/src/backup/pcsbackupmanager.py
new file mode 100644
index 0000000..92a5cc7
--- /dev/null
+++ b/src/backup/pcsbackupmanager.py
@@ -0,0 +1,168 @@
+import os
+
+from PyQt4.QtCore import *
+from zipfile import *
+
+import pcsbackuputils as utils
+
+
+HOME = os.path.expanduser("~")
+USER_HOST = "root"
+DEVICES_POINT = "%s/.pcsuite/devices/" % HOME
+
+
+class PcsBackupManager(QObject):
+
+    def __init__(self):
+        QObject.__init__(self)
+        self._backupList = []
+
+    def loadBackups(self):
+        return False
+
+    def saveBackups(self):
+        return False
+
+    def getBackupList(self):
+        return None
+    
+    def createBackup(self, backup_name, path, host_ip, categories, comment=""):
+        return False
+
+    def removeBackup(self, backup_name):
+        return False
+
+    def getBackupInfo(self, backupName):
+        return None
+    
+    def renameBackup(self, backupName, newName):
+        return False
+    
+    def changeBackupComment(self, backupName, new_comment):
+        return False
+    
+    def listBackupContent(self, backupName):
+        content = []
+        backupInfo = self.getBackupInfo(backupName)
+        backupPath = backupInfo.getPath()
+        fullPath = os.path.join(str(backupPath), str(backupName))
+        
+        for entry in os.listdir(fullPath):
+            if entry.endswith(".zip"):
+                zipfile = utils.openZip(os.path.join(fullPath, entry), "r")
+                for member in zipfile.namelist():
+                    folders = member.split("/")
+                    memberName = "../" + "/".join([folders[-2], folders[-1]])
+                    content.append(memberName)
+        return content
+    
+    def restoreBackup(self, backupInfo, host_ip, categories):
+        """ Restore a PC backup to device with given IP address.
+        
+        Attributes:
+        String backupInfo - Object representing the backup
+        String host_ip - IP address of device.
+        Dictionary categories - dictionary with categories as keys and with
+                            value True if that category should be restored.
+                            
+        """
+        self.setRestoreInProgress(True)
+        # Set restore needed paths
+        devicePath = os.path.join(DEVICES_POINT, "%s" % host_ip)
+        mountPath = os.path.join(devicePath, "Root" )
+        tempPath = os.path.join(mountPath, "tmp/paths")
+        restScriptsPath = ("/etc/osso-backup/restore.d/always")
+        try:
+            utils.mountDevice(USER_HOST, host_ip, mountPath)
+            # Get backup location depending from backup source
+            if backupInfo == None:
+                return False
+            if backupInfo.fromDevice:
+                backup_path = backupInfo.getPath()
+            else:
+                backup_path = os.path.join(str(backupInfo.getPath()), 
+                                           str(backupInfo.getName()))
+            # Get backup files list for each category and write it on a file
+            # that will be needed by restore scripts.
+            pathsDictonary = utils.getBackupFilesPath(backup_path)
+            if utils.writeBackupFilesPath(pathsDictonary, tempPath) == False:
+                return False
+            # --- Initialize restore progress ---
+            currentSize = 0
+            # Get total number of files to restore
+            numberOfFiles = 0
+            for categ in pathsDictonary:
+                for file in pathsDictonary[categ]:
+                    numberOfFiles += 1
+            # Get size of all categories being restored
+            totalSize = 0
+            for file in os.listdir(backup_path):
+                if file.endswith(".zip"):
+                    categ = file[:-4]
+                    if categories[categ]:
+                        catPath = os.path.join(backup_path, file)
+                        zip = utils.openZip(catPath)
+                        for member in zip.namelist():
+                            totalSize += zip.getinfo(member).file_size
+            # Extract zip files to device
+            for entry in os.listdir(backup_path):
+                category = entry[:-4]
+                if entry.endswith(".zip") and categories[category]:
+                    zipPath = os.path.join(backup_path, entry)
+                    zip = utils.openZip(zipPath)
+                    # Update restore progress, extract current f print "member %s: %.2f" % (member, zip.getinfo(member).file_size)ile and emit
+                    # progress sinal
+                    for member in zip.namelist():
+                        if not self.restoreInProgress:
+                            return 0
+                        percentage = "%.1f" % self.computePercentage(totalSize,
+                                                                currentSize)
+                        
+                        status = (percentage, category, numberOfFiles, totalSize)
+                        self.emit(SIGNAL("restoreProgress"), status)
+                        zip.extract(member, devicePath)
+                        currentSize += zip.getinfo(member).file_size
+                    percentage = "%.1f" % ((currentSize / float(totalSize)) * 100)
+                    status = (percentage, category, numberOfFiles, totalSize)
+                    self.emit(SIGNAL("restoreProgress"), status)
+                    zip.close()
+            # Execute restore scripts
+            os.system("ssh %s@%s ..%s/*.sh %s" % (USER_HOST, host_ip, 
+                                                  restScriptsPath, tempPath))
+            self.setRestoreInProgress(False)
+            # --- Restore finished ---
+        finally:
+            utils.unmountDevice(mountPath)
+            
+    
+    def computePercentage(self, totalSize, currentSize):
+        if totalSize == 0:
+            percentage = 100
+        else:
+            percentage = (currentSize / float(totalSize)) * 100
+            if percentage > 100:
+                percentage = 100
+        return percentage
+    
+    def copy(self, sourcePath, destinationPath):
+        numberOfFiles = 0
+        for entry in os.listdir(sourcePath):
+            zipPath = os.path.join(sourcePath, entry)
+            if zipPath.endswith(".zip"):
+                zip = utils.openZip(zipPath)
+                numberOfFiles += len(zip.namelist())
+        totalSize = float(utils.getSize(sourcePath))
+        currentSize = 0
+        self.emit(SIGNAL("copyProgress"), ("0.00", numberOfFiles, totalSize))
+        for entry in os.listdir(sourcePath):
+            if not self.copyInProgress:
+                utils.removePath(destinationPath)
+                return 0
+            entryPath = os.path.join(sourcePath, entry)
+            utils.copy(entryPath, destinationPath)
+            currentSize += utils.getSize(entryPath)
+            progress = "%.2f" % ((currentSize / totalSize) * 100)
+            self.emit(SIGNAL("copyProgress"), (progress, numberOfFiles,
+                                                    totalSize))
+            
+    
\ No newline at end of file