build.py: Expand data to addtask
[bitbake.git] / lib / bb / build.py
1 # ex:ts=4:sw=4:sts=4:et
2 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
3 #
4 # BitBake 'Build' implementation
5 #
6 # Core code for function execution and task handling in the
7 # BitBake build tools.
8 #
9 # Copyright (C) 2003, 2004  Chris Larson
10 #
11 # Based on Gentoo's portage.py.
12 #
13 # This program is free software; you can redistribute it and/or modify
14 # it under the terms of the GNU General Public License version 2 as
15 # published by the Free Software Foundation.
16 #
17 # This program is distributed in the hope that it will be useful,
18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 # GNU General Public License for more details.
21 #
22 # You should have received a copy of the GNU General Public License along
23 # with this program; if not, write to the Free Software Foundation, Inc.,
24 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 #
26 #Based on functions from the base bb module, Copyright 2003 Holger Schurig
27
28 from bb import data, fetch, event, mkdirhier, utils
29 import bb, os
30
31 # events
32 class FuncFailed(Exception):
33     """Executed function failed"""
34
35 class EventException(Exception):
36     """Exception which is associated with an Event."""
37
38     def __init__(self, msg, event):
39         self.args = msg, event
40
41 class TaskBase(event.Event):
42     """Base class for task events"""
43
44     def __init__(self, t, d ):
45         self._task = t
46         event.Event.__init__(self, d)
47
48     def getTask(self):
49         return self._task
50
51     def setTask(self, task):
52         self._task = task
53
54     task = property(getTask, setTask, None, "task property")
55
56 class TaskStarted(TaskBase):
57     """Task execution started"""
58
59 class TaskSucceeded(TaskBase):
60     """Task execution completed"""
61
62 class TaskFailed(TaskBase):
63     """Task execution failed"""
64
65 class InvalidTask(TaskBase):
66     """Invalid Task"""
67
68 # functions
69
70 def exec_func(func, d, dirs = None):
71     """Execute an BB 'function'"""
72
73     body = data.getVar(func, d)
74     if not body:
75         return
76
77     if not dirs:
78         dirs = (data.getVarFlag(func, 'dirs', d) or "").split()
79     for adir in dirs:
80         adir = data.expand(adir, d)
81         mkdirhier(adir)
82
83     if len(dirs) > 0:
84         adir = dirs[-1]
85     else:
86         adir = data.getVar('B', d, 1)
87
88     adir = data.expand(adir, d)
89
90     try:
91         prevdir = os.getcwd()
92     except OSError:
93         prevdir = data.expand('${TOPDIR}', d)
94     if adir and os.access(adir, os.F_OK):
95         os.chdir(adir)
96
97     if data.getVarFlag(func, "python", d):
98         exec_func_python(func, d)
99     else:
100         exec_func_shell(func, d)
101
102     if os.path.exists(prevdir):
103         os.chdir(prevdir)
104
105 def exec_func_python(func, d):
106     """Execute a python BB 'function'"""
107     import re, os
108
109     tmp  = "def " + func + "():\n%s" % data.getVar(func, d)
110     tmp += '\n' + func + '()'
111     comp = utils.better_compile(tmp, func, bb.data.getVar('FILE', d, 1) )
112     prevdir = os.getcwd()
113     g = {} # globals
114     g['bb'] = bb
115     g['os'] = os
116     g['d'] = d
117     utils.better_exec(comp,g,tmp, bb.data.getVar('FILE',d,1))
118     if os.path.exists(prevdir):
119         os.chdir(prevdir)
120
121 def exec_func_shell(func, d):
122     """Execute a shell BB 'function' Returns true if execution was successful.
123
124     For this, it creates a bash shell script in the tmp dectory, writes the local
125     data into it and finally executes. The output of the shell will end in a log file and stdout.
126
127     Note on directory behavior.  The 'dirs' varflag should contain a list
128     of the directories you need created prior to execution.  The last
129     item in the list is where we will chdir/cd to.
130     """
131     import sys
132
133     deps = data.getVarFlag(func, 'deps', d)
134     check = data.getVarFlag(func, 'check', d)
135     interact = data.getVarFlag(func, 'interactive', d)
136     if check in globals():
137         if globals()[check](func, deps):
138             return
139
140     global logfile
141     t = data.getVar('T', d, 1)
142     if not t:
143         return 0
144     mkdirhier(t)
145     logfile = "%s/log.%s.%s" % (t, func, str(os.getpid()))
146     runfile = "%s/run.%s.%s" % (t, func, str(os.getpid()))
147
148     f = open(runfile, "w")
149     f.write("#!/bin/sh -e\n")
150     if bb.msg.debug_level['default'] > 0: f.write("set -x\n")
151     data.emit_env(f, d)
152
153     f.write("cd %s\n" % os.getcwd())
154     if func: f.write("%s\n" % func)
155     f.close()
156     os.chmod(runfile, 0775)
157     if not func:
158         bb.msg.error(bb.msg.domain.Build, "Function not specified")
159         raise FuncFailed()
160
161     # open logs
162     si = file('/dev/null', 'r')
163     try:
164         if bb.msg.debug_level['default'] > 0:
165             so = os.popen("tee \"%s\"" % logfile, "w")
166         else:
167             so = file(logfile, 'w')
168     except OSError, e:
169         bb.msg.error(bb.msg.domain.Build, "opening log file: %s" % e)
170         pass
171
172     se = so
173
174     if not interact:
175         # dup the existing fds so we dont lose them
176         osi = [os.dup(sys.stdin.fileno()), sys.stdin.fileno()]
177         oso = [os.dup(sys.stdout.fileno()), sys.stdout.fileno()]
178         ose = [os.dup(sys.stderr.fileno()), sys.stderr.fileno()]
179
180         # replace those fds with our own
181         os.dup2(si.fileno(), osi[1])
182         os.dup2(so.fileno(), oso[1])
183         os.dup2(se.fileno(), ose[1])
184
185     # execute function
186     prevdir = os.getcwd()
187     if data.getVarFlag(func, "fakeroot", d):
188         maybe_fakeroot = "PATH=\"%s\" fakeroot " % bb.data.getVar("PATH", d, 1)
189     else:
190         maybe_fakeroot = ''
191     lang_environment = "LC_ALL=C "
192     ret = os.system('%s%ssh -e %s' % (lang_environment, maybe_fakeroot, runfile))
193     try:
194         os.chdir(prevdir)
195     except:
196         pass
197
198     if not interact:
199         # restore the backups
200         os.dup2(osi[0], osi[1])
201         os.dup2(oso[0], oso[1])
202         os.dup2(ose[0], ose[1])
203
204         # close our logs
205         si.close()
206         so.close()
207         se.close()
208
209         # close the backup fds
210         os.close(osi[0])
211         os.close(oso[0])
212         os.close(ose[0])
213
214     if ret==0:
215         if bb.msg.debug_level['default'] > 0:
216             os.remove(runfile)
217 #            os.remove(logfile)
218         return
219     else:
220         bb.msg.error(bb.msg.domain.Build, "function %s failed" % func)
221         if data.getVar("BBINCLUDELOGS", d):
222             bb.msg.error(bb.msg.domain.Build, "log data follows (%s)" % logfile)
223             number_of_lines = data.getVar("BBINCLUDELOGS_LINES", d)
224             if number_of_lines:
225                 os.system('tail -n%s %s' % (number_of_lines, logfile))
226             else:
227                 f = open(logfile, "r")
228                 while True:
229                     l = f.readline()
230                     if l == '':
231                         break
232                     l = l.rstrip()
233                     print '| %s' % l
234                 f.close()
235         else:
236             bb.msg.error(bb.msg.domain.Build, "see log in %s" % logfile)
237         raise FuncFailed( logfile )
238
239
240 def exec_task(task, d):
241     """Execute an BB 'task'
242
243        The primary difference between executing a task versus executing
244        a function is that a task exists in the task digraph, and therefore
245        has dependencies amongst other tasks."""
246
247     # check if the task is in the graph..
248     task_graph = data.getVar('_task_graph', d)
249     if not task_graph:
250         task_graph = bb.digraph()
251         data.setVar('_task_graph', task_graph, d)
252     task_cache = data.getVar('_task_cache', d)
253     if not task_cache:
254         task_cache = []
255         data.setVar('_task_cache', task_cache, d)
256     if not task_graph.hasnode(task):
257         raise EventException("Missing node in task graph", InvalidTask(task, d))
258
259     # check whether this task needs executing..
260     if stamp_is_current(task, d):
261         return 1
262
263     # follow digraph path up, then execute our way back down
264     def execute(graph, item):
265         if data.getVarFlag(item, 'task', d):
266             if item in task_cache:
267                 return 1
268
269             if task != item:
270                 # deeper than toplevel, exec w/ deps
271                 exec_task(item, d)
272                 return 1
273
274             try:
275                 bb.msg.debug(1, bb.msg.domain.Build, "Executing task %s" % item)
276                 old_overrides = data.getVar('OVERRIDES', d, 0)
277                 localdata = data.createCopy(d)
278                 data.setVar('OVERRIDES', 'task_%s:%s' % (item, old_overrides), localdata)
279                 data.update_data(localdata)
280                 event.fire(TaskStarted(item, localdata))
281                 exec_func(item, localdata)
282                 event.fire(TaskSucceeded(item, localdata))
283                 task_cache.append(item)
284                 data.setVar('_task_cache', task_cache, d)
285             except FuncFailed, reason:
286                 bb.msg.note(1, bb.msg.domain.Build, "Task failed: %s" % reason )
287                 failedevent = TaskFailed(item, d)
288                 event.fire(failedevent)
289                 raise EventException("Function failed in task: %s" % reason, failedevent)
290
291     if data.getVarFlag(task, 'dontrundeps', d):
292         execute(None, task)
293     else:
294         task_graph.walkdown(task, execute)
295
296     # make stamp, or cause event and raise exception
297     if not data.getVarFlag(task, 'nostamp', d):
298         make_stamp(task, d)
299
300 def extract_stamp_data(d, fn):
301     """
302     Extracts stamp data from d which is either a data dictonary (fn unset) 
303     or a dataCache entry (fn set). 
304     """
305     if fn:
306         return (d.task_queues[fn], d.stamp[fn], d.task_deps[fn])
307     task_graph = data.getVar('_task_graph', d)
308     if not task_graph:
309         task_graph = bb.digraph()
310         data.setVar('_task_graph', task_graph, d)
311     return (task_graph, data.getVar('STAMP', d, 1), None)
312
313 def extract_stamp(d, fn):
314     """
315     Extracts stamp format which is either a data dictonary (fn unset) 
316     or a dataCache entry (fn set). 
317     """
318     if fn:
319         return d.stamp[fn]
320     return data.getVar('STAMP', d, 1)
321
322 def stamp_is_current(task, d, file_name = None, checkdeps = 1):
323     """
324     Check status of a given task's stamp. 
325     Returns 0 if it is not current and needs updating.
326     (d can be a data dict or dataCache)
327     """
328
329     (task_graph, stampfn, taskdep) = extract_stamp_data(d, file_name)
330
331     if not stampfn:
332         return 0
333
334     stampfile = "%s.%s" % (stampfn, task)
335     if not os.access(stampfile, os.F_OK):
336         return 0
337
338     if checkdeps == 0:
339         return 1
340
341     import stat
342     tasktime = os.stat(stampfile)[stat.ST_MTIME]
343
344     _deps = []
345     def checkStamp(graph, task):
346         # check for existance
347         if file_name:
348             if 'nostamp' in taskdep and task in taskdep['nostamp']:
349                 return 1
350         else:
351             if data.getVarFlag(task, 'nostamp', d):
352                 return 1
353
354         if not stamp_is_current(task, d, file_name, 0                                           ):
355             return 0
356
357         depfile = "%s.%s" % (stampfn, task)
358         deptime = os.stat(depfile)[stat.ST_MTIME]
359         if deptime > tasktime:
360             return 0
361         return 1
362
363     return task_graph.walkdown(task, checkStamp)
364
365 def stamp_internal(task, d, file_name):
366     """
367     Internal stamp helper function
368     Removes any stamp for the given task
369     Makes sure the stamp directory exists
370     Returns the stamp path+filename
371     """
372     stamp = extract_stamp(d, file_name)
373     if not stamp:
374         return
375     stamp = "%s.%s" % (stamp, task)
376     mkdirhier(os.path.dirname(stamp))
377     # Remove the file and recreate to force timestamp
378     # change on broken NFS filesystems
379     if os.access(stamp, os.F_OK):
380         os.remove(stamp)
381     return stamp
382
383 def make_stamp(task, d, file_name = None):
384     """
385     Creates/updates a stamp for a given task
386     (d can be a data dict or dataCache)
387     """
388     stamp = stamp_internal(task, d, file_name)
389     if stamp:
390         f = open(stamp, "w")
391         f.close()
392
393 def del_stamp(task, d, file_name = None):
394     """
395     Removes a stamp for a given task
396     (d can be a data dict or dataCache)
397     """
398     stamp_internal(task, d, file_name)
399
400 def add_task(task, deps, d):
401     task_graph = data.getVar('_task_graph', d)
402     if not task_graph:
403         task_graph = bb.digraph()
404
405     task = data.expand(task, d)
406
407     data.setVarFlag(task, 'task', 1, d)
408     task_graph.addnode(task, None)
409     for dep in deps:
410         dep = data.expand(dep, d)
411         if not task_graph.hasnode(dep):
412             task_graph.addnode(dep, None)
413         task_graph.addnode(task, dep)
414     # don't assume holding a reference
415     data.setVar('_task_graph', task_graph, d)
416
417     task_deps = data.getVar('_task_deps', d)
418     if not task_deps:
419         task_deps = {}
420     def getTask(name):
421         deptask = data.getVarFlag(task, name, d)
422         if deptask:
423             deptask = data.expand(deptask, d)
424             if not name in task_deps:
425                 task_deps[name] = {}
426             task_deps[name][task] = deptask
427     getTask('depends')
428     getTask('deptask')
429     getTask('rdeptask')
430     getTask('recrdeptask')
431     getTask('nostamp')
432
433     data.setVar('_task_deps', task_deps, d)
434
435 def remove_task(task, kill, d):
436     """Remove an BB 'task'.
437
438        If kill is 1, also remove tasks that depend on this task."""
439
440     task_graph = data.getVar('_task_graph', d)
441     if not task_graph:
442         task_graph = bb.digraph()
443     if not task_graph.hasnode(task):
444         return
445
446     data.delVarFlag(task, 'task', d)
447     ref = 1
448     if kill == 1:
449         ref = 2
450     task_graph.delnode(task, ref)
451     data.setVar('_task_graph', task_graph, d)
452
453 def task_exists(task, d):
454     task_graph = data.getVar('_task_graph', d)
455     if not task_graph:
456         task_graph = bb.digraph()
457         data.setVar('_task_graph', task_graph, d)
458     return task_graph.hasnode(task)