class NoRProvider(Exception):
"""Exception raised when no provider of a runtime dependency can be found"""
-def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
+
+def sortPriorities(pn, dataCache, pkg_pn = None):
"""
- If there is a PREFERRED_VERSION, find the highest-priority bbfile
- providing that version. If not, find the latest version provided by
- an bbfile in the highest-priority set.
+ Reorder pkg_pn by file priority and default preference
"""
+
if not pkg_pn:
pkg_pn = dataCache.pkg_pn
priorities = {}
for f in files:
priority = dataCache.bbfile_priority[f]
+ preference = dataCache.pkg_dp[f]
if priority not in priorities:
- priorities[priority] = []
- priorities[priority].append(f)
- p_list = priorities.keys()
- p_list.sort(lambda a, b: a - b)
+ priorities[priority] = {}
+ if preference not in priorities[priority]:
+ priorities[priority][preference] = []
+ priorities[priority][preference].append(f)
+ pri_list = priorities.keys()
+ pri_list.sort(lambda a, b: a - b)
tmp_pn = []
- for p in p_list:
- tmp_pn = [priorities[p]] + tmp_pn
+ for pri in pri_list:
+ pref_list = priorities[pri].keys()
+ pref_list.sort(lambda a, b: b - a)
+ tmp_pref = []
+ for pref in pref_list:
+ tmp_pref.extend(priorities[pri][pref])
+ tmp_pn = [tmp_pref] + tmp_pn
+
+ return tmp_pn
+
+
+def findPreferredProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
+ """
+ Find the first provider in pkg_pn with a PREFERRED_VERSION set.
+ """
preferred_file = None
preferred_e = None
preferred_r = None
- for file_set in tmp_pn:
+ for file_set in pkg_pn:
for f in file_set:
pe,pv,pr = dataCache.pkg_pepvpr[f]
if preferred_v == pv and (preferred_r == pr or preferred_r == None) and (preferred_e == pe or preferred_e == None):
else:
bb.msg.debug(1, bb.msg.domain.Provider, "selecting %s as PREFERRED_VERSION %s of package %s%s" % (preferred_file, pv_str, pn, itemstr))
- del localdata
+ return (preferred_v, preferred_file)
+
- # get highest priority file set
- files = tmp_pn[0]
+def findLatestProvider(pn, cfgData, dataCache, file_set):
+ """
+ Return the highest version of the providers in file_set.
+ Take default preferences into account.
+ """
latest = None
latest_p = 0
latest_f = None
- for file_name in files:
+ for file_name in file_set:
pe,pv,pr = dataCache.pkg_pepvpr[file_name]
dp = dataCache.pkg_dp[file_name]
latest = (pe, pv, pr)
latest_f = file_name
latest_p = dp
+
+ return (latest, latest_f)
+
+
+def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
+ """
+ If there is a PREFERRED_VERSION, find the highest-priority bbfile
+ providing that version. If not, find the latest version provided by
+ an bbfile in the highest-priority set.
+ """
+
+ sortpkg_pn = sortPriorities(pn, dataCache, pkg_pn)
+ # Find the highest priority provider with a PREFERRED_VERSION set
+ (preferred_ver, preferred_file) = findPreferredProvider(pn, cfgData, dataCache, sortpkg_pn, item)
+ # Find the latest version of the highest priority provider
+ (latest, latest_f) = findLatestProvider(pn, cfgData, dataCache, sortpkg_pn[0])
+
if preferred_file is None:
preferred_file = latest_f
preferred_ver = latest
- return (latest,latest_f,preferred_ver, preferred_file)
+ return (latest, latest_f, preferred_ver, preferred_file)
+
def _filterProviders(providers, item, cfgData, dataCache):
"""
"""
eligible = []
preferred_versions = {}
+ sortpkg_pn = {}
# The order of providers depends on the order of the files on the disk
# up to here. Sort pkg_pn to make dependency issues reproducible rather
bb.msg.debug(1, bb.msg.domain.Provider, "providers for %s are: %s" % (item, pkg_pn.keys()))
+ # First add PREFERRED_VERSIONS
+ for pn in pkg_pn.keys():
+ sortpkg_pn[pn] = sortPriorities(pn, dataCache, pkg_pn)
+ preferred_versions[pn] = findPreferredProvider(pn, cfgData, dataCache, sortpkg_pn[pn], item)
+ if preferred_versions[pn][1]:
+ eligible.append(preferred_versions[pn][1])
+
+ # Now add latest verisons
for pn in pkg_pn.keys():
- preferred_versions[pn] = bb.providers.findBestProvider(pn, cfgData, dataCache, pkg_pn, item)[2:4]
+ if pn in preferred_versions and preferred_versions[pn][1]:
+ continue
+ preferred_versions[pn] = findLatestProvider(pn, cfgData, dataCache, sortpkg_pn[pn][0])
eligible.append(preferred_versions[pn][1])
if len(eligible) == 0:
bb.msg.error(bb.msg.domain.Provider, "no eligible providers for %s" % item)
return 0
-
# If pn == item, give it a slight default preference
# This means PREFERRED_PROVIDER_foobar defaults to foobar if available
for p in providers:
eligible = [fn] + eligible
break
- return eligible, preferred_versions
+ return eligible
def filterProviders(providers, item, cfgData, dataCache):
Takes a "normal" target item
"""
- eligible, pref_vers = _filterProviders(providers, item, cfgData, dataCache)
+ eligible = _filterProviders(providers, item, cfgData, dataCache)
prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % item, cfgData, 1)
if prefervar:
foundUnique = True
break
+ bb.msg.debug(1, bb.msg.domain.Provider, "sorted providers for %s are: %s" % (item, eligible))
+
return eligible, foundUnique
def filterProvidersRunTime(providers, item, cfgData, dataCache):
Takes a "runtime" target item
"""
- eligible, pref_vers = _filterProviders(providers, item, cfgData, dataCache)
+ eligible = _filterProviders(providers, item, cfgData, dataCache)
# Should use dataCache.preferred here?
preferred = []
numberPreferred = len(preferred)
+ bb.msg.debug(1, bb.msg.domain.Provider, "sorted providers for %s are: %s" % (item, eligible))
+
return eligible, numberPreferred
def getRuntimeProviders(dataCache, rdepend):
