예제 #1
0
    def __init__(self, root_dir, parser, argv):
        Command.__init__(self, root_dir, parser, argv)

        if not self.args:
            self.error("A spec argument is required")

        try:
            specs_end = self.args.index('--')
            if len(self.args) > specs_end:
                self.build_args = self.args.__getslice__(
                    specs_end + 1,
                    len(self.args) + 1)
            else:
                self.build_args = []
        except ValueError:
            specs_end = 1
            self.build_args = self.args[1:] if len(self.args) > 1 else []

        self.targets = OrderedSet()
        for spec in self.args.__getslice__(0, specs_end):
            try:
                address = Address.parse(root_dir, spec)
            except:
                self.error("Problem parsing spec %s: %s" %
                           (spec, traceback.format_exc()))

            try:
                target = Target.get(address)
            except:
                self.error("Problem parsing BUILD target %s: %s" %
                           (address, traceback.format_exc()))

            try:
                InternalTarget.check_cycles(target)
            except CycleException as e:
                self.error("Target contains an internal dependency cycle: %s" %
                           e)

            if not target:
                self.error("Target %s does not exist" % address)
            if not target.address.is_meta:
                target.address.is_meta = self.options.is_meta or address.is_meta
            self.targets.add(target)

        self.is_ide = self.options.is_ide
        self.ide_transitivity = self.options.ide_transitivity
예제 #2
0
파일: build.py 프로젝트: collude/collude
  def __init__(self, root_dir, parser, argv):
    Command.__init__(self, root_dir, parser, argv)

    if not self.args:
      self.error("A spec argument is required")

    try:
      specs_end = self.args.index('--')
      if len(self.args) > specs_end:
        self.build_args = self.args.__getslice__(specs_end + 1, len(self.args) + 1)
      else:
        self.build_args = []
    except ValueError:
      specs_end = 1
      self.build_args = self.args[1:] if len(self.args) > 1 else []

    self.targets = OrderedSet()
    for spec in self.args.__getslice__(0, specs_end):
      try:
        address = Address.parse(root_dir, spec)
      except:
        self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))

      try:
        target = Target.get(address)
      except:
        self.error("Problem parsing BUILD target %s: %s" % (address, traceback.format_exc()))

      try:
        InternalTarget.check_cycles(target)
      except CycleException as e:
        self.error("Target contains an internal dependency cycle: %s" % e)

      if not target:
        self.error("Target %s does not exist" % address)
      if not target.address.is_meta:
        target.address.is_meta = self.options.is_meta or address.is_meta
      self.targets.add(target)

    self.is_ide = self.options.is_ide
    self.ide_transitivity = self.options.ide_transitivity
