|
342
|
1 """
|
|
|
2 This module defines tasks and a runner for these tasks. Tasks can
|
|
|
3 have dependencies and it can be determined if they need to be run.
|
|
|
4 """
|
|
334
|
5
|
|
|
6 import logging
|
|
377
|
7 import re
|
|
|
8 import os
|
|
|
9 import glob
|
|
|
10
|
|
|
11
|
|
|
12 task_map = {}
|
|
|
13 def register_task(name):
|
|
|
14 """ Decorator that registers a task class """
|
|
|
15 def f(cls):
|
|
|
16 task_map[name] = cls
|
|
|
17 return cls
|
|
|
18 return f
|
|
|
19
|
|
329
|
20
|
|
|
21 class TaskError(Exception):
|
|
377
|
22 """ When a task fails, this exception is raised """
|
|
346
|
23 def __init__(self, msg):
|
|
|
24 self.msg = msg
|
|
329
|
25
|
|
|
26
|
|
377
|
27 class Project:
|
|
393
|
28 """ A project contains a set of named targets that can depend upon
|
|
377
|
29 eachother """
|
|
329
|
30 def __init__(self, name):
|
|
|
31 self.name = name
|
|
377
|
32 self.targets = {}
|
|
|
33 self.properties = {}
|
|
|
34 self.macro_regex = re.compile('\$\{([^\}]+)\}')
|
|
|
35
|
|
|
36 def set_property(self, name, value):
|
|
|
37 self.properties[name] = value
|
|
|
38
|
|
|
39 def get_property(self, name):
|
|
|
40 if name not in self.properties:
|
|
|
41 raise TaskError('Property "{}" not found'.format(name))
|
|
|
42 return self.properties[name]
|
|
|
43
|
|
|
44 def add_target(self, t):
|
|
|
45 if t.name in self.targets:
|
|
|
46 raise TaskError("Duplicate target '{}'".format(t.name))
|
|
|
47 self.targets[t.name] = t
|
|
|
48
|
|
|
49 def get_target(self, target_name):
|
|
|
50 if target_name not in self.targets:
|
|
|
51 raise TaskError('target "{}" not found'.format(target_name))
|
|
|
52 return self.targets[target_name]
|
|
|
53
|
|
|
54 def expand_macros(self, txt):
|
|
|
55 """ Replace all macros in txt with the correct properties """
|
|
|
56 while True:
|
|
|
57 mo = self.macro_regex.search(txt)
|
|
|
58 if not mo:
|
|
|
59 break
|
|
|
60 propname = mo.group(1)
|
|
|
61 propval = self.get_property(propname)
|
|
|
62 txt = txt[:mo.start()] + propval + txt[mo.end():]
|
|
|
63 return txt
|
|
|
64
|
|
|
65 def dfs(self, target_name, state):
|
|
|
66 state.add(target_name)
|
|
|
67 target = self.get_target(target_name)
|
|
|
68 for dep in target.dependencies:
|
|
|
69 if dep in state:
|
|
393
|
70 raise TaskError('Dependency loop detected {} -> {}'
|
|
|
71 .format(target_name, dep))
|
|
377
|
72 self.dfs(dep, state)
|
|
|
73
|
|
|
74 def check_target(self, target_name):
|
|
|
75 state = set()
|
|
|
76 self.dfs(target_name, state)
|
|
|
77
|
|
|
78 def dependencies(self, target_name):
|
|
|
79 assert type(target_name) is str
|
|
|
80 target = self.get_target(target_name)
|
|
|
81 cdst = list(self.dependencies(dep) for dep in target.dependencies)
|
|
|
82 cdst.append(target.dependencies)
|
|
|
83 return set.union(*cdst)
|
|
|
84
|
|
|
85
|
|
|
86 class Target:
|
|
|
87 """ Defines a target that has a name and a list of tasks to execute """
|
|
|
88 def __init__(self, name, project):
|
|
|
89 self.name = name
|
|
|
90 self.project = project
|
|
|
91 self.tasks = []
|
|
342
|
92 self.dependencies = set()
|
|
377
|
93
|
|
|
94 def add_task(self, task):
|
|
|
95 self.tasks.append(task)
|
|
|
96
|
|
|
97 def add_dependency(self, target_name):
|
|
|
98 """ Add another task as a dependency for this task """
|
|
|
99 self.dependencies.add(target_name)
|
|
|
100
|
|
|
101 def __gt__(self, other):
|
|
|
102 return other.name in self.project.dependencies(self.name)
|
|
|
103
|
|
|
104 def __repr__(self):
|
|
|
105 return 'Target "{}"'.format(self.name)
|
|
|
106
|
|
|
107
|
|
|
108 class Task:
|
|
|
109 """ Task that can run, and depend on other tasks """
|
|
|
110 def __init__(self, target, kwargs, sub_elements=[]):
|
|
|
111 self.logger = logging.getLogger('task')
|
|
|
112 self.target = target
|
|
|
113 self.name = self.__class__.__name__
|
|
|
114 self.arguments = kwargs
|
|
|
115 self.subs = sub_elements
|
|
|
116
|
|
|
117 def get_argument(self, name):
|
|
|
118 if name not in self.arguments:
|
|
|
119 raise TaskError('attribute "{}" not specified'.format(name))
|
|
|
120 return self.arguments[name]
|
|
|
121
|
|
|
122 def get_property(self, name):
|
|
|
123 return self.target.project.get_property(name)
|
|
|
124
|
|
|
125 def relpath(self, filename):
|
|
|
126 basedir = self.get_property('basedir')
|
|
|
127 return os.path.join(basedir, filename)
|
|
|
128
|
|
|
129 def open_file_set(self, s):
|
|
|
130 """ Creates a list of open file handles. s can be one of these:
|
|
|
131 - A string like "a.c3"
|
|
|
132 - A string like "*.c3"
|
|
|
133 - A string like "a.c3;src/*.c3"
|
|
|
134 """
|
|
|
135 assert type(s) is str
|
|
|
136 fns = []
|
|
|
137 for part in s.split(';'):
|
|
|
138 fns += glob.glob(self.relpath(part))
|
|
|
139 return fns
|
|
329
|
140
|
|
|
141 def run(self):
|
|
|
142 raise NotImplementedError("Implement this abstract method!")
|
|
|
143
|
|
332
|
144 def __repr__(self):
|
|
|
145 return 'Task "{}"'.format(self.name)
|
|
|
146
|
|
329
|
147
|
|
|
148 class TaskRunner:
|
|
332
|
149 """ Basic task runner that can run some tasks in sequence """
|
|
329
|
150 def __init__(self):
|
|
334
|
151 self.logger = logging.getLogger('taskrunner')
|
|
332
|
152
|
|
377
|
153 def run(self, project, targets=[]):
|
|
|
154 """ Try to run a project """
|
|
|
155 # Determine what targets to run:
|
|
|
156 if targets:
|
|
|
157 target_list = targets
|
|
|
158 else:
|
|
|
159 if project.default:
|
|
|
160 target_list = [project.default]
|
|
|
161 else:
|
|
|
162 target_list = []
|
|
329
|
163
|
|
377
|
164 try:
|
|
|
165 if not target_list:
|
|
|
166 self.logger.info('Done!')
|
|
|
167 return 0
|
|
|
168
|
|
|
169 # Check for loops:
|
|
|
170 for target in target_list:
|
|
|
171 project.check_target(target)
|
|
334
|
172
|
|
377
|
173 # Calculate all dependencies:
|
|
|
174 target_list = set.union(*[project.dependencies(t) for t in target_list]).union(set(target_list))
|
|
|
175 # Lookup actual targets:
|
|
|
176 target_list = [project.get_target(target_name) for target_name in target_list]
|
|
|
177 target_list.sort()
|
|
|
178
|
|
|
179 self.logger.info('Target sequence: {}'.format(target_list))
|
|
342
|
180
|
|
377
|
181 # Run tasks:
|
|
|
182 for target in target_list:
|
|
|
183 self.logger.info('Target {}'.format(target.name))
|
|
|
184 for task in target.tasks:
|
|
|
185 if type(task) is tuple:
|
|
|
186 tname, props = task
|
|
|
187 for arg in props:
|
|
|
188 props[arg] = project.expand_macros(props[arg])
|
|
|
189 task = task_map[tname](target, props)
|
|
|
190 self.logger.info('Running {}'.format(task))
|
|
|
191 task.run()
|
|
|
192 else:
|
|
|
193 raise Exception()
|
|
|
194 self.logger.info('Done!')
|
|
329
|
195 except TaskError as e:
|
|
342
|
196 self.logger.error(str(e.msg))
|
|
329
|
197 return 1
|
|
|
198 return 0
|
