from Tools.CList import CList
-class Job:
+class Job(object):
NOT_STARTED, IN_PROGRESS, FINISHED, FAILED = range(4)
def __init__(self, name):
self.tasks = [ ]
self.name = name
self.finished = False
self.end = 100
- self.progress = 0
+ self.__progress = 0
self.weightScale = 1
- self.job_state_changed = CList()
- #triggered when task finishes/fails
-
- self.task_state_changed = CList()
- #triggered when external app generates output
+ self.state_changed = CList()
self.status = self.NOT_STARTED
def createDescription(self):
return None
- def task_state_changed_CB(self):
+ def getProgress(self):
+ if self.current_task == len(self.tasks):
+ return self.end
t = self.tasks[self.current_task]
jobprogress = t.weighting * t.progress / float(t.end) + sum([task.weighting for task in self.tasks[:self.current_task]])
- self.progress = jobprogress*self.weightScale
- self.task_state_changed()
+ return int(jobprogress*self.weightScale)
+
+ progress = property(getProgress)
+
+ def task_progress_changed_CB(self):
+ self.state_changed()
def addTask(self, task):
task.job = self
assert self.callback is None
self.callback = callback
self.status = self.IN_PROGRESS
- self.job_state_changed()
+ self.state_changed()
self.runNext()
sumTaskWeightings = sum([t.weighting for t in self.tasks])
self.weightScale = (self.end+1) / float(sumTaskWeightings)
if self.current_task == len(self.tasks):
self.callback(self, [])
self.status = self.FINISHED
- self.job_state_changed()
+ self.state_changed()
else:
- self.tasks[self.current_task].run(self.taskCallback,self.task_state_changed_CB)
- self.job_state_changed()
+ self.tasks[self.current_task].run(self.taskCallback,self.task_progress_changed_CB)
+ self.state_changed()
def taskCallback(self, res):
if len(res):
print ">>> Error:", res
self.status = self.FAILED
- self.job_state_changed()
+ self.state_changed()
self.callback(self, res)
else:
- self.progress = (self.progress + self.tasks[self.current_task].weighting*self.weightScale )
+ self.state_changed();
self.current_task += 1
self.runNext()
-class Task:
+ def abort(self):
+ if self.current_task < len(self.tasks):
+ self.tasks[self.current_task].abort()
+
+ def cancel(self):
+ # some Jobs might have a better idea of how to cancel a job
+ self.abort()
+
+class Task(object) :
def __init__(self, job, name):
self.name = name
self.immediate_preconditions = [ ]
self.end = 100
self.weighting = 100
- self.progress = 0
+ self.__progress = 0
self.cmd = None
self.cwd = "/tmp"
self.args = [ ]
- self.task_state_changed = None
+ self.task_progress_changed = None
job.addTask(self)
def setCommandline(self, cmd, args):
not_met.append(precondition)
return not_met
- def run(self, callback, task_state_changed):
+ def run(self, callback, task_progress_changed):
failed_preconditions = self.checkPreconditions(True) + self.checkPreconditions(False)
if len(failed_preconditions):
callback(failed_preconditions)
self.prepare()
self.callback = callback
- self.task_state_changed = task_state_changed
+ self.task_progress_changed = task_progress_changed
from enigma import eConsoleAppContainer
self.container = eConsoleAppContainer()
self.container.appClosed.get().append(self.processFinished)
assert self.cmd is not None
assert len(self.args) >= 1
-
+
if self.cwd is not None:
self.container.setCWD(self.cwd)
self.returncode = returncode
self.finish()
- def finish(self):
+ def abort(self):
+ self.container.kill()
+ self.finish(aborted = True)
+
+ def finish(self, aborted = False):
self.afterRun()
not_met = [ ]
- for postcondition in self.postconditions:
- if not postcondition.check(self):
- not_met.append(postcondition)
+ if aborted:
+ not_met.append(AbortedPostcondition())
+ else:
+ for postcondition in self.postconditions:
+ if not postcondition.check(self):
+ not_met.append(postcondition)
self.callback(not_met)
def writeInput(self, input):
self.container.write(input)
+ def getProgress(self):
+ return self.__progress
+
+ def setProgress(self, progress):
+ print "progress now", progress
+ self.__progress = progress
+ self.task_progress_changed()
+
+ progress = property(getProgress, setProgress)
+
class JobManager:
def __init__(self):
self.active_jobs = [ ]
# def check(self, task):
# return getFreeDiskspace(task.workspace) >= self.diskspace_required
#
+
class ToolExistsPrecondition:
def check(self, task):
import os
realpath = self.cwd + '/' + self.cmd
return os.access(realpath, os.X_OK)
+class AbortedPostcondition:
+ pass
+
class ReturncodePostcondition:
def check(self, task):
return task.returncode == 0
def __init__(self, session, job, cancelable = True, close_on_finish = False):
from Components.Sources.StaticText import StaticText
from Components.Sources.Progress import Progress
+ from Components.Sources.Boolean import Boolean
from Components.ActionMap import ActionMap
Screen.__init__(self, session)
self.job = job
self.close_on_finish = close_on_finish
+ self.cancelable = cancelable
self["job_name"] = StaticText(job.name)
self["job_progress"] = Progress()
self["job_status"] = StaticText()
self["job_task"] = StaticText()
+ self["finished"] = Boolean()
self.onShow.append(self.windowShow)
self.onHide.append(self.windowHide)
def state_changed(self):
j = self.job
- self["job_progress"].range = len(j.tasks)
- self["job_progress"].value = j.current_task
+ self["job_progress"].range = j.end
+ self["job_progress"].value = j.progress
+ print "JobView::state_changed:", j.end, j.progress
self["job_status"].text = {j.NOT_STARTED: _("Waiting"), j.IN_PROGRESS: _("In Progress"), j.FINISHED: _("Finished"), j.FAILED: _("Failed")}[j.status]
if j.status == j.IN_PROGRESS:
self["job_task"].text = j.tasks[j.current_task].name
else:
self["job_task"].text = ""
- if j.status in [j.FINISHED, j.FAILED] and self.close_on_finish:
- self.close()
+ if j.status in [j.FINISHED, j.FAILED]:
+ if self.close_on_finish:
+ self.close()
+ else:
+ self["finished"].boolean = True
def ok(self):
if self.job.status in [self.job.FINISHED, self.job.FAILED]:
projects / vuplus_dvbapp / commitdiff