bitbake-layers 46 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039
  1. #!/usr/bin/env python
  2. # This script has subcommands which operate against your bitbake layers, either
  3. # displaying useful information, or acting against them.
  4. # See the help output for details on available commands.
  5. # Copyright (C) 2011 Mentor Graphics Corporation
  6. # Copyright (C) 2011-2015 Intel Corporation
  7. #
  8. # This program is free software; you can redistribute it and/or modify
  9. # it under the terms of the GNU General Public License version 2 as
  10. # published by the Free Software Foundation.
  11. #
  12. # This program is distributed in the hope that it will be useful,
  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. # GNU General Public License for more details.
  16. #
  17. # You should have received a copy of the GNU General Public License along
  18. # with this program; if not, write to the Free Software Foundation, Inc.,
  19. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20. import logging
  21. import os
  22. import sys
  23. import fnmatch
  24. from collections import defaultdict
  25. import argparse
  26. import re
  27. import httplib, urlparse, json
  28. import subprocess
  29. bindir = os.path.dirname(__file__)
  30. topdir = os.path.dirname(bindir)
  31. sys.path[0:0] = [os.path.join(topdir, 'lib')]
  32. import bb.cache
  33. import bb.cooker
  34. import bb.providers
  35. import bb.utils
  36. import bb.tinfoil
  37. def logger_create(name, output=sys.stderr):
  38. logger = logging.getLogger(name)
  39. console = logging.StreamHandler(output)
  40. format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
  41. if output.isatty():
  42. format.enable_color()
  43. console.setFormatter(format)
  44. logger.addHandler(console)
  45. logger.setLevel(logging.INFO)
  46. return logger
  47. logger = logger_create('bitbake-layers', sys.stdout)
  48. class Commands():
  49. def __init__(self):
  50. self.bbhandler = None
  51. self.bblayers = []
  52. def init_bbhandler(self, config_only = False):
  53. if not self.bbhandler:
  54. self.bbhandler = bb.tinfoil.Tinfoil()
  55. self.bblayers = (self.bbhandler.config_data.getVar('BBLAYERS', True) or "").split()
  56. self.bbhandler.prepare(config_only)
  57. def do_show_layers(self, args):
  58. """show current configured layers"""
  59. self.init_bbhandler(config_only = True)
  60. logger.plain("%s %s %s" % ("layer".ljust(20), "path".ljust(40), "priority"))
  61. logger.plain('=' * 74)
  62. for layerdir in self.bblayers:
  63. layername = self.get_layer_name(layerdir)
  64. layerpri = 0
  65. for layer, _, regex, pri in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
  66. if regex.match(os.path.join(layerdir, 'test')):
  67. layerpri = pri
  68. break
  69. logger.plain("%s %s %d" % (layername.ljust(20), layerdir.ljust(40), layerpri))
  70. def do_add_layer(self, args):
  71. """Add a layer to bblayers.conf
  72. Adds the specified layer to bblayers.conf
  73. """
  74. layerdir = os.path.abspath(args.layerdir)
  75. if not os.path.exists(layerdir):
  76. sys.stderr.write("Specified layer directory doesn't exist\n")
  77. return 1
  78. layer_conf = os.path.join(layerdir, 'conf', 'layer.conf')
  79. if not os.path.exists(layer_conf):
  80. sys.stderr.write("Specified layer directory doesn't contain a conf/layer.conf file\n")
  81. return 1
  82. bblayers_conf = os.path.join('conf', 'bblayers.conf')
  83. if not os.path.exists(bblayers_conf):
  84. sys.stderr.write("Unable to find bblayers.conf\n")
  85. return 1
  86. (notadded, _) = bb.utils.edit_bblayers_conf(bblayers_conf, layerdir, None)
  87. if notadded:
  88. for item in notadded:
  89. sys.stderr.write("Specified layer %s is already in BBLAYERS\n" % item)
  90. def do_remove_layer(self, args):
  91. """Remove a layer from bblayers.conf
  92. Removes the specified layer from bblayers.conf
  93. """
  94. bblayers_conf = os.path.join('conf', 'bblayers.conf')
  95. if not os.path.exists(bblayers_conf):
  96. sys.stderr.write("Unable to find bblayers.conf\n")
  97. return 1
  98. if args.layerdir.startswith('*'):
  99. layerdir = args.layerdir
  100. else:
  101. layerdir = os.path.abspath(args.layerdir)
  102. (_, notremoved) = bb.utils.edit_bblayers_conf(bblayers_conf, None, layerdir)
  103. if notremoved:
  104. for item in notremoved:
  105. sys.stderr.write("No layers matching %s found in BBLAYERS\n" % item)
  106. return 1
  107. def get_json_data(self, apiurl):
  108. proxy_settings = os.environ.get("http_proxy", None)
  109. conn = None
  110. _parsedurl = urlparse.urlparse(apiurl)
  111. path = _parsedurl.path
  112. query = _parsedurl.query
  113. def parse_url(url):
  114. parsedurl = urlparse.urlparse(url)
  115. if parsedurl.netloc[0] == '[':
  116. host, port = parsedurl.netloc[1:].split(']', 1)
  117. if ':' in port:
  118. port = port.rsplit(':', 1)[1]
  119. else:
  120. port = None
  121. else:
  122. if parsedurl.netloc.count(':') == 1:
  123. (host, port) = parsedurl.netloc.split(":")
  124. else:
  125. host = parsedurl.netloc
  126. port = None
  127. return (host, 80 if port is None else int(port))
  128. if proxy_settings is None:
  129. host, port = parse_url(apiurl)
  130. conn = httplib.HTTPConnection(host, port)
  131. conn.request("GET", path + "?" + query)
  132. else:
  133. host, port = parse_url(proxy_settings)
  134. conn = httplib.HTTPConnection(host, port)
  135. conn.request("GET", apiurl)
  136. r = conn.getresponse()
  137. if r.status != 200:
  138. raise Exception("Failed to read " + path + ": %d %s" % (r.status, r.reason))
  139. return json.loads(r.read())
  140. def get_layer_deps(self, layername, layeritems, layerbranches, layerdependencies, branchnum, selfname=False):
  141. def layeritems_info_id(items_name, layeritems):
  142. litems_id = None
  143. for li in layeritems:
  144. if li['name'] == items_name:
  145. litems_id = li['id']
  146. break
  147. return litems_id
  148. def layerbranches_info(items_id, layerbranches):
  149. lbranch = {}
  150. for lb in layerbranches:
  151. if lb['layer'] == items_id and lb['branch'] == branchnum:
  152. lbranch['id'] = lb['id']
  153. lbranch['vcs_subdir'] = lb['vcs_subdir']
  154. break
  155. return lbranch
  156. def layerdependencies_info(lb_id, layerdependencies):
  157. ld_deps = []
  158. for ld in layerdependencies:
  159. if ld['layerbranch'] == lb_id and not ld['dependency'] in ld_deps:
  160. ld_deps.append(ld['dependency'])
  161. if not ld_deps:
  162. logger.error("The dependency of layerDependencies is not found.")
  163. return ld_deps
  164. def layeritems_info_name_subdir(items_id, layeritems):
  165. litems = {}
  166. for li in layeritems:
  167. if li['id'] == items_id:
  168. litems['vcs_url'] = li['vcs_url']
  169. litems['name'] = li['name']
  170. break
  171. return litems
  172. if selfname:
  173. selfid = layeritems_info_id(layername, layeritems)
  174. lbinfo = layerbranches_info(selfid, layerbranches)
  175. if lbinfo:
  176. selfsubdir = lbinfo['vcs_subdir']
  177. else:
  178. logger.error("%s is not found in the specified branch" % layername)
  179. return
  180. selfurl = layeritems_info_name_subdir(selfid, layeritems)['vcs_url']
  181. if selfurl:
  182. return selfurl, selfsubdir
  183. else:
  184. logger.error("Cannot get layer %s git repo and subdir" % layername)
  185. return
  186. ldict = {}
  187. itemsid = layeritems_info_id(layername, layeritems)
  188. if not itemsid:
  189. return layername, None
  190. lbid = layerbranches_info(itemsid, layerbranches)
  191. if lbid:
  192. lbid = layerbranches_info(itemsid, layerbranches)['id']
  193. else:
  194. logger.error("%s is not found in the specified branch" % layername)
  195. return None, None
  196. for dependency in layerdependencies_info(lbid, layerdependencies):
  197. lname = layeritems_info_name_subdir(dependency, layeritems)['name']
  198. lurl = layeritems_info_name_subdir(dependency, layeritems)['vcs_url']
  199. lsubdir = layerbranches_info(dependency, layerbranches)['vcs_subdir']
  200. ldict[lname] = lurl, lsubdir
  201. return None, ldict
  202. def get_fetch_layer(self, fetchdir, url, subdir, fetch_layer):
  203. layername = self.get_layer_name(url)
  204. if os.path.splitext(layername)[1] == '.git':
  205. layername = os.path.splitext(layername)[0]
  206. repodir = os.path.join(fetchdir, layername)
  207. layerdir = os.path.join(repodir, subdir)
  208. if not os.path.exists(repodir):
  209. if fetch_layer:
  210. result = subprocess.call('git clone %s %s' % (url, repodir), shell = True)
  211. if result:
  212. logger.error("Failed to download %s" % url)
  213. return None, None
  214. else:
  215. return layername, layerdir
  216. else:
  217. logger.plain("Repository %s needs to be fetched" % url)
  218. return layername, layerdir
  219. elif os.path.exists(layerdir):
  220. return layername, layerdir
  221. else:
  222. logger.error("%s is not in %s" % (url, subdir))
  223. return None, None
  224. def do_layerindex_fetch(self, args):
  225. """Fetches a layer from a layer index along with its dependent layers, and adds them to conf/bblayers.conf.
  226. """
  227. self.init_bbhandler(config_only = True)
  228. apiurl = self.bbhandler.config_data.getVar('BBLAYERS_LAYERINDEX_URL', True)
  229. if not apiurl:
  230. logger.error("Cannot get BBLAYERS_LAYERINDEX_URL")
  231. else:
  232. if apiurl[-1] != '/':
  233. apiurl += '/'
  234. apiurl += "api/"
  235. apilinks = self.get_json_data(apiurl)
  236. branches = self.get_json_data(apilinks['branches'])
  237. branchnum = 0
  238. for branch in branches:
  239. if branch['name'] == args.branch:
  240. branchnum = branch['id']
  241. break
  242. if branchnum == 0:
  243. validbranches = ', '.join([branch['name'] for branch in branches])
  244. logger.error('Invalid layer branch name "%s". Valid branches: %s' % (args.branch, validbranches))
  245. return 1
  246. ignore_layers = []
  247. for collection in self.bbhandler.config_data.getVar('BBFILE_COLLECTIONS', True).split():
  248. lname = self.bbhandler.config_data.getVar('BBLAYERS_LAYERINDEX_NAME_%s' % collection, True)
  249. if lname:
  250. ignore_layers.append(lname)
  251. if args.ignore:
  252. ignore_layers.extend(args.ignore.split(','))
  253. layeritems = self.get_json_data(apilinks['layerItems'])
  254. layerbranches = self.get_json_data(apilinks['layerBranches'])
  255. layerdependencies = self.get_json_data(apilinks['layerDependencies'])
  256. invaluenames = []
  257. repourls = {}
  258. printlayers = []
  259. def query_dependencies(layers, layeritems, layerbranches, layerdependencies, branchnum):
  260. depslayer = []
  261. for layername in layers:
  262. invaluename, layerdict = self.get_layer_deps(layername, layeritems, layerbranches, layerdependencies, branchnum)
  263. if layerdict:
  264. repourls[layername] = self.get_layer_deps(layername, layeritems, layerbranches, layerdependencies, branchnum, selfname=True)
  265. for layer in layerdict:
  266. if not layer in ignore_layers:
  267. depslayer.append(layer)
  268. printlayers.append((layername, layer, layerdict[layer][0], layerdict[layer][1]))
  269. if not layer in ignore_layers and not layer in repourls:
  270. repourls[layer] = (layerdict[layer][0], layerdict[layer][1])
  271. if invaluename and not invaluename in invaluenames:
  272. invaluenames.append(invaluename)
  273. return depslayer
  274. depslayers = query_dependencies(args.layername, layeritems, layerbranches, layerdependencies, branchnum)
  275. while depslayers:
  276. depslayer = query_dependencies(depslayers, layeritems, layerbranches, layerdependencies, branchnum)
  277. depslayers = depslayer
  278. if invaluenames:
  279. for invaluename in invaluenames:
  280. logger.error('Layer "%s" not found in layer index' % invaluename)
  281. return 1
  282. logger.plain("%s %s %s %s" % ("Layer".ljust(19), "Required by".ljust(19), "Git repository".ljust(54), "Subdirectory"))
  283. logger.plain('=' * 115)
  284. for layername in args.layername:
  285. layerurl = repourls[layername]
  286. logger.plain("%s %s %s %s" % (layername.ljust(20), '-'.ljust(20), layerurl[0].ljust(55), layerurl[1]))
  287. printedlayers = []
  288. for layer, dependency, gitrepo, subdirectory in printlayers:
  289. if dependency in printedlayers:
  290. continue
  291. logger.plain("%s %s %s %s" % (dependency.ljust(20), layer.ljust(20), gitrepo.ljust(55), subdirectory))
  292. printedlayers.append(dependency)
  293. if repourls:
  294. fetchdir = self.bbhandler.config_data.getVar('BBLAYERS_FETCH_DIR', True)
  295. if not fetchdir:
  296. logger.error("Cannot get BBLAYERS_FETCH_DIR")
  297. return 1
  298. if not os.path.exists(fetchdir):
  299. os.makedirs(fetchdir)
  300. addlayers = []
  301. for repourl, subdir in repourls.values():
  302. name, layerdir = self.get_fetch_layer(fetchdir, repourl, subdir, not args.show_only)
  303. if not name:
  304. # Error already shown
  305. return 1
  306. addlayers.append((subdir, name, layerdir))
  307. if not args.show_only:
  308. for subdir, name, layerdir in set(addlayers):
  309. if os.path.exists(layerdir):
  310. if subdir:
  311. logger.plain("Adding layer \"%s\" to conf/bblayers.conf" % subdir)
  312. else:
  313. logger.plain("Adding layer \"%s\" to conf/bblayers.conf" % name)
  314. localargs = argparse.Namespace()
  315. localargs.layerdir = layerdir
  316. self.do_add_layer(localargs)
  317. else:
  318. break
  319. def do_layerindex_show_depends(self, args):
  320. """Find layer dependencies from layer index.
  321. """
  322. args.show_only = True
  323. args.ignore = []
  324. self.do_layerindex_fetch(args)
  325. def version_str(self, pe, pv, pr = None):
  326. verstr = "%s" % pv
  327. if pr:
  328. verstr = "%s-%s" % (verstr, pr)
  329. if pe:
  330. verstr = "%s:%s" % (pe, verstr)
  331. return verstr
  332. def do_show_overlayed(self, args):
  333. """list overlayed recipes (where the same recipe exists in another layer)
  334. Lists the names of overlayed recipes and the available versions in each
  335. layer, with the preferred version first. Note that skipped recipes that
  336. are overlayed will also be listed, with a " (skipped)" suffix.
  337. """
  338. self.init_bbhandler()
  339. items_listed = self.list_recipes('Overlayed recipes', None, True, args.same_version, args.filenames, True)
  340. # Check for overlayed .bbclass files
  341. classes = defaultdict(list)
  342. for layerdir in self.bblayers:
  343. classdir = os.path.join(layerdir, 'classes')
  344. if os.path.exists(classdir):
  345. for classfile in os.listdir(classdir):
  346. if os.path.splitext(classfile)[1] == '.bbclass':
  347. classes[classfile].append(classdir)
  348. # Locating classes and other files is a bit more complicated than recipes -
  349. # layer priority is not a factor; instead BitBake uses the first matching
  350. # file in BBPATH, which is manipulated directly by each layer's
  351. # conf/layer.conf in turn, thus the order of layers in bblayers.conf is a
  352. # factor - however, each layer.conf is free to either prepend or append to
  353. # BBPATH (or indeed do crazy stuff with it). Thus the order in BBPATH might
  354. # not be exactly the order present in bblayers.conf either.
  355. bbpath = str(self.bbhandler.config_data.getVar('BBPATH', True))
  356. overlayed_class_found = False
  357. for (classfile, classdirs) in classes.items():
  358. if len(classdirs) > 1:
  359. if not overlayed_class_found:
  360. logger.plain('=== Overlayed classes ===')
  361. overlayed_class_found = True
  362. mainfile = bb.utils.which(bbpath, os.path.join('classes', classfile))
  363. if args.filenames:
  364. logger.plain('%s' % mainfile)
  365. else:
  366. # We effectively have to guess the layer here
  367. logger.plain('%s:' % classfile)
  368. mainlayername = '?'
  369. for layerdir in self.bblayers:
  370. classdir = os.path.join(layerdir, 'classes')
  371. if mainfile.startswith(classdir):
  372. mainlayername = self.get_layer_name(layerdir)
  373. logger.plain(' %s' % mainlayername)
  374. for classdir in classdirs:
  375. fullpath = os.path.join(classdir, classfile)
  376. if fullpath != mainfile:
  377. if args.filenames:
  378. print(' %s' % fullpath)
  379. else:
  380. print(' %s' % self.get_layer_name(os.path.dirname(classdir)))
  381. if overlayed_class_found:
  382. items_listed = True;
  383. if not items_listed:
  384. logger.plain('No overlayed files found.')
  385. def do_show_recipes(self, args):
  386. """list available recipes, showing the layer they are provided by
  387. Lists the names of recipes and the available versions in each
  388. layer, with the preferred version first. Optionally you may specify
  389. pnspec to match a specified recipe name (supports wildcards). Note that
  390. skipped recipes will also be listed, with a " (skipped)" suffix.
  391. """
  392. self.init_bbhandler()
  393. title = 'Available recipes:'
  394. self.list_recipes(title, args.pnspec, False, False, args.filenames, args.multiple)
  395. def list_recipes(self, title, pnspec, show_overlayed_only, show_same_ver_only, show_filenames, show_multi_provider_only):
  396. pkg_pn = self.bbhandler.cooker.recipecache.pkg_pn
  397. (latest_versions, preferred_versions) = bb.providers.findProviders(self.bbhandler.config_data, self.bbhandler.cooker.recipecache, pkg_pn)
  398. allproviders = bb.providers.allProviders(self.bbhandler.cooker.recipecache)
  399. # Ensure we list skipped recipes
  400. # We are largely guessing about PN, PV and the preferred version here,
  401. # but we have no choice since skipped recipes are not fully parsed
  402. skiplist = self.bbhandler.cooker.skiplist.keys()
  403. skiplist.sort( key=lambda fileitem: self.bbhandler.cooker.collection.calc_bbfile_priority(fileitem) )
  404. skiplist.reverse()
  405. for fn in skiplist:
  406. recipe_parts = os.path.splitext(os.path.basename(fn))[0].split('_')
  407. p = recipe_parts[0]
  408. if len(recipe_parts) > 1:
  409. ver = (None, recipe_parts[1], None)
  410. else:
  411. ver = (None, 'unknown', None)
  412. allproviders[p].append((ver, fn))
  413. if not p in pkg_pn:
  414. pkg_pn[p] = 'dummy'
  415. preferred_versions[p] = (ver, fn)
  416. def print_item(f, pn, ver, layer, ispref):
  417. if f in skiplist:
  418. skipped = ' (skipped)'
  419. else:
  420. skipped = ''
  421. if show_filenames:
  422. if ispref:
  423. logger.plain("%s%s", f, skipped)
  424. else:
  425. logger.plain(" %s%s", f, skipped)
  426. else:
  427. if ispref:
  428. logger.plain("%s:", pn)
  429. logger.plain(" %s %s%s", layer.ljust(20), ver, skipped)
  430. preffiles = []
  431. items_listed = False
  432. for p in sorted(pkg_pn):
  433. if pnspec:
  434. if not fnmatch.fnmatch(p, pnspec):
  435. continue
  436. if len(allproviders[p]) > 1 or not show_multi_provider_only:
  437. pref = preferred_versions[p]
  438. realfn = bb.cache.Cache.virtualfn2realfn(pref[1])
  439. preffile = realfn[0]
  440. # We only display once per recipe, we should prefer non extended versions of the
  441. # recipe if present (so e.g. in OpenEmbedded, openssl rather than nativesdk-openssl
  442. # which would otherwise sort first).
  443. if realfn[1] and realfn[0] in self.bbhandler.cooker.recipecache.pkg_fn:
  444. continue
  445. if preffile not in preffiles:
  446. preflayer = self.get_file_layer(preffile)
  447. multilayer = False
  448. same_ver = True
  449. provs = []
  450. for prov in allproviders[p]:
  451. provfile = bb.cache.Cache.virtualfn2realfn(prov[1])[0]
  452. provlayer = self.get_file_layer(provfile)
  453. provs.append((provfile, provlayer, prov[0]))
  454. if provlayer != preflayer:
  455. multilayer = True
  456. if prov[0] != pref[0]:
  457. same_ver = False
  458. if (multilayer or not show_overlayed_only) and (same_ver or not show_same_ver_only):
  459. if not items_listed:
  460. logger.plain('=== %s ===' % title)
  461. items_listed = True
  462. print_item(preffile, p, self.version_str(pref[0][0], pref[0][1]), preflayer, True)
  463. for (provfile, provlayer, provver) in provs:
  464. if provfile != preffile:
  465. print_item(provfile, p, self.version_str(provver[0], provver[1]), provlayer, False)
  466. # Ensure we don't show two entries for BBCLASSEXTENDed recipes
  467. preffiles.append(preffile)
  468. return items_listed
  469. def do_flatten(self, args):
  470. """flatten layer configuration into a separate output directory.
  471. Takes the specified layers (or all layers in the current layer
  472. configuration if none are specified) and builds a "flattened" directory
  473. containing the contents of all layers, with any overlayed recipes removed
  474. and bbappends appended to the corresponding recipes. Note that some manual
  475. cleanup may still be necessary afterwards, in particular:
  476. * where non-recipe files (such as patches) are overwritten (the flatten
  477. command will show a warning for these)
  478. * where anything beyond the normal layer setup has been added to
  479. layer.conf (only the lowest priority number layer's layer.conf is used)
  480. * overridden/appended items from bbappends will need to be tidied up
  481. * when the flattened layers do not have the same directory structure (the
  482. flatten command should show a warning when this will cause a problem)
  483. Warning: if you flatten several layers where another layer is intended to
  484. be used "inbetween" them (in layer priority order) such that recipes /
  485. bbappends in the layers interact, and then attempt to use the new output
  486. layer together with that other layer, you may no longer get the same
  487. build results (as the layer priority order has effectively changed).
  488. """
  489. if len(args.layer) == 1:
  490. logger.error('If you specify layers to flatten you must specify at least two')
  491. return 1
  492. outputdir = args.outputdir
  493. if os.path.exists(outputdir) and os.listdir(outputdir):
  494. logger.error('Directory %s exists and is non-empty, please clear it out first' % outputdir)
  495. return 1
  496. self.init_bbhandler()
  497. layers = self.bblayers
  498. if len(args.layer) > 2:
  499. layernames = args.layer
  500. found_layernames = []
  501. found_layerdirs = []
  502. for layerdir in layers:
  503. layername = self.get_layer_name(layerdir)
  504. if layername in layernames:
  505. found_layerdirs.append(layerdir)
  506. found_layernames.append(layername)
  507. for layername in layernames:
  508. if not layername in found_layernames:
  509. logger.error('Unable to find layer %s in current configuration, please run "%s show-layers" to list configured layers' % (layername, os.path.basename(sys.argv[0])))
  510. return
  511. layers = found_layerdirs
  512. else:
  513. layernames = []
  514. # Ensure a specified path matches our list of layers
  515. def layer_path_match(path):
  516. for layerdir in layers:
  517. if path.startswith(os.path.join(layerdir, '')):
  518. return layerdir
  519. return None
  520. appended_recipes = []
  521. for layer in layers:
  522. overlayed = []
  523. for f in self.bbhandler.cooker.collection.overlayed.iterkeys():
  524. for of in self.bbhandler.cooker.collection.overlayed[f]:
  525. if of.startswith(layer):
  526. overlayed.append(of)
  527. logger.plain('Copying files from %s...' % layer )
  528. for root, dirs, files in os.walk(layer):
  529. for f1 in files:
  530. f1full = os.sep.join([root, f1])
  531. if f1full in overlayed:
  532. logger.plain(' Skipping overlayed file %s' % f1full )
  533. else:
  534. ext = os.path.splitext(f1)[1]
  535. if ext != '.bbappend':
  536. fdest = f1full[len(layer):]
  537. fdest = os.path.normpath(os.sep.join([outputdir,fdest]))
  538. bb.utils.mkdirhier(os.path.dirname(fdest))
  539. if os.path.exists(fdest):
  540. if f1 == 'layer.conf' and root.endswith('/conf'):
  541. logger.plain(' Skipping layer config file %s' % f1full )
  542. continue
  543. else:
  544. logger.warn('Overwriting file %s', fdest)
  545. bb.utils.copyfile(f1full, fdest)
  546. if ext == '.bb':
  547. if f1 in self.bbhandler.cooker.collection.appendlist:
  548. appends = self.bbhandler.cooker.collection.appendlist[f1]
  549. if appends:
  550. logger.plain(' Applying appends to %s' % fdest )
  551. for appendname in appends:
  552. if layer_path_match(appendname):
  553. self.apply_append(appendname, fdest)
  554. appended_recipes.append(f1)
  555. # Take care of when some layers are excluded and yet we have included bbappends for those recipes
  556. for recipename in self.bbhandler.cooker.collection.appendlist.iterkeys():
  557. if recipename not in appended_recipes:
  558. appends = self.bbhandler.cooker.collection.appendlist[recipename]
  559. first_append = None
  560. for appendname in appends:
  561. layer = layer_path_match(appendname)
  562. if layer:
  563. if first_append:
  564. self.apply_append(appendname, first_append)
  565. else:
  566. fdest = appendname[len(layer):]
  567. fdest = os.path.normpath(os.sep.join([outputdir,fdest]))
  568. bb.utils.mkdirhier(os.path.dirname(fdest))
  569. bb.utils.copyfile(appendname, fdest)
  570. first_append = fdest
  571. # Get the regex for the first layer in our list (which is where the conf/layer.conf file will
  572. # have come from)
  573. first_regex = None
  574. layerdir = layers[0]
  575. for layername, pattern, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
  576. if regex.match(os.path.join(layerdir, 'test')):
  577. first_regex = regex
  578. break
  579. if first_regex:
  580. # Find the BBFILES entries that match (which will have come from this conf/layer.conf file)
  581. bbfiles = str(self.bbhandler.config_data.getVar('BBFILES', True)).split()
  582. bbfiles_layer = []
  583. for item in bbfiles:
  584. if first_regex.match(item):
  585. newpath = os.path.join(outputdir, item[len(layerdir)+1:])
  586. bbfiles_layer.append(newpath)
  587. if bbfiles_layer:
  588. # Check that all important layer files match BBFILES
  589. for root, dirs, files in os.walk(outputdir):
  590. for f1 in files:
  591. ext = os.path.splitext(f1)[1]
  592. if ext in ['.bb', '.bbappend']:
  593. f1full = os.sep.join([root, f1])
  594. entry_found = False
  595. for item in bbfiles_layer:
  596. if fnmatch.fnmatch(f1full, item):
  597. entry_found = True
  598. break
  599. if not entry_found:
  600. logger.warning("File %s does not match the flattened layer's BBFILES setting, you may need to edit conf/layer.conf or move the file elsewhere" % f1full)
  601. def get_file_layer(self, filename):
  602. for layer, _, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
  603. if regex.match(filename):
  604. for layerdir in self.bblayers:
  605. if regex.match(os.path.join(layerdir, 'test')) and re.match(layerdir, filename):
  606. return self.get_layer_name(layerdir)
  607. return "?"
  608. def get_file_layerdir(self, filename):
  609. for layer, _, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
  610. if regex.match(filename):
  611. for layerdir in self.bblayers:
  612. if regex.match(os.path.join(layerdir, 'test')) and re.match(layerdir, filename):
  613. return layerdir
  614. return "?"
  615. def remove_layer_prefix(self, f):
  616. """Remove the layer_dir prefix, e.g., f = /path/to/layer_dir/foo/blah, the
  617. return value will be: layer_dir/foo/blah"""
  618. f_layerdir = self.get_file_layerdir(f)
  619. prefix = os.path.join(os.path.dirname(f_layerdir), '')
  620. return f[len(prefix):] if f.startswith(prefix) else f
  621. def get_layer_name(self, layerdir):
  622. return os.path.basename(layerdir.rstrip(os.sep))
  623. def apply_append(self, appendname, recipename):
  624. appendfile = open(appendname, 'r')
  625. recipefile = open(recipename, 'a')
  626. recipefile.write('\n')
  627. recipefile.write('##### bbappended from %s #####\n' % self.get_file_layer(appendname))
  628. recipefile.writelines(appendfile.readlines())
  629. recipefile.close()
  630. appendfile.close()
  631. def do_show_appends(self, args):
  632. """list bbappend files and recipe files they apply to
  633. Lists recipes with the bbappends that apply to them as subitems.
  634. """
  635. self.init_bbhandler()
  636. if not self.bbhandler.cooker.collection.appendlist:
  637. logger.plain('No append files found')
  638. return 0
  639. logger.plain('=== Appended recipes ===')
  640. pnlist = list(self.bbhandler.cooker_data.pkg_pn.keys())
  641. pnlist.sort()
  642. for pn in pnlist:
  643. self.show_appends_for_pn(pn)
  644. self.show_appends_for_skipped()
  645. def show_appends_for_pn(self, pn):
  646. filenames = self.bbhandler.cooker_data.pkg_pn[pn]
  647. best = bb.providers.findBestProvider(pn,
  648. self.bbhandler.config_data,
  649. self.bbhandler.cooker_data,
  650. self.bbhandler.cooker_data.pkg_pn)
  651. best_filename = os.path.basename(best[3])
  652. self.show_appends_output(filenames, best_filename)
  653. def show_appends_for_skipped(self):
  654. filenames = [os.path.basename(f)
  655. for f in self.bbhandler.cooker.skiplist.iterkeys()]
  656. self.show_appends_output(filenames, None, " (skipped)")
  657. def show_appends_output(self, filenames, best_filename, name_suffix = ''):
  658. appended, missing = self.get_appends_for_files(filenames)
  659. if appended:
  660. for basename, appends in appended:
  661. logger.plain('%s%s:', basename, name_suffix)
  662. for append in appends:
  663. logger.plain(' %s', append)
  664. if best_filename:
  665. if best_filename in missing:
  666. logger.warn('%s: missing append for preferred version',
  667. best_filename)
  668. def get_appends_for_files(self, filenames):
  669. appended, notappended = [], []
  670. for filename in filenames:
  671. _, cls = bb.cache.Cache.virtualfn2realfn(filename)
  672. if cls:
  673. continue
  674. basename = os.path.basename(filename)
  675. appends = self.bbhandler.cooker.collection.get_file_appends(basename)
  676. if appends:
  677. appended.append((basename, list(appends)))
  678. else:
  679. notappended.append(basename)
  680. return appended, notappended
  681. def do_show_cross_depends(self, args):
  682. """Show dependencies between recipes that cross layer boundaries.
  683. Figure out the dependencies between recipes that cross layer boundaries.
  684. NOTE: .bbappend files can impact the dependencies.
  685. """
  686. ignore_layers = (args.ignore or '').split(',')
  687. self.init_bbhandler()
  688. pkg_fn = self.bbhandler.cooker_data.pkg_fn
  689. bbpath = str(self.bbhandler.config_data.getVar('BBPATH', True))
  690. self.require_re = re.compile(r"require\s+(.+)")
  691. self.include_re = re.compile(r"include\s+(.+)")
  692. self.inherit_re = re.compile(r"inherit\s+(.+)")
  693. global_inherit = (self.bbhandler.config_data.getVar('INHERIT', True) or "").split()
  694. # The bb's DEPENDS and RDEPENDS
  695. for f in pkg_fn:
  696. f = bb.cache.Cache.virtualfn2realfn(f)[0]
  697. # Get the layername that the file is in
  698. layername = self.get_file_layer(f)
  699. # The DEPENDS
  700. deps = self.bbhandler.cooker_data.deps[f]
  701. for pn in deps:
  702. if pn in self.bbhandler.cooker_data.pkg_pn:
  703. best = bb.providers.findBestProvider(pn,
  704. self.bbhandler.config_data,
  705. self.bbhandler.cooker_data,
  706. self.bbhandler.cooker_data.pkg_pn)
  707. self.check_cross_depends("DEPENDS", layername, f, best[3], args.filenames, ignore_layers)
  708. # The RDPENDS
  709. all_rdeps = self.bbhandler.cooker_data.rundeps[f].values()
  710. # Remove the duplicated or null one.
  711. sorted_rdeps = {}
  712. # The all_rdeps is the list in list, so we need two for loops
  713. for k1 in all_rdeps:
  714. for k2 in k1:
  715. sorted_rdeps[k2] = 1
  716. all_rdeps = sorted_rdeps.keys()
  717. for rdep in all_rdeps:
  718. all_p = bb.providers.getRuntimeProviders(self.bbhandler.cooker_data, rdep)
  719. if all_p:
  720. if f in all_p:
  721. # The recipe provides this one itself, ignore
  722. continue
  723. best = bb.providers.filterProvidersRunTime(all_p, rdep,
  724. self.bbhandler.config_data,
  725. self.bbhandler.cooker_data)[0][0]
  726. self.check_cross_depends("RDEPENDS", layername, f, best, args.filenames, ignore_layers)
  727. # The RRECOMMENDS
  728. all_rrecs = self.bbhandler.cooker_data.runrecs[f].values()
  729. # Remove the duplicated or null one.
  730. sorted_rrecs = {}
  731. # The all_rrecs is the list in list, so we need two for loops
  732. for k1 in all_rrecs:
  733. for k2 in k1:
  734. sorted_rrecs[k2] = 1
  735. all_rrecs = sorted_rrecs.keys()
  736. for rrec in all_rrecs:
  737. all_p = bb.providers.getRuntimeProviders(self.bbhandler.cooker_data, rrec)
  738. if all_p:
  739. if f in all_p:
  740. # The recipe provides this one itself, ignore
  741. continue
  742. best = bb.providers.filterProvidersRunTime(all_p, rrec,
  743. self.bbhandler.config_data,
  744. self.bbhandler.cooker_data)[0][0]
  745. self.check_cross_depends("RRECOMMENDS", layername, f, best, args.filenames, ignore_layers)
  746. # The inherit class
  747. cls_re = re.compile('classes/')
  748. if f in self.bbhandler.cooker_data.inherits:
  749. inherits = self.bbhandler.cooker_data.inherits[f]
  750. for cls in inherits:
  751. # The inherits' format is [classes/cls, /path/to/classes/cls]
  752. # ignore the classes/cls.
  753. if not cls_re.match(cls):
  754. classname = os.path.splitext(os.path.basename(cls))[0]
  755. if classname in global_inherit:
  756. continue
  757. inherit_layername = self.get_file_layer(cls)
  758. if inherit_layername != layername and not inherit_layername in ignore_layers:
  759. if not args.filenames:
  760. f_short = self.remove_layer_prefix(f)
  761. cls = self.remove_layer_prefix(cls)
  762. else:
  763. f_short = f
  764. logger.plain("%s inherits %s" % (f_short, cls))
  765. # The 'require/include xxx' in the bb file
  766. pv_re = re.compile(r"\${PV}")
  767. fnfile = open(f, 'r')
  768. line = fnfile.readline()
  769. while line:
  770. m, keyword = self.match_require_include(line)
  771. # Found the 'require/include xxxx'
  772. if m:
  773. needed_file = m.group(1)
  774. # Replace the ${PV} with the real PV
  775. if pv_re.search(needed_file) and f in self.bbhandler.cooker_data.pkg_pepvpr:
  776. pv = self.bbhandler.cooker_data.pkg_pepvpr[f][1]
  777. needed_file = re.sub(r"\${PV}", pv, needed_file)
  778. self.print_cross_files(bbpath, keyword, layername, f, needed_file, args.filenames, ignore_layers)
  779. line = fnfile.readline()
  780. fnfile.close()
  781. # The "require/include xxx" in conf/machine/*.conf, .inc and .bbclass
  782. conf_re = re.compile(".*/conf/machine/[^\/]*\.conf$")
  783. inc_re = re.compile(".*\.inc$")
  784. # The "inherit xxx" in .bbclass
  785. bbclass_re = re.compile(".*\.bbclass$")
  786. for layerdir in self.bblayers:
  787. layername = self.get_layer_name(layerdir)
  788. for dirpath, dirnames, filenames in os.walk(layerdir):
  789. for name in filenames:
  790. f = os.path.join(dirpath, name)
  791. s = conf_re.match(f) or inc_re.match(f) or bbclass_re.match(f)
  792. if s:
  793. ffile = open(f, 'r')
  794. line = ffile.readline()
  795. while line:
  796. m, keyword = self.match_require_include(line)
  797. # Only bbclass has the "inherit xxx" here.
  798. bbclass=""
  799. if not m and f.endswith(".bbclass"):
  800. m, keyword = self.match_inherit(line)
  801. bbclass=".bbclass"
  802. # Find a 'require/include xxxx'
  803. if m:
  804. self.print_cross_files(bbpath, keyword, layername, f, m.group(1) + bbclass, args.filenames, ignore_layers)
  805. line = ffile.readline()
  806. ffile.close()
  807. def print_cross_files(self, bbpath, keyword, layername, f, needed_filename, show_filenames, ignore_layers):
  808. """Print the depends that crosses a layer boundary"""
  809. needed_file = bb.utils.which(bbpath, needed_filename)
  810. if needed_file:
  811. # Which layer is this file from
  812. needed_layername = self.get_file_layer(needed_file)
  813. if needed_layername != layername and not needed_layername in ignore_layers:
  814. if not show_filenames:
  815. f = self.remove_layer_prefix(f)
  816. needed_file = self.remove_layer_prefix(needed_file)
  817. logger.plain("%s %s %s" %(f, keyword, needed_file))
  818. def match_inherit(self, line):
  819. """Match the inherit xxx line"""
  820. return (self.inherit_re.match(line), "inherits")
  821. def match_require_include(self, line):
  822. """Match the require/include xxx line"""
  823. m = self.require_re.match(line)
  824. keyword = "requires"
  825. if not m:
  826. m = self.include_re.match(line)
  827. keyword = "includes"
  828. return (m, keyword)
  829. def check_cross_depends(self, keyword, layername, f, needed_file, show_filenames, ignore_layers):
  830. """Print the DEPENDS/RDEPENDS file that crosses a layer boundary"""
  831. best_realfn = bb.cache.Cache.virtualfn2realfn(needed_file)[0]
  832. needed_layername = self.get_file_layer(best_realfn)
  833. if needed_layername != layername and not needed_layername in ignore_layers:
  834. if not show_filenames:
  835. f = self.remove_layer_prefix(f)
  836. best_realfn = self.remove_layer_prefix(best_realfn)
  837. logger.plain("%s %s %s" % (f, keyword, best_realfn))
  838. def main():
  839. cmds = Commands()
  840. def add_command(cmdname, function, *args, **kwargs):
  841. # Convert docstring for function to help (one-liner shown in main --help) and description (shown in subcommand --help)
  842. docsplit = function.__doc__.splitlines()
  843. help = docsplit[0]
  844. if len(docsplit) > 1:
  845. desc = '\n'.join(docsplit[1:])
  846. else:
  847. desc = help
  848. subparser = subparsers.add_parser(cmdname, *args, help=help, description=desc, formatter_class=argparse.RawTextHelpFormatter, **kwargs)
  849. subparser.set_defaults(func=function)
  850. return subparser
  851. parser = argparse.ArgumentParser(description="BitBake layers utility",
  852. epilog="Use %(prog)s <subcommand> --help to get help on a specific command")
  853. parser.add_argument('-d', '--debug', help='Enable debug output', action='store_true')
  854. parser.add_argument('-q', '--quiet', help='Print only errors', action='store_true')
  855. subparsers = parser.add_subparsers(title='subcommands', metavar='<subcommand>')
  856. parser_show_layers = add_command('show-layers', cmds.do_show_layers)
  857. parser_add_layer = add_command('add-layer', cmds.do_add_layer)
  858. parser_add_layer.add_argument('layerdir', help='Layer directory to add')
  859. parser_remove_layer = add_command('remove-layer', cmds.do_remove_layer)
  860. parser_remove_layer.add_argument('layerdir', help='Layer directory to remove (wildcards allowed, enclose in quotes to avoid shell expansion)')
  861. parser_remove_layer.set_defaults(func=cmds.do_remove_layer)
  862. parser_show_overlayed = add_command('show-overlayed', cmds.do_show_overlayed)
  863. parser_show_overlayed.add_argument('-f', '--filenames', help='instead of the default formatting, list filenames of higher priority recipes with the ones they overlay indented underneath', action='store_true')
  864. parser_show_overlayed.add_argument('-s', '--same-version', help='only list overlayed recipes where the version is the same', action='store_true')
  865. parser_show_recipes = add_command('show-recipes', cmds.do_show_recipes)
  866. parser_show_recipes.add_argument('-f', '--filenames', help='instead of the default formatting, list filenames of higher priority recipes with the ones they overlay indented underneath', action='store_true')
  867. parser_show_recipes.add_argument('-m', '--multiple', help='only list where multiple recipes (in the same layer or different layers) exist for the same recipe name', action='store_true')
  868. parser_show_recipes.add_argument('pnspec', nargs='?', help='optional recipe name specification (wildcards allowed, enclose in quotes to avoid shell expansion)')
  869. parser_show_appends = add_command('show-appends', cmds.do_show_appends)
  870. parser_flatten = add_command('flatten', cmds.do_flatten)
  871. parser_flatten.add_argument('layer', nargs='*', help='Optional layer(s) to flatten (otherwise all are flattened)')
  872. parser_flatten.add_argument('outputdir', help='Output directory')
  873. parser_show_cross_depends = add_command('show-cross-depends', cmds.do_show_cross_depends)
  874. parser_show_cross_depends.add_argument('-f', '--filenames', help='show full file path', action='store_true')
  875. parser_show_cross_depends.add_argument('-i', '--ignore', help='ignore dependencies on items in the specified layer(s) (split multiple layer names with commas, no spaces)', metavar='LAYERNAME')
  876. parser_layerindex_fetch = add_command('layerindex-fetch', cmds.do_layerindex_fetch)
  877. parser_layerindex_fetch.add_argument('-n', '--show-only', help='show dependencies and do nothing else', action='store_true')
  878. parser_layerindex_fetch.add_argument('-b', '--branch', help='branch name to fetch (default %(default)s)', default='master')
  879. parser_layerindex_fetch.add_argument('-i', '--ignore', help='assume the specified layers do not need to be fetched/added (separate multiple layers with commas, no spaces)', metavar='LAYER')
  880. parser_layerindex_fetch.add_argument('layername', nargs='+', help='layer to fetch')
  881. parser_layerindex_show_depends = add_command('layerindex-show-depends', cmds.do_layerindex_show_depends)
  882. parser_layerindex_show_depends.add_argument('-b', '--branch', help='branch name to fetch (default %(default)s)', default='master')
  883. parser_layerindex_show_depends.add_argument('layername', nargs='+', help='layer to query')
  884. args = parser.parse_args()
  885. if args.debug:
  886. logger.setLevel(logging.DEBUG)
  887. elif args.quiet:
  888. logger.setLevel(logging.ERROR)
  889. ret = args.func(args)
  890. return ret
  891. if __name__ == "__main__":
  892. try:
  893. ret = main()
  894. except Exception:
  895. ret = 1
  896. import traceback
  897. traceback.print_exc(5)
  898. sys.exit(ret)