예제 #3
0
파일: bang.py 프로젝트: collude/collude
def extract_target(java_targets, name = None):
  """Extracts a minimal set of linked targets from the given target's internal transitive dependency
  set.  The root target in the extracted target set is returned.  The algorithm does a topological
  sort of the internal targets and then tries to coalesce targets of a given type.  Any target with
  a custom ant build xml will be excluded from the coalescing."""

  # TODO(John Sirois): this is broken - representative_target is not necessarily representative
  representative_target = list(java_targets)[0]

  meta_target_base_name = "fast-%s" % (name if name else representative_target.name)
  provides = None
  deployjar = hasattr(representative_target, 'deployjar') and representative_target.deployjar
  buildflags = representative_target.buildflags

  def create_target(target_type, target_name, target_index, targets):
    def name(name):
      return "%s-%s-%d" % (target_name, name, target_index)

    if target_type == JavaProtobufLibrary:
      return JavaProtobufLibrary._aggregate(name('protobuf'), provides, buildflags, targets)
    elif target_type == JavaThriftLibrary:
      return JavaThriftLibrary._aggregate(name('thrift'), provides, buildflags, targets)
    elif target_type == JavaLibrary:
      return JavaLibrary._aggregate(name('java'), provides, deployjar, buildflags, targets)
    elif target_type == ScalaLibrary:
      return ScalaLibrary._aggregate(name('scala'), provides, deployjar, buildflags, targets)
    elif target_type == JavaTests:
      return JavaTests._aggregate(name('java-tests'), buildflags, targets)
    elif target_type == ScalaTests:
      return ScalaTests._aggregate(name('scala-tests'), buildflags, targets)
    else:
      raise Exception("Cannot aggregate targets of type: %s" % target_type)

  # chunk up our targets by type & custom build xml
  coalesced = InternalTarget.coalesce_targets(java_targets)
  coalesced = list(reversed(coalesced))

  start_type = type(coalesced[0])
  start = 0
  descriptors = []

  for current in range(0, len(coalesced)):
    current_target = coalesced[current]
    current_type = type(current_target)

    if current_target.custom_antxml_path:
      if start < current:
        # if we have a type chunk to our left, record it
        descriptors.append((start_type, coalesced[start:current]))

      # record a chunk containing just the target that has the custom build xml to be conservative
      descriptors.append((current_type, [current_target]))
      start = current + 1
      if current < (len(coalesced) - 1):
        start_type = type(coalesced[start])

    elif start_type != current_type:
      # record the type chunk we just left
      descriptors.append((start_type, coalesced[start:current]))
      start = current
      start_type = current_type

  if start < len(coalesced):
    # record the tail chunk
    descriptors.append((start_type, coalesced[start:]))

  # build meta targets aggregated from the chunks and keep track of which targets end up in which
  # meta targets
  meta_targets_by_target_id = dict()
  targets_by_meta_target = []
  for (target_type, targets), index in zip(descriptors, reversed(range(0, len(descriptors)))):
    meta_target = create_target(target_type, meta_target_base_name, index, targets)
    targets_by_meta_target.append((meta_target, targets))
    for target in targets:
      meta_targets_by_target_id[target._id] = meta_target

  # calculate the other meta-targets (if any) each meta-target depends on
  extra_targets_by_meta_target = []
  for meta_target, targets in targets_by_meta_target:
    meta_deps = set()
    custom_antxml_path = None
    for target in targets:
      if target.custom_antxml_path:
        custom_antxml_path = target.custom_antxml_path
      for dep in target.resolved_dependencies:
        if is_jvm(dep):
          meta = meta_targets_by_target_id[dep._id]
          if meta != meta_target:
            meta_deps.add(meta)
    extra_targets_by_meta_target.append((meta_target, meta_deps, custom_antxml_path))

  def lift_excludes(meta_target):
    excludes = set()
    def lift(target):
      if target.excludes:
        excludes.update(target.excludes)
      for jar_dep in target.jar_dependencies:
        excludes.update(jar_dep.excludes)
      for internal_dep in target.internal_dependencies:
        lift(internal_dep)
    lift(meta_target)
    return excludes

  # link in the extra inter-meta deps
  meta_targets = []
  for meta_target, extra_deps, custom_antxml_path in extra_targets_by_meta_target:
    meta_targets.append(meta_target)
    meta_target.update_dependencies(extra_deps)
    meta_target.excludes = lift_excludes(meta_target)
    meta_target.custom_antxml_path = custom_antxml_path

  sorted_meta_targets = InternalTarget.sort_targets(meta_targets)
  def prune_metas(target):
    if sorted_meta_targets:
      try:
        sorted_meta_targets.remove(target)
      except ValueError:
        # we've already removed target in the current walk
        pass

  # link any disconnected meta_target graphs so we can return 1 root target
  root = None
  while sorted_meta_targets:
    new_root = sorted_meta_targets[0]
    new_root.walk(prune_metas, is_jvm)
    if root:
      new_root.update_dependencies([root])
    root = new_root

  return root
