--- /dev/null
+# low_backup_manager module
+# Authors: Nicholas Alexander && Otacilio Lacerda
+# Backup_manager class:
+# Class responsible for backup functions like creating and removing backups
+
+import os.path
+import os
+import zlib
+import pickle
+
+from PyQt4.QtCore import *
+from zipfile import *
+
+from pcsbackupparser import *
+from pcsbackupinfo import *
+from pcsbackupmanager import *
+from pcsbackupxml import *
+
+import pcsbackuputils as utils
+
+HOME = os.path.expanduser("~")
+BACKUP_FILES_PATH = os.path.join(HOME, ".pcsuite/Backup")
+DEFAULT_CONFIG_PATH = "%s/.pcsuite/config" % HOME
+BACKUPS_FILE = os.path.join(HOME, ".pcsuite/Backup/.backups")
+
+
+class PcsPcBackupManager(PcsBackupManager):
+
+ def __init__(self):
+ PcsBackupManager.__init__(self)
+ self._backupList = []
+ self.backupInProgress = False
+ self.restoreInProgress = False
+ self.copyInProgress = False
+
+ self.myDocsPath = "Root/home/user/MyDocs/"
+ self.backupPath = ""
+ self.currentCategory = ""
+ self.totalSize = 0
+
+ def loadBackups(self):
+ # 'XX Loading the backup list available in the PC'
+ try:
+ if os.path.exists(BACKUPS_FILE):
+ file = open(BACKUPS_FILE)
+ self._backupList = pickle.load(file)
+ file.close()
+ except IOError:
+ print "IOError while loading the PC backups"
+ # FIXME
+ #raise Exception("Error while reading backups")
+ return False
+
+ return True
+
+ def saveBackups(self):
+ # 'XX Saving the backup list in the config file'
+ try:
+ obj = self._backupList
+ file = open(BACKUPS_FILE, "w")
+ pickle.dump(obj, file)
+ file.close()
+ except:
+ #raise Exception("Error while saving backups")
+ return False
+
+ return True
+
+ def getBackupList(self):
+ """Return a list with the name of all done backups. """
+ self.loadBackups()
+ return self._backupList[:]
+
+ def createBackup(self, backup_name, path, host_ip, categories, comment=""):
+ self.backupThread = NewBackupThread(self, backup_name, path, host_ip,
+ categories, comment)
+ self.backupThread.start()
+
+
+ def renameBackup(self, backupName, newName):
+ self.loadBackups()
+
+ backupInfo = self.getBackupInfo(backupName)
+ if backupInfo != None:
+ try:
+ old = os.path.join(str(backupInfo.getPath()), str(backupName))
+ new = os.path.join(str(backupInfo.getPath()), str(newName))
+ os.rename(old, new)
+ backupInfo.setName(newName)
+ except:
+ print "Error while changing backup name"
+ return False
+ else:
+ # "Backup not found"
+ return False
+
+ self.saveBackups()
+ return True
+
+ def removeBackup(self, backupName):
+ """
+ Remove a backup from pc and from _backupList.
+ """
+ self.loadBackups()
+ backupInfo = self.getBackupInfo(backupName)
+ completePath = os.path.join(str(backupInfo.getPath()),
+ str(backupInfo.getName()))
+ if os.path.exists(completePath):
+ utils.removePath(completePath)
+ self._backupList.remove(backupInfo)
+ self.saveBackups()
+
+ return True
+
+ def copyBackupToDevice(self, deviceIp, backupName, memoryStick):
+ """ Copy a backup in the PC to some memory card inside the chosen device.
+
+ Attributes:
+ String deviceIp - String with ip address of device.
+ String backupName - Name of backup to be copied.
+ Int memoryStick - Integer representing which memory stick backup
+ should be copied to.
+ 0 - Removable memory stick
+ 1 - Internal memory stick
+ """
+ try:
+ self.loadBackups()
+ mountPoint = os.path.join(DEVICES_POINT, "%s/Root" % deviceIp)
+ utils.mountDevice(USER_HOST, deviceIp, mountPoint)
+
+ backup = self.getBackupInfo(backupName)
+ backupPath = os.path.join(str(backup.getPath()), str(backupName))
+ if memoryStick != 0 and memoryStick != 1:
+ return -1
+ destination = os.path.join(mountPoint, 'media/mmc%s' %
+ (memoryStick+1), 'backups', backupName)
+
+ self.setCopyInProgress(True)
+ if self.copy(backupPath, destination) == 0:
+ return 0
+ self.setCopyInProgress(False)
+ finally:
+ utils.unmountDevice(mountPoint)
+
+
+ def getBackupInfo(self, backupName):
+ for backupInfo in self._backupList:
+ if backupInfo.getName() == backupName:
+ return backupInfo
+ return None
+
+ def startBackupRestore(self, backupInfo, device_ip, categories):
+ return self.restoreBackup(backupInfo, device_ip, categories)
+
+ def setCopyInProgress(self, status):
+ self.copyInProgress = status
+
+ def setBackupInProgress(self, status):
+ self.backupInProgress = status
+
+
+ def setRestoreInProgress(self, status):
+ self.restoreInProgress = status
+
+ # FIXME: rewrite this method. Add error handling, some more reliable code
+ def _runCreateBackup(self, backup_name, path, host_ip, categories, comment=""):
+ """Create a backup and add it to _backupList.
+
+ Backup all files and directories of categories chosen. The device
+ system file is mounted on PC and them files are compressed in a zip
+ format. All zip files from each category are saved in the given path.
+
+ Arguments:
+ backup_name -- Backup's name. This name will be the name of the backup
+ folder.
+ path -- Location to save Backup file
+ host_ip -- The device IP address.
+ categories -- A python dictonary where the keys are the categories from
+ osso-backup, and the value can be either True or False, to identify
+ which categories to backup.
+ comment -- Any comment about the backup. It will be saved in Backup
+ object.
+
+ """
+
+ backupInfo = None
+ self.setBackupInProgress(True)
+ self.currentCategory = ""
+
+ try:
+ # Mount device folders
+ self.loadBackups()
+ mountPoint = os.path.join(DEVICES_POINT, "%s/Root" % host_ip)
+ utils.mountDevice(USER_HOST, host_ip, mountPoint)
+
+ # Create backup folder in the given path
+ self.backupPath = os.path.join(str(path), backup_name)
+ self._createBackupFolder(self.backupPath)
+
+ # Copying osso-backup configuration files to TabletSuite folder and
+ # parsing backup information from these files.
+ # ( Information = which paths should be in each backup category)
+ utils.copyOssoBackupConfigFiles(DEFAULT_CONFIG_PATH, mountPoint)
+ xmlParser = PcsBackupParser()
+ xmlParser.fillLocationsDict(DEFAULT_CONFIG_PATH)
+ backupItemDict = xmlParser.getLocationsDict()
+
+ # Changing work directory to ease file search. Keeping previous
+ # folder to come back after backup process.
+ current_dir = os.getcwd()
+ workPath = DEVICES_POINT + str(host_ip)
+ os.chdir(workPath)
+
+ # Computing total size that this backup will have.
+ self.totalSize = self._getTotalSize(backupItemDict, categories)
+
+
+ # Start backup process. Create backup of paths for each locations
+ # category
+ self.backedUpNumber = 0
+ filesByCategory = {}
+ for category in backupItemDict.keys():
+ self.currentCategory = category
+
+ for backupItem in backupItemDict[category]:
+ self._emitProgress()
+ # If current backupInfo category is valid and it's value is
+ # True in categories dictionary, add it to current backup.
+ if (category in categories) and (categories[category]):
+ categoryFilesNumber = 0
+ categoryFile = os.path.join(self.backupPath,
+ category + '.zip')
+
+ if os.path.exists(categoryFile):
+ zipfile = utils.openZip(categoryFile, 'a')
+ else:
+ zipfile = utils.openZip(categoryFile, 'w')
+
+ objPath = backupItem.path.replace('/','Root/',1)
+ backupFolder = os.path.join(workPath, objPath)
+ categoryFilesNumber = self.zipFolder(backupFolder,
+ zipfile, objPath,
+ category)
+ if categoryFilesNumber == -1:
+ os.chdir(current_dir)
+ return 0
+ self.backedUpNumber += categoryFilesNumber
+ self._emitProgress()
+
+ # Update the filesByCategory dictionary with the
+ # current number of files from current category that
+ # were already copied.
+ self._updateCategoryCount(filesByCategory, category,
+ categoryFilesNumber)
+ utils.closeZip(zipfile)
+ # If category had no file to copy remove its folder
+ if int(utils.getSize(categoryFile) == 0):
+ os.remove(categoryFile)
+
+
+ # Copying media files from device user folder if media category is
+ # True in categories dictionary.
+ if ("media" in categories) and (categories["media"]):
+ self.currentCategory = "media"
+ result = self._backupMedias(workPath)
+ if result == -1:
+ os.chdir(current_dir)
+ return 0
+ # Update backup files number count
+ self.backedUpNumber += result
+ self._updateCategoryCount(filesByCategory, "media", result)
+ zipPath = os.path.join(self.backupPath,'media.zip')
+ if int(utils.getSize(zipPath) == 0):
+ os.remove(zipPath)
+
+
+ # Copying documents files from device user folder if documents
+ # category is True in categories dictionary.
+ if ("documents" in categories) and (categories["documents"]):
+ self.currentCategory = "documents"
+ result = self._backupDocuments(workPath)
+ # Update backup files number count
+ self.backedUpNumber += result
+ if result == -1:
+ os.chdir(current_dir)
+ return 0
+ self._updateCategoryCount(filesByCategory, "documents",
+ result)
+ zipPath = os.path.join(self.backupPath, 'documents.zip')
+ if int(utils.getSize(zipPath) == 0):
+ os.remove(zipPath)
+
+
+ # Change to previous work directory
+ os.chdir(current_dir)
+
+ if self.backedUpNumber == 0:
+ utils.removePath(self.backupPath)
+ return -1
+
+ # Create Backup Object, add it to this manager backup list and save
+ # the list in the backup file.
+ backup_size = utils.getSize(self.backupPath)
+ backupInfo = PcsBackupInfo(backup_name, path, backup_size, comment)
+ backupInfo.setFilesNumber(self.backedUpNumber)
+ self._backupList.append(backupInfo)
+ self.saveBackups()
+
+ createXml(backupInfo, filesByCategory, host_ip)
+ self.setBackupInProgress(False)
+ finally:
+ utils.unmountDevice(mountPoint)
+
+ return backupInfo
+
+
+ def _backupDocuments(self, workPath):
+ """ Create backup of documents files in user folder. """
+ categoryFilesNumber = 0
+ destinationPath = os.path.join(self.backupPath,'documents.zip')
+ if os.path.exists(destinationPath):
+ zipfile = utils.openZip(destinationPath, 'a')
+ else:
+ zipfile = utils.openZip(destinationPath, 'w')
+
+ docsPath = os.path.join(self.myDocsPath, ".documents")
+
+ if os.path.exists(docsPath):
+ backupPath = os.path.join(workPath, docsPath)
+ categoryFilesNumber = self.zipFolder(backupPath, zipfile, docsPath,
+ "documents")
+
+ utils.closeZip(zipfile)
+ return categoryFilesNumber
+
+
+ def _backupMedias(self, workPath):
+ """ Create backup of media files in user folder. """
+ categoryFilesNumber = 0
+ destinationPath = os.path.join(self.backupPath,'media.zip')
+ if os.path.exists(destinationPath):
+ zipfile = utils.openZip(destinationPath, 'a')
+ else:
+ zipfile = utils.openZip(destinationPath, 'w')
+
+ userFilesPath = self.myDocsPath
+ if os.path.exists(os.path.join(userFilesPath)):
+ for folder in os.listdir(userFilesPath):
+ if folder != '.documents':
+ objPath = os.path.join(userFilesPath, folder)
+ backupDir = os.path.join(workPath, objPath)
+ result = self.zipFolder(backupDir, zipfile,
+ objPath, "media")
+ if result != -1:
+ categoryFilesNumber += result
+ else:
+ return result
+
+ utils.closeZip(zipfile)
+ return categoryFilesNumber
+
+
+ def _createBackupFolder(self, newBackupPath):
+ if not utils.createFolder(newBackupPath):
+ return False
+
+
+ def _emitProgress(self):
+ currentSize = utils.getSize(self.backupPath)
+ percentage = self.computePercentage(self.totalSize, currentSize)
+ self.emit(SIGNAL("backupProgress"), (percentage, self.currentCategory))
+
+
+ def _getTotalSize(self, backupFileDict, categories):
+ size = 0
+ for category in backupFileDict.keys():
+ for backupItem in backupFileDict[category]:
+ if (category in categories) and (categories[category]):
+ objPath = backupItem.path.replace('/','Root/',1)
+ size += utils.getSize(objPath)
+
+ if categories["documents"]:
+ size += utils.getSize(os.path.join(self.myDocsPath,
+ ".documents"))
+ if categories["media"]:
+ for folder in os.listdir(self.myDocsPath):
+ if folder != '.documents':
+ objPath = os.path.join(self.myDocsPath, folder)
+ size += utils.getSize(objPath)
+ return size
+
+ def _updateCategoryCount(self, filesByCategory, category, backed_up_number):
+ if str(category) not in filesByCategory.keys():
+ filesByCategory[category] = backed_up_number
+ else:
+ filesByCategory[category] += backed_up_number
+
+
+ def _verify_backup_name(self, backup_name):
+ """ Check if already exists any backup with the given name inside the
+ pc backup list. In case there is one, this function will return another
+ name to be set as the new backup name, else it will return the same
+ name that was given.
+
+ """
+ if self.getBackupInfo(backup_name) != None:
+ counter = 1
+ new_name = backup_name + "%02d" % counter
+ while(self.getBackupInfo(new_name)) != None:
+ counter += 1
+ new_name = backup_name + "%02d" % counter
+
+ backup_name = new_name
+ return backup_name
+
+ def zipFolder(self, path, zipfile, obj_path, category):
+ # Compress the folder from the given path, with all directories and
+ # files inside it
+ # zipfile: The ZipFile object to append the folder
+ # obj_path: The ZipFile path
+ count = 0
+ self._emitProgress()
+ if os.path.exists(path):
+ if os.path.isdir(path):
+ files = os.listdir(path)
+ for node in files:
+ if os.path.isdir(os.path.join(path, node)):
+ zipCount = self.zipFolder(os.path.join(path, node), zipfile,
+ os.path.join(obj_path, node), category)
+ if zipCount == -1:
+ return -1
+ else:
+ count += zipCount
+ else:
+ # Check if backup was canceled and return -1 case positive
+ if not self.backupInProgress:
+ utils.removePath(self.backupPath)
+ return -1
+
+ if utils.zip(zipfile, os.path.join(obj_path, node)):
+ count += 1
+ self._emitProgress()
+ else:
+ # Check if backup was canceled and return -1 case positive
+ if not self.backupInProgress:
+ utils.removePath(self.backupPath)
+ return -1
+
+ if utils.zip(zipfile, obj_path):
+ count += 1
+ self._emitProgress()
+ return count
+
+
+
+class NewBackupThread(QThread):
+ def __init__(self, manager, backupName, path, hostIp, categories, comment):
+ QThread.__init__(self)
+
+ self.manager = manager
+ self.backupName = backupName
+ self.path = path
+ self.hostIp = hostIp
+ self.categories = categories
+ self.comment = comment
+
+ def run(self):
+ ret = self.manager._runCreateBackup (self.backupName, self.path,
+ self.hostIp, self.categories,
+ str(self.comment))
+ self.manager.emit(SIGNAL("backupDone"), ret,
+ (self.manager.totalSize, self.manager.backedUpNumber))
+
+
+
\ No newline at end of file
projects / tablet-suite / blobdiff