def update_manifest_cache(self, force=False):
if not self._refresh_cache and not force:
return
self._refresh_cache = False
for directory in self.path:
choices = []
choices.extend(
[path.join(directory, x) for x in MANIFEST_FILENAMES])
for item in path.easy_listdir(directory):
choices.extend([
path.join(directory, item, x) for x in MANIFEST_FILENAMES
])
choices.extend([
path.join(directory, item, 'craftr', x)
for x in MANIFEST_FILENAMES
])
for filename in map(path.norm, choices):
if filename in self._manifest_cache:
continue # don't parse a manifest that we already parsed
if not path.isfile(filename):
continue
try:
self.parse_manifest(filename)
except Manifest.Invalid as exc:
logger.warn('invalid manifest found:', filename)
logger.warn(exc, indent=1)
def find_module(self, name, version, resolve_preferred_version=True):
"""
Finds a module in the :attr:`path` matching the specified *name* and
*version*.
:param name: The name of the module.
:param version: A :class:`VersionCriteria`, :class:`Version` or string
in a VersionCritiera format.
:param resolve_preferred_version: If this parameter is True (default)
and a preferred version is specified in :attr:`preferred_versions`,
that preferred version is loaded or :class:`ModuleNotFound` is raised.
:raise ModuleNotFound: If the module can not be found.
:return: :class:`Module`
"""
argspec.validate('name', name, {'type': str})
argspec.validate('version', version,
{'type': [str, Version, VersionCriteria]})
if name in renames.renames:
logger.warn('"{}" is deprecated, use "{}" instead'.format(
name, renames.renames[name]))
name = renames.renames[name]
if isinstance(version, str):
try:
version = Version(version)
except ValueError as exc:
version = VersionCriteria(version)
if session.module and resolve_preferred_version:
data = self.preferred_versions.get(session.module.manifest.name)
if data is not None:
versions = data.get(str(session.module.manifest.version))
if versions is not None:
preferred_version = versions.get(name)
if preferred_version is not None:
version = Version(preferred_version)
logger.debug(
'note: loading preferred version {} of module "{}" '
'requested by module "{}"'.format(
version, name, session.module.ident))
self.update_manifest_cache()
if name in self.modules:
if isinstance(version, Version):
if version in self.modules[name]:
return self.modules[name][version]
raise ModuleNotFound(name, version)
for module in sorted(self.modules[name].values(),
key=lambda x: x.manifest.version,
reverse=True):
if version(module.manifest.version):
return module
raise ModuleNotFound(name, version)
def build(self,
commands,
inputs=(),
outputs=(),
implicit_deps=(),
order_only_deps=(),
metadata=None,
**kwargs):
"""
Create a :class:`build.Target` from the information in the builder,
add it to the build graph and return it.
"""
unused_keys = set(self.option_kwargs.keys()) - self.used_option_keys
if unused_keys:
logger.warn('TargetBuilder: "{}" unhandled option keys'.format(
self.name))
with logger.indent():
for key in unused_keys:
logger.warn('[-] {}={!r}'.format(key,
self.option_kwargs[key]))
# TODO: We could make this a bit shorter..
inputs = self.inputs + list(inputs or ())
outputs = self.outputs + list(outputs or ())
implicit_deps = self.implicit_deps + list(implicit_deps or ())
order_only_deps = self.order_only_deps + list(order_only_deps or ())
if metadata is None:
metadata = self.metadata
elif self.metadata:
raise RuntimeError('metadata specified in constructor and build()')
implicit_deps = list(implicit_deps)
for item in self.get_list('implicit_deps'):
if isinstance(item, build.Target):
implicit_deps += item.outputs
elif isinstance(item, str):
implicit_deps.append(item)
else:
raise TypeError(
'expected Target or str in "implicit_deps", found {}'.
format(type(item).__name__))
target = build.Target(self.name,
commands,
inputs,
outputs,
implicit_deps,
order_only_deps,
metadata=metadata,
frameworks=self.frameworks,
**kwargs)
session.graph.add_target(target)
return target
def read_cache(show_errors_and_exit=True):
cachefile = os.path.join(session.builddir, '.craftrcache')
try:
with open(cachefile) as fp:
try:
session.read_cache(fp)
except ValueError as exc:
logger.warn('Invalid cache: "{}"'.format(cachefile))
logger.warn('Load error is: {}'.format(exc))
return False
except IOError as exc:
if show_errors_and_exit:
logger.error('Unable to find file: "{}"'.format(cachefile))
logger.error('Does not seem to be a build directory: "{}"'.format(
session.builddir))
logger.error(
"Export build information using the 'craftr export' command.")
sys.exit(1)
return False
return True
def update_manifest_cache(self, force=False):
if not self._refresh_cache and not force:
return
self._refresh_cache = False
for directory in self.path:
choices = []
choices.append(path.join(directory, MANIFEST_FILENAME))
for item in path.easy_listdir(directory):
choices.append(path.join(directory, item, MANIFEST_FILENAME))
choices.append(path.join(directory, item, 'craftr', MANIFEST_FILENAME))
for filename in map(path.norm, choices):
if filename in self._manifest_cache:
continue # don't parse a manifest that we already parsed
if not path.isfile(filename):
continue
try:
self.parse_manifest(filename)
except Manifest.Invalid as exc:
logger.warn('invalid manifest found:', filename)
logger.warn(exc, indent=1)
def build(self, commands, inputs=(), outputs=(), implicit_deps=(),
order_only_deps=(), metadata=None, **kwargs):
"""
Create a :class:`build.Target` from the information in the builder,
add it to the build graph and return it.
"""
unused_keys = set(self.option_kwargs.keys()) - self.used_option_keys
if unused_keys:
logger.warn('TargetBuilder: "{}" unhandled option keys'.format(self.name))
with logger.indent():
for key in unused_keys:
logger.warn('[-] {}={!r}'.format(key, self.option_kwargs[key]))
# TODO: We could make this a bit shorter..
inputs = self.inputs + list(inputs or ())
outputs = self.outputs + list(outputs or ())
implicit_deps = self.implicit_deps + list(implicit_deps or ())
order_only_deps = self.order_only_deps + list(order_only_deps or ())
if metadata is None:
metadata = self.metadata
elif self.metadata:
raise RuntimeError('metadata specified in constructor and build()')
implicit_deps = list(implicit_deps)
for item in self.get_list('implicit_deps'):
if isinstance(item, build.Target):
implicit_deps += item.outputs
elif isinstance(item, str):
implicit_deps.append(item)
else:
raise TypeError('expected Target or str in "implicit_deps", found {}'
.format(type(item).__name__))
target = build.Target(self.name, commands, inputs, outputs, implicit_deps,
order_only_deps, metadata=metadata, frameworks=self.frameworks, **kwargs)
session.graph.add_target(target)
return target
def find_module(self, name, version):
"""
Finds a module in the :attr:`path` matching the specified *name* and
*version*.
:param name: The name of the module.
:param version: A :class:`VersionCriteria`, :class:`Version` or string
in a VersionCritiera format.
:raise ModuleNotFound: If the module can not be found.
:return: :class:`Module`
"""
argspec.validate('name', name, {'type': str})
argspec.validate('version', version, {'type': [str, Version, VersionCriteria]})
if name in renames.renames:
logger.warn('"{}" is deprecated, use "{}" instead'.format(
name, renames.renames[name]))
name = renames.renames[name]
if isinstance(version, str):
try:
version = Version(version)
except ValueError as exc:
version = VersionCriteria(version)
self.update_manifest_cache()
if name in self.modules:
if isinstance(version, Version):
if version in self.modules[name]:
return self.modules[name][version]
raise ModuleNotFound(name, version)
for module in sorted(self.modules[name].values(),
key=lambda x: x.manifest.version, reverse=True):
if version(module.manifest.version):
return module
raise ModuleNotFound(name, version)
def load_module(*args, **kwargs):
logger.warn('load_module() is deprecated, use load() instead')
kwargs['_stackframe'] = kwargs.get('_stackframe', 1) + 1
return load(*args, **kwargs)
