def __init__(self, srcRoot, storageRoot, stateStoragePath = 'd:/state.txt', tmpStorageRoot = 'd:/tmp/removeAfterComplete', decCopier = encryptionStorageBase.arc4DecSimpleCopier('defaultPass')): misc.ensureDir(tmpStorageRoot) misc.ensureDir(storageRoot) zipStorage.zipStorage.__init__(self, srcRoot, storageRoot, stateStoragePath) self.tmpStorageRoot = transform.transformDirToInternal(tmpStorageRoot) self.decCopier = decCopier
def backupDbSingle(dbName, targetDir, password, user): if user is None: dbSysInst = dbSys.dbSysSmart() else: dbSysInst = dbSys.dbSysSmart(sessionBase.sessionInstanceBase(user)) db = dbSysInst.getDb(dbName) res = [] e = enc.encryptor() if not os.path.exists(targetDir): misc.ensureDir(targetDir) for i in db.keys(): #print i #values = db.testFunc(i) values = db[i] encryptedValues = [] for i in values: print i.encode('gbk', 'replace') encryptedValues.append(e.en(i, password)) j = {"key":e.en(i, password), "value":encryptedValues, "encHash":unicode(md5.new(password).hexdigest())} res.append(j) #print res s = json.dumps(res, sort_keys=True, indent=4) f = open(os.path.join(targetDir, dbName+'_for_user_'+str(user)+'.json'),'w') f.write(s) f.close()
def __init__(self, lastState, workingDir, zipStorageDir, passwd): self.lastState = zipStorageLocalState(lastState) self.zipContentState = {} self.workingDir = workingDir + '/zipfiles' self.decryptionWorkingDir = workingDir + '/decrypted' self.zipStorageDir = zipStorageDir self.passwd = passwd self.encCopier = encryptionStorageBase.arc4EncSimpleCopier(passwd) self.decCopier = encryptionStorageBase.arc4DecSimpleCopier(passwd) misc.ensureDir(self.workingDir) misc.ensureDir(self.decryptionWorkingDir) ######################################## #Internal used vars ######################################## #The current zipfile object self.curArchive = None #Not necessary init as it will be inited with self.curArchive #The current archived size self.curArchivedSize = 0 #The info of files in the current zip file self.zippedFileInfo = {} #The info of the whole storage self.zipStorageState = None
def encInfoZip(self, pendingCollection): ############################ # Save info for zipped files ############################ logFilePath = transform.transformDirToInternal( fileTools.getTimestampWithFreeName(self.workingDir, '.log')) s = json.dumps(self.zippedFileInfo, sort_keys=True, indent=4) f = open(logFilePath,'w') f.write(s) f.close() logZipPath = logFilePath.replace(u'.log',u'.log.zip') logZip = zipClass.ZFile(logZipPath, 'w') logZip.addfile(unicode(logFilePath), os.path.basename(logFilePath)) logZip.close() gTimeV = time.gmtime() yearStr = time.strftime("%Y", gTimeV) monthStr = time.strftime("%m", gTimeV) dayStr = time.strftime("%d", gTimeV) dateTimeDir = yearStr+"/"+monthStr+"/"+dayStr newEncDir = unicode(os.path.join(self.zipStorageDir, dateTimeDir)) misc.ensureDir(newEncDir) targetPath = transform.transformDirToInternal( fileTools.getTimestampWithFreeName(newEncDir, '.enc')) self.encCopier.copy(logZipPath, targetPath.replace('.enc', '.encziplog')) ############################ # Update state in storage state ############################ self.updateZipLog(self.zippedFileInfo, pendingCollection) #Clean the current zipped file info self.zippedFileInfo = {}
def store(self, item): #Check if the item in folder storage is newer than the target one relaPath = item.getRelaPath() localFullPath = os.path.join(self.rootDir, relaPath) localItem = folderStorageItem(self.rootDir, localFullPath) extItem = externalItem(self.rootDir, localFullPath, item.getItemInfo()) extItemLocalCopy = folderStorageItem(self.rootDir, localFullPath, self.lastState.getItemState(item)) localPathDir = os.path.dirname(localFullPath) fullPath = item.getFullPath() if (not os.path.exists(localFullPath)): #Copy the updated file to local path misc.ensureDir(localPathDir) item.saveTo(self.rootDir) #Check if the timestamp are updated if localItem.getTimestamp() != extItem.timestamp(): raise 'not work as expected, need to manually update time for local copy' self.lastState.update(extItem) elif self.lastState.updated(item): #print 'item updated:', item.getRelaPath() #The item has been updated, check content if isSameItems(item, localItem): print 'same, ignore:', fullPath.encode('gbk','replace'), localFullPath.encode('gbk','replace') #Need to update the item state self.lastState.update(extItem) else: #Seems external storage and local storage both updated this file. What to do? Ignore for now? pass else: #Not updated, check if the 2 items are same if isSameItems(item, extItemLocalCopy): print 'According to saved state, same, ignore:', fullPath.encode('gbk','replace'), localFullPath.encode('gbk','replace') #Need to update the item state self.lastState.update(extItem) elif extItemLocalCopy.isExternal(): #It is an external file, check time if (extItemLocalCopy.getExtTs() < item.getTimestamp()): #External storage has updated the item, update the local one backupFullPath = fileTools.getFreeNameFromFullPath(os.path.join(self.backupDir, relaPath)) backupPathDir = os.path.dirname(backupFullPath) misc.ensureDir(backupPathDir) shutil.move(localFullPath, backupFullPath) #Copy the updated file to local path misc.ensureDir(localPathDir) item.saveTo(self.rootDir) self.lastState.update(extItem) else: if extItemLocalCopy.getTimestamp < item.getTimestamp(): #External storage has updated the item, update the local one backupFullPath = fileTools.getFreeNameFromFullPath(os.path.join(self.backupDir, relaPath)) backupPathDir = os.path.dirname(backupFullPath) misc.ensureDir(backupPathDir) shutil.move(localFullPath, backupFullPath) #Copy the updated file to local path misc.ensureDir(localPathDir) item.saveTo(self.rootDir) self.lastState.update(extItem)
def store(self, item, pendingCollection): #Check if the item in folder storage is newer than the target one relaPath = item.getRelaPath() localFullPath = os.path.join(self.rootDir, relaPath) localPathDir = os.path.dirname(localFullPath) localItem = folderStorage.folderStorageItem(self.rootDir, localFullPath) extItem = folderStorage.externalItem(self.rootDir, localFullPath, item.getItemInfo()) #This item stores the item info in local collection. It will be used to check #if the item is changed after the last write from external storage info = self.lastState.getItemState(localItem) if info is None: info = {} extItemLocalCopy = folderStorage.folderStorageItem(self.rootDir, localFullPath, info) if (not os.path.exists(localFullPath)): cl('item does not exist, add it') #Copy the updated file to local path misc.ensureDir(localPathDir) item.saveTo(self.rootDir) #Check if the timestamp are updated if localItem.getTimestamp() != extItem.timestamp(): raise 'not work as expected, need to manually update time for local copy' self.lastState.update(extItem) elif self.lastState.updated(localItem): ncl('item updated, check it') if extItemLocalCopy.isExternal(): ncl("External obj") #It is an external file, check time if (extItemLocalCopy.getExtTs() < item.getTimestamp()): ncl("External storage has updated the item, update the local one") #External storage has updated the item, update the local one backupFullPath = fileTools.getFreeNameFromFullPath(os.path.join(self.backupDir, relaPath)) backupPathDir = os.path.dirname(backupFullPath) misc.ensureDir(backupPathDir) shutil.move(localFullPath, backupFullPath) #Copy the updated file to local path misc.ensureDir(localPathDir) item.saveTo(self.rootDir) self.lastState.update(extItem) else: if extItemLocalCopy.getTimestamp() < item.getTimestamp(): #External storage has updated the item, update the local one cl(extItemLocalCopy.getTimestamp() , item.getTimestamp()) backupFullPath = fileTools.getFreeNameFromFullPath(os.path.join(self.backupDir, relaPath)) backupPathDir = os.path.dirname(backupFullPath) misc.ensureDir(backupPathDir) shutil.move(localFullPath, backupFullPath) #Copy the updated file to local path misc.ensureDir(localPathDir) item.saveTo(self.rootDir) self.lastState.update(extItem) else: ncl("The item need to be stored is not newer than the local one, the info for local item will be updated") self.lastState.updateLocal(localItem)
def getStorgePathWithDateFolder(rootPath, ext = ".enc"): gTimeV = time.gmtime() yearStr = time.strftime("%Y", gTimeV) monthStr = time.strftime("%m", gTimeV) dayStr = time.strftime("%d", gTimeV) dateTimeDir = yearStr+"/"+monthStr+"/"+dayStr newEncDir = unicode(os.path.join(rootPath, dateTimeDir)) misc.ensureDir(newEncDir) targetPath = transform.transformDirToInternal( fileTools.getTimestampWithFreeName(newEncDir, ext)) return targetPath
def __init__(self, taskId, appUuid, collectionId, workingDir, passwd, targetCollection): processorBase.cacheCollectionProcessorBase.__init__(self, taskId, appUuid, collectionId) #This dir stores zip files which were decrypted self.workingDir = workingDir self.decryptionWorkingDir = workingDir + '/decrypted' misc.ensureDir(self.decryptionWorkingDir) self.logCollectionId = self.appConfigObj["logCollectionId"] self.logCollection = collectionDatabase.collectionOnMongoDbBase(self.logCollectionId, self.db.getCollectionDb()) self.targetCollection = targetCollection self.passwd = passwd self.encCopier = encryptionStorageBase.arc4EncSimpleCopier(passwd) self.decCopier = encryptionStorageBase.arc4DecSimpleCopier(passwd)
def __init__ ( self, tubeName, workingDir = "d:/tmp/working/zippedCollectionListHandler", passwd = '123'): misc.ensureDir(workingDir) super(zippedCollectionListHandler, self).__init__(tubeName) threading.Thread.__init__(self) # Stores collection instance for given monitoring path, all zipped objects # in this monitoring path will be stored in this collection self.collectionInDbForMonitoringPath = {} self.dbInst = objectDatabase.objectDatabase() self.workingDir = workingDir self.encCopier = encryptionStorageBase.arc4EncSimpleCopier(passwd) self.decCopier = encryptionStorageBase.arc4DecSimpleCopier(passwd) self.zippedInfoCollectionList = collectionDatabase.collectionOnMongoDbBase(gZippedInfoCollectionId, self.dbInst.getCollectionDb())
def processItem(self, job, item): #fullPath = transform.transformDirToInternal(item["fullPath"]) #monitoringFullPath = transform.transformDirToInternal(item["monitoringPath"]) workingDir = item["workingDir"] misc.ensureDir(workingDir) inputTubeName = item["inputTubeName"] if self.taskDict.has_key(inputTubeName): job.delete() return False t = fileArchiveThread(inputTubeName, self.storageClass(workingDir)) self.taskDict[inputTubeName] = t t.start() return True
def initParam(self, zipDir, folderDir, workingDir, encryptionPass, direction): ################################# #Make dir if not exist ################################# misc.ensureDir(zipDir) misc.ensureDir(workingDir) misc.ensureDir(folderDir) self.configPath = os.path.join(workingDir, 'workingState.txt') self.backupPath = os.path.join(workingDir, 'backup') misc.ensureDir(self.backupPath) self.tmpStorageRoot = transform.transformDirToInternal(os.path.join(workingDir, 'working')) self.config = configDict.configFileDict(self.configPath, {"zipStorageState":{}, "folderState":{}}) ################################# #Create source storage ################################# self.storage1 = encZipStorage.encZipStorage(self.config["zipStorageState"], self.tmpStorageRoot, zipDir, encryptionPass) ################################# #Create target storage ################################# self.storage2 = folderStorage.folderStorage(self.config["folderState"], folderDir, self.backupPath) if direction == "extract": self.srcStorage = self.storage1 self.dstStorage = self.storage2 else: self.srcStorage = self.storage2 self.dstStorage = self.storage1
def store(self, item): #Check if the item in folder storage is newer than the target one fullPath = item.getFullPath() relaPath = item.getRelaPath() localFullPath = os.path.join(self.rootDir, relaPath) localItem = folderStorageItem(self.rootDir, localFullPath) localPathDir = os.path.dirname(localFullPath) if (not os.path.exists(localFullPath)): #Copy the updated file to local path misc.ensureDir(localPathDir) shutil.move(fullPath, localFullPath) #print localFullPath self.lastState.update(item) elif isSameItems(item, localItem): print 'same, ignore:', fullPath, localFullPath elif isItem1Newer(item, localItem): #The file need to be stored is newer, copy the older file to backup storage backupFullPath = fileTools.getFreeNameFromFullPath(os.path.join(self.backupDir, relaPath)) backupPathDir = os.path.dirname(backupFullPath) misc.ensureDir(backupPathDir) shutil.move(localFullPath, backupFullPath) #Copy the updated file to local path misc.ensureDir(localPathDir) shutil.copy(fullPath, localFullPath) self.lastState.update(item) else: #The file need to be stored is old, copy it to backup storage backupFullPath = fileTools.getFreeNameFromFullPath(os.path.join(self.backupDir, relaPath)) backupPathDir = os.path.dirname(backupFullPath) misc.ensureDir(backupPathDir) shutil.copy(fullPath, backupPathDir)
def createNewZip(self): #################### # Create new zip file #################### gTimeV = time.gmtime() yearStr = time.strftime("%Y", gTimeV) monthStr = time.strftime("%m", gTimeV) dayStr = time.strftime("%d", gTimeV) dateTimeDir = yearStr+"/"+monthStr+"/"+dayStr newEncDir = unicode(os.path.join(self.zipStorageDir, dateTimeDir)) misc.ensureDir(newEncDir) self.curArchiveName = transform.transformDirToInternal( fileTools.getTimestampWithFreeName(self.workingDir, '.zip')) self.targetPath = transform.transformDirToInternal( fileTools.getTimestampWithFreeName(newEncDir, '.enc')) cl("Creating new zip file", self.curArchiveName) self.curArchive = zipClass.ZFile(self.curArchiveName, 'w') self.curArchivedSize = 0
def __init__(self, collectionId, logCollectionId, workingDir, passwd, dbInst): ''' collectionId is the ID of the enc zip storage collection, it should be the dir path storing the enc zip files, and it will be used to retieve all enc zip files. ''' super(encZipInfoCollection, self).__init__(collectionId, logCollectionId, workingDir, passwd, dbInst) ######################################## #Internal used vars ######################################## #The info of files in the current zip file self.zippedFileInfo = {} #File count for the current info storage, encZipCollection does #not have this self.fileCnt = 0 self.zipStorageDir = transform.transformDirToInternal(collectionId) misc.ensureDir(self.zipStorageDir)
def backupDbSingle(dbName, targetDir, password, user, afterTimeStamp, beforeTimeStamp): if user is None: dbSysInst = dbSys.dbSysSmart() else: dbSysInst = dbSys.dbSysSmart(sessionBase.sessionInstanceBase(user)) db = dbSysInst.getDb(dbName) res = [] if not os.path.exists(targetDir): misc.ensureDir(targetDir) for i in db.keysDuring(afterTimeStamp, beforeTimeStamp): #print i #values = db.testFunc(i) values = db[i] j = {"db": dbName, "user": user, "key":i, "value":values, "t": beforeTimeStamp} res.append(j) return res
def __init__(self, collectionId, logCollectionId, workingDir, passwd, dbInst): ''' collectionId is the ID of the enc zip storage collection, it should be the dir path storing the enc zip files, and it will be used to retieve all enc zip files. ''' encZipStorageCollectionEnum.encZipStorageCollectionEnum.__init__(self, collectionId, logCollectionId, workingDir, passwd, dbInst) ######################################## #Internal used vars ######################################## #The current zipfile object self.curArchive = None #Not necessary init as it will be inited with self.curArchive #The current archived size self.curArchivedSize = 0 #The info of files in the current zip file self.zippedFileInfo = {} self.zipStorageDir = transform.transformDirToInternal(collectionId) misc.ensureDir(self.zipStorageDir)
def store(self, item, pendingCollection): #Check if the item in folder storage is newer than the target one relaPath = item["idInCol"] localFullPath = transform.transformDirToInternal(os.path.join(self.rootDir, relaPath)) localPathDir = transform.transformDirToInternal(os.path.dirname(localFullPath)) #Check the updates of the object is done in advCollectionProcess. #When we come here, the item is for sure needed for update #Backup if it exists if os.path.exists(localFullPath): backupFullPath = fileTools.getFreeNameFromFullPath(os.path.join(self.backupDir, relaPath)) backupPathDir = os.path.dirname(backupFullPath) misc.ensureDir(backupPathDir) shutil.move(localFullPath, backupFullPath) misc.ensureDir(localPathDir) item.saveTo(self.rootDir) ################################# #Update collection info ################################# #Remove the legacy timestamp objInfo = copy.copy(item.getItemInfo()) if objInfo.has_key("timestamp"): objInfo["externalTimestamp"] = objInfo["timestamp"] del objInfo["timestamp"] obj = objectDatabase.fsObjBase(localFullPath, objInfo) #ncl(obj.getItemInfo()) #print type(obj.getItemInfo()) #ncl(self.objDb.getDbObj(obj.getItemObjUrl())) itemUuid = self.objDb.addDbObj(obj.getObjUrl(), obj.getItemInfo()) ncl("collection obj uuid:", itemUuid) #ncl(self.objDb.getDbObj(obj.getItemObjUrl())) self.updateObjUuid(item["idInCol"], itemUuid) return True
def __init__(self, lastState, workingDir, zipStorageDir, passwd): self.lastState = folderStorage.folderStorageState(lastState) #self.selfState = folderStorage.folderStorageState({}) self.zipContentState = {} self.workingDir = workingDir + '/zipfiles' self.decryptionWorkingDir = workingDir + '/decrypted' self.zipStorageDir = zipStorageDir self.passwd = passwd self.encCopier = encryptionStorageBase.arc4EncSimpleCopier(passwd) self.decCopier = encryptionStorageBase.arc4DecSimpleCopier(passwd) misc.ensureDir(self.workingDir) misc.ensureDir(self.decryptionWorkingDir) ######################################## #Internal used vars ######################################## self.curArchive = None #Not necessary init as it will be inited with self.curArchive self.curArchivedSize = 0 self.zippedFileInfo = {} self.zipStorageState = None
def __init__(self, collectionId, logCollectionId, workingDir, passwd, dbInst): ''' collectionId is the id of a collection contains all enc zip files logCollectionId is the id of a collection contains all extracted info ''' self.objDb = dbInst self.collectionDbInst = dbInst.getCollectionDb() #This dir stores zip files which were decrypted self.workingDir = workingDir self.decryptionWorkingDir = workingDir + '/decrypted' misc.ensureDir(self.decryptionWorkingDir) #This is the folder collection that contains all encrypted zip files self.collectionId = collectionId ncl(collectionId) self.collection = folderRecursiveEnumCollection.folderRecursiveEnumCollection(self.collectionId, dbInst) #This is the log collection which stores all extracted info, these info may #be extracted every time the folder is scaned, but it'll be better to store them for future use self.logCollectionId = logCollectionId self.logCollection = collectionDatabase.collectionOnMongoDbBase(self.logCollectionId, self.collectionDbInst) self.passwd = passwd self.encCopier = encryptionStorageBase.arc4EncSimpleCopier(passwd) self.decCopier = encryptionStorageBase.arc4DecSimpleCopier(passwd)
def __init__(self, taskName): #print taskName taskInterface.localTaskBase.__init__(self, taskName) parser = OptionParser() parser.add_option("-f", "--folder", action="store",help="copy from which directory") parser.add_option("-p", "--encryptionPass", action="store",help="encryption password") parser.add_option("-z", "--zipDir", action="store", help="target directory") #parser.add_option("-c", "--configPath", action="store", help="path for the config file") parser.add_option("-w", "--workingPath", action="store", help="path for temp file") #parser.add_option("-b", "--backupPath", action="store", help="path for backup files") parser.add_option("-d", "--direction", action="store", help="syncDirection") (options, args) = parser.parse_args() self.options = options ################################# #Make dir if not exist ################################# misc.ensureDir(options.zipDir) misc.ensureDir(options.workingPath) misc.ensureDir(self.options.folder) self.configPath = os.path.join(options.workingPath, 'workingState.txt') self.backupPath = os.path.join(options.workingPath, 'backup') misc.ensureDir(self.backupPath) self.tmpStorageRoot = transform.transformDirToInternal(os.path.join(options.workingPath, 'working')) self.config = configDict.configFileDict(self.configPath, {"zipStorageState":{}, "folderState":{}}) ################################# #Create source storage ################################# self.storage1 = encZipStorage.encZipStorage(self.config["zipStorageState"], self.tmpStorageRoot, self.options.zipDir, self.options.encryptionPass) ################################# #Create target storage ################################# self.storage2 = folderStorage.folderStorage(self.config["folderState"], self.options.folder, self.backupPath) if self.options.direction == "extract": self.srcStorage = self.storage1 self.dstStorage = self.storage2 else: self.srcStorage = self.storage2 self.dstStorage = self.storage1
def __init__(self, taskName): #print taskName taskInterface.localTaskBase.__init__(self, taskName) parser = OptionParser() parser.add_option("-s", "--sourceDir", action="store",help="copy from which directory") parser.add_option("-p", "--encryptionPass", action="store",help="encryption password") parser.add_option("-t", "--targetDir", action="store", help="target directory") parser.add_option("-c", "--configPath", action="store", help="path for the config file") parser.add_option("-w", "--workingPath", action="store", help="path for temp file") (options, args) = parser.parse_args() self.options = options self.configPath = options.configPath self.config = configDict.configFileDict(options.configPath, {'timestamp':{}}) misc.ensureDir(options.targetDir) self.objList = dirTreeGenerator(self.options.sourceDir) self.tmpStorageRoot = transform.transformDirToInternal(options.workingPath) misc.ensureDir(self.tmpStorageRoot) misc.ensureDir(self.options.targetDir) self.encCopier = encryptionStorageBase.arc4DecSimpleCopier(options.encryptionPass) #self.createNewZip() self.curArchive = None
#print c sys.path.insert(0, os.path.join(c,'prodRoot')) #import localLibs.localDb.sqliteAttrDb.sqliteEntryDbWithHistory as entryDbMod #import localLibs.localDb.sqliteAttrDb.sqliteTokenDb as tokenDbMod import localLibs.localDb.shoveInDefaultPath as shove #gAppPath = 'd:/tmp/fileman/' #gDbPath = os.path.join(gAppPath, 'db') #import libs.utils.misc as misc #import libs.ufsDb.ufsDbBase as ufsDbBase #misc.ensureDir(gAppPath) #misc.ensureDir(gDbPath) gAppPath = 'd:/tmp/test/' gDbPath = os.path.join(gAppPath, 'db') import wwjufsdatabase.libs.utils.misc as misc misc.ensureDir(gAppPath) misc.ensureDir(gDbPath) class testDbSys(dbSysInterface.dbSysInterface): def __init__(self, sessionInstance = None): self.sessInst = sessionInstance def getObjId2PathShove(self): return self.getDb("objId2PathShove") def getPath2ObjIdShove(self): return self.getDb("path2ObjIdShove") def getCollectionCacheIdDb(self): return self.getDb("collectionCacheIdDb") def getCollectionCacheUpdateDb(self): return self.getDb("collectionCacheUpdateDb") def getCollectionCacheDb(self):
import dbus.service import localLibSys import localLibs.logWin.dbusServices.dbusServiceBase as dbusServiceBase import wwjufsdatabase.libs.ufsDb.ufsDbSingleUser as ufsDbSingleUser import wwjufsdatabase.libs.utils.transform as transform import wwjufsdatabase.libs.thumb.thumbInterface as thumbLib import wwjufsdatabase.libs.utils.misc as misc import os import uuid gAppPath = 'd:/tmp/fileman/' gThumbPath = os.path.join(gAppPath, 'thumb') misc.ensureDir(gAppPath) misc.ensureDir(gThumbPath) INTERFACE_NAME = 'com.wwjufsdatabase.thumbService' class simpleSysUser: def getUserName(self): return 'system.default' def getPasswd(self): return 'simplePass' def getProdRoot(): c = os.getcwd() while c.find('prodRoot') != -1: c = os.path.dirname(c) return os.path.join(c, 'prodRoot') class thumbService(dbusServiceBase.dbusServiceBase):
from optparse import OptionParser import localLibSys import desktopApp.lib.archiver.encryptionStorageBase as encryptionStorageBase import desktopApp.lib.archiver.archiveStorageBase as archiveStorageBase import desktopApp.lib.archiver.archiverV2 as archiver import wwjufsdatabase.libs.utils.misc as misc if __name__ == "__main__": parser = OptionParser() parser.add_option("-s", "--sourceDir", action="store",help="copy from which directory") parser.add_option("-p", "--encryptionPass", action="store",help="encryption password") parser.add_option("-t", "--targetDir", action="store", help="target directory") parser.add_option("-c", "--configPath", action="store", help="path for the config file") (options, args) = parser.parse_args() ar = archiver.archiverInterface() src = archiveStorageBase.folder(options.sourceDir) misc.ensureDir(options.targetDir) s = encryptionStorageBase.encryptionStorageBase(options.sourceDir, options.targetDir, stateStoragePath = options.configPath, encCopier = encryptionStorageBase.arc4EncSimpleCopier(options.encryptionPass)) ar.archive(src, s) s.saveState()