예제 #4
0
파일: bang.py 프로젝트: collude/collude
def extract_target(java_targets, name=None):
    """Extracts a minimal set of linked targets from the given target's internal transitive dependency
  set.  The root target in the extracted target set is returned.  The algorithm does a topological
  sort of the internal targets and then tries to coalesce targets of a given type.  Any target with
  a custom ant build xml will be excluded from the coalescing."""

    # TODO(John Sirois): this is broken - representative_target is not necessarily representative
    representative_target = list(java_targets)[0]

    meta_target_base_name = "fast-%s" % (name if name else
                                         representative_target.name)
    provides = None
    deployjar = hasattr(representative_target,
                        'deployjar') and representative_target.deployjar
    buildflags = representative_target.buildflags

    def create_target(target_type, target_name, target_index, targets):
        def name(name):
            return "%s-%s-%d" % (target_name, name, target_index)

        if target_type == JavaProtobufLibrary:
            return JavaProtobufLibrary._aggregate(name('protobuf'), provides,
                                                  buildflags, targets)
        elif target_type == JavaThriftLibrary:
            return JavaThriftLibrary._aggregate(name('thrift'), provides,
                                                buildflags, targets)
        elif target_type == JavaLibrary:
            return JavaLibrary._aggregate(name('java'), provides, deployjar,
                                          buildflags, targets)
        elif target_type == ScalaLibrary:
            return ScalaLibrary._aggregate(name('scala'), provides, deployjar,
                                           buildflags, targets)
        elif target_type == JavaTests:
            return JavaTests._aggregate(name('java-tests'), buildflags,
                                        targets)
        elif target_type == ScalaTests:
            return ScalaTests._aggregate(name('scala-tests'), buildflags,
                                         targets)
        else:
            raise Exception("Cannot aggregate targets of type: %s" %
                            target_type)

    # chunk up our targets by type & custom build xml
    coalesced = InternalTarget.coalesce_targets(java_targets)
    coalesced = list(reversed(coalesced))

    start_type = type(coalesced[0])
    start = 0
    descriptors = []

    for current in range(0, len(coalesced)):
        current_target = coalesced[current]
        current_type = type(current_target)

        if current_target.custom_antxml_path:
            if start < current:
                # if we have a type chunk to our left, record it
                descriptors.append((start_type, coalesced[start:current]))

            # record a chunk containing just the target that has the custom build xml to be conservative
            descriptors.append((current_type, [current_target]))
            start = current + 1
            if current < (len(coalesced) - 1):
                start_type = type(coalesced[start])

        elif start_type != current_type:
            # record the type chunk we just left
            descriptors.append((start_type, coalesced[start:current]))
            start = current
            start_type = current_type

    if start < len(coalesced):
        # record the tail chunk
        descriptors.append((start_type, coalesced[start:]))

    # build meta targets aggregated from the chunks and keep track of which targets end up in which
    # meta targets
    meta_targets_by_target_id = dict()
    targets_by_meta_target = []
    for (target_type,
         targets), index in zip(descriptors,
                                reversed(range(0, len(descriptors)))):
        meta_target = create_target(target_type, meta_target_base_name, index,
                                    targets)
        targets_by_meta_target.append((meta_target, targets))
        for target in targets:
            meta_targets_by_target_id[target._id] = meta_target

    # calculate the other meta-targets (if any) each meta-target depends on
    extra_targets_by_meta_target = []
    for meta_target, targets in targets_by_meta_target:
        meta_deps = set()
        custom_antxml_path = None
        for target in targets:
            if target.custom_antxml_path:
                custom_antxml_path = target.custom_antxml_path
            for dep in target.resolved_dependencies:
                if is_jvm(dep):
                    meta = meta_targets_by_target_id[dep._id]
                    if meta != meta_target:
                        meta_deps.add(meta)
        extra_targets_by_meta_target.append(
            (meta_target, meta_deps, custom_antxml_path))

    def lift_excludes(meta_target):
        excludes = set()

        def lift(target):
            if target.excludes:
                excludes.update(target.excludes)
            for jar_dep in target.jar_dependencies:
                excludes.update(jar_dep.excludes)
            for internal_dep in target.internal_dependencies:
                lift(internal_dep)

        lift(meta_target)
        return excludes

    # link in the extra inter-meta deps
    meta_targets = []
    for meta_target, extra_deps, custom_antxml_path in extra_targets_by_meta_target:
        meta_targets.append(meta_target)
        meta_target.update_dependencies(extra_deps)
        meta_target.excludes = lift_excludes(meta_target)
        meta_target.custom_antxml_path = custom_antxml_path

    sorted_meta_targets = InternalTarget.sort_targets(meta_targets)

    def prune_metas(target):
        if sorted_meta_targets:
            try:
                sorted_meta_targets.remove(target)
            except ValueError:
                # we've already removed target in the current walk
                pass

    # link any disconnected meta_target graphs so we can return 1 root target
    root = None
    while sorted_meta_targets:
        new_root = sorted_meta_targets[0]
        new_root.walk(prune_metas, is_jvm)
        if root:
            new_root.update_dependencies([root])
        root = new_root

    return root