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 #
  11 # This program is free software; you can redistribute it and/or modify it under
  12 # the terms of the GNU General Public License as published by the Free Software
  13 # Foundation; either version 2 of the License, or (at your option) any later
  14 # version.
  15 #
  16 # This program is distributed in the hope that it will be useful, but WITHOUT
  17 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  18 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License along with
  21 # this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  22 # Place, Suite 330, Boston, MA 02111-1307 USA.
  23
  24 import sys, os, getopt, glob, copy, os.path, re, time
  25 sys.path.append(os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
  26 import bb
  27 from bb import utils, data, parse, debug, event, fatal
  28 from sets import Set
  29 import itertools, optparse
  30
  31 parsespin = itertools.cycle( r'|/-\\' )
  32 bbdebug = 0
  33
  34 __version__ = "1.3.2"
  35
  36 #============================================================================#
  37 # BBParsingStatus
  38 #============================================================================#
  39 class BBParsingStatus:
  40     """
  41     The initial idea for this status class is to use the data when it is
  42     already loaded instead of loading it from various place over and over
  43     again.
  44     """
  45
  46     def __init__(self):
  47         self.cache_dirty = False
  48         self.providers   = {}
  49         self.bbfile_priority = {}
  50         self.bbfile_config_priorities = []
  51         self.ignored_dependencies = None
  52         self.possible_world = []
  53         self.world_target = Set()
  54         self.pkg_pn = {}
  55         self.pkg_fn = {}
  56         self.pkg_pvpr = {}
  57         self.pkg_dp = {}
  58         self.pn_provides = {}
  59         self.all_depends = Set()
  60
  61     def handle_bb_data(self, file_name, bb_data, cached):
  62         """
  63         We will fill the dictionaries with the stuff we
  64         need for building the tree more fast
  65         """
  66         if bb_data == None:
  67             return
  68
  69         if not cached:
  70             self.cache_dirty = True
  71
  72         pn       = bb.data.getVar('PN', bb_data, True)
  73         pv       = bb.data.getVar('PV', bb_data, True)
  74         pr       = bb.data.getVar('PR', bb_data, True)
  75         dp       = int(bb.data.getVar('DEFAULT_PREFERENCE', bb_data, True) or "0")
  76         provides = Set([pn] + (bb.data.getVar("PROVIDES", bb_data, 1) or "").split())
  77         depends  = (bb.data.getVar("DEPENDS", bb_data, True) or "").split()
  78
  79
  80         # build PackageName to FileName lookup table
  81         if pn not in self.pkg_pn:
  82             self.pkg_pn[pn] = []
  83         self.pkg_pn[pn].append(file_name)
  84
  85         # build FileName to PackageName lookup table
  86         self.pkg_fn[file_name] = pn
  87         self.pkg_pvpr[file_name] = (pv,pr)
  88         self.pkg_dp[file_name] = dp
  89
  90         # Build forward and reverse provider hashes
  91         # Forward: virtual -> [filenames]
  92         # Reverse: PN -> [virtuals]
  93         if pn not in self.pn_provides:
  94             self.pn_provides[pn] = Set()
  95         self.pn_provides[pn] |= provides
  96
  97         for provide in provides:
  98             if provide not in self.providers:
  99                 self.providers[provide] = []
 100             self.providers[provide].append(file_name)
 101
 102         for dep in depends:
 103             self.all_depends.add(dep)
 104
 105         # Collect files we may need for possible world-dep
 106         # calculations
 107         if not bb.data.getVar('BROKEN', bb_data, True) and not bb.data.getVar('EXCLUDE_FROM_WORLD', bb_data, True):
 108             self.possible_world.append(file_name)
 109
 110
 111 #============================================================================#
 112 # BBStatistics
 113 #============================================================================#
 114 class BBStatistics:
 115     """
 116     Manage build statistics for one run
 117     """
 118     def __init__(self ):
 119         self.attempt = 0
 120         self.success = 0
 121         self.fail = 0
 122         self.deps = 0
 123
 124     def show( self ):
 125         print "Build statistics:"
 126         print "  Attempted builds: %d" % self.attempt
 127         if self.fail:
 128             print "  Failed builds: %d" % self.fail
 129         if self.deps:
 130             print "  Dependencies not satisfied: %d" % self.deps
 131         if self.fail or self.deps: return 1
 132         else: return 0
 133
 134
 135 #============================================================================#
 136 # BBOptions
 137 #============================================================================#
 138 class BBConfiguration( object ):
 139     """
 140     Manages build options and configurations for one run
 141     """
 142     def __init__( self, options ):
 143         for key, val in options.__dict__.items():
 144             setattr( self, key, val )
 145         self.data = data.init()
 146
 147 #============================================================================#
 148 # BBCooker
 149 #============================================================================#
 150 class BBCooker:
 151     """
 152     Manages one bitbake build run
 153     """
 154
 155     ParsingStatus = BBParsingStatus     # make it visible from the shell
 156     Statistics = BBStatistics           # make it visible from the shell
 157
 158     def __init__( self ):
 159         self.build_cache_fail = []
 160         self.build_cache = []
 161         self.building_list = []
 162         self.build_path = []
 163         self.consider_msgs_cache = []
 164         self.preferred = {}
 165         self.stats = BBStatistics()
 166         self.status = None
 167
 168         self.pkgdata = None
 169         self.cache = None
 170
 171     def tryBuildPackage( self, fn, item, the_data ):
 172         """Build one package"""
 173         bb.event.fire(bb.event.PkgStarted(item, the_data))
 174         try:
 175             self.stats.attempt += 1
 176             if self.configuration.force:
 177                 bb.data.setVarFlag('do_%s' % self.configuration.cmd, 'force', 1, the_data)
 178             if not self.configuration.dry_run:
 179                 bb.build.exec_task('do_%s' % self.configuration.cmd, the_data)
 180             bb.event.fire(bb.event.PkgSucceeded(item, the_data))
 181             self.build_cache.append(fn)
 182             return True
 183         except bb.build.FuncFailed:
 184             self.stats.fail += 1
 185             bb.error("task stack execution failed")
 186             bb.event.fire(bb.event.PkgFailed(item, the_data))
 187             self.build_cache_fail.append(fn)
 188             raise
 189         except bb.build.EventException, e:
 190             self.stats.fail += 1
 191             event = e.args[1]
 192             bb.error("%s event exception, aborting" % bb.event.getName(event))
 193             bb.event.fire(bb.event.PkgFailed(item, the_data))
 194             self.build_cache_fail.append(fn)
 195             raise
 196
 197     def tryBuild( self, fn, virtual ):
 198         """Build a provider and its dependencies"""
 199         if fn in self.building_list:
 200             bb.error("%s depends on itself (eventually)" % fn)
 201             bb.error("upwards chain is: %s" % (" -> ".join(self.build_path)))
 202             return False
 203
 204         the_data = self.pkgdata[fn]
 205         item = self.status.pkg_fn[fn]
 206
 207         self.building_list.append(fn)
 208
 209         pathstr = "%s (%s)" % (item, virtual)
 210         self.build_path.append(pathstr)
 211
 212         depends_list = (bb.data.getVar('DEPENDS', the_data, 1) or "").split()
 213         if self.configuration.verbose:
 214             bb.note("current path: %s" % (" -> ".join(self.build_path)))
 215             bb.note("dependencies for %s are: %s" % (item, " ".join(depends_list)))
 216
 217         try:
 218             failed = False
 219
 220             depcmd = self.configuration.cmd
 221             bbdepcmd = bb.data.getVarFlag('do_%s' % self.configuration.cmd, 'bbdepcmd', the_data)
 222             if bbdepcmd is not None:
 223                 if bbdepcmd == "":
 224                     depcmd = None
 225                 else:
 226                     depcmd = bbdepcmd
 227
 228             if depcmd:
 229                 oldcmd = self.configuration.cmd
 230                 self.configuration.cmd = depcmd
 231
 232             for dependency in depends_list:
 233                 if dependency in self.status.ignored_dependencies:
 234                     continue
 235                 if not depcmd:
 236                     continue
 237                 if self.buildProvider( dependency ) == 0:
 238                     bb.error("dependency %s (for %s) not satisfied" % (dependency,item))
 239                     failed = True
 240                     if self.configuration.abort:
 241                         break
 242
 243             if depcmd:
 244                 self.configuration.cmd = oldcmd
 245
 246             if failed:
 247                 self.stats.deps += 1
 248                 return False
 249
 250             if bb.build.stamp_is_current('do_%s' % self.configuration.cmd, the_data):
 251                 self.build_cache.append(fn)
 252                 return True
 253
 254             return self.tryBuildPackage( fn, item, the_data )
 255
 256         finally:
 257             self.building_list.remove(fn)
 258             self.build_path.remove(pathstr)
 259
 260     def findBestProvider( self, pn, pkg_pn = None):
 261         """
 262         If there is a PREFERRED_VERSION, find the highest-priority bbfile
 263         providing that version.  If not, find the latest version provided by
 264         an bbfile in the highest-priority set.
 265         """
 266         if not pkg_pn:
 267             pkg_pn = self.status.pkg_pn
 268
 269         files = pkg_pn[pn]
 270         priorities = {}
 271         for f in files:
 272             priority = self.status.bbfile_priority[f]
 273             if priority not in priorities:
 274                 priorities[priority] = []
 275             priorities[priority].append(f)
 276         p_list = priorities.keys()
 277         p_list.sort(lambda a, b: a - b)
 278         tmp_pn = []
 279         for p in p_list:
 280             tmp_pn = [priorities[p]] + tmp_pn
 281
 282         preferred_file = None
 283
 284         localdata = data.createCopy(self.configuration.data)
 285         bb.data.setVar('OVERRIDES', "%s:%s" % (pn, data.getVar('OVERRIDES', localdata)), localdata)
 286         bb.data.update_data(localdata)
 287
 288         preferred_v = bb.data.getVar('PREFERRED_VERSION_%s' % pn, localdata, 1)
 289         if preferred_v:
 290             m = re.match('(.*)_(.*)', preferred_v)
 291             if m:
 292                 preferred_v = m.group(1)
 293                 preferred_r = m.group(2)
 294             else:
 295                 preferred_r = None
 296
 297             for file_set in tmp_pn:
 298                 for f in file_set:
 299                     pv,pr = self.status.pkg_pvpr[f]
 300                     if preferred_v == pv and (preferred_r == pr or preferred_r == None):
 301                         preferred_file = f
 302                         preferred_ver = (pv, pr)
 303                         break
 304                 if preferred_file:
 305                     break;
 306             if preferred_r:
 307                 pv_str = '%s-%s' % (preferred_v, preferred_r)
 308             else:
 309                 pv_str = preferred_v
 310             if preferred_file is None:
 311                 bb.note("preferred version %s of %s not available" % (pv_str, pn))
 312             else:
 313                 bb.debug(1, "selecting %s as PREFERRED_VERSION %s of package %s" % (preferred_file, pv_str, pn))
 314
 315         del localdata
 316
 317         # get highest priority file set
 318         files = tmp_pn[0]
 319         latest = None
 320         latest_p = 0
 321         latest_f = None
 322         for file_name in files:
 323             pv,pr = self.status.pkg_pvpr[file_name]
 324             dp = self.status.pkg_dp[file_name]
 325
 326             if (latest is None) or ((latest_p == dp) and (utils.vercmp(latest, (pv, pr)) < 0)) or (dp > latest_p):
 327                 latest = (pv, pr)
 328                 latest_f = file_name
 329                 latest_p = dp
 330         if preferred_file is None:
 331             preferred_file = latest_f
 332             preferred_ver = latest
 333
 334         return (latest,latest_f,preferred_ver, preferred_file)
 335
 336     def showVersions( self ):
 337         pkg_pn = self.status.pkg_pn
 338         preferred_versions = {}
 339         latest_versions = {}
 340
 341         # Sort by priority
 342         for pn in pkg_pn.keys():
 343             (last_ver,last_file,pref_ver,pref_file) = self.findBestProvider(pn)
 344             preferred_versions[pn] = (pref_ver, pref_file)
 345             latest_versions[pn] = (last_ver, last_file)
 346
 347         pkg_list = pkg_pn.keys()
 348         pkg_list.sort()
 349
 350         for p in pkg_list:
 351             pref = preferred_versions[p]
 352             latest = latest_versions[p]
 353
 354             if pref != latest:
 355                 prefstr = pref[0][0] + "-" + pref[0][1]
 356             else:
 357                 prefstr = ""
 358
 359             print "%-30s %20s %20s" % (p, latest[0][0] + "-" + latest[0][1],
 360                                         prefstr)
 361
 362     def showEnvironment( self ):
 363         """Show the outer or per-package environment"""
 364         if self.configuration.buildfile:
 365             try:
 366                 self.configuration.data, fromCache = self.load_bbfile( self.configuration.buildfile )
 367             except IOError, e:
 368                 fatal("Unable to read %s: %s" % ( self.configuration.buildfile, e ))
 369             except Exception, e:
 370                 fatal("%s" % e)
 371         # emit variables and shell functions
 372         try:
 373             data.update_data( self.configuration.data )
 374             data.emit_env(sys.__stdout__, self.configuration.data, True)
 375         except Exception, e:
 376             fatal("%s" % e)
 377         # emit the metadata which isnt valid shell
 378         for e in self.configuration.data.keys():
 379             if data.getVarFlag( e, 'python', self.configuration.data ):
 380                 sys.__stdout__.write("\npython %s () {\n%s}\n" % (e, data.getVar(e, self.configuration.data, 1)))
 381
 382     def buildProvider( self, item ):
 383         fn = None
 384
 385         discriminated = False
 386
 387         if item not in self.status.providers:
 388             bb.error("Nothing provides %s" % item)
 389             return 0
 390
 391         all_p = self.status.providers[item]
 392
 393         for p in all_p:
 394             if p in self.build_cache:
 395                 bb.debug(1, "already built %s in this run\n" % p)
 396                 return 1
 397
 398         eligible = []
 399         preferred_versions = {}
 400
 401         # Collate providers by PN
 402         pkg_pn = {}
 403         for p in all_p:
 404             pn = self.status.pkg_fn[p]
 405             if pn not in pkg_pn:
 406                 pkg_pn[pn] = []
 407             pkg_pn[pn].append(p)
 408
 409         bb.debug(1, "providers for %s are: %s" % (item, pkg_pn.keys()))
 410
 411         for pn in pkg_pn.keys():
 412             preferred_versions[pn] = self.findBestProvider(pn, pkg_pn)[2:4]
 413             eligible.append(preferred_versions[pn][1])
 414
 415         for p in eligible:
 416             if p in self.build_cache_fail:
 417                 bb.debug(1, "rejecting already-failed %s" % p)
 418                 eligible.remove(p)
 419
 420         if len(eligible) == 0:
 421             bb.error("no eligible providers for %s" % item)
 422             return 0
 423
 424         # look to see if one of them is already staged, or marked as preferred.
 425         # if so, bump it to the head of the queue
 426         for p in all_p:
 427             the_data = self.pkgdata[p]
 428             pn = bb.data.getVar('PN', the_data, 1)
 429             pv = bb.data.getVar('PV', the_data, 1)
 430             pr = bb.data.getVar('PR', the_data, 1)
 431             tmpdir = bb.data.getVar('TMPDIR', the_data, 1)
 432             stamp = '%s/stamps/%s-%s-%s.do_populate_staging' % (tmpdir, pn, pv, pr)
 433             if os.path.exists(stamp):
 434                 (newvers, fn) = preferred_versions[pn]
 435                 if not fn in eligible:
 436                     # package was made ineligible by already-failed check
 437                     continue
 438                 oldver = "%s-%s" % (pv, pr)
 439                 newver = '-'.join(newvers)
 440                 if (newver != oldver):
 441                     extra_chat = "; upgrading from %s to %s" % (oldver, newver)
 442                 else:
 443                     extra_chat = ""
 444                 if self.configuration.verbose:
 445                     bb.note("selecting already-staged %s to satisfy %s%s" % (pn, item, extra_chat))
 446                 eligible.remove(fn)
 447                 eligible = [fn] + eligible
 448                 discriminated = True
 449                 break
 450
 451         prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % item, self.configuration.data, 1)
 452         if prefervar:
 453             self.preferred[item] = prefervar
 454
 455         if item in self.preferred:
 456             for p in eligible:
 457                 pn = self.status.pkg_fn[p]
 458                 if self.preferred[item] == pn:
 459                     if self.configuration.verbose:
 460                         bb.note("selecting %s to satisfy %s due to PREFERRED_PROVIDERS" % (pn, item))
 461                     eligible.remove(p)
 462                     eligible = [p] + eligible
 463                     discriminated = True
 464                     break
 465
 466         if len(eligible) > 1 and discriminated == False:
 467             if item not in self.consider_msgs_cache:
 468                 providers_list = []
 469                 for fn in eligible:
 470                     providers_list.append(self.status.pkg_fn[fn])
 471                 bb.note("multiple providers are available (%s);" % ", ".join(providers_list))
 472                 bb.note("consider defining PREFERRED_PROVIDER_%s" % item)
 473             self.consider_msgs_cache.append(item)
 474
 475
 476         # run through the list until we find one that we can build
 477         for fn in eligible:
 478             bb.debug(2, "selecting %s to satisfy %s" % (fn, item))
 479             if self.tryBuild(fn, item):
 480                 return 1
 481
 482         bb.note("no buildable providers for %s" % item)
 483         return 0
 484
 485     def buildDepgraph( self ):
 486         all_depends = self.status.all_depends
 487         pn_provides = self.status.pn_provides
 488
 489         def calc_bbfile_priority(filename):
 490             for (regex, pri) in self.status.bbfile_config_priorities:
 491                 if regex.match(filename):
 492                     return pri
 493             return 0
 494
 495         # Handle PREFERRED_PROVIDERS
 496         for p in (bb.data.getVar('PREFERRED_PROVIDERS', self.configuration.data, 1) or "").split():
 497             (providee, provider) = p.split(':')
 498             if providee in self.preferred and self.preferred[providee] != provider:
 499                 bb.error("conflicting preferences for %s: both %s and %s specified" % (providee, provider, self.preferred[providee]))
 500             self.preferred[providee] = provider
 501
 502         # Calculate priorities for each file
 503         for p in self.pkgdata.keys():
 504             self.status.bbfile_priority[p] = calc_bbfile_priority(p)
 505
 506         # Build package list for "bitbake world"
 507         bb.debug(1, "collating packages for \"world\"")
 508         for f in self.status.possible_world:
 509             terminal = True
 510             pn = self.status.pkg_fn[f]
 511
 512             for p in pn_provides[pn]:
 513                 if p.startswith('virtual/'):
 514                     bb.debug(2, "skipping %s due to %s provider starting with virtual/" % (f, p))
 515                     terminal = False
 516                     break
 517                 for pf in self.status.providers[p]:
 518                     if self.status.pkg_fn[pf] != pn:
 519                         bb.debug(2, "skipping %s due to both us and %s providing %s" % (f, pf, p))
 520                         terminal = False
 521                         break
 522             if terminal:
 523                 self.status.world_target.add(pn)
 524
 525             # drop reference count now
 526             self.status.possible_world = None
 527             self.status.all_depends    = None
 528
 529     def myProgressCallback( self, x, y, f, file_data, from_cache ):
 530         # feed the status with new input
 531         self.status.handle_bb_data(f, file_data, from_cache)
 532
 533         if bbdebug > 0:
 534             return
 535         if os.isatty(sys.stdout.fileno()):
 536             sys.stdout.write("\rNOTE: Handling BitBake files: %s (%04d/%04d) [%2d %%]" % ( parsespin.next(), x, y, x*100/y ) )
 537             sys.stdout.flush()
 538         else:
 539             if x == 1:
 540                 sys.stdout.write("Parsing .bb files, please wait...")
 541                 sys.stdout.flush()
 542             if x == y:
 543                 sys.stdout.write("done.")
 544                 sys.stdout.flush()
 545
 546     def interactiveMode( self ):
 547         """Drop off into a shell"""
 548         try:
 549             from bb import shell
 550         except ImportError, details:
 551             bb.fatal("Sorry, shell not available (%s)" % details )
 552         else:
 553             bb.data.update_data( self.configuration.data )
 554             shell.start( self )
 555             sys.exit( 0 )
 556
 557     def parseConfigurationFile( self, afile ):
 558         try:
 559             self.configuration.data = bb.parse.handle( afile, self.configuration.data )
 560         except IOError:
 561             bb.fatal( "Unable to open %s" % afile )
 562         except bb.parse.ParseError, details:
 563             bb.fatal( "Unable to parse %s (%s)" % (afile, details) )
 564
 565     def handleCollections( self, collections ):
 566         """Handle collections"""
 567         if collections:
 568             collection_list = collections.split()
 569             for c in collection_list:
 570                 regex = bb.data.getVar("BBFILE_PATTERN_%s" % c, self.configuration.data, 1)
 571                 if regex == None:
 572                     bb.error("BBFILE_PATTERN_%s not defined" % c)
 573                     continue
 574                 priority = bb.data.getVar("BBFILE_PRIORITY_%s" % c, self.configuration.data, 1)
 575                 if priority == None:
 576                     bb.error("BBFILE_PRIORITY_%s not defined" % c)
 577                     continue
 578                 try:
 579                     cre = re.compile(regex)
 580                 except re.error:
 581                     bb.error("BBFILE_PATTERN_%s \"%s\" is not a valid regular expression" % (c, regex))
 582                     continue
 583                 try:
 584                     pri = int(priority)
 585                     self.status.bbfile_config_priorities.append((cre, pri))
 586                 except ValueError:
 587                     bb.error("invalid value for BBFILE_PRIORITY_%s: \"%s\"" % (c, priority))
 588
 589
 590     def cook( self, configuration, args ):
 591         self.configuration = configuration
 592
 593         if not self.configuration.cmd:
 594             self.configuration.cmd = "build"
 595
 596         if self.configuration.debug:
 597             bb.debug_level = self.configuration.debug
 598
 599         self.configuration.data = bb.data.init()
 600
 601         for f in self.configuration.file:
 602             self.parseConfigurationFile( f )
 603
 604         self.parseConfigurationFile( os.path.join( "conf", "bitbake.conf" ) )
 605
 606         if self.configuration.show_environment:
 607             self.showEnvironment()
 608             sys.exit( 0 )
 609
 610         # inject custom variables
 611         if not bb.data.getVar("BUILDNAME", self.configuration.data):
 612             bb.data.setVar("BUILDNAME", os.popen('date +%Y%m%d%H%M').readline().strip(), self.configuration.data)
 613         bb.data.setVar("BUILDSTART", time.strftime('%m/%d/%Y %H:%M:%S',time.gmtime()),self.configuration.data)
 614
 615         buildname = bb.data.getVar("BUILDNAME", self.configuration.data)
 616
 617         if self.configuration.interactive:
 618             self.interactiveMode()
 619
 620         if self.configuration.buildfile is not None:
 621             bf = os.path.abspath( self.configuration.buildfile )
 622             try:
 623                 bbfile_data = bb.parse.handle(bf, self.configuration.data)
 624             except IOError:
 625                 bb.fatal("Unable to open %s" % bf)
 626
 627             item = bb.data.getVar('PN', bbfile_data, 1)
 628             try:
 629                 self.tryBuildPackage( bf, item, bbfile_data )
 630             except bb.build.EventException:
 631                 bb.error( "Build of '%s' failed" % item )
 632
 633             sys.exit( self.stats.show() )
 634
 635         # initialise the parsing status now we know we will need deps
 636         self.status = BBParsingStatus()
 637
 638         ignore = bb.data.getVar("ASSUME_PROVIDED", self.configuration.data, 1) or ""
 639         self.status.ignored_dependencies = Set( ignore.split() )
 640
 641         self.handleCollections( bb.data.getVar("BBFILE_COLLECTIONS", self.configuration.data, 1) )
 642
 643         pkgs_to_build = None
 644         if args:
 645             if not pkgs_to_build:
 646                 pkgs_to_build = []
 647             pkgs_to_build.extend(args)
 648         if not pkgs_to_build:
 649                 bbpkgs = bb.data.getVar('BBPKGS', self.configuration.data, 1)
 650                 if bbpkgs:
 651                         pkgs_to_build = bbpkgs.split()
 652         if not pkgs_to_build and not self.configuration.show_versions \
 653                              and not self.configuration.interactive \
 654                              and not self.configuration.show_environment:
 655                 print "Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help'"
 656                 print "for usage information."
 657                 sys.exit(0)
 658
 659         # Import Psyco if available and not disabled
 660         if not self.configuration.disable_psyco:
 661             try:
 662                 import psyco
 663             except ImportError:
 664                 if bbdebug == 0:
 665                     bb.note("Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
 666             else:
 667                 psyco.bind( self.collect_bbfiles )
 668         else:
 669             bb.note("You have disabled Psyco. This decreases performance.")
 670
 671         try:
 672             bb.debug(1, "collecting .bb files")
 673             self.collect_bbfiles( self.myProgressCallback )
 674             bb.debug(1, "parsing complete")
 675             if bbdebug == 0:
 676                 print
 677             if self.configuration.parse_only:
 678                 print "Requested parsing .bb files only.  Exiting."
 679                 return
 680
 681             bb.data.update_data( self.configuration.data )
 682             self.buildDepgraph()
 683
 684             if self.configuration.show_versions:
 685                 self.showVersions()
 686                 sys.exit( 0 )
 687             if 'world' in pkgs_to_build:
 688                 pkgs_to_build.remove('world')
 689                 for t in self.status.world_target:
 690                     pkgs_to_build.append(t)
 691
 692             bb.event.fire(bb.event.BuildStarted(buildname, pkgs_to_build, self.configuration.data))
 693
 694             for k in pkgs_to_build:
 695                 failed = False
 696                 try:
 697                     if self.buildProvider( k ) == 0:
 698                         # already diagnosed
 699                         failed = True
 700                 except bb.build.EventException:
 701                     bb.error("Build of " + k + " failed")
 702                     failed = True
 703
 704                 if failed:
 705                     if self.configuration.abort:
 706                         sys.exit(1)
 707
 708             bb.event.fire(bb.event.BuildCompleted(buildname, pkgs_to_build, self.configuration.data))
 709
 710             sys.exit( self.stats.show() )
 711
 712         except KeyboardInterrupt:
 713             print "\nNOTE: KeyboardInterrupt - Build not completed."
 714             sys.exit(1)
 715
 716     def get_bbfiles( self, path = os.getcwd() ):
 717         """Get list of default .bb files by reading out the current directory"""
 718         contents = os.listdir(path)
 719         bbfiles = []
 720         for f in contents:
 721             (root, ext) = os.path.splitext(f)
 722             if ext == ".bb":
 723                 bbfiles.append(os.path.abspath(os.path.join(os.getcwd(),f)))
 724         return bbfiles
 725
 726     def find_bbfiles( self, path ):
 727         """Find all the .bb files in a directory (uses find)"""
 728         findcmd = 'find ' + path + ' -name *.bb | grep -v SCCS/'
 729         try:
 730             finddata = os.popen(findcmd)
 731         except OSError:
 732             return []
 733         return finddata.readlines()
 734
 735     def deps_clean(self, d):
 736         depstr = data.getVar('__depends', d)
 737         if depstr:
 738             deps = depstr.split(" ")
 739             for dep in deps:
 740                 (f,old_mtime_s) = dep.split("@")
 741                 old_mtime = int(old_mtime_s)
 742                 new_mtime = parse.cached_mtime(f)
 743                 if (new_mtime > old_mtime):
 744                     return False
 745         return True
 746
 747     def load_bbfile( self, bbfile ):
 748         """Load and parse one .bb build file"""
 749
 750         if not self.cache in [None, '']:
 751             # get the times
 752             cache_mtime = data.init_db_mtime(self.cache, bbfile)
 753             file_mtime = parse.cached_mtime(bbfile)
 754
 755             if file_mtime > cache_mtime:
 756                 #print " : '%s' dirty. reparsing..." % bbfile
 757                 pass
 758             else:
 759                 #print " : '%s' clean. loading from cache..." % bbfile
 760                 cache_data = data.init_db( self.cache, bbfile, False )
 761                 if self.deps_clean(cache_data):
 762                     return cache_data, True
 763
 764         topdir = data.getVar('TOPDIR', self.configuration.data)
 765         if not topdir:
 766             topdir = os.path.abspath(os.getcwd())
 767             # set topdir to here
 768             data.setVar('TOPDIR', topdir, self.configuration)
 769         bbfile = os.path.abspath(bbfile)
 770         bbfile_loc = os.path.abspath(os.path.dirname(bbfile))
 771         # expand tmpdir to include this topdir
 772         data.setVar('TMPDIR', data.getVar('TMPDIR', self.configuration.data, 1) or "", self.configuration.data)
 773         # set topdir to location of .bb file
 774         topdir = bbfile_loc
 775         #data.setVar('TOPDIR', topdir, cfg)
 776         # go there
 777         oldpath = os.path.abspath(os.getcwd())
 778         os.chdir(topdir)
 779         bb = data.init_db(self.cache,bbfile, True, self.configuration.data)
 780         try:
 781             parse.handle(bbfile, bb) # read .bb data
 782             if not self.cache in [None, '']:
 783                 bb.commit(parse.cached_mtime(bbfile)) # write cache
 784             os.chdir(oldpath)
 785             return bb, False
 786         finally:
 787             os.chdir(oldpath)
 788
 789     def collect_bbfiles( self, progressCallback ):
 790         """Collect all available .bb build files"""
 791         self.cb = progressCallback
 792         parsed, cached, skipped, masked = 0, 0, 0, 0
 793         self.cache   = bb.data.getVar( "CACHE", self.configuration.data, 1 )
 794         self.pkgdata = data.pkgdata( not self.cache in [None, ''], self.cache, self.configuration.data )
 795
 796         if not self.cache in [None, '']:
 797             if self.cb is not None:
 798                 print "NOTE: Using cache in '%s'" % self.cache
 799             try:
 800                 os.stat( self.cache )
 801             except OSError:
 802                 bb.mkdirhier( self.cache )
 803         else:
 804             if self.cb is not None:
 805                 print "NOTE: Not using a cache. Set CACHE = <directory> to enable."
 806         files = (data.getVar( "BBFILES", self.configuration.data, 1 ) or "").split()
 807         data.setVar("BBFILES", " ".join(files), self.configuration.data)
 808
 809         if not len(files):
 810             files = self.get_bbfiles()
 811
 812         if not len(files):
 813             bb.error("no files to build.")
 814
 815         newfiles = []
 816         for f in files:
 817             if os.path.isdir(f):
 818                 dirfiles = self.find_bbfiles(f)
 819                 if dirfiles:
 820                     newfiles += dirfiles
 821                     continue
 822             newfiles += glob.glob(f) or [ f ]
 823
 824         bbmask = bb.data.getVar('BBMASK', self.configuration.data, 1) or ""
 825         try:
 826             bbmask_compiled = re.compile(bbmask)
 827         except sre_constants.error:
 828             bb.fatal("BBMASK is not a valid regular expression.")
 829
 830         for i in xrange( len( newfiles ) ):
 831             f = newfiles[i]
 832             if bbmask and bbmask_compiled.search(f):
 833                 bb.debug(1, "bbmake: skipping %s" % f)
 834                 masked += 1
 835                 continue
 836             debug(1, "bbmake: parsing %s" % f)
 837
 838             # read a file's metadata
 839             try:
 840                 bb_data, fromCache = self.load_bbfile(f)
 841                 if fromCache: cached += 1
 842                 else: parsed += 1
 843                 deps = None
 844                 if bb_data is not None:
 845                     # allow metadata files to add items to BBFILES
 846                     #data.update_data(self.pkgdata[f])
 847                     addbbfiles = data.getVar('BBFILES', bb_data) or None
 848                     if addbbfiles:
 849                         for aof in addbbfiles.split():
 850                             if not files.count(aof):
 851                                 if not os.path.isabs(aof):
 852                                     aof = os.path.join(os.path.dirname(f),aof)
 853                                 files.append(aof)
 854                     for var in bb_data.keys():
 855                         if data.getVarFlag(var, "handler", bb_data) and data.getVar(var, bb_data):
 856                             event.register(data.getVar(var, bb_data))
 857                     self.pkgdata[f] = bb_data
 858
 859                 # now inform the caller
 860                 if self.cb is not None:
 861                     self.cb( i + 1, len( newfiles ), f, bb_data, fromCache )
 862
 863             except IOError, e:
 864                 bb.error("opening %s: %s" % (f, e))
 865                 pass
 866             except bb.parse.SkipPackage:
 867                 skipped += 1
 868                 pass
 869             except KeyboardInterrupt:
 870                 raise
 871             except Exception, e:
 872                 bb.error("%s while parsing %s" % (e, f))
 873
 874         if self.cb is not None:
 875             print "\rNOTE: Parsing finished. %d cached, %d parsed, %d skipped, %d masked." % ( cached, parsed, skipped, masked ),
 876
 877 #============================================================================#
 878 # main
 879 #============================================================================#
 880
 881 if __name__ == "__main__":
 882
 883     parser = optparse.OptionParser( version = "BitBake Build Tool Core version %s, %%prog version %s" % ( bb.__version__, __version__ ),
 884     usage = """%prog [options] [package ...]
 885
 886 Executes the specified task (default is 'build') for a given set of BitBake files.
 887 It expects that BBFILES is defined, which is a space seperated list of files to
 888 be executed.  BBFILES does support wildcards.
 889 Default BBFILES are the .bb files in the current directory.""" )
 890
 891     parser.add_option( "-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
 892                action = "store", dest = "buildfile", default = None )
 893
 894     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.",
 895                action = "store_false", dest = "abort", default = True )
 896
 897     parser.add_option( "-f", "--force", help = "force run of specified cmd, regardless of stamp status",
 898                action = "store_true", dest = "force", default = False )
 899
 900     parser.add_option( "-i", "--interactive", help = "drop into the interactive mode.",
 901                action = "store_true", dest = "interactive", default = False )
 902
 903     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)",
 904                action = "store", dest = "cmd", default = "build" )
 905
 906     parser.add_option( "-r", "--read", help = "read the specified file before bitbake.conf",
 907                action = "append", dest = "file", default = [] )
 908
 909     parser.add_option( "-v", "--verbose", help = "output more chit-chat to the terminal",
 910                action = "store_true", dest = "verbose", default = False )
 911
 912     parser.add_option( "-D", "--debug", help = "Increase the debug level",
 913                action = "count", dest="debug", default = 0)
 914
 915     parser.add_option( "-n", "--dry-run", help = "don't execute, just go through the motions",
 916                action = "store_true", dest = "dry_run", default = False )
 917
 918     parser.add_option( "-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
 919                action = "store_true", dest = "parse_only", default = False )
 920
 921     parser.add_option( "-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
 922                action = "store_true", dest = "disable_psyco", default = False )
 923
 924     parser.add_option( "-s", "--show-versions", help = "show current and preferred versions of all packages",
 925                action = "store_true", dest = "show_versions", default = False )
 926
 927     parser.add_option( "-e", "--environment", help = "show the global or per-package environment (this is what used to be bbread)",
 928                action = "store_true", dest = "show_environment", default = False )
 929
 930     options, args = parser.parse_args( sys.argv )
 931
 932     cooker = BBCooker()
 933     cooker.cook( BBConfiguration( options ), args[1:] )