--- /dev/null
+# A Job consists of many "Tasks".
+# A task is the run of an external tool, with proper methods for failure handling
+
+from Tools.CList import CList
+
+class Job:
+ NOT_STARTED, IN_PROGRESS, FINISHED, FAILED = range(4)
+ def __init__(self, name):
+ self.tasks = [ ]
+ self.current_task = 0
+ self.callback = None
+ self.name = name
+ self.finished = False
+
+ self.state_changed = CList()
+
+ self.status = self.NOT_STARTED
+
+ # description is a dict
+ def fromDescription(self, description):
+ pass
+
+ def createDescription(self):
+ return None
+
+ def addTask(self, task):
+ self.tasks.append(task)
+
+ def start(self, callback):
+ assert self.callback is None
+ self.callback = callback
+ self.status = self.IN_PROGRESS
+ self.state_changed()
+ self.runNext()
+
+ def runNext(self):
+ if self.current_task == len(self.tasks):
+ self.callback(self, [])
+ self.status = self.FINISHED
+ self.state_changed()
+ else:
+ self.tasks[self.current_task].run(self.taskCallback)
+ self.state_changed()
+
+ def taskCallback(self, res):
+ if len(res):
+ print ">>> Error:", res
+ self.status = self.FAILED
+ self.state_changed()
+ self.callback(self, res)
+ else:
+ self.current_task += 1
+ self.runNext()
+
+class Task:
+ def __init__(self, name):
+ self.name = name
+ self.workspace = "/tmp"
+ self.immediate_preconditions = [ ]
+ self.global_preconditions = [ ]
+ self.postconditions = [ ]
+ self.returncode = None
+ self.initial_input = None
+
+ self.cmd = None
+ self.args = [ ]
+
+ def setCommandline(self, cmd, args):
+ self.cmd = cmd
+ self.args = args
+
+ def setTool(self, tool):
+ self.cmd = tool
+ self.args = [tool]
+ self.global_preconditions.append(ToolExistsPrecondition())
+ self.postconditions.append(ReturncodePostcondition())
+
+ def checkPreconditions(self, immediate = False):
+ not_met = [ ]
+ if immediate:
+ preconditions = self.immediate_preconditions
+ else:
+ preconditions = self.global_preconditions
+ for precondition in preconditions:
+ if not precondition.check(self):
+ not_met.append(precondition)
+ return not_met
+
+ def run(self, callback):
+ failed_preconditions = self.checkPreconditions(True)
+ if len(failed_preconditions):
+ errback(failed_preconditions)
+ return
+
+ self.callback = callback
+ from enigma import eConsoleAppContainer
+ self.container = eConsoleAppContainer()
+ self.container.appClosed.get().append(self.processFinished)
+ self.container.dataAvail.get().append(self.processOutput)
+
+ assert self.cmd is not None
+ assert len(self.args) >= 1
+
+ print "execute:", self.container.execute(self.cmd, self.args), self.cmd, self.args
+ if self.initial_input:
+ self.writeInput(self.initial_input)
+
+ def prepare(self):
+ pass
+
+ def cleanup(self, failed):
+ pass
+
+ def processOutput(self, data):
+ pass
+
+ def processFinished(self, returncode):
+ self.returncode = returncode
+ self.finish()
+
+ def finish(self):
+ self.afterRun()
+ not_met = [ ]
+ for postcondition in self.postconditions:
+ if not postcondition.check(self):
+ not_met.append(postcondition)
+
+ self.callback(not_met)
+
+ def afterRun(self):
+ pass
+
+ def writeInput(self, input):
+ self.container.write(input)
+
+class JobManager:
+ def __init__(self):
+ self.active_jobs = [ ]
+ self.failed_jobs = [ ]
+ self.job_classes = [ ]
+ self.active_job = None
+
+ def AddJob(self, job):
+ self.active_jobs.append(job)
+ self.kick()
+
+ def kick(self):
+ if self.active_job is None:
+ if len(self.active_jobs):
+ self.active_job = self.active_jobs.pop(0)
+ self.active_job.start(self.jobDone)
+
+ def jobDone(self, job, problems):
+ print "job", job, "completed with", problems
+ if problems:
+ self.failed_jobs.append(self.active_job)
+
+ self.active_job = None
+ self.kick()
+
+# some examples:
+#class PartitionExistsPostcondition:
+# def __init__(self, device):
+# self.device = device
+#
+# def check(self, task):
+# import os
+# return os.access(self.device + "part1", os.F_OK)
+#
+#class CreatePartitionTask(Task):
+# def __init__(self, device):
+# Task.__init__(self, _("Create Partition"))
+# self.device = device
+# self.setTool("/sbin/sfdisk")
+# self.args += ["-f", self.device + "disc"]
+# self.initial_input = "0,\n;\n;\n;\ny\n"
+# self.postconditions.append(PartitionExistsPostcondition(self.device))
+#
+#class CreateFilesystemTask(Task):
+# def __init__(self, device, partition = 1, largefile = True):
+# Task.__init__(self, _("Create Filesystem"))
+# self.setTool("/sbin/mkfs.ext")
+# if largefile:
+# self.args += ["-T", "largefile"]
+# self.args.append("-m0")
+# self.args.append(device + "part%d" % partition)
+#
+#class FilesystemMountTask(Task):
+# def __init__(self, device, partition = 1, filesystem = "ext3"):
+# Task.__init__(self, _("Mounting Filesystem"))
+# self.setTool("/bin/mount")
+# if filesystem is not None:
+# self.args += ["-t", filesystem]
+# self.args.append(device + "part%d" % partition)
+#
+#class DiskspacePrecondition:
+# def __init__(self, diskspace_required):
+# self.diskspace_required = diskspace_required
+#
+# def check(self, task):
+# return getFreeDiskspace(task.workspace) >= self.diskspace_required
+#
+#class ToolExistsPrecondition:
+# def check(self, task):
+# import os
+# return os.access(task.cmd, os.X_OK)
+#
+#class ReturncodePostcondition:
+# def check(self, task):
+# return task.returncode == 0
+#
+#class HDDInitJob(Job):
+# def __init__(self, device):
+# Job.__init__(self, _("Initialize Harddisk"))
+# self.device = device
+# self.fromDescription(self.createDescription())
+#
+# def fromDescription(self, description):
+# self.device = description["device"]
+# self.addTask(CreatePartitionTask(self.device))
+# self.addTask(CreateFilesystemTask(self.device))
+# self.addTask(FilesystemMountTask(self.device))
+#
+# def createDescription(self):
+# return {"device": self.device}
+
+job_manager = JobManager()
git.cweiske.de / enigma2.git / commitdiff