1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
# This file is part of ipsutils.
# ipsutils is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ipsutils is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with ipsutils. If not, see <http://www.gnu.org/licenses/>.
class TaskException(Exception):
pass
class InternalTaskException(Exception):
pass
class TaskControllerException(Exception):
pass
class Controller(object):
def __init__(self):
"""Simple FILO execution stack of task objects
Example:
from ipsutils import tasks
#Create a new controller
controller = task.Controller()
#Add a tasks
controller.task(task.Task(name='Some task'))
controller.task(task.Task(name='Some other task'))
#Execute tasks
controller.do_tasks()
Output:
+ Running task: Some task
+ Running task: Some other task
"""
self.stack = []
def task(self, t):
"""
t: Task object
"""
if not isinstance(t, Task):
raise TaskControllerException("'{}' is not an instance of Task".format(type(t)))
self.stack.append(t)
def do_tasks(self, atexit=None):
""" FILO execution of tasks
"""
if not self.stack:
raise TaskException("Empty controller stack")
for stack_entry in self.stack:
status = stack_entry.run()
if type(status) == type(True):
if not status:
print("Internal error: {}".format(status))
if atexit is not None:
atexit()
exit(status)
else:
if status is not 0 \
and status is not None:
print("exit: {}".format(status))
if atexit is not None:
atexit()
exit(status)
class Task(object):
def __init__(self, *args, **kwargs):
"""Task engine base class.
Keyword arguments:
name = Description of the task
func = Function reference
cls = An instance of the calling class (if any)
"""
self.name = ''
if 'name' in kwargs:
self.name = kwargs['name']
if 'func' in kwargs:
self.func = kwargs['func']
else:
self.func = None
if 'cls' in kwargs:
self.cls = kwargs['cls']
if not isinstance(self.cls, object):
raise TaskException("'{}' is not an instance of a class".format(type(self.cls)))
else:
self.cls = object()
def run(self):
if not self.name:
raise TaskException("Unnamed task in: {}".format(self.__class__.__name__))
print("+ Running task: {0:s}".format(self.name))
status = self.task()
return status
def task(self):
raise NotImplementedError('Task undefined')
class Internal(Task):
def __init__(self, *args, **kwargs):
"""Implements an internal task denoted by a slightly different output.
"""
super(Internal, self).__init__(self, *args, **kwargs)
def run(self):
if not self.name:
raise InternalTaskException("Unnamed task in : {}".format(self.name))
print("> Running internal task: {0:s}".format(self.name))
status = self.task()
return status
|
