mirror of
https://github.com/robweber/xbmcbackup.git
synced 2024-11-15 04:45:49 +01:00
637 lines
27 KiB
Python
637 lines
27 KiB
Python
from __future__ import unicode_literals
|
|
import time
|
|
import json
|
|
import xbmc
|
|
import xbmcgui
|
|
import xbmcvfs
|
|
import os.path
|
|
from . import utils as utils
|
|
from datetime import datetime
|
|
from . vfs import XBMCFileSystem, DropboxFileSystem, ZipFileSystem
|
|
from . progressbar import BackupProgressBar
|
|
from resources.lib.guisettings import GuiSettingsManager
|
|
from resources.lib.extractor import ZipExtractor
|
|
|
|
|
|
def folderSort(aKey):
|
|
result = aKey[0]
|
|
|
|
if(len(result) < 8):
|
|
result = result + "0000"
|
|
|
|
return result
|
|
|
|
|
|
class XbmcBackup:
|
|
# constants for initiating a back or restore
|
|
Backup = 0
|
|
Restore = 1
|
|
|
|
# list of dirs for the "simple" file selection
|
|
simple_directory_list = ['addons', 'addon_data', 'database', 'game_saves', 'playlists', 'profiles', 'thumbnails', 'config']
|
|
|
|
# file systems
|
|
xbmc_vfs = None
|
|
remote_vfs = None
|
|
saved_remote_vfs = None
|
|
|
|
restoreFile = None
|
|
remote_base_path = None
|
|
|
|
# for the progress bar
|
|
progressBar = None
|
|
transferSize = 0
|
|
transferLeft = 0
|
|
|
|
restore_point = None
|
|
skip_advanced = False # if we should check for the existance of advancedsettings in the restore
|
|
|
|
def __init__(self):
|
|
self.xbmc_vfs = XBMCFileSystem(xbmc.translatePath('special://home'))
|
|
|
|
self.configureRemote()
|
|
utils.log(utils.getString(30046))
|
|
|
|
def configureRemote(self):
|
|
if(utils.getSetting('remote_selection') == '1'):
|
|
self.remote_base_path = utils.getSetting('remote_path_2')
|
|
self.remote_vfs = XBMCFileSystem(utils.getSetting('remote_path_2'))
|
|
utils.setSetting("remote_path", "")
|
|
elif(utils.getSetting('remote_selection') == '0'):
|
|
self.remote_base_path = utils.getSetting('remote_path')
|
|
self.remote_vfs = XBMCFileSystem(utils.getSetting("remote_path"))
|
|
elif(utils.getSetting('remote_selection') == '2'):
|
|
self.remote_base_path = "/"
|
|
self.remote_vfs = DropboxFileSystem("/")
|
|
|
|
def remoteConfigured(self):
|
|
result = True
|
|
|
|
if(self.remote_base_path == ""):
|
|
result = False
|
|
|
|
return result
|
|
|
|
# reverse - should reverse the resulting, default is true - newest to oldest
|
|
def listBackups(self, reverse=True):
|
|
result = []
|
|
|
|
# get all the folders in the current root path
|
|
dirs, files = self.remote_vfs.listdir(self.remote_base_path)
|
|
|
|
for aDir in dirs:
|
|
if(self.remote_vfs.exists(self.remote_base_path + aDir + "/xbmcbackup.val")):
|
|
|
|
# format the name according to regional settings
|
|
folderName = self._dateFormat(aDir)
|
|
|
|
result.append((aDir, folderName))
|
|
|
|
for aFile in files:
|
|
file_ext = aFile.split('.')[-1]
|
|
folderName = aFile.split('.')[0]
|
|
|
|
if(file_ext == 'zip' and len(folderName) == 12 and folderName.isdigit()):
|
|
|
|
# format the name according to regional settings and display the file size
|
|
folderName = "%s - %s" % (self._dateFormat(folderName), utils.diskString(self.remote_vfs.fileSize(self.remote_base_path + aFile)))
|
|
|
|
result.append((aFile, folderName))
|
|
|
|
result.sort(key=folderSort, reverse=reverse)
|
|
|
|
return result
|
|
|
|
def selectRestore(self, restore_point):
|
|
self.restore_point = restore_point
|
|
|
|
def skipAdvanced(self):
|
|
self.skip_advanced = True
|
|
|
|
def backup(self, progressOverride=False):
|
|
shouldContinue = self._setupVFS(self.Backup, progressOverride)
|
|
|
|
if(shouldContinue):
|
|
utils.log(utils.getString(30023) + " - " + utils.getString(30016))
|
|
# check if remote path exists
|
|
if(self.remote_vfs.exists(self.remote_vfs.root_path)):
|
|
# may be data in here already
|
|
utils.log(utils.getString(30050))
|
|
else:
|
|
# make the remote directory
|
|
self.remote_vfs.mkdir(self.remote_vfs.root_path)
|
|
|
|
utils.log(utils.getString(30051))
|
|
utils.log('File Selection Type: ' + str(utils.getSetting('backup_selection_type')))
|
|
allFiles = []
|
|
|
|
if(utils.getSettingInt('backup_selection_type') == 0):
|
|
# read in a list of the directories to backup
|
|
selectedDirs = self._readBackupConfig(utils.addon_dir() + "/resources/data/default_files.json")
|
|
|
|
# simple mode - get file listings for all enabled directories
|
|
for aDir in self.simple_directory_list:
|
|
# if this dir enabled
|
|
if(utils.getSettingBool('backup_' + aDir)):
|
|
# get a file listing and append it to the allfiles array
|
|
allFiles.append(self._addBackupDir(aDir, selectedDirs[aDir]['root'], selectedDirs[aDir]['dirs']))
|
|
else:
|
|
# advanced mode - load custom paths
|
|
selectedDirs = self._readBackupConfig(utils.data_dir() + "/custom_paths.json")
|
|
|
|
# get the set names
|
|
keys = list(selectedDirs.keys())
|
|
|
|
# go through the custom sets
|
|
for aKey in keys:
|
|
# get the set
|
|
aSet = selectedDirs[aKey]
|
|
|
|
# get file listing and append
|
|
allFiles.append(self._addBackupDir(aKey, aSet['root'], aSet['dirs']))
|
|
|
|
# create a validation file for backup rotation
|
|
writeCheck = self._createValidationFile(allFiles)
|
|
|
|
if(not writeCheck):
|
|
# we may not be able to write to this destination for some reason
|
|
shouldContinue = xbmcgui.Dialog().yesno(utils.getString(30089), utils.getString(30090), utils.getString(30044), autoclose=25000)
|
|
|
|
if(not shouldContinue):
|
|
return
|
|
|
|
orig_base_path = self.remote_vfs.root_path
|
|
|
|
# backup all the files
|
|
self.transferLeft = self.transferSize
|
|
for fileGroup in allFiles:
|
|
self.xbmc_vfs.set_root(xbmc.translatePath(fileGroup['source']))
|
|
self.remote_vfs.set_root(fileGroup['dest'] + fileGroup['name'])
|
|
filesCopied = self._copyFiles(fileGroup['files'], self.xbmc_vfs, self.remote_vfs)
|
|
|
|
if(not filesCopied):
|
|
utils.showNotification(utils.getString(30092))
|
|
utils.log(utils.getString(30092))
|
|
|
|
# reset remote and xbmc vfs
|
|
self.xbmc_vfs.set_root("special://home/")
|
|
self.remote_vfs.set_root(orig_base_path)
|
|
|
|
if(utils.getSettingBool("compress_backups")):
|
|
fileManager = FileManager(self.xbmc_vfs)
|
|
|
|
# send the zip file to the real remote vfs
|
|
zip_name = self.remote_vfs.root_path[:-1] + ".zip"
|
|
self.remote_vfs.cleanup()
|
|
self.xbmc_vfs.rename(xbmc.translatePath("special://temp/xbmc_backup_temp.zip"), xbmc.translatePath("special://temp/" + zip_name))
|
|
fileManager.addFile(xbmc.translatePath("special://temp/" + zip_name))
|
|
|
|
# set root to data dir home and reset remote
|
|
self.xbmc_vfs.set_root(xbmc.translatePath("special://temp/"))
|
|
self.remote_vfs = self.saved_remote_vfs
|
|
|
|
# update the amount to transfer
|
|
self.transferSize = fileManager.fileSize()
|
|
self.transferLeft = self.transferSize
|
|
fileCopied = self._copyFiles(fileManager.getFiles(), self.xbmc_vfs, self.remote_vfs)
|
|
|
|
if(not fileCopied):
|
|
# zip archive copy filed, inform the user
|
|
shouldContinue = xbmcgui.Dialog().ok(utils.getString(30089), utils.getString(30090), utils.getString(30091))
|
|
|
|
# delete the temp zip file
|
|
self.xbmc_vfs.rmfile(xbmc.translatePath("special://temp/" + zip_name))
|
|
|
|
# remove old backups
|
|
self._rotateBackups()
|
|
|
|
# close any files
|
|
self._closeVFS()
|
|
|
|
def restore(self, progressOverride=False, selectedSets=None):
|
|
shouldContinue = self._setupVFS(self.Restore, progressOverride)
|
|
|
|
if(shouldContinue):
|
|
utils.log(utils.getString(30023) + " - " + utils.getString(30017))
|
|
|
|
# catch for if the restore point is actually a zip file
|
|
if(self.restore_point.split('.')[-1] == 'zip'):
|
|
self.progressBar.updateProgress(2, utils.getString(30088))
|
|
utils.log("copying zip file: " + self.restore_point)
|
|
|
|
# set root to data dir home
|
|
self.xbmc_vfs.set_root(xbmc.translatePath("special://temp/"))
|
|
|
|
if(not self.xbmc_vfs.exists(xbmc.translatePath("special://temp/" + self.restore_point))):
|
|
# copy just this file from the remote vfs
|
|
self.transferSize = self.remote_vfs.fileSize(self.remote_base_path + self.restore_point)
|
|
zipFile = []
|
|
zipFile.append({'file': self.remote_base_path + self.restore_point, 'size': self.transferSize})
|
|
|
|
# set transfer size
|
|
self.transferLeft = self.transferSize
|
|
self._copyFiles(zipFile, self.remote_vfs, self.xbmc_vfs)
|
|
else:
|
|
utils.log("zip file exists already")
|
|
|
|
# extract the zip file
|
|
zip_vfs = ZipFileSystem(xbmc.translatePath("special://temp/" + self.restore_point), 'r')
|
|
extractor = ZipExtractor()
|
|
|
|
if(not extractor.extract(zip_vfs, xbmc.translatePath("special://temp/"), self.progressBar)):
|
|
# we had a problem extracting the archive, delete everything
|
|
zip_vfs.cleanup()
|
|
self.xbmc_vfs.rmfile(xbmc.translatePath("special://temp/" + self.restore_point))
|
|
|
|
xbmcgui.Dialog().ok(utils.getString(30010), utils.getString(30101))
|
|
return
|
|
|
|
zip_vfs.cleanup()
|
|
|
|
self.progressBar.updateProgress(0, utils.getString(30049) + "......")
|
|
# set the new remote vfs and fix xbmc path
|
|
self.remote_vfs = XBMCFileSystem(xbmc.translatePath("special://temp/" + self.restore_point.split(".")[0] + "/"))
|
|
self.xbmc_vfs.set_root(xbmc.translatePath("special://home/"))
|
|
|
|
# for restores remote path must exist
|
|
if(not self.remote_vfs.exists(self.remote_vfs.root_path)):
|
|
xbmcgui.Dialog().ok(utils.getString(30010), utils.getString(30045), self.remote_vfs.root_path)
|
|
return
|
|
|
|
valFile = self._checkValidationFile(self.remote_vfs.root_path)
|
|
if(valFile is None):
|
|
# don't continue
|
|
return
|
|
|
|
utils.log(utils.getString(30051))
|
|
allFiles = []
|
|
fileManager = FileManager(self.remote_vfs)
|
|
|
|
# check for the existance of an advancedsettings file
|
|
if(self.remote_vfs.exists(self.remote_vfs.root_path + "config/advancedsettings.xml") and not self.skip_advanced):
|
|
# let the user know there is an advanced settings file present
|
|
restartXbmc = xbmcgui.Dialog().yesno(utils.getString(30038), utils.getString(30039), utils.getString(30040), utils.getString(30041))
|
|
|
|
if(restartXbmc):
|
|
# add only this file to the file list
|
|
fileManager.addFile(self.remote_vfs.root_path + "config/advancedsettings.xml")
|
|
self._copyFiles(fileManager.getFiles(), self.remote_vfs, self.xbmc_vfs)
|
|
|
|
# let the service know to resume this backup on startup
|
|
self._createResumeBackupFile()
|
|
|
|
# do not continue running
|
|
xbmcgui.Dialog().ok(utils.getString(30077), utils.getString(30078))
|
|
return
|
|
|
|
# use a multiselect dialog to select sets to restore
|
|
restoreSets = [n['name'] for n in valFile['directories']]
|
|
|
|
# if passed in list, skip selection
|
|
if(selectedSets is None):
|
|
selectedSets = xbmcgui.Dialog().multiselect(utils.getString(30131), restoreSets)
|
|
else:
|
|
selectedSets = [restoreSets.index(n) for n in selectedSets if n in restoreSets] # if set name not found just skip it
|
|
|
|
if(selectedSets is not None):
|
|
# go through each of the directories in the backup and write them to the correct location
|
|
for index in selectedSets:
|
|
|
|
# add this directory
|
|
aDir = valFile['directories'][index]
|
|
|
|
self.xbmc_vfs.set_root(xbmc.translatePath(aDir['path']))
|
|
if(self.remote_vfs.exists(self.remote_vfs.root_path + aDir['name'] + '/')):
|
|
# walk the directory
|
|
fileManager.walkTree(self.remote_vfs.root_path + aDir['name'] + '/')
|
|
self.transferSize = self.transferSize + fileManager.fileSize()
|
|
|
|
allFiles.append({"source": self.remote_vfs.root_path + aDir['name'], "dest": self.xbmc_vfs.root_path, "files": fileManager.getFiles()})
|
|
else:
|
|
utils.log("error path not found: " + self.remote_vfs.root_path + aDir['name'])
|
|
xbmcgui.Dialog().ok(utils.getString(30010), utils.getString(30045), self.remote_vfs.root_path + aDir['name'])
|
|
|
|
# restore all the files
|
|
self.transferLeft = self.transferSize
|
|
for fileGroup in allFiles:
|
|
self.remote_vfs.set_root(fileGroup['source'])
|
|
self.xbmc_vfs.set_root(fileGroup['dest'])
|
|
self._copyFiles(fileGroup['files'], self.remote_vfs, self.xbmc_vfs)
|
|
|
|
self.progressBar.updateProgress(99, "Clean up operations .....")
|
|
|
|
if(self.restore_point.split('.')[-1] == 'zip'):
|
|
# delete the zip file and the extracted directory
|
|
self.xbmc_vfs.rmfile(xbmc.translatePath("special://temp/" + self.restore_point))
|
|
self.xbmc_vfs.rmdir(self.remote_vfs.root_path)
|
|
|
|
# update the guisettings information (or what we can from it)
|
|
gui_settings = GuiSettingsManager()
|
|
gui_settings.run()
|
|
|
|
# call update addons to refresh everything
|
|
xbmc.executebuiltin('UpdateLocalAddons')
|
|
|
|
def _setupVFS(self, mode=-1, progressOverride=False):
|
|
# set windows setting to true
|
|
window = xbmcgui.Window(10000)
|
|
window.setProperty(utils.__addon_id__ + ".running", "true")
|
|
|
|
# append backup folder name
|
|
progressBarTitle = utils.getString(30010) + " - "
|
|
if(mode == self.Backup and self.remote_vfs.root_path != ''):
|
|
if(utils.getSettingBool("compress_backups")):
|
|
# delete old temp file
|
|
if(self.xbmc_vfs.exists(xbmc.translatePath('special://temp/xbmc_backup_temp.zip'))):
|
|
if(not self.xbmc_vfs.rmfile(xbmc.translatePath('special://temp/xbmc_backup_temp.zip'))):
|
|
# we had some kind of error deleting the old file
|
|
xbmcgui.Dialog().ok(utils.getString(30010), utils.getString(30096), utils.getString(30097))
|
|
return False
|
|
|
|
# save the remote file system and use the zip vfs
|
|
self.saved_remote_vfs = self.remote_vfs
|
|
self.remote_vfs = ZipFileSystem(xbmc.translatePath("special://temp/xbmc_backup_temp.zip"), "w")
|
|
|
|
self.remote_vfs.set_root(self.remote_vfs.root_path + time.strftime("%Y%m%d%H%M") + "/")
|
|
progressBarTitle = progressBarTitle + utils.getString(30023) + ": " + utils.getString(30016)
|
|
elif(mode == self.Restore and self.restore_point is not None and self.remote_vfs.root_path != ''):
|
|
if(self.restore_point.split('.')[-1] != 'zip'):
|
|
self.remote_vfs.set_root(self.remote_vfs.root_path + self.restore_point + "/")
|
|
progressBarTitle = progressBarTitle + utils.getString(30023) + ": " + utils.getString(30017)
|
|
else:
|
|
# kill the program here
|
|
self.remote_vfs = None
|
|
return False
|
|
|
|
utils.log(utils.getString(30047) + ": " + self.xbmc_vfs.root_path)
|
|
utils.log(utils.getString(30048) + ": " + self.remote_vfs.root_path)
|
|
|
|
# setup the progress bar
|
|
self.progressBar = BackupProgressBar(progressOverride)
|
|
self.progressBar.create(progressBarTitle, utils.getString(30049) + "......")
|
|
|
|
# if we made it this far we're good
|
|
return True
|
|
|
|
def _closeVFS(self):
|
|
self.xbmc_vfs.cleanup()
|
|
self.remote_vfs.cleanup()
|
|
self.progressBar.close()
|
|
|
|
# reset the window setting
|
|
window = xbmcgui.Window(10000)
|
|
window.setProperty(utils.__addon_id__ + ".running", "")
|
|
|
|
def _copyFiles(self, fileList, source, dest):
|
|
result = True
|
|
|
|
utils.log("Source: " + source.root_path)
|
|
utils.log("Destination: " + dest.root_path)
|
|
|
|
# make sure the dest folder exists - can cause write errors if the full path doesn't exist
|
|
if(not dest.exists(dest.root_path)):
|
|
dest.mkdir(dest.root_path)
|
|
|
|
for aFile in fileList:
|
|
if(not self.progressBar.checkCancel()):
|
|
if(utils.getSettingBool('verbose_logging')):
|
|
utils.log('Writing file: ' + aFile['file'])
|
|
|
|
if(aFile['file'].startswith("-")):
|
|
self._updateProgress('%s remaining, writing %s' % (utils.diskString(self.transferLeft), os.path.basename(aFile['file'][len(source.root_path):]) + "/"))
|
|
dest.mkdir(dest.root_path + aFile['file'][len(source.root_path) + 1:])
|
|
else:
|
|
self._updateProgress('%s remaining, writing %s' % (utils.diskString(self.transferLeft), os.path.basename(aFile['file'][len(source.root_path):])))
|
|
self.transferLeft = self.transferLeft - aFile['size']
|
|
|
|
wroteFile = True
|
|
destFile = dest.root_path + aFile['file'][len(source.root_path):]
|
|
if(isinstance(source, DropboxFileSystem)):
|
|
# if copying from cloud storage we need the file handle, use get_file
|
|
wroteFile = source.get_file(aFile['file'], destFile)
|
|
else:
|
|
# copy using normal method
|
|
wroteFile = dest.put(aFile['file'], destFile)
|
|
|
|
# if result is still true but this file failed
|
|
if(not wroteFile and result):
|
|
result = False
|
|
|
|
return result
|
|
|
|
def _addBackupDir(self, folder_name, root_path, dirList):
|
|
utils.log('Backup set: ' + folder_name)
|
|
fileManager = FileManager(self.xbmc_vfs)
|
|
|
|
self.xbmc_vfs.set_root(xbmc.translatePath(root_path))
|
|
for aDir in dirList:
|
|
fileManager.addDir(aDir)
|
|
|
|
# walk all the root trees
|
|
fileManager.walk()
|
|
|
|
# update total size
|
|
self.transferSize = self.transferSize + fileManager.fileSize()
|
|
|
|
return {"name": folder_name, "source": root_path, "dest": self.remote_vfs.root_path, "files": fileManager.getFiles()}
|
|
|
|
def _dateFormat(self, dirName):
|
|
# create date_time object from foldername YYYYMMDDHHmm
|
|
date_time = datetime(int(dirName[0:4]), int(dirName[4:6]), int(dirName[6:8]), int(dirName[8:10]), int(dirName[10:12]))
|
|
|
|
# format the string based on region settings
|
|
result = utils.getRegionalTimestamp(date_time, ['dateshort', 'time'])
|
|
|
|
return result
|
|
|
|
def _updateProgress(self, message=None):
|
|
self.progressBar.updateProgress(int((float(self.transferSize - self.transferLeft) / float(self.transferSize)) * 100), message)
|
|
|
|
def _rotateBackups(self):
|
|
total_backups = utils.getSettingInt('backup_rotation')
|
|
|
|
if(total_backups > 0):
|
|
# get a list of valid backup folders
|
|
dirs = self.listBackups(reverse=False)
|
|
|
|
if(len(dirs) > total_backups):
|
|
# remove backups to equal total wanted
|
|
remove_num = 0
|
|
|
|
# update the progress bar if it is available
|
|
while(remove_num < (len(dirs) - total_backups) and not self.progressBar.checkCancel()):
|
|
self._updateProgress(utils.getString(30054) + " " + dirs[remove_num][1])
|
|
utils.log("Removing backup " + dirs[remove_num][0])
|
|
|
|
if(dirs[remove_num][0].split('.')[-1] == 'zip'):
|
|
# this is a file, remove it that way
|
|
self.remote_vfs.rmfile(self.remote_vfs.clean_path(self.remote_base_path) + dirs[remove_num][0])
|
|
else:
|
|
self.remote_vfs.rmdir(self.remote_vfs.clean_path(self.remote_base_path) + dirs[remove_num][0] + "/")
|
|
|
|
remove_num = remove_num + 1
|
|
|
|
def _createValidationFile(self, dirList):
|
|
valInfo = {"name": "XBMC Backup Validation File", "xbmc_version": xbmc.getInfoLabel('System.BuildVersion'), "type": 0}
|
|
valDirs = []
|
|
|
|
for aDir in dirList:
|
|
valDirs.append({"name": aDir['name'], "path": aDir['source']})
|
|
valInfo['directories'] = valDirs
|
|
|
|
vFile = xbmcvfs.File(xbmc.translatePath(utils.data_dir() + "xbmcbackup.val"), 'w')
|
|
vFile.write(json.dumps(valInfo))
|
|
vFile.write("")
|
|
vFile.close()
|
|
|
|
success = self.remote_vfs.put(xbmc.translatePath(utils.data_dir() + "xbmcbackup.val"), self.remote_vfs.root_path + "xbmcbackup.val")
|
|
|
|
# remove the validation file
|
|
xbmcvfs.delete(xbmc.translatePath(utils.data_dir() + "xbmcbackup.val"))
|
|
|
|
if(success):
|
|
# android requires a .nomedia file to not index the directory as media
|
|
if(not xbmcvfs.exists(xbmc.translatePath(utils.data_dir() + ".nomedia"))):
|
|
nmFile = xbmcvfs.File(xbmc.translatePath(utils.data_dir() + ".nomedia"), 'w')
|
|
nmFile.close()
|
|
|
|
success = self.remote_vfs.put(xbmc.translatePath(utils.data_dir() + ".nomedia"), self.remote_vfs.root_path + ".nomedia")
|
|
|
|
return success
|
|
|
|
def _checkValidationFile(self, path):
|
|
result = None
|
|
|
|
# copy the file and open it
|
|
if(isinstance(self.remote_vfs, DropboxFileSystem)):
|
|
self.remote_vfs.get_file(path + "xbmcbackup.val", xbmc.translatePath(utils.data_dir() + "xbmcbackup_restore.val"))
|
|
else:
|
|
self.xbmc_vfs.put(path + "xbmcbackup.val", xbmc.translatePath(utils.data_dir() + "xbmcbackup_restore.val"))
|
|
|
|
with xbmcvfs.File(xbmc.translatePath(utils.data_dir() + "xbmcbackup_restore.val"), 'r') as vFile:
|
|
jsonString = vFile.read()
|
|
|
|
# delete after checking
|
|
xbmcvfs.delete(xbmc.translatePath(utils.data_dir() + "xbmcbackup_restore.val"))
|
|
|
|
try:
|
|
result = json.loads(jsonString)
|
|
|
|
if(xbmc.getInfoLabel('System.BuildVersion') != result['xbmc_version']):
|
|
shouldContinue = xbmcgui.Dialog().yesno(utils.getString(30085), utils.getString(30086), utils.getString(30044))
|
|
|
|
if(not shouldContinue):
|
|
result = None
|
|
|
|
except ValueError:
|
|
# may fail on older archives
|
|
result = None
|
|
|
|
return result
|
|
|
|
def _createResumeBackupFile(self):
|
|
with xbmcvfs.File(xbmc.translatePath(utils.data_dir() + "resume.txt"), 'w') as f:
|
|
f.write(self.restore_point)
|
|
|
|
def _readBackupConfig(self, aFile):
|
|
with xbmcvfs.File(xbmc.translatePath(aFile), 'r') as f:
|
|
jsonString = f.read()
|
|
return json.loads(jsonString)
|
|
|
|
|
|
class FileManager:
|
|
not_dir = ['.zip', '.xsp', '.rar']
|
|
exclude_dir = []
|
|
root_dirs = []
|
|
pathSep = '/'
|
|
totalSize = 0
|
|
|
|
def __init__(self, vfs):
|
|
self.vfs = vfs
|
|
self.fileArray = []
|
|
self.exclude_dir = []
|
|
self.root_dirs = []
|
|
|
|
def walk(self):
|
|
|
|
for aDir in self.root_dirs:
|
|
self.addFile('-' + xbmc.translatePath(aDir['path']))
|
|
self.walkTree(xbmc.translatePath(aDir['path']), aDir['recurse'])
|
|
|
|
def walkTree(self, directory, recurse=True):
|
|
if(utils.getSettingBool('verbose_logging')):
|
|
utils.log('walking ' + directory + ', recurse: ' + str(recurse))
|
|
|
|
if(directory[-1:] == '/' or directory[-1:] == '\\'):
|
|
directory = directory[:-1]
|
|
|
|
if(self.vfs.exists(directory + self.pathSep)):
|
|
dirs, files = self.vfs.listdir(directory)
|
|
|
|
if(recurse):
|
|
# create all the subdirs first
|
|
for aDir in dirs:
|
|
dirPath = xbmcvfs.validatePath(xbmc.translatePath(directory + self.pathSep + aDir))
|
|
file_ext = aDir.split('.')[-1]
|
|
|
|
# check if directory is excluded
|
|
if(not any(dirPath.startswith(exDir) for exDir in self.exclude_dir)):
|
|
|
|
self.addFile("-" + dirPath)
|
|
|
|
# catch for "non directory" type files
|
|
shouldWalk = True
|
|
|
|
for s in file_ext:
|
|
if(s in self.not_dir):
|
|
shouldWalk = False
|
|
|
|
if(shouldWalk):
|
|
self.walkTree(dirPath)
|
|
|
|
# copy all the files
|
|
for aFile in files:
|
|
filePath = xbmc.translatePath(directory + self.pathSep + aFile)
|
|
self.addFile(filePath)
|
|
|
|
def addDir(self, dirMeta):
|
|
if(dirMeta['type'] == 'include'):
|
|
self.root_dirs.append({'path': dirMeta['path'], 'recurse': dirMeta['recurse']})
|
|
else:
|
|
self.excludeFile(xbmc.translatePath(dirMeta['path']))
|
|
|
|
def addFile(self, filename):
|
|
# write the full remote path name of this file
|
|
if(utils.getSettingBool('verbose_logging')):
|
|
utils.log("Add File: " + filename)
|
|
|
|
# get the file size
|
|
fSize = self.vfs.fileSize(filename)
|
|
self.totalSize = self.totalSize + fSize
|
|
|
|
self.fileArray.append({'file': filename, 'size': fSize})
|
|
|
|
def excludeFile(self, filename):
|
|
# remove trailing slash
|
|
if(filename[-1] == '/' or filename[-1] == '\\'):
|
|
filename = filename[:-1]
|
|
|
|
# write the full remote path name of this file
|
|
utils.log("Exclude File: " + filename)
|
|
self.exclude_dir.append(filename)
|
|
|
|
def getFiles(self):
|
|
result = self.fileArray
|
|
self.fileArray = []
|
|
self.root_dirs = []
|
|
self.exclude_dir = []
|
|
self.totalSize = 0
|
|
|
|
return result
|
|
|
|
def totalFiles(self):
|
|
return len(self.fileArray)
|
|
|
|
def fileSize(self):
|
|
return self.totalSize
|