def _make_test_amt(self, recipes, publish):
amt = AMT(recipes=recipes)
publish = object_util.listify(publish)
check.check_string_seq(publish)
for p in publish:
amt.publish(p)
return amt
def _requires_no_resolve(self, modules):
modules = object_util.listify(modules)
check.check_string_seq(modules)
reqs = []
for name in modules:
reqs.extend(self._get_pc_file(module_name).requires)
return algorithm.unique(reqs)
def resolve_deps(self, names, system, hardness, include_names):
'Resolve dependencies.'
self.log_i(
'resolve_deps(names=%s, system=%s, hardness=%s, include_names=%s)'
% (' '.join(names), system, ' '.join(hardness), include_names))
check.check_string_seq(names)
names = object_util.listify(names)
hardness = self._normalize_hardness(hardness)
reqs = requirement_list()
for name in names:
desc = self._descriptor_map.get(name, None)
if not desc:
raise KeyError('Not found in packages: %s' % (name))
reqs.extend(desc.requirements.filter_by(hardness, system))
self.log_i('resolve_deps() reqs=%s' % (str(reqs.names())))
dep_map = self.dependency_map(hardness, system)
result = package_descriptor_list(
dependency_resolver.resolve_and_order_deps(reqs.names(),
self._descriptor_map,
dep_map))
self.log_i('resolve_deps() 1 result=%s' % (str(result.names())))
if include_names:
result += self.descriptors(names)
result.remove_dups()
self.log_i('resolve_deps() 2 result=%s' % (str(result.names())))
return result
def __new__(clazz, filename, sources, headers, ldflags):
check.check_string(filename)
check.check_fake_package_source_seq(sources)
check.check_fake_package_source_seq(headers)
ldflags = ldflags or []
check.check_string_seq(ldflags)
return clazz.__bases__[0].__new__(clazz, filename, sources, headers,
ldflags)
def package_env_files(self, package_names):
'Return a list of env files for the given packages in the same order as packages.'
check.check_string_seq(package_names)
result = []
for package_name in package_names:
entry = self.db.find_package(package_name)
assert entry
result.extend([f.filename for f in entry.files.env_files])
return result
def descriptors(self, names):
check.check_string_seq(names)
result = package_descriptor_list()
for name in names:
desc = self._descriptor_map.get(name, None)
if not desc:
raise ValueError('no such package found: %s' % (name))
result.append(desc)
return result
def make_temp_repo(clazz, content = None):
tmp_dir = temp_file.make_temp_dir()
r = repo(tmp_dir, address = None)
r.init()
if content:
check.check_string_seq(content)
r.write_temp_content(content)
r.add('.')
r.commit('add temp repo content', '.')
return r
def _resolve_requires(self, modules):
modules = object_util.listify(modules)
check.check_string_seq(modules)
immediate_reqs = self.module_requires(module_name)
immediate_req_names = [req.name for req in reqs]
order = dependency_resolver.resolve_deps(self.dep_map, req_names)
for mod in reqs:
cflags.extend(self._single_module_cflags(mod.name))
cflags.extend(self._single_module_cflags(module_name))
return cflags
def resolve_and_order_deps(clazz, names, descriptor_map, dependency_map): check.check_string_seq(names) check.check_dict(descriptor_map) check.check_dict(dependency_map) resolved_names = clazz.resolve_deps(dependency_map, names) resolved = [ descriptor_map[name] for name in resolved_names ] resolved_map = dict_util.filter_with_keys(dependency_map, resolved_names) build_order = clazz.build_order_flat(resolved_map) resolved = [ descriptor_map[name] for name in build_order ] return resolved
def validate(clazz, arch, system, distro):
'Return True normalized arch if it is valid for system otherwise None.'
arch = clazz.normalize(arch)
check.check_string_seq(arch)
build_system.check_system(system)
valid_archs = clazz.VALID_ARCHS[system]
for next_arch in arch:
if not next_arch in valid_archs:
return None
return arch
def __new__(clazz, name, unixpath, pythonpath, requires):
check.check_string(name)
unixpath = unixpath or []
if check.is_string(unixpath):
unixpath = unixpath.split(':')
check.check_string_seq(unixpath)
pythonpath = pythonpath or []
if check.is_string(pythonpath):
pythonpath = pythonpath.split(':')
check.check_string_seq(pythonpath)
requires = requires or set()
check.check_set(requires)
return clazz.__bases__[0].__new__(clazz, name, unixpath, pythonpath, requires)
def _call_pkg_config(clazz,
args,
PKG_CONFIG_LIBDIR=[],
PKG_CONFIG_PATH=[]):
check.check_string_seq(PKG_CONFIG_PATH)
cmd = [clazz._PKG_CONFIG_EXE] + object_util.listify(args)
env = {
'PKG_CONFIG_DEBUG_SPEW': '1',
'PKG_CONFIG_LIBDIR': ':'.join(PKG_CONFIG_LIBDIR),
'PKG_CONFIG_PATH': ':'.join(PKG_CONFIG_PATH),
# 'PATH': os_env_var('PATH').value,
}
for p in PKG_CONFIG_PATH:
file_util.mkdir(p)
#build_blurb.blurb_verbose('pkg_config', '_call_pkg_config() cmd=%s' % (str(cmd)))
#print('pkg_config', '_call_pkg_config() cmd=%s; env=%s' % (str(cmd), str(env)))
#print('pkg_config', '_call_pkg_config() cmd=%s' % (str(cmd)))
rv = execute.execute(cmd, env=env)
return rv
def transform_env(self, env, package_names):
check.check_string_seq(package_names)
env = env or {'PATH': os_env.DEFAULT_SYSTEM_PATH}
if not 'PATH' in env:
env = copy.deepcopy(env)
env['PATH'] = os_env.DEFAULT_SYSTEM_PATH
result = copy.deepcopy(env)
os_env.update(result, self._shell_env, prepend=False)
files = self.package_env_files(package_names)
if not files:
return result
if not path.isdir(self._env_dir):
return result
ed = env_dir(self._env_dir, files=files)
result = ed.transform_env(result)
for key, value in result.items():
if key.startswith('_BES'):
del result[key]
return result
def test_string_seq(self):
C.check_string_seq(['x'])
with self.assertRaises(TypeError) as context:
C.check_string_seq(6)
C.check_string(6)
def __new__(clazz, directory, patterns):
check.check_string(directory)
if patterns:
check.check_string_seq(patterns)
return clazz.__bases__[0].__new__(clazz, directory, patterns)
def requires(self, modules, resolved=False):
modules = object_util.listify(modules)
check.check_string_seq(modules)
def filter_files(self, files): check.check_string_seq(files) return [ f for f in files if not self.should_ignore(f) ]
def requirements_from_string_list(clazz, l):
check.check_string_seq(l)
result = requirement_list()
for n in l:
result.extend(requirement_list.parse(n))
return result
def sql_encode_string_list(clazz, l, quoted=True):
check.check_string_seq(l)
return clazz.sql_encode_string(json_util.to_json(l), quoted=quoted)
def join(clazz, arch, delimiter=','):
'Join arch parts by delimiter.'
check.check_string_seq(arch)
arch = [a.strip() for a in arch]
return delimiter.join(arch)
def _parse_requirements(clazz, l):
check.check_string_seq(l)
reqs = requirement_list()
for n in l:
reqs.extend(requirement_list.parse(n))
return reqs
