def run(self):
"""
Runs a new `Job` from that `Task`.
Called from `RunTasks()` method if it is possible to start a new task -
the maximum number of simultaneously running `Jobs` is limited.
"""
iter_and_path = backup_fs.WalkByID(self.pathID)
if iter_and_path is None:
dhnio.Dprint(4, 'backup_control.Task.run ERROR %s not found in the index' % self.pathID)
# self.defer.callback('error', self.pathID)
return
itemInfo, sourcePath = iter_and_path
if isinstance(itemInfo, dict):
try:
itemInfo = itemInfo[backup_fs.INFO_KEY]
except:
dhnio.DprintException()
return
if not backup_fs.pathExist(sourcePath):
dhnio.Dprint(4, 'backup_control.Task.run WARNING path not exist: %s' % sourcePath)
reactor.callLater(0, OnTaskFailed, self.pathID, 'not exist')
return
dataID = misc.NewBackupID()
if itemInfo.has_version(dataID):
# ups - we already have same version
# let's add 1,2,3... to the end to make absolutely unique version ID
i = 1
while itemInfo.has_version(dataID+str(i)):
i += 1
dataID += str(i)
backupID = self.pathID + '/' + dataID
try:
backupPath = backup_fs.MakeLocalDir(settings.getLocalBackupsDir(), backupID)
except:
dhnio.DprintException()
dhnio.Dprint(4, 'backup_control.Task.run ERROR creating destination folder for %s' % self.pathID)
# self.defer.callback('error', self.pathID)
return
if backup_fs.pathIsDir(sourcePath):
backupPipe = backup_tar.backuptar(sourcePath, compress='gz')
else:
backupPipe = backup_tar.backuptarfile(sourcePath, compress='gz')
backupPipe.make_nonblocking()
resultDefer = Deferred()
blockSize = settings.getBackupBlockSize()
job = backup.backup(backupID, backupPipe, OnJobDone, OnBackupBlockReport, settings.getBackupBlockSize())
jobs()[backupID] = job
itemInfo.add_version(dataID)
if itemInfo.type in [ backup_fs.PARENT, backup_fs.DIR ]:
dirsize.ask(sourcePath, FoundFolderSize, (self.pathID, dataID))
# self.defer.callback('started', backupID)
reactor.callLater(0, FireTaskStartedCallbacks, self.pathID, dataID)
dhnio.Dprint(4, 'backup_control.Task.run %s [%s], size=%d' % (self.pathID, dataID, itemInfo.size))
def __init__(self, callOnReceived, creatorID, packetID, ownerID, remoteID):
self.callOnReceived = []
self.callOnReceived.append(callOnReceived)
self.creatorID = creatorID
self.packetID = packetID
self.ownerID = ownerID
self.remoteID = remoteID
self.backupID, x, self.fileName = packetID.rpartition('/') # [0:packetID.find("-")]
self.requestTime = None
self.fileReceivedTime = None
self.requestTimeout = max(30, 2*int(settings.getBackupBlockSize()/settings.SendingSpeedLimit()))
self.result = ''
PacketReport('request', self.remoteID, self.packetID, 'init')
def __init__(self, backupID, pipe, finishCallback=None, blockResultCallback=None, blockSize=None,): # resultDeferred=None
self.backupID = backupID
self.eccmap = eccmap.Current()
self.pipe = pipe
self.blockSize = blockSize
if self.blockSize is None:
self.blockSize = settings.getBackupBlockSize()
self.ask4abort = False
self.stateEOF = False
self.stateReading = False
self.currentBlockData = cStringIO.StringIO()
self.currentBlockSize = 0
self.blockNumber = 0
self.dataSent = 0
self.blocksSent = 0
self.closed = False
self.finishCallback = finishCallback
self.blockResultCallback = blockResultCallback
automat.Automat.__init__(self, 'backup', 'AT_STARTUP', 14)
self.automat('init')
events.info('backup', '%s started' % self.backupID)
