code.vuplus.com Git - vuplus_bitbake/blob - 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.1"
  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.configuration.data)
 128
 129         item = self.status.pkg_fn[fn]
 130
 131         if bb.build.stamp_is_current('do_%s' % self.configuration.cmd, the_data) and not self.configuration.force:
 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.configuration.data)
 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, from_cache ):
 407         """Update any tty with the progress change"""
 408         if os.isatty(sys.stdout.fileno()):
 409             sys.stdout.write("\rNOTE: Handling BitBake files: %s (%04d/%04d) [%2d %%]" % ( parsespin.next(), x, y, x*100/y ) )
 410             sys.stdout.flush()
 411         else:
 412             if x == 1:
 413                 sys.stdout.write("Parsing .bb files, please wait...")
 414                 sys.stdout.flush()
 415             if x == y:
 416                 sys.stdout.write("done.")
 417                 sys.stdout.flush()
 418
 419     def interactiveMode( self ):
 420         """Drop off into a shell"""
 421         try:
 422             from bb import shell
 423         except ImportError, details:
 424             bb.msg.fatal(bb.msg.domain.Parsing, "Sorry, shell not available (%s)" % details )
 425         else:
 426             bb.data.update_data( self.configuration.data )
 427             shell.start( self )
 428             sys.exit( 0 )
 429
 430     def parseConfigurationFile( self, afile ):
 431         try:
 432             self.configuration.data = bb.parse.handle( afile, self.configuration.data )
 433
 434             # Add the handlers we inherited by INHERIT
 435             # we need to do this manually as it is not guranteed
 436             # we will pick up these classes... as we only INHERIT
 437             # on .inc and .bb files but not on .conf
 438             data = bb.data.createCopy( self.configuration.data )
 439             inherits  = ["base"] + (bb.data.getVar('INHERIT', data, True ) or "").split()
 440             for inherit in inherits:
 441                 data = bb.parse.handle( os.path.join('classes', '%s.bbclass' % inherit ), data, True )
 442
 443             # FIXME: This assumes that we included at least one .inc file
 444             for var in bb.data.keys(data):
 445                 if bb.data.getVarFlag(var, 'handler', data):
 446                     bb.event.register(var,bb.data.getVar(var, data))
 447
 448         except IOError:
 449             bb.msg.fatal(bb.msg.domain.Parsing, "Unable to open %s" % afile )
 450         except bb.parse.ParseError, details:
 451             bb.msg.fatal(bb.msg.domain.Parsing, "Unable to parse %s (%s)" % (afile, details) )
 452
 453     def handleCollections( self, collections ):
 454         """Handle collections"""
 455         if collections:
 456             collection_list = collections.split()
 457             for c in collection_list:
 458                 regex = bb.data.getVar("BBFILE_PATTERN_%s" % c, self.configuration.data, 1)
 459                 if regex == None:
 460                     bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PATTERN_%s not defined" % c)
 461                     continue
 462                 priority = bb.data.getVar("BBFILE_PRIORITY_%s" % c, self.configuration.data, 1)
 463                 if priority == None:
 464                     bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PRIORITY_%s not defined" % c)
 465                     continue
 466                 try:
 467                     cre = re.compile(regex)
 468                 except re.error:
 469                     bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PATTERN_%s \"%s\" is not a valid regular expression" % (c, regex))
 470                     continue
 471                 try:
 472                     pri = int(priority)
 473                     self.status.bbfile_config_priorities.append((cre, pri))
 474                 except ValueError:
 475                     bb.msg.error(bb.msg.domain.Parsing, "invalid value for BBFILE_PRIORITY_%s: \"%s\"" % (c, priority))
 476
 477
 478     def cook( self, configuration, args ):
 479         """
 480         We are building stuff here. We do the building
 481         from here. By default we try to execute task
 482         build.
 483         """
 484
 485         self.configuration = configuration
 486
 487         if self.configuration.verbose:
 488             bb.msg.set_verbose(True)
 489
 490         if self.configuration.debug:
 491             bb.msg.set_debug_level(self.configuration.debug)
 492         else:
 493             bb.msg.set_debug_level(0)
 494
 495         if self.configuration.debug_domains:
 496             bb.msg.set_debug_domains(self.configuration.debug_domains)
 497
 498         self.configuration.data = bb.data.init()
 499
 500         for f in self.configuration.file:
 501             self.parseConfigurationFile( f )
 502
 503         self.parseConfigurationFile( os.path.join( "conf", "bitbake.conf" ) )
 504
 505         if not self.configuration.cmd:
 506             self.configuration.cmd = bb.data.getVar("BB_DEFAULT_TASK", self.configuration.data)
 507
 508         # For backwards compatibility - REMOVE ME
 509         if not self.configuration.cmd:
 510             self.configuration.cmd = "build"
 511
 512         #
 513         # Special updated configuration we use for firing events
 514         #
 515         self.configuration.event_data = bb.data.createCopy(self.configuration.data)
 516         bb.data.update_data(self.configuration.event_data)
 517
 518         if self.configuration.show_environment:
 519             self.showEnvironment()
 520             sys.exit( 0 )
 521
 522         # inject custom variables
 523         if not bb.data.getVar("BUILDNAME", self.configuration.data):
 524             bb.data.setVar("BUILDNAME", os.popen('date +%Y%m%d%H%M').readline().strip(), self.configuration.data)
 525         bb.data.setVar("BUILDSTART", time.strftime('%m/%d/%Y %H:%M:%S',time.gmtime()),self.configuration.data)
 526
 527         buildname = bb.data.getVar("BUILDNAME", self.configuration.data)
 528
 529         if self.configuration.interactive:
 530             self.interactiveMode()
 531
 532         if self.configuration.buildfile is not None:
 533             bf = os.path.abspath( self.configuration.buildfile )
 534             try:
 535                 os.stat(bf)
 536             except OSError:
 537                 (filelist, masked) = self.collect_bbfiles()
 538                 regexp = re.compile(self.configuration.buildfile)
 539                 matches = 0
 540                 for f in filelist:
 541                     if regexp.search(f):
 542                         bf = f
 543                         matches = matches + 1
 544                 if matches != 1:
 545                     bb.msg.fatal(bb.msg.domain.Parsing, "Unable to match %s (%s matches found)" % (self.configuration.buildfile, matches))
 546
 547             bbfile_data = bb.parse.handle(bf, self.configuration.data)
 548
 549             item = bb.data.getVar('PN', bbfile_data, 1)
 550             try:
 551                 self.tryBuildPackage(bf, item, self.configuration.cmd, bbfile_data, True)
 552             except bb.build.EventException:
 553                 bb.msg.error(bb.msg.domain.Build,  "Build of '%s' failed" % item )
 554
 555             sys.exit( self.stats.show() )
 556
 557         # initialise the parsing status now we know we will need deps
 558         self.status = bb.cache.CacheData()
 559
 560         ignore = bb.data.getVar("ASSUME_PROVIDED", self.configuration.data, 1) or ""
 561         self.status.ignored_dependencies = Set( ignore.split() )
 562
 563         self.handleCollections( bb.data.getVar("BBFILE_COLLECTIONS", self.configuration.data, 1) )
 564
 565         pkgs_to_build = None
 566         if args:
 567             if not pkgs_to_build:
 568                 pkgs_to_build = []
 569             pkgs_to_build.extend(args)
 570         if not pkgs_to_build:
 571                 bbpkgs = bb.data.getVar('BBPKGS', self.configuration.data, 1)
 572                 if bbpkgs:
 573                         pkgs_to_build = bbpkgs.split()
 574         if not pkgs_to_build and not self.configuration.show_versions \
 575                              and not self.configuration.interactive \
 576                              and not self.configuration.show_environment:
 577                 print "Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help'"
 578                 print "for usage information."
 579                 sys.exit(0)
 580
 581         # Import Psyco if available and not disabled
 582         if not self.configuration.disable_psyco:
 583             try:
 584                 import psyco
 585             except ImportError:
 586                 bb.msg.note(1, bb.msg.domain.Collection, "Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
 587             else:
 588                 psyco.bind( self.parse_bbfiles )
 589         else:
 590             bb.msg.note(1, bb.msg.domain.Collection, "You have disabled Psyco. This decreases performance.")
 591
 592         try:
 593             bb.msg.debug(1, bb.msg.domain.Collection, "collecting .bb files")
 594             (filelist, masked) = self.collect_bbfiles()
 595             self.parse_bbfiles(filelist, masked, self.myProgressCallback)
 596             bb.msg.debug(1, bb.msg.domain.Collection, "parsing complete")
 597             print
 598             if self.configuration.parse_only:
 599                 bb.msg.note(1, bb.msg.domain.Collection, "Requested parsing .bb files only.  Exiting.")
 600                 return
 601
 602
 603             self.buildDepgraph()
 604
 605             if self.configuration.show_versions:
 606                 self.showVersions()
 607                 sys.exit( 0 )
 608             if 'world' in pkgs_to_build:
 609                 self.buildWorldTargetList()
 610                 pkgs_to_build.remove('world')
 611                 for t in self.status.world_target:
 612                     pkgs_to_build.append(t)
 613
 614             if self.configuration.dot_graph:
 615                 self.generateDotGraph( pkgs_to_build, self.configuration.ignored_dot_deps )
 616                 sys.exit( 0 )
 617
 618             bb.event.fire(bb.event.BuildStarted(buildname, pkgs_to_build, self.configuration.event_data))
 619
 620             taskdata = bb.taskdata.TaskData()
 621
 622             runlist = []
 623             try:
 624                 for k in pkgs_to_build:
 625                     taskdata.add_provider(self.configuration.data, self.status, k)
 626                     runlist.append([k, "do_%s" % self.configuration.cmd])
 627                 taskdata.add_unresolved(self.configuration.data, self.status)
 628             except bb.providers.NoProvider:
 629                 sys.exit(1)
 630
 631             rq = bb.runqueue.RunQueue()
 632             rq.prepare_runqueue(self.configuration.data, self.status, taskdata, runlist)
 633             try:
 634                 failures = rq.execute_runqueue(self, self.configuration.data, self.status, taskdata, runlist)
 635             except runqueue.TaskFailure, (fnid, fn, taskname):
 636                 bb.msg.error(bb.msg.domain.Build, "'%s, %s' failed" % (fn, taskname))
 637                 sys.exit(1)
 638
 639             bb.event.fire(bb.event.BuildCompleted(buildname, pkgs_to_build, self.configuration.event_data, failures))
 640
 641             sys.exit( self.stats.show() )
 642
 643         except KeyboardInterrupt:
 644             bb.msg.note(1, bb.msg.domain.Collection, "KeyboardInterrupt - Build not completed.")
 645             sys.exit(1)
 646
 647     def get_bbfiles( self, path = os.getcwd() ):
 648         """Get list of default .bb files by reading out the current directory"""
 649         contents = os.listdir(path)
 650         bbfiles = []
 651         for f in contents:
 652             (root, ext) = os.path.splitext(f)
 653             if ext == ".bb":
 654                 bbfiles.append(os.path.abspath(os.path.join(os.getcwd(),f)))
 655         return bbfiles
 656
 657     def find_bbfiles( self, path ):
 658         """Find all the .bb files in a directory (uses find)"""
 659         findcmd = 'find ' + path + ' -name *.bb | grep -v SCCS/'
 660         try:
 661             finddata = os.popen(findcmd)
 662         except OSError:
 663             return []
 664         return finddata.readlines()
 665
 666     def collect_bbfiles( self ):
 667         """Collect all available .bb build files"""
 668         parsed, cached, skipped, masked = 0, 0, 0, 0
 669         self.bb_cache = bb.cache.init(self)
 670
 671         files = (data.getVar( "BBFILES", self.configuration.data, 1 ) or "").split()
 672         data.setVar("BBFILES", " ".join(files), self.configuration.data)
 673
 674         if not len(files):
 675             files = self.get_bbfiles()
 676
 677         if not len(files):
 678             bb.msg.error(bb.msg.domain.Collection, "no files to build.")
 679
 680         newfiles = []
 681         for f in files:
 682             if os.path.isdir(f):
 683                 dirfiles = self.find_bbfiles(f)
 684                 if dirfiles:
 685                     newfiles += dirfiles
 686                     continue
 687             newfiles += glob.glob(f) or [ f ]
 688
 689         bbmask = bb.data.getVar('BBMASK', self.configuration.data, 1)
 690
 691         if not bbmask:
 692             return (newfiles, 0)
 693
 694         try:
 695             bbmask_compiled = re.compile(bbmask)
 696         except sre_constants.error:
 697             bb.msg.fatal(bb.msg.domain.Collection, "BBMASK is not a valid regular expression.")
 698
 699         finalfiles = []
 700         for i in xrange( len( newfiles ) ):
 701             f = newfiles[i]
 702             if bbmask and bbmask_compiled.search(f):
 703                 bb.msg.debug(1, bb.msg.domain.Collection, "skipping masked file %s" % f)
 704                 masked += 1
 705                 continue
 706             finalfiles.append(f)
 707
 708         return (finalfiles, masked)
 709
 710     def parse_bbfiles(self, filelist, masked, progressCallback = None):
 711         parsed, cached, skipped = 0, 0, 0
 712         for i in xrange( len( filelist ) ):
 713             f = filelist[i]
 714
 715             bb.msg.debug(1, bb.msg.domain.Collection, "parsing %s" % f)
 716
 717             # read a file's metadata
 718             try:
 719                 fromCache, skip = self.bb_cache.loadData(f, self.configuration.data)
 720                 if skip:
 721                     skipped += 1
 722                     bb.msg.debug(2, bb.msg.domain.Collection, "skipping %s" % f)
 723                     self.bb_cache.skip(f)
 724                     continue
 725                 elif fromCache: cached += 1
 726                 else: parsed += 1
 727                 deps = None
 728
 729                 # Disabled by RP as was no longer functional
 730                 # allow metadata files to add items to BBFILES
 731                 #data.update_data(self.pkgdata[f])
 732                 #addbbfiles = self.bb_cache.getVar('BBFILES', f, False) or None
 733                 #if addbbfiles:
 734                 #    for aof in addbbfiles.split():
 735                 #        if not files.count(aof):
 736                 #            if not os.path.isabs(aof):
 737                 #                aof = os.path.join(os.path.dirname(f),aof)
 738                 #            files.append(aof)
 739
 740                 self.bb_cache.handle_data(f, self.status)
 741
 742                 # now inform the caller
 743                 if progressCallback is not None:
 744                     progressCallback( i + 1, len( filelist ), f, fromCache )
 745
 746             except IOError, e:
 747                 self.bb_cache.remove(f)
 748                 bb.msg.error(bb.msg.domain.Collection, "opening %s: %s" % (f, e))
 749                 pass
 750             except KeyboardInterrupt:
 751                 self.bb_cache.sync()
 752                 raise
 753             except Exception, e:
 754                 self.bb_cache.remove(f)
 755                 bb.msg.error(bb.msg.domain.Collection, "%s while parsing %s" % (e, f))
 756             except:
 757                 self.bb_cache.remove(f)
 758                 raise
 759
 760         if progressCallback is not None:
 761             print "\r" # need newline after Handling Bitbake files message
 762             bb.msg.note(1, bb.msg.domain.Collection, "Parsing finished. %d cached, %d parsed, %d skipped, %d masked." % ( cached, parsed, skipped, masked ))
 763
 764         self.bb_cache.sync()
 765
 766 #============================================================================#
 767 # main
 768 #============================================================================#
 769
 770 def main():
 771     parser = optparse.OptionParser( version = "BitBake Build Tool Core version %s, %%prog version %s" % ( bb.__version__, __version__ ),
 772     usage = """%prog [options] [package ...]
 773
 774 Executes the specified task (default is 'build') for a given set of BitBake files.
 775 It expects that BBFILES is defined, which is a space seperated list of files to
 776 be executed.  BBFILES does support wildcards.
 777 Default BBFILES are the .bb files in the current directory.""" )
 778
 779     parser.add_option( "-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
 780                action = "store", dest = "buildfile", default = None )
 781
 782     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.",
 783                action = "store_false", dest = "abort", default = True )
 784
 785     parser.add_option( "-f", "--force", help = "force run of specified cmd, regardless of stamp status",
 786                action = "store_true", dest = "force", default = False )
 787
 788     parser.add_option( "-i", "--interactive", help = "drop into the interactive mode also called the BitBake shell.",
 789                action = "store_true", dest = "interactive", default = False )
 790
 791     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",
 792                action = "store", dest = "cmd" )
 793
 794     parser.add_option( "-r", "--read", help = "read the specified file before bitbake.conf",
 795                action = "append", dest = "file", default = [] )
 796
 797     parser.add_option( "-v", "--verbose", help = "output more chit-chat to the terminal",
 798                action = "store_true", dest = "verbose", default = False )
 799
 800     parser.add_option( "-D", "--debug", help = "Increase the debug level. You can specify this more than once.",
 801                action = "count", dest="debug", default = 0)
 802
 803     parser.add_option( "-n", "--dry-run", help = "don't execute, just go through the motions",
 804                action = "store_true", dest = "dry_run", default = False )
 805
 806     parser.add_option( "-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
 807                action = "store_true", dest = "parse_only", default = False )
 808
 809     parser.add_option( "-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
 810                action = "store_true", dest = "disable_psyco", default = False )
 811
 812     parser.add_option( "-s", "--show-versions", help = "show current and preferred versions of all packages",
 813                action = "store_true", dest = "show_versions", default = False )
 814
 815     parser.add_option( "-e", "--environment", help = "show the global or per-package environment (this is what used to be bbread)",
 816                action = "store_true", dest = "show_environment", default = False )
 817
 818     parser.add_option( "-g", "--graphviz", help = "emit the dependency trees of the specified packages in the dot syntax",
 819                 action = "store_true", dest = "dot_graph", default = False )
 820
 821     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""",
 822                 action = "append", dest = "ignored_dot_deps", default = [] )
 823
 824     parser.add_option( "-l", "--log-domains", help = """Show debug logging for the specified logging domains""",
 825                 action = "append", dest = "debug_domains", default = [] )
 826
 827
 828     options, args = parser.parse_args( sys.argv )
 829
 830     cooker = BBCooker()
 831     cooker.cook( BBConfiguration( options ), args[1:] )
 832
 833
 834
 835 if __name__ == "__main__":
 836     print """WARNING, WARNING, WARNING
 837 This is a Bitbake from the Unstable/Development Branch.
 838 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."""
 839     import time
 840     time.sleep(5)
 841     main()