bitbake/lib/bb/shell.py:
[bitbake.git] / bin / bitbake
1 #!/usr/bin/env python
2 # ex:ts=4:sw=4:sts=4:et
3 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
4 #
5 # Copyright (C) 2003, 2004  Chris Larson
6 # Copyright (C) 2003, 2004  Phil Blundell
7 # Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer
8 # Copyright (C) 2005        Holger Hans Peter Freyther
9 # Copyright (C) 2005        ROAD GmbH
10 # Copyright (C) 2006        Richard Purdie
11 #
12 # This program is free software; you can redistribute it and/or modify it under
13 # the terms of the GNU General Public License as published by the Free Software
14 # Foundation; either version 2 of the License, or (at your option) any later
15 # version.
16 #
17 # This program is distributed in the hope that it will be useful, but WITHOUT
18 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
20 #
21 # You should have received a copy of the GNU General Public License along with
22 # this program; if not, write to the Free Software Foundation, Inc., 59 Temple
23 # Place, Suite 330, Boston, MA 02111-1307 USA.
24
25 import sys, os, getopt, glob, copy, os.path, re, time
26 sys.path.insert(0,os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
27 import bb
28 from bb import utils, data, parse, event, cache, providers, taskdata, runqueue
29 from sets import Set
30 import itertools, optparse
31
32 parsespin = itertools.cycle( r'|/-\\' )
33
34 __version__ = "1.7.0"
35
36 #============================================================================#
37 # BBStatistics
38 #============================================================================#
39 class BBStatistics:
40     """
41     Manage build statistics for one run
42     """
43     def __init__(self ):
44         self.attempt = 0
45         self.success = 0
46         self.fail = 0
47         self.deps = 0
48
49     def show( self ):
50         print "Build statistics:"
51         print "  Attempted builds: %d" % self.attempt
52         if self.fail:
53             print "  Failed builds: %d" % self.fail
54         if self.deps:
55             print "  Dependencies not satisfied: %d" % self.deps
56         if self.fail or self.deps: return 1
57         else: return 0
58
59
60 #============================================================================#
61 # BBOptions
62 #============================================================================#
63 class BBConfiguration( object ):
64     """
65     Manages build options and configurations for one run
66     """
67     def __init__( self, options ):
68         for key, val in options.__dict__.items():
69             setattr( self, key, val )
70
71 #============================================================================#
72 # BBCooker
73 #============================================================================#
74 class BBCooker:
75     """
76     Manages one bitbake build run
77     """
78
79     Statistics = BBStatistics           # make it visible from the shell
80
81     def __init__( self ):
82         self.build_cache_fail = []
83         self.build_cache = []
84         self.stats = BBStatistics()
85         self.status = None
86
87         self.cache = None
88         self.bb_cache = None
89
90     def tryBuildPackage(self, fn, item, task, the_data, build_depends):
91         """
92         Build one task of a package, optionally build following task depends
93         """
94         bb.event.fire(bb.event.PkgStarted(item, the_data))
95         try:
96             self.stats.attempt += 1
97             if self.configuration.force:
98                 bb.data.setVarFlag('do_%s' % task, 'force', 1, the_data)
99             if not build_depends:
100                 bb.data.setVarFlag('do_%s' % task, 'dontrundeps', 1, the_data)
101             if not self.configuration.dry_run:
102                 bb.build.exec_task('do_%s' % task, the_data)
103             bb.event.fire(bb.event.PkgSucceeded(item, the_data))
104             self.build_cache.append(fn)
105             return True
106         except bb.build.FuncFailed:
107             self.stats.fail += 1
108             bb.msg.error(bb.msg.domain.Build, "task stack execution failed")
109             bb.event.fire(bb.event.PkgFailed(item, the_data))
110             self.build_cache_fail.append(fn)
111             raise
112         except bb.build.EventException, e:
113             self.stats.fail += 1
114             event = e.args[1]
115             bb.msg.error(bb.msg.domain.Build, "%s event exception, aborting" % bb.event.getName(event))
116             bb.event.fire(bb.event.PkgFailed(item, the_data))
117             self.build_cache_fail.append(fn)
118             raise
119
120     def tryBuild( self, fn, build_depends):
121         """
122         Build a provider and its dependencies. 
123         build_depends is a list of previous build dependencies (not runtime)
124         If build_depends is empty, we're dealing with a runtime depends
125         """
126
127         the_data = self.bb_cache.loadDataFull(fn, self)
128
129         item = self.status.pkg_fn[fn]
130
131         if bb.build.stamp_is_current('do_%s' % self.configuration.cmd, the_data):
132             self.build_cache.append(fn)
133             return True
134
135         return self.tryBuildPackage(fn, item, self.configuration.cmd, the_data, build_depends)
136
137     def showVersions( self ):
138         pkg_pn = self.status.pkg_pn
139         preferred_versions = {}
140         latest_versions = {}
141
142         # Sort by priority
143         for pn in pkg_pn.keys():
144             (last_ver,last_file,pref_ver,pref_file) = bb.providers.findBestProvider(pn, self.configuration.data, self.status)
145             preferred_versions[pn] = (pref_ver, pref_file)
146             latest_versions[pn] = (last_ver, last_file)
147
148         pkg_list = pkg_pn.keys()
149         pkg_list.sort()
150
151         for p in pkg_list:
152             pref = preferred_versions[p]
153             latest = latest_versions[p]
154
155             if pref != latest:
156                 prefstr = pref[0][0] + "-" + pref[0][1]
157             else:
158                 prefstr = ""
159
160             print "%-30s %20s %20s" % (p, latest[0][0] + "-" + latest[0][1],
161                                         prefstr)
162
163
164     def showEnvironment( self ):
165         """Show the outer or per-package environment"""
166         if self.configuration.buildfile:
167             self.cb = None
168             self.bb_cache = bb.cache.init(self)
169             try:
170                 self.configuration.data = self.bb_cache.loadDataFull(self.configuration.buildfile, self)
171             except IOError, e:
172                 bb.msg.fatal(bb.msg.domain.Parsing, "Unable to read %s: %s" % ( self.configuration.buildfile, e ))
173             except Exception, e:
174                 bb.msg.fatal(bb.msg.domain.Parsing, "%s" % e)
175         # emit variables and shell functions
176         try:
177             data.update_data( self.configuration.data )
178             data.emit_env(sys.__stdout__, self.configuration.data, True)
179         except Exception, e:
180             bb.msg.fatal(bb.msg.domain.Parsing, "%s" % e)
181         # emit the metadata which isnt valid shell
182         for e in self.configuration.data.keys():
183             if data.getVarFlag( e, 'python', self.configuration.data ):
184                 sys.__stdout__.write("\npython %s () {\n%s}\n" % (e, data.getVar(e, self.configuration.data, 1)))
185
186     def generateDotGraph( self, pkgs_to_build, ignore_deps ):
187         """
188         Generate two graphs one for the DEPENDS and RDEPENDS. The current
189         implementation creates crappy graphs ;)
190
191         pkgs_to_build A list of packages that needs to be built
192         ignore_deps   A list of names where processing of dependencies
193                       should be stopped. e.g. dependencies that get
194         """
195
196         def myFilterProvider( providers, item):
197             """
198             Take a list of providers and filter according to environment
199             variables. In contrast to filterProviders we do not discriminate
200             and take PREFERRED_PROVIDER into account.
201             """
202             eligible = []
203             preferred_versions = {}
204
205             # Collate providers by PN
206             pkg_pn = {}
207             for p in providers:
208                 pn = self.status.pkg_fn[p]
209                 if pn not in pkg_pn:
210                     pkg_pn[pn] = []
211                 pkg_pn[pn].append(p)
212
213             bb.msg.debug(1, bb.msg.domain.Provider, "providers for %s are: %s" % (item, pkg_pn.keys()))
214
215             for pn in pkg_pn.keys():
216                 preferred_versions[pn] = bb.providers.findBestProvider(pn, self.configuration.data, self.status, pkg_pn)[2:4]
217                 eligible.append(preferred_versions[pn][1])
218
219             for p in eligible:
220                 if p in self.build_cache_fail:
221                     bb.msg.debug(1, bb.msg.domain.Provider, "rejecting already-failed %s" % p)
222                     eligible.remove(p)
223
224             if len(eligible) == 0:
225                 bb.msg.error(bb.msg.domain.Provider, "no eligible providers for %s" % item)
226                 return 0
227
228             prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % item, self.configuration.data, 1)
229
230             # try the preferred provider first
231             if prefervar:
232                 for p in eligible:
233                     if prefervar == self.status.pkg_fn[p]:
234                         bb.msg.note(1, bb.msg.domain.Provider, "Selecting PREFERRED_PROVIDER %s" % prefervar)
235                         eligible.remove(p)
236                         eligible = [p] + eligible
237
238             return eligible
239
240
241         # try to avoid adding the same rdepends over an over again
242         seen_depends  = []
243         seen_rdepends = []
244
245
246         def add_depends(package_list):
247             """
248             Add all depends of all packages from this list
249             """
250             for package in package_list:
251                 if package in seen_depends or package in ignore_deps:
252                     continue
253
254                 seen_depends.append( package )
255                 if not package in self.status.providers:
256                     """
257                     We have not seen this name -> error in
258                     dependency handling
259                     """
260                     bb.msg.note(1, bb.msg.domain.Depends, "ERROR with provider: %(package)s" % vars() )
261                     print >> depends_file, '"%(package)s" -> ERROR' % vars()
262                     continue
263
264                 # get all providers for this package
265                 providers = self.status.providers[package]
266
267                 # now let us find the bestProvider for it
268                 fn = myFilterProvider(providers, package)[0]
269
270                 depends  = bb.utils.explode_deps(self.bb_cache.getVar('DEPENDS', fn, True) or "")
271                 version  = self.bb_cache.getVar('PV', fn, True ) + '-' + self.bb_cache.getVar('PR', fn, True)
272                 add_depends ( depends )
273
274                 # now create the node
275                 print >> depends_file, '"%(package)s" [label="%(package)s\\n%(version)s"]' % vars()
276
277                 depends = filter( (lambda x: x not in ignore_deps), depends )
278                 for depend in depends:
279                     print >> depends_file, '"%(package)s" -> "%(depend)s"' % vars()
280
281
282         def add_all_depends( the_depends, the_rdepends ):
283             """
284             Add both DEPENDS and RDEPENDS. RDEPENDS will get dashed
285             lines
286             """
287             package_list = the_depends + the_rdepends
288             for package in package_list:
289                 if package in seen_rdepends or package in ignore_deps:
290                     continue
291
292                 seen_rdepends.append( package )
293
294                 # Let us find out if the package is a DEPENDS or RDEPENDS
295                 # and we will set 'providers' with the avilable providers
296                 # for the package.
297                 if package in the_depends:
298                     if not package in self.status.providers:
299                         bb.msg.note(1, bb.msg.domain.Depends, "ERROR with provider: %(package)s" % vars() )
300                         print >> alldepends_file, '"%(package)s" -> ERROR' % vars()
301                         continue
302
303                     providers = self.status.providers[package]
304                 elif package in the_rdepends:
305                     if len(bb.providers.getRuntimeProviders(self.status, package)) == 0:
306                         bb.msg.note(1, bb.msg.domain.Depends, "ERROR with rprovider: %(package)s" % vars() )
307                         print >> alldepends_file, '"%(package)s" -> ERROR [style="dashed"]' % vars()
308                         continue
309
310                     providers = bb.providers.getRuntimeProviders(self.status, package)
311                 else:
312                     # something went wrong...
313                     print "Complete ERROR! %s" % package
314                     continue
315
316                 # now let us find the bestProvider for it
317                 fn = myFilterProvider(providers, package)[0]
318
319                 # Now we have a filename let us get the depends and RDEPENDS of it
320                 depends  = bb.utils.explode_deps(self.bb_cache.getVar('DEPENDS', fn, True) or "")
321                 if fn in self.status.rundeps and package in self.status.rundeps[fn]:
322                     rdepends= self.status.rundeps[fn][package].keys()
323                 else:
324                     rdepends = []
325                 version  = self.bb_cache.getVar('PV', fn, True ) + '-' + self.bb_cache.getVar('PR', fn, True)
326
327                 # handle all the depends and rdepends of package
328                 add_all_depends ( depends, rdepends )
329
330                 # now create the node using package name
331                 print >> alldepends_file, '"%(package)s" [label="%(package)s\\n%(version)s"]' % vars()
332
333                 # remove the stuff we want to ignore and add the edges
334                 depends = filter( (lambda x: x not in ignore_deps), depends )
335                 rdepends = filter( (lambda x: x not in ignore_deps), rdepends )
336                 for depend in depends:
337                     print >> alldepends_file, '"%(package)s" -> "%(depend)s"' % vars()
338                 for depend in rdepends:
339                     print >> alldepends_file, '"%(package)s" -> "%(depend)s" [style=dashed]' % vars()
340
341
342         # Add depends now
343         depends_file = file('depends.dot', 'w' )
344         print >> depends_file, "digraph depends {"
345         add_depends( pkgs_to_build )
346         print >> depends_file,  "}"
347
348         # Add all depends now
349         alldepends_file = file('alldepends.dot', 'w' )
350         print >> alldepends_file, "digraph alldepends {"
351         add_all_depends( pkgs_to_build, [] )
352         print >> alldepends_file, "}"
353
354     def buildDepgraph( self ):
355         all_depends = self.status.all_depends
356         pn_provides = self.status.pn_provides
357
358         localdata = data.createCopy(self.configuration.data)
359         bb.data.update_data(localdata)
360
361         def calc_bbfile_priority(filename):
362             for (regex, pri) in self.status.bbfile_config_priorities:
363                 if regex.match(filename):
364                     return pri
365             return 0
366
367         # Handle PREFERRED_PROVIDERS
368         for p in (bb.data.getVar('PREFERRED_PROVIDERS', localdata, 1) or "").split():
369             (providee, provider) = p.split(':')
370             if providee in self.status.preferred and self.status.preferred[providee] != provider:
371                 bb.msg.error(bb.msg.domain.Provider, "conflicting preferences for %s: both %s and %s specified" % (providee, provider, self.status.preferred[providee]))
372             self.status.preferred[providee] = provider
373
374         # Calculate priorities for each file
375         for p in self.status.pkg_fn.keys():
376             self.status.bbfile_priority[p] = calc_bbfile_priority(p)
377
378     def buildWorldTargetList(self):
379         """
380          Build package list for "bitbake world"
381         """
382         all_depends = self.status.all_depends
383         pn_provides = self.status.pn_provides
384         bb.msg.debug(1, bb.msg.domain.Parsing, "collating packages for \"world\"")
385         for f in self.status.possible_world:
386             terminal = True
387             pn = self.status.pkg_fn[f]
388
389             for p in pn_provides[pn]:
390                 if p.startswith('virtual/'):
391                     bb.msg.debug(2, bb.msg.domain.Parsing, "World build skipping %s due to %s provider starting with virtual/" % (f, p))
392                     terminal = False
393                     break
394                 for pf in self.status.providers[p]:
395                     if self.status.pkg_fn[pf] != pn:
396                         bb.msg.debug(2, bb.msg.domain.Parsing, "World build skipping %s due to both us and %s providing %s" % (f, pf, p))
397                         terminal = False
398                         break
399             if terminal:
400                 self.status.world_target.add(pn)
401
402             # drop reference count now
403             self.status.possible_world = None
404             self.status.all_depends    = None
405
406     def myProgressCallback( self, x, y, f, bb_cache, from_cache ):
407         # feed the status with new input
408
409         bb_cache.handle_data(f, self.status)
410
411         if os.isatty(sys.stdout.fileno()):
412             sys.stdout.write("\rNOTE: Handling BitBake files: %s (%04d/%04d) [%2d %%]" % ( parsespin.next(), x, y, x*100/y ) )
413             sys.stdout.flush()
414         else:
415             if x == 1:
416                 sys.stdout.write("Parsing .bb files, please wait...")
417                 sys.stdout.flush()
418             if x == y:
419                 sys.stdout.write("done.")
420                 sys.stdout.flush()
421
422     def interactiveMode( self ):
423         """Drop off into a shell"""
424         try:
425             from bb import shell
426         except ImportError, details:
427             bb.msg.fatal(bb.msg.domain.Parsing, "Sorry, shell not available (%s)" % details )
428         else:
429             bb.data.update_data( self.configuration.data )
430             shell.start( self )
431             sys.exit( 0 )
432
433     def parseConfigurationFile( self, afile ):
434         try:
435             self.configuration.data = bb.parse.handle( afile, self.configuration.data )
436
437             # Add the handlers we inherited by INHERIT
438             # we need to do this manually as it is not guranteed
439             # we will pick up these classes... as we only INHERIT
440             # on .inc and .bb files but not on .conf
441             data = bb.data.createCopy( self.configuration.data )
442             inherits  = ["base"] + (bb.data.getVar('INHERIT', data, True ) or "").split()
443             for inherit in inherits:
444                 data = bb.parse.handle( os.path.join('classes', '%s.bbclass' % inherit ), data, True )
445
446             # FIXME: This assumes that we included at least one .inc file
447             for var in bb.data.keys(data):
448                 if bb.data.getVarFlag(var, 'handler', data):
449                     bb.event.register(var,bb.data.getVar(var, data))
450
451         except IOError:
452             bb.msg.fatal(bb.msg.domain.Parsing, "Unable to open %s" % afile )
453         except bb.parse.ParseError, details:
454             bb.msg.fatal(bb.msg.domain.Parsing, "Unable to parse %s (%s)" % (afile, details) )
455
456     def handleCollections( self, collections ):
457         """Handle collections"""
458         if collections:
459             collection_list = collections.split()
460             for c in collection_list:
461                 regex = bb.data.getVar("BBFILE_PATTERN_%s" % c, self.configuration.data, 1)
462                 if regex == None:
463                     bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PATTERN_%s not defined" % c)
464                     continue
465                 priority = bb.data.getVar("BBFILE_PRIORITY_%s" % c, self.configuration.data, 1)
466                 if priority == None:
467                     bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PRIORITY_%s not defined" % c)
468                     continue
469                 try:
470                     cre = re.compile(regex)
471                 except re.error:
472                     bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PATTERN_%s \"%s\" is not a valid regular expression" % (c, regex))
473                     continue
474                 try:
475                     pri = int(priority)
476                     self.status.bbfile_config_priorities.append((cre, pri))
477                 except ValueError:
478                     bb.msg.error(bb.msg.domain.Parsing, "invalid value for BBFILE_PRIORITY_%s: \"%s\"" % (c, priority))
479
480
481     def cook( self, configuration, args ):
482         """
483         We are building stuff here. We do the building
484         from here. By default we try to execute task
485         build.
486         """
487
488         self.configuration = configuration
489
490         if self.configuration.verbose:
491             bb.msg.set_verbose(True)
492
493         if self.configuration.debug:
494             bb.msg.set_debug_level(self.configuration.debug)
495         else:
496             bb.msg.set_debug_level(0)
497
498         if self.configuration.debug_domains:
499             bb.msg.set_debug_domains(self.configuration.debug_domains)
500
501         self.configuration.data = bb.data.init()
502
503         for f in self.configuration.file:
504             self.parseConfigurationFile( f )
505
506         self.parseConfigurationFile( os.path.join( "conf", "bitbake.conf" ) )
507
508         if not self.configuration.cmd:
509             self.configuration.cmd = bb.data.getVar("BB_DEFAULT_TASK", self.configuration.data)
510
511         # For backwards compatibility - REMOVE ME
512         if not self.configuration.cmd:
513             self.configuration.cmd = "build"
514
515         #
516         # Special updated configuration we use for firing events
517         #
518         self.configuration.event_data = bb.data.createCopy(self.configuration.data)
519         bb.data.update_data(self.configuration.event_data)
520
521         if self.configuration.show_environment:
522             self.showEnvironment()
523             sys.exit( 0 )
524
525         # inject custom variables
526         if not bb.data.getVar("BUILDNAME", self.configuration.data):
527             bb.data.setVar("BUILDNAME", os.popen('date +%Y%m%d%H%M').readline().strip(), self.configuration.data)
528         bb.data.setVar("BUILDSTART", time.strftime('%m/%d/%Y %H:%M:%S',time.gmtime()),self.configuration.data)
529
530         buildname = bb.data.getVar("BUILDNAME", self.configuration.data)
531
532         if self.configuration.interactive:
533             self.interactiveMode()
534
535         if self.configuration.buildfile is not None:
536             bf = self.configuration.buildfile
537             try:
538                 os.stat(bf)
539             except OSError:
540                 bf = os.path.abspath( self.configuration.buildfile )
541                 try:
542                     os.stat(bf)
543                 except OSError:
544                     (filelist, masked) = self.collect_bbfiles()
545                     regexp = re.compile(self.configuration.buildfile)
546                     matches = 0
547                     for f in filelist:
548                         if regexp.search(f):
549                             bf = f
550                             matches = matches + 1
551                     if matches != 1:
552                         bb.msg.fatal(bb.msg.domain.Parsing, "Unable to match %s (%s matches found)" % (self.configuration.buildfile, matches))
553
554             bbfile_data = bb.parse.handle(bf, self.configuration.data)
555
556             item = bb.data.getVar('PN', bbfile_data, 1)
557             try:
558                 self.tryBuildPackage(bf, item, self.configuration.cmd, bbfile_data, True)
559             except bb.build.EventException:
560                 bb.msg.error(bb.msg.domain.Build,  "Build of '%s' failed" % item )
561
562             sys.exit( self.stats.show() )
563
564         # initialise the parsing status now we know we will need deps
565         self.status = bb.cache.CacheData()
566
567         ignore = bb.data.getVar("ASSUME_PROVIDED", self.configuration.data, 1) or ""
568         self.status.ignored_dependencies = Set( ignore.split() )
569
570         self.handleCollections( bb.data.getVar("BBFILE_COLLECTIONS", self.configuration.data, 1) )
571
572         pkgs_to_build = None
573         if args:
574             if not pkgs_to_build:
575                 pkgs_to_build = []
576             pkgs_to_build.extend(args)
577         if not pkgs_to_build:
578                 bbpkgs = bb.data.getVar('BBPKGS', self.configuration.data, 1)
579                 if bbpkgs:
580                         pkgs_to_build = bbpkgs.split()
581         if not pkgs_to_build and not self.configuration.show_versions \
582                              and not self.configuration.interactive \
583                              and not self.configuration.show_environment:
584                 print "Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help'"
585                 print "for usage information."
586                 sys.exit(0)
587
588         # Import Psyco if available and not disabled
589         if not self.configuration.disable_psyco:
590             try:
591                 import psyco
592             except ImportError:
593                 bb.msg.note(1, bb.msg.domain.Collection, "Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
594             else:
595                 psyco.bind( self.parse_bbfiles )
596         else:
597             bb.msg.note(1, bb.msg.domain.Collection, "You have disabled Psyco. This decreases performance.")
598
599         try:
600             bb.msg.debug(1, bb.msg.domain.Collection, "collecting .bb files")
601             (filelist, masked) = self.collect_bbfiles()
602             self.parse_bbfiles(filelist, masked, self.myProgressCallback)
603             bb.msg.debug(1, bb.msg.domain.Collection, "parsing complete")
604             print
605             if self.configuration.parse_only:
606                 bb.msg.note(1, bb.msg.domain.Collection, "Requested parsing .bb files only.  Exiting.")
607                 return
608
609
610             self.buildDepgraph()
611
612             if self.configuration.show_versions:
613                 self.showVersions()
614                 sys.exit( 0 )
615             if 'world' in pkgs_to_build:
616                 self.buildWorldTargetList()
617                 pkgs_to_build.remove('world')
618                 for t in self.status.world_target:
619                     pkgs_to_build.append(t)
620
621             if self.configuration.dot_graph:
622                 self.generateDotGraph( pkgs_to_build, self.configuration.ignored_dot_deps )
623                 sys.exit( 0 )
624
625             bb.event.fire(bb.event.BuildStarted(buildname, pkgs_to_build, self.configuration.event_data))
626
627             taskdata = bb.taskdata.TaskData()
628
629             runlist = []
630             try:
631                 for k in pkgs_to_build:
632                     taskdata.add_provider(self.configuration.data, self.status, k)
633                     runlist.append([k, "do_%s" % self.configuration.cmd])
634                 taskdata.add_unresolved(self.configuration.data, self.status)
635             except bb.providers.NoProvider:
636                 sys.exit(1)
637
638             rq = bb.runqueue.RunQueue()
639             rq.prepare_runqueue(self.configuration.data, self.status, taskdata, runlist)
640             try:
641                 failures = rq.execute_runqueue(self, self.configuration.data, self.status, taskdata, runlist)
642             except runqueue.TaskFailure, (fnid, fn, taskname):
643                 bb.msg.error(bb.msg.domain.Build, "'%s, %s' failed" % (fn, taskname))
644                 sys.exit(1)
645
646             bb.event.fire(bb.event.BuildCompleted(buildname, pkgs_to_build, self.configuration.event_data, failures))
647
648             sys.exit( self.stats.show() )
649
650         except KeyboardInterrupt:
651             bb.msg.note(1, bb.msg.domain.Collection, "KeyboardInterrupt - Build not completed.")
652             sys.exit(1)
653
654     def get_bbfiles( self, path = os.getcwd() ):
655         """Get list of default .bb files by reading out the current directory"""
656         contents = os.listdir(path)
657         bbfiles = []
658         for f in contents:
659             (root, ext) = os.path.splitext(f)
660             if ext == ".bb":
661                 bbfiles.append(os.path.abspath(os.path.join(os.getcwd(),f)))
662         return bbfiles
663
664     def find_bbfiles( self, path ):
665         """Find all the .bb files in a directory (uses find)"""
666         findcmd = 'find ' + path + ' -name *.bb | grep -v SCCS/'
667         try:
668             finddata = os.popen(findcmd)
669         except OSError:
670             return []
671         return finddata.readlines()
672
673     def collect_bbfiles( self ):
674         """Collect all available .bb build files"""
675         parsed, cached, skipped, masked = 0, 0, 0, 0
676         self.bb_cache = bb.cache.init(self)
677
678         files = (data.getVar( "BBFILES", self.configuration.data, 1 ) or "").split()
679         data.setVar("BBFILES", " ".join(files), self.configuration.data)
680
681         if not len(files):
682             files = self.get_bbfiles()
683
684         if not len(files):
685             bb.msg.error(bb.msg.domain.Collection, "no files to build.")
686
687         newfiles = []
688         for f in files:
689             if os.path.isdir(f):
690                 dirfiles = self.find_bbfiles(f)
691                 if dirfiles:
692                     newfiles += dirfiles
693                     continue
694             newfiles += glob.glob(f) or [ f ]
695
696         bbmask = bb.data.getVar('BBMASK', self.configuration.data, 1)
697
698         if not bbmask:
699             return (newfiles, 0)
700
701         try:
702             bbmask_compiled = re.compile(bbmask)
703         except sre_constants.error:
704             bb.msg.fatal(bb.msg.domain.Collection, "BBMASK is not a valid regular expression.")
705
706         finalfiles = []
707         for i in xrange( len( newfiles ) ):
708             f = newfiles[i]
709             if bbmask and bbmask_compiled.search(f):
710                 bb.msg.debug(1, bb.msg.domain.Collection, "skipping masked file %s" % f)
711                 masked += 1
712                 continue
713             finalfiles.append(f)
714
715         return (finalfiles, masked)
716
717     def parse_bbfiles(self, filelist, masked, progressCallback = None):
718         parsed, cached, skipped = 0, 0, 0
719         for i in xrange( len( filelist ) ):
720             f = filelist[i]
721
722             bb.msg.debug(1, bb.msg.domain.Collection, "parsing %s" % f)
723
724             # read a file's metadata
725             try:
726                 fromCache, skip = self.bb_cache.loadData(f, self)
727                 if skip:
728                     skipped += 1
729                     bb.msg.debug(2, bb.msg.domain.Collection, "skipping %s" % f)
730                     self.bb_cache.skip(f)
731                     continue
732                 elif fromCache: cached += 1
733                 else: parsed += 1
734                 deps = None
735
736                 # Disabled by RP as was no longer functional
737                 # allow metadata files to add items to BBFILES
738                 #data.update_data(self.pkgdata[f])
739                 #addbbfiles = self.bb_cache.getVar('BBFILES', f, False) or None
740                 #if addbbfiles:
741                 #    for aof in addbbfiles.split():
742                 #        if not files.count(aof):
743                 #            if not os.path.isabs(aof):
744                 #                aof = os.path.join(os.path.dirname(f),aof)
745                 #            files.append(aof)
746
747                 # now inform the caller
748                 if progressCallback is not None:
749                     progressCallback( i + 1, len( filelist ), f, self.bb_cache, fromCache )
750
751             except IOError, e:
752                 self.bb_cache.remove(f)
753                 bb.msg.error(bb.msg.domain.Collection, "opening %s: %s" % (f, e))
754                 pass
755             except KeyboardInterrupt:
756                 self.bb_cache.sync()
757                 raise
758             except Exception, e:
759                 self.bb_cache.remove(f)
760                 bb.msg.error(bb.msg.domain.Collection, "%s while parsing %s" % (e, f))
761             except:
762                 self.bb_cache.remove(f)
763                 raise
764
765         if progressCallback is not None:
766             print "\r" # need newline after Handling Bitbake files message
767             bb.msg.note(1, bb.msg.domain.Collection, "Parsing finished. %d cached, %d parsed, %d skipped, %d masked." % ( cached, parsed, skipped, masked ))
768
769         self.bb_cache.sync()
770
771 #============================================================================#
772 # main
773 #============================================================================#
774
775 def main():
776     parser = optparse.OptionParser( version = "BitBake Build Tool Core version %s, %%prog version %s" % ( bb.__version__, __version__ ),
777     usage = """%prog [options] [package ...]
778
779 Executes the specified task (default is 'build') for a given set of BitBake files.
780 It expects that BBFILES is defined, which is a space seperated list of files to
781 be executed.  BBFILES does support wildcards.
782 Default BBFILES are the .bb files in the current directory.""" )
783
784     parser.add_option( "-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
785                action = "store", dest = "buildfile", default = None )
786
787     parser.add_option( "-k", "--continue", help = "continue as much as possible after an error. While the target that failed, and those that depend on it, cannot be remade, the other dependencies of these targets can be processed all the same.",
788                action = "store_false", dest = "abort", default = True )
789
790     parser.add_option( "-f", "--force", help = "force run of specified cmd, regardless of stamp status",
791                action = "store_true", dest = "force", default = False )
792
793     parser.add_option( "-i", "--interactive", help = "drop into the interactive mode also called the BitBake shell.",
794                action = "store_true", dest = "interactive", default = False )
795
796     parser.add_option( "-c", "--cmd", help = "Specify task to execute. Note that this only executes the specified task for the providee and the packages it depends on, i.e. 'compile' does not implicitly call stage for the dependencies (IOW: use only if you know what you are doing). Depending on the base.bbclass a listtaks tasks is defined and will show available tasks",
797                action = "store", dest = "cmd" )
798
799     parser.add_option( "-r", "--read", help = "read the specified file before bitbake.conf",
800                action = "append", dest = "file", default = [] )
801
802     parser.add_option( "-v", "--verbose", help = "output more chit-chat to the terminal",
803                action = "store_true", dest = "verbose", default = False )
804
805     parser.add_option( "-D", "--debug", help = "Increase the debug level. You can specify this more than once.",
806                action = "count", dest="debug", default = 0)
807
808     parser.add_option( "-n", "--dry-run", help = "don't execute, just go through the motions",
809                action = "store_true", dest = "dry_run", default = False )
810
811     parser.add_option( "-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
812                action = "store_true", dest = "parse_only", default = False )
813
814     parser.add_option( "-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
815                action = "store_true", dest = "disable_psyco", default = False )
816
817     parser.add_option( "-s", "--show-versions", help = "show current and preferred versions of all packages",
818                action = "store_true", dest = "show_versions", default = False )
819
820     parser.add_option( "-e", "--environment", help = "show the global or per-package environment (this is what used to be bbread)",
821                action = "store_true", dest = "show_environment", default = False )
822
823     parser.add_option( "-g", "--graphviz", help = "emit the dependency trees of the specified packages in the dot syntax",
824                 action = "store_true", dest = "dot_graph", default = False )
825
826     parser.add_option( "-I", "--ignore-deps", help = """Stop processing at the given list of dependencies when generating dependency graphs. This can help to make the graph more appealing""",
827                 action = "append", dest = "ignored_dot_deps", default = [] )
828
829     parser.add_option( "-l", "--log-domains", help = """Show debug logging for the specified logging domains""",
830                 action = "append", dest = "debug_domains", default = [] )
831
832
833     options, args = parser.parse_args( sys.argv )
834
835     cooker = BBCooker()
836     cooker.cook( BBConfiguration( options ), args[1:] )
837
838
839
840 if __name__ == "__main__":
841     print """WARNING, WARNING, WARNING
842 This is a Bitbake from the Unstable/Development Branch.
843 You might want to use the bitbake-1.6 stable branch (if you are not a BitBake developer or tester). I'm going to sleep 5 seconds now to make sure you see that."""
844     import time
845     time.sleep(5)
846     main()