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)