# Utility functions for reading and modifying recipes
#
# Some code borrowed from the OE layer index
#
# Copyright (C) 2013-2015 Intel Corporation
#
import sys
import os
import os.path
import tempfile
import textwrap
import difflib
import utils
import shutil
import re
import fnmatch
from collections import OrderedDict, defaultdict
# Help us to find places to insert values
recipe_progression = ['SUMMARY', 'DESCRIPTION', 'HOMEPAGE', 'BUGTRACKER', 'SECTION', 'LICENSE', 'LIC_FILES_CHKSUM', 'PROVIDES', 'DEPENDS', 'PR', 'PV', 'SRCREV', 'SRC_URI', 'S', 'do_fetch()', 'do_unpack()', 'do_patch()', 'EXTRA_OECONF', 'do_configure()', 'EXTRA_OEMAKE', 'do_compile()', 'do_install()', 'do_populate_sysroot()', 'INITSCRIPT', 'USERADD', 'GROUPADD', 'PACKAGES', 'FILES', 'RDEPENDS', 'RRECOMMENDS', 'RSUGGESTS', 'RPROVIDES', 'RREPLACES', 'RCONFLICTS', 'ALLOW_EMPTY', 'do_package()', 'do_deploy()']
# Variables that sometimes are a bit long but shouldn't be wrapped
nowrap_vars = ['SUMMARY', 'HOMEPAGE', 'BUGTRACKER', 'SRC_URI[md5sum]', 'SRC_URI[sha256sum]']
list_vars = ['SRC_URI', 'LIC_FILES_CHKSUM']
meta_vars = ['SUMMARY', 'DESCRIPTION', 'HOMEPAGE', 'BUGTRACKER', 'SECTION']
def pn_to_recipe(cooker, pn):
"""Convert a recipe name (PN) to the path to the recipe file"""
import bb.providers
if pn in cooker.recipecache.pkg_pn:
best = bb.providers.findBestProvider(pn, cooker.data, cooker.recipecache, cooker.recipecache.pkg_pn)
return best[3]
elif pn in cooker.recipecache.providers:
filenames = cooker.recipecache.providers[pn]
eligible, foundUnique = bb.providers.filterProviders(filenames, pn, cooker.expanded_data, cooker.recipecache)
filename = eligible[0]
return filename
else:
return None
def get_unavailable_reasons(cooker, pn):
"""If a recipe could not be found, find out why if possible"""
import bb.taskdata
taskdata = bb.taskdata.TaskData(None, skiplist=cooker.skiplist)
return taskdata.get_reasons(pn)
def parse_recipe(fn, appendfiles, d):
"""
Parse an individual recipe file, optionally with a list of
bbappend files.
"""
import bb.cache
envdata = bb.cache.Cache.loadDataFull(fn, appendfiles, d)
return envdata
def parse_recipe_simple(cooker, pn, d, appends=True):
"""
Parse a recipe and optionally all bbappends that apply to it
in the current configuration.
"""
import bb.providers
recipefile = pn_to_recipe(cooker, pn)
if not recipefile:
skipreasons = get_unavailable_reasons(cooker, pn)
# We may as well re-use bb.providers.NoProvider here
if skipreasons:
raise bb.providers.NoProvider(skipreasons)
else:
raise bb.providers.NoProvider('Unable to find any recipe file matching %s' % pn)
if appends:
appendfiles = cooker.collection.get_file_appends(recipefile)
else:
appendfiles = None
return parse_recipe(recipefile, appendfiles, d)
def get_var_files(fn, varlist, d):
"""Find the file in which each of a list of variables is set.
Note: requires variable history to be enabled when parsing.
"""
varfiles = {}
for v in varlist:
history = d.varhistory.variable(v)
files = []
for event in history:
if 'file' in event and not 'flag' in event:
files.append(event['file'])
if files:
actualfile = files[-1]
else:
actualfile = None
varfiles[v] = actualfile
return varfiles
def split_var_value(value, assignment=True):
"""
Split a space-separated variable's value into a list of items,
taking into account that some of the items might be made up of
expressions containing spaces that should not be split.
Parameters:
value:
The string value to split
assignment:
True to assume that the value represents an assignment
statement, False otherwise. If True, and an assignment
statement is passed in the first item in
the returned list will be the part of the assignment
statement up to and including the opening quote character,
and the last item will be the closing quote.
"""
inexpr = 0
lastchar = None
out = []
buf = ''
for char in value:
if char == '{':
if lastchar == '$':
inexpr += 1
elif char == '}':
inexpr -= 1
elif assignment and char in '"\'' and inexpr == 0:
if buf:
out.append(buf)
out.append(char)
char = ''
buf = ''
elif char.isspace() and inexpr == 0:
char = ''
if buf:
out.append(buf)
buf = ''
buf += char
lastchar = char
if buf:
out.append(buf)
# Join together assignment statement and opening quote
outlist = out
if assignment:
assigfound = False
for idx, item in enumerate(out):
if '=' in item:
assigfound = True
if assigfound:
if '"' in item or "'" in item:
outlist = [' '.join(out[:idx+1])]
outlist.extend(out[idx+1:])
break
return outlist
def patch_recipe_file(fn, values, patch=False, relpath=''):
"""Update or insert variable values into a recipe file (assuming you
have already identified the exact file you want to update.)
Note that some manual inspection/intervention may be required
since this cannot handle all situations.
"""
import bb.utils
recipe_progression_res = []
recipe_progression_restrs = []
for item in recipe_progression:
if item.endswith('()'):
key = item[:-2]
else:
key = item
restr = '%s(_[a-zA-Z0-9-_$(){}]+|\[[^\]]*\])?' % key
if item.endswith('()'):
recipe_progression_restrs.append(restr + '()')
else:
recipe_progression_restrs.append(restr)
recipe_progression_res.append(re.compile('^%s$' % restr))
def get_recipe_pos(variable):
for i, p in enumerate(recipe_progression_res):
if p.match(variable):
return i
return -1
remainingnames = {}
for k in values.keys():
remainingnames[k] = get_recipe_pos(k)
remainingnames = OrderedDict(sorted(remainingnames.iteritems(), key=lambda x: x[1]))
modifying = False
def outputvalue(name, lines, rewindcomments=False):
if values[name] is None:
return
rawtext = '%s = "%s"\n' % (name, values[name])
addlines = []
if name in nowrap_vars:
addlines.append(rawtext)
elif name in list_vars:
splitvalue = split_var_value(values[name], assignment=False)
if len(splitvalue) > 1:
linesplit = ' \\\n' + (' ' * (len(name) + 4))
addlines.append('%s = "%s%s"\n' % (name, linesplit.join(splitvalue), linesplit))
else:
addlines.append(rawtext)
else:
wrapped = textwrap.wrap(rawtext)
for wrapline in wrapped[:-1]:
addlines.append('%s \\\n' % wrapline)
addlines.append('%s\n' % wrapped[-1])
if rewindcomments:
# Ensure we insert the lines before any leading comments
# (that we'd want to ensure remain leading the next value)
for i, ln in reversed(list(enumerate(lines))):
if ln[0] != '#':
lines[i+1:i+1] = addlines
break
else:
lines.extend(addlines)
else:
lines.extend(addlines)
existingnames = []
def patch_recipe_varfunc(varname, origvalue, op, newlines):
if modifying:
# Insert anything that should come before this variable
pos = get_recipe_pos(varname)
for k in remainingnames.keys()[:]:
if remainingnames[k] > -1 and pos >= remainingnames[k] and not k in existingnames:
outputvalue(k, newlines, rewindcomments=True)
del remainingnames[k]
# Now change this variable, if it needs to be changed
if varname in existingnames:
outputvalue(varname, newlines)
del remainingnames[varname]
return None, None, 0, True
else:
if varname in values:
existingnames.append(varname)
return origvalue, None, 0, True
# First run - establish which values we want to set are already in the file
varlist = [re.escape(item) for item in values.keys()]
with open(fn, 'r') as f:
changed, fromlines = bb.utils.edit_metadata(f, varlist, patch_recipe_varfunc)
# Second run - actually set everything
modifying = True
varlist.extend(recipe_progression_restrs)
changed, tolines = bb.utils.edit_metadata(fromlines, varlist, patch_recipe_varfunc, match_overrides=True)
if remainingnames:
if tolines[-1].strip() != '':
tolines.append('\n')
for k in remainingnames.keys():
outputvalue(k, tolines)
if patch:
relfn = os.path.relpath(fn, relpath)
diff = difflib.unified_diff(fromlines, tolines, 'a/%s' % relfn, 'b/%s' % relfn)
return diff
else:
with open(fn, 'w') as f:
f.writelines(tolines)
return None
def localise_file_vars(fn, varfiles, varlist):
"""Given a list of variables and variable history (fetched with get_var_files())
find where each variable should be set/changed. This handles for example where a
recipe includes an inc file where variables might be changed - in most cases
we want to update the inc file when changing the variable value rather than adding
it to the recipe itself.
"""
fndir = os.path.dirname(fn) + os.sep
first_meta_file = None
for v in meta_vars:
f = varfiles.get(v, None)
if f:
actualdir = os.path.dirname(f) + os.sep
if actualdir.startswith(fndir):
first_meta_file = f
break
filevars = defaultdict(list)
for v in varlist:
f = varfiles[v]
# Only return files that are in the same directory as the recipe or in some directory below there
# (this excludes bbclass files and common inc files that wouldn't be appropriate to set the variable
# in if we were going to set a value specific to this recipe)
if f:
actualfile = f
else:
# Variable isn't in a file, if it's one of the "meta" vars, use the first file with a meta var in it
if first_meta_file:
actualfile = first_meta_file
else:
actualfile = fn
actualdir = os.path.dirname(actualfile) + os.sep
if not actualdir.startswith(fndir):
actualfile = fn
filevars[actualfile].append(v)
return filevars
def patch_recipe(d, fn, varvalues, patch=False, relpath=''):
"""Modify a list of variable values in the specified recipe. Handles inc files if
used by the recipe.
"""
varlist = varvalues.keys()
varfiles = get_var_files(fn, varlist, d)
locs = localise_file_vars(fn, varfiles, varlist)
patches = []
for f,v in locs.iteritems():
vals = {k: varvalues[k] for k in v}
patchdata = patch_recipe_file(f, vals, patch, relpath)
if patch:
patches.append(patchdata)
if patch:
return patches
else:
return None
def copy_recipe_files(d, tgt_dir, whole_dir=False, download=True):
"""Copy (local) recipe files, including both files included via include/require,
and files referred to in the SRC_URI variable."""
import bb.fetch2
import oe.path
# FIXME need a warning if the unexpanded SRC_URI value contains variable references
uris = (d.getVar('SRC_URI', True) or "").split()
fetch = bb.fetch2.Fetch(uris, d)
if download:
fetch.download()
# Copy local files to target directory and gather any remote files
bb_dir = os.path.dirname(d.getVar('FILE', True)) + os.sep
remotes = []
includes = [path for path in d.getVar('BBINCLUDED', True).split() if
path.startswith(bb_dir) and os.path.exists(path)]
for path in fetch.localpaths() + includes:
# Only import files that are under the meta directory
if path.startswith(bb_dir):
if not whole_dir:
relpath = os.path.relpath(path, bb_dir)
subdir = os.path.join(tgt_dir, os.path.dirname(relpath))
if not os.path.exists(subdir):
os.makedirs(subdir)
shutil.copy2(path, os.path.join(tgt_dir, relpath))
else:
remotes.append(path)
# Simply copy whole meta dir, if requested
if whole_dir:
shutil.copytree(bb_dir, tgt_dir)
return remotes
def get_recipe_local_files(d, patches=False):
"""Get a list of local files in SRC_URI within a recipe."""
uris = (d.getVar('SRC_URI', True) or "").split()
fetch = bb.fetch2.Fetch(uris, d)
ret = {}
for uri in uris:
if fetch.ud[uri].type == 'file':
if (not patches and
bb.utils.exec_flat_python_func('patch_path', uri, fetch, '')):
continue
# Skip files that are referenced by absolute path
if not os.path.isabs(fetch.ud[uri].basepath):
ret[fetch.ud[uri].basepath] = fetch.localpath(uri)
return ret
def get_recipe_patches(d):
"""Get a list of the patches included in SRC_URI within a recipe."""
patchfiles = []
# Execute src_patches() defined in patch.bbclass - this works since that class
# is inherited globally
patches = bb.utils.exec_flat_python_func('src_patches', d)
for patch in patches:
_, _, local, _, _, parm = bb.fetch.decodeurl(patch)
patchfiles.append(local)
return patchfiles
def get_recipe_patched_files(d):
"""
Get the list of patches for a recipe along with the files each patch modifies.
Params:
d: the datastore for the recipe
Returns:
a dict mapping patch file path to a list of tuples of changed files and
change mode ('A' for add, 'D' for delete or 'M' for modify)
"""
import oe.patch
# Execute src_patches() defined in patch.bbclass - this works since that class
# is inherited globally
patches = bb.utils.exec_flat_python_func('src_patches', d)
patchedfiles = {}
for patch in patches:
_, _, patchfile, _, _, parm = bb.fetch.decodeurl(patch)
striplevel = int(parm['striplevel'])
patchedfiles[patchfile] = oe.patch.PatchSet.getPatchedFiles(patchfile, striplevel, os.path.join(d.getVar('S', True), parm.get('patchdir', '')))
return patchedfiles
def validate_pn(pn):
"""Perform validation on a recipe name (PN) for a new recipe."""
reserved_names = ['forcevariable', 'append', 'prepend', 'remove']
if not re.match('[0-9a-z-.]+', pn):
return 'Recipe name "%s" is invalid: only characters 0-9, a-z, - and . are allowed' % pn
elif pn in reserved_names:
return 'Recipe name "%s" is invalid: is a reserved keyword' % pn
elif pn.startswith('pn-'):
return 'Recipe name "%s" is invalid: names starting with "pn-" are reserved' % pn
elif pn.endswith(('.bb', '.bbappend', '.bbclass', '.inc', '.conf')):
return 'Recipe name "%s" is invalid: should be just a name, not a file name' % pn
return ''
def get_bbappend_path(d, destlayerdir, wildcardver=False):
"""Determine how a bbappend for a recipe should be named and located within another layer"""
import bb.cookerdata
destlayerdir = os.path.abspath(destlayerdir)
recipefile = d.getVar('FILE', True)
recipefn = os.path.splitext(os.path.basename(recipefile))[0]
if wildcardver and '_' in recipefn:
recipefn = recipefn.split('_', 1)[0] + '_%'
appendfn = recipefn + '.bbappend'
# Parse the specified layer's layer.conf file directly, in case the layer isn't in bblayers.conf
confdata = d.createCopy()
confdata.setVar('BBFILES', '')
confdata.setVar('LAYERDIR', destlayerdir)
destlayerconf = os.path.join(destlayerdir, "conf", "layer.conf")
confdata = bb.cookerdata.parse_config_file(destlayerconf, confdata)
origlayerdir = find_layerdir(recipefile)
if not origlayerdir:
return (None, False)
# Now join this to the path where the bbappend is going and check if it is covered by BBFILES
appendpath = os.path.join(destlayerdir, os.path.relpath(os.path.dirname(recipefile), origlayerdir), appendfn)
closepath = ''
pathok = True
for bbfilespec in confdata.getVar('BBFILES', True).split():
if fnmatch.fnmatchcase(appendpath, bbfilespec):
# Our append path works, we're done
break
elif bbfilespec.startswith(destlayerdir) and fnmatch.fnmatchcase('test.bbappend', os.path.basename(bbfilespec)):
# Try to find the longest matching path
if len(bbfilespec) > len(closepath):
closepath = bbfilespec
else:
# Unfortunately the bbappend layer and the original recipe's layer don't have the same structure
if closepath:
# bbappend layer's layer.conf at least has a spec that picks up .bbappend files
# Now we just need to substitute out any wildcards
appendsubdir = os.path.relpath(os.path.dirname(closepath), destlayerdir)
if 'recipes-*' in appendsubdir:
# Try to copy this part from the original recipe path
res = re.search('/recipes-[^/]+/', recipefile)
if res:
appendsubdir = appendsubdir.replace('/recipes-*/', res.group(0))
# This is crude, but we have to do something
appendsubdir = appendsubdir.replace('*', recipefn.split('_')[0])
appendsubdir = appendsubdir.replace('?', 'a')
appendpath = os.path.join(destlayerdir, appendsubdir, appendfn)
else:
pathok = False
return (appendpath, pathok)
def bbappend_recipe(rd, destlayerdir, srcfiles, install=None, wildcardver=False, machine=None, extralines=None, removevalues=None):
"""
Writes a bbappend file for a recipe
Parameters:
rd: data dictionary for the recipe
destlayerdir: base directory of the layer to place the bbappend in
(subdirectory path from there will be determined automatically)
srcfiles: dict of source files to add to SRC_URI, where the value
is the full path to the file to be added, and the value is the
original filename as it would appear in SRC_URI or None if it
isn't already present. You may pass None for this parameter if
you simply want to specify your own content via the extralines
parameter.
install: dict mapping entries in srcfiles to a tuple of two elements:
install path (*without* ${D} prefix) and permission value (as a
string, e.g. '0644').
wildcardver: True to use a % wildcard in the bbappend filename, or
False to make the bbappend specific to the recipe version.
machine:
If specified, make the changes in the bbappend specific to this
machine. This will also cause PACKAGE_ARCH = "${MACHINE_ARCH}"
to be added to the bbappend.
extralines:
Extra lines to add to the bbappend. This may be a dict of name
value pairs, or simply a list of the lines.
removevalues:
Variable values to remove - a dict of names/values.
"""
if not removevalues:
removevalues = {}
# Determine how the bbappend should be named
appendpath, pathok = get_bbappend_path(rd, destlayerdir, wildcardver)
if not appendpath:
bb.error('Unable to determine layer directory containing %s' % recipefile)
return (None, None)
if not pathok:
bb.warn('Unable to determine correct subdirectory path for bbappend file - check that what %s adds to BBFILES also matches .bbappend files. Using %s for now, but until you fix this the bbappend will not be applied.' % (os.path.join(destlayerdir, 'conf', 'layer.conf'), os.path.dirname(appendpath)))
appenddir = os.path.dirname(appendpath)
bb.utils.mkdirhier(appenddir)
# FIXME check if the bbappend doesn't get overridden by a higher priority layer?
layerdirs = [os.path.abspath(layerdir) for layerdir in rd.getVar('BBLAYERS', True).split()]
if not os.path.abspath(destlayerdir) in layerdirs:
bb.warn('Specified layer is not currently enabled in bblayers.conf, you will need to add it before this bbappend will be active')
bbappendlines = []
if extralines:
if isinstance(extralines, dict):
for name, value in extralines.iteritems():
bbappendlines.append((name, '=', value))
else:
# Do our best to split it
for line in extralines:
if line[-1] == '\n':
line = line[:-1]
splitline = line.split(None, 2)
if len(splitline) == 3:
bbappendlines.append(tuple(splitline))
else:
raise Exception('Invalid extralines value passed')
def popline(varname):
for i in xrange(0, len(bbappendlines)):
if bbappendlines[i][0] == varname:
line = bbappendlines.pop(i)
return line
return None
def appendline(varname, op, value):
for i in xrange(0, len(bbappendlines)):
item = bbappendlines[i]
if item[0] == varname:
bbappendlines[i] = (item[0], item[1], item[2] + ' ' + value)
break
else:
bbappendlines.append((varname, op, value))
destsubdir = rd.getVar('PN', True)
if srcfiles:
bbappendlines.append(('FILESEXTRAPATHS_prepend', ':=', '${THISDIR}/${PN}:'))
appendoverride = ''
if machine:
bbappendlines.append(('PACKAGE_ARCH', '=', '${MACHINE_ARCH}'))
appendoverride = '_%s' % machine
copyfiles = {}
if srcfiles:
instfunclines = []
for newfile, origsrcfile in srcfiles.iteritems():
srcfile = origsrcfile
srcurientry = None
if not srcfile:
srcfile = os.path.basename(newfile)
srcurientry = 'file://%s' % srcfile
# Double-check it's not there already
# FIXME do we care if the entry is added by another bbappend that might go away?
if not srcurientry in rd.getVar('SRC_URI', True).split():
if machine:
appendline('SRC_URI_append%s' % appendoverride, '=', ' ' + srcurientry)
else:
appendline('SRC_URI', '+=', srcurientry)
copyfiles[newfile] = srcfile
if install:
institem = install.pop(newfile, None)
if institem:
(destpath, perms) = institem
instdestpath = replace_dir_vars(destpath, rd)
instdirline = 'install -d ${D}%s' % os.path.dirname(instdestpath)
if not instdirline in instfunclines:
instfunclines.append(instdirline)
instfunclines.append('install -m %s ${WORKDIR}/%s ${D}%s' % (perms, os.path.basename(srcfile), instdestpath))
if instfunclines:
bbappendlines.append(('do_install_append%s()' % appendoverride, '', instfunclines))
bb.note('Writing append file %s' % appendpath)
if os.path.exists(appendpath):
# Work around lack of nonlocal in python 2
extvars = {'destsubdir': destsubdir}
def appendfile_varfunc(varname, origvalue, op, newlines):
if varname == 'FILESEXTRAPATHS_prepend':
if origvalue.startswith('${THISDIR}/'):
popline('FILESEXTRAPATHS_prepend')
extvars['destsubdir'] = rd.expand(origvalue.split('${THISDIR}/', 1)[1].rstrip(':'))
elif varname == 'PACKAGE_ARCH':
if machine:
popline('PACKAGE_ARCH')
return (machine, None, 4, False)
elif varname.startswith('do_install_append'):
func = popline(varname)
if func:
instfunclines = [line.strip() for line in origvalue.strip('\n').splitlines()]
for line in func[2]:
if not line in instfunclines:
instfunclines.append(line)
return (instfunclines, None, 4, False)
else:
splitval = split_var_value(origvalue, assignment=False)
changed = False
removevar = varname
if varname in ['SRC_URI', 'SRC_URI_append%s' % appendoverride]:
removevar = 'SRC_URI'
line = popline(varname)
if line:
if line[2] not in splitval:
splitval.append(line[2])
changed = True
else:
line = popline(varname)
if line:
splitval = [line[2]]
changed = True
if removevar in removevalues:
remove = removevalues[removevar]
if isinstance(remove, basestring):
if remove in splitval:
splitval.remove(remove)
changed = True
else:
for removeitem in remove:
if removeitem in splitval:
splitval.remove(removeitem)
changed = True
if changed:
newvalue = splitval
if len(newvalue) == 1:
# Ensure it's written out as one line
if '_append' in varname:
newvalue = ' ' + newvalue[0]
else:
newvalue = newvalue[0]
if not newvalue and (op in ['+=', '.='] or '_append' in varname):
# There's no point appending nothing
newvalue = None
if varname.endswith('()'):
indent = 4
else:
indent = -1
return (newvalue, None, indent, True)
return (origvalue, None, 4, False)
varnames = [item[0] for item in bbappendlines]
if removevalues:
varnames.extend(removevalues.keys())
with open(appendpath, 'r') as f:
(updated, newlines) = bb.utils.edit_metadata(f, varnames, appendfile_varfunc)
destsubdir = extvars['destsubdir']
else:
updated = False
newlines = []
if bbappendlines:
for line in bbappendlines:
if line[0].endswith('()'):
newlines.append('%s {\n %s\n}\n' % (line[0], '\n '.join(line[2])))
else:
newlines.append('%s %s "%s"\n\n' % line)
updated = True
if updated:
with open(appendpath, 'w') as f:
f.writelines(newlines)
if copyfiles:
if machine:
destsubdir = os.path.join(destsubdir, machine)
for newfile, srcfile in copyfiles.iteritems():
filedest = os.path.join(appenddir, destsubdir, os.path.basename(srcfile))
if os.path.abspath(newfile) != os.path.abspath(filedest):
bb.note('Copying %s to %s' % (newfile, filedest))
bb.utils.mkdirhier(os.path.dirname(filedest))
shutil.copyfile(newfile, filedest)
return (appendpath, os.path.join(appenddir, destsubdir))
def find_layerdir(fn):
""" Figure out relative path to base of layer for a file (e.g. a recipe)"""
pth = os.path.dirname(fn)
layerdir = ''
while pth:
if os.path.exists(os.path.join(pth, 'conf', 'layer.conf')):
layerdir = pth
break
pth = os.path.dirname(pth)
return layerdir
def replace_dir_vars(path, d):
"""Replace common directory paths with appropriate variable references (e.g. /etc becomes ${sysconfdir})"""
dirvars = {}
# Sort by length so we get the variables we're interested in first
for var in sorted(d.keys(), key=len):
if var.endswith('dir') and var.lower() == var:
value = d.getVar(var, True)
if value.startswith('/') and not '\n' in value and value not in dirvars:
dirvars[value] = var
for dirpath in sorted(dirvars.keys(), reverse=True):
path = path.replace(dirpath, '${%s}' % dirvars[dirpath])
return path
def get_recipe_pv_without_srcpv(pv, uri_type):
"""
Get PV without SRCPV common in SCM's for now only
support git.
Returns tuple with pv, prefix and suffix.
"""
pfx = ''
sfx = ''
if uri_type == 'git':
git_regex = re.compile("(?P<pfx>v?)(?P<ver>[^\+]*)((?P<sfx>\+(git)?r?(AUTOINC\+))(?P<rev>.*))?")
m = git_regex.match(pv)
if m:
pv = m.group('ver')
pfx = m.group('pfx')
sfx = m.group('sfx')
else:
regex = re.compile("(?P<pfx>(v|r)?)(?P<ver>.*)")
m = regex.match(pv)
if m:
pv = m.group('ver')
pfx = m.group('pfx')
return (pv, pfx, sfx)
def get_recipe_upstream_version(rd):
"""
Get upstream version of recipe using bb.fetch2 methods with support for
http, https, ftp and git.
bb.fetch2 exceptions can be raised,
FetchError when don't have network access or upstream site don't response.
NoMethodError when uri latest_versionstring method isn't implemented.
Returns a dictonary with version, type and datetime.
Type can be A for Automatic, M for Manual and U for Unknown.
"""
from bb.fetch2 import decodeurl
from datetime import datetime
ru = {}
ru['version'] = ''
ru['type'] = 'U'
ru['datetime'] = ''
pv = rd.getVar('PV', True)
# XXX: If don't have SRC_URI means that don't have upstream sources so
# returns the current recipe version, so that upstream version check
# declares a match.
src_uris = rd.getVar('SRC_URI', True)
if not src_uris:
ru['version'] = pv
ru['type'] = 'M'
ru['datetime'] = datetime.now()
return ru
# XXX: we suppose that the first entry points to the upstream sources
src_uri = src_uris.split()[0]
uri_type, _, _, _, _, _ = decodeurl(src_uri)
manual_upstream_version = rd.getVar("RECIPE_UPSTREAM_VERSION", True)
if manual_upstream_version:
# manual tracking of upstream version.
ru['version'] = manual_upstream_version
ru['type'] = 'M'
manual_upstream_date = rd.getVar("CHECK_DATE", True)
if manual_upstream_date:
date = datetime.strptime(manual_upstream_date, "%b %d, %Y")
else:
date = datetime.now()
ru['datetime'] = date
elif uri_type == "file":
# files are always up-to-date
ru['version'] = pv
ru['type'] = 'A'
ru['datetime'] = datetime.now()
else:
ud = bb.fetch2.FetchData(src_uri, rd)
pupver = ud.method.latest_versionstring(ud, rd)
(upversion, revision) = pupver
# format git version version+gitAUTOINC+HASH
if uri_type == 'git':
(pv, pfx, sfx) = get_recipe_pv_without_srcpv(pv, uri_type)
# if contains revision but not upversion use current pv
if upversion == '' and revision:
upversion = pv
if upversion:
tmp = upversion
upversion = ''
if pfx:
upversion = pfx + tmp
else:
upversion = tmp
if sfx:
upversion = upversion + sfx + revision[:10]
if upversion:
ru['version'] = upversion
ru['type'] = 'A'
ru['datetime'] = datetime.now()
return ru