add possibility to choose the finished timer timerlist position in usage config

[enigma2.git] / lib / python / Components / Task.py

diff --git a/lib/python/Components/Task.py b/lib/python/Components/Task.py
index 7ea64f1afa1b1bf0d31beb63cad2b7705b23ec0e..3a755405e5a0bc73e270c5f6d1e3b3028d90f0aa 100644 (file)
--- a/lib/python/Components/Task.py
+++ b/lib/python/Components/Task.py
@@ -16,6 +16,7 @@ class Job(object):
                self.end = 100
                self.__progress = 0
                self.weightScale = 1
+               self.afterEvent = None
 
                self.state_changed = CList()
 
@@ -45,6 +46,7 @@ class Job(object):
 
        def addTask(self, task):
                task.job = self
+               task.task_progress_changed = self.task_progress_changed_CB
                self.tasks.append(task)
 
        def start(self, callback):
@@ -62,15 +64,14 @@ class Job(object):
        def runNext(self):
                if self.current_task == len(self.tasks):
                        if len(self.resident_tasks) == 0:
-                               cb = self.callback
-                               self.callback = None
                                self.status = self.FINISHED
                                self.state_changed()
-                               cb(self, None, [])
+                               self.callback(self, None, [])
+                               self.callback = None
                        else:
                                print "still waiting for %d resident task(s) %s to finish" % (len(self.resident_tasks), str(self.resident_tasks))
                else:
-                       self.tasks[self.current_task].run(self.taskCallback, self.task_progress_changed_CB)
+                       self.tasks[self.current_task].run(self.taskCallback)
                        self.state_changed()
 
        def taskCallback(self, task, res, stay_resident = False):
@@ -126,9 +127,11 @@ class Task(object):
                self.cmd = None
                self.cwd = "/tmp"
                self.args = [ ]
+               self.cmdline = None
                self.task_progress_changed = None
                self.output_line = ""
                job.addTask(self)
+               self.container = None
 
        def setCommandline(self, cmd, args):
                self.cmd = cmd
@@ -140,6 +143,9 @@ class Task(object):
                self.global_preconditions.append(ToolExistsPrecondition())
                self.postconditions.append(ReturncodePostcondition())
 
+       def setCmdline(self, cmdline):
+               self.cmdline = cmdline
+
        def checkPreconditions(self, immediate = False):
                not_met = [ ]
                if immediate:
@@ -151,7 +157,7 @@ class Task(object):
                                not_met.append(precondition)
                return not_met
 
-       def run(self, callback, task_progress_changed):
+       def run(self, callback):
                failed_preconditions = self.checkPreconditions(True) + self.checkPreconditions(False)
                if len(failed_preconditions):
                        callback(self, failed_preconditions)
@@ -159,21 +165,21 @@ class Task(object):
                self.prepare()
 
                self.callback = callback
-               self.task_progress_changed = task_progress_changed
                from enigma import eConsoleAppContainer
                self.container = eConsoleAppContainer()
                self.container.appClosed.append(self.processFinished)
                self.container.stdoutAvail.append(self.processStdout)
                self.container.stderrAvail.append(self.processStderr)
 
-               assert self.cmd is not None
-               assert len(self.args) >= 1
-
                if self.cwd is not None:
                        self.container.setCWD(self.cwd)
 
-               execstr = self.cmd + " ".join(self.args)
-               print "execute:", self.container.execute(execstr), execstr
+               if not self.cmd and self.cmdline:
+                       print "execute:", self.container.execute(self.cmdline), self.cmdline
+               else:
+                       assert self.cmd is not None
+                       assert len(self.args) >= 1
+                       print "execute:", self.container.execute(self.cmd, *self.args), ' '.join(self.args)
                if self.initial_input:
                        self.writeInput(self.initial_input)
 
@@ -206,7 +212,8 @@ class Task(object):
                self.finish()
 
        def abort(self):
-               self.container.kill()
+               if self.container:
+                       self.container.kill()
                self.finish(aborted = True)
 
        def finish(self, aborted = False):
@@ -236,7 +243,8 @@ class Task(object):
                if progress < 0:
                        progress = 0
                self.__progress = progress
-               self.task_progress_changed()
+               if self.task_progress_changed:
+                       self.task_progress_changed()
 
        progress = property(getProgress, setProgress)
 
@@ -266,6 +274,7 @@ class JobManager:
                from Tools import Notifications
                if self.in_background:
                        from Screens.TaskView import JobView
+                       self.in_background = False
                        Notifications.AddNotification(JobView, self.active_job)
                if problems:
                        from Screens.MessageBox import MessageBox
@@ -361,18 +370,27 @@ class DiskspacePrecondition(Condition):
 class ToolExistsPrecondition(Condition):
        def check(self, task):
                import os
+               
                if task.cmd[0]=='/':
-                       realpath = task.cmd
+                       self.realpath = task.cmd
+                       print "[Task.py][ToolExistsPrecondition] WARNING: usage of absolute paths for tasks should be avoided!" 
+                       return os.access(self.realpath, os.X_OK)
                else:
-                       realpath = task.cwd + '/' + task.cmd
-               self.realpath = realpath
-               return os.access(realpath, os.X_OK)
+                       self.realpath = task.cmd
+                       path = os.environ.get('PATH', '').split(os.pathsep)
+                       path.append(task.cwd + '/')
+                       absolutes = filter(lambda file: os.access(file, os.X_OK), map(lambda directory, file = task.cmd: os.path.join(directory, file), path))
+                       if len(absolutes) > 0:
+                               self.realpath = task.cmd[0]
+                               return True
+               return False 
 
        def getErrorMessage(self, task):
                return _("A required tool (%s) was not found.") % (self.realpath)
 
 class AbortedPostcondition(Condition):
-       pass
+       def getErrorMessage(self, task):
+               return "Cancelled upon user request"
 
 class ReturncodePostcondition(Condition):
        def check(self, task):