Example #1
0
  def init_loader(self, recursive=False, _break_recursion=None):
    """
    Check all available loaders as defined in the :attr:`manifest` until the
    first loads successfully.

    :param recursive: Initialize the loaders of all dependencies as well.
    :raise RuntimeError: If there is no current session context.
    :raise LoaderInitializationError: If none of the loaders matched.
    """

    if not session:
      raise RuntimeError('no current session')
    if not self.manifest.loaders:
      return
    if _break_recursion is self:
      return

    if recursive:
      for name, version in self.manifest.dependencies.items():
        module = session.find_module(name, version)
        module.init_loader(True, _break_recursion=self)

    self.init_options()
    if self.loader is not None:
      return

    logger.info('running loaders for {}'.format(self.ident))
    with logger.indent():
      # Read the cached loader data and create the context.
      installdir = path.join(session.builddir, self.ident, 'src')
      cache = session.cache['loaders'].get(self.ident)
      context = LoaderContext(self.directory, self.manifest, self.options,
          installdir = installdir)
      context.get_temporary_directory = session.get_temporary_directory

      # Check all loaders in-order.
      errors = []
      for loader in self.manifest.loaders:
        logger.info('[+]', loader.name)
        with logger.indent():
          try:
            if cache and loader.name == cache['name']:
              new_data = loader.load(context, cache['data'])
            else:
              new_data = loader.load(context, None)
          except manifest.LoaderError as exc:
            errors.append(exc)
          else:
            self.loader = loader
            session.cache['loaders'][self.ident] = {
                'name': loader.name, 'data': new_data}
            break
      else:
        raise LoaderInitializationError(self, errors)
Example #2
0
    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
Example #3
0
  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