Example #1
0
    def test_jvm_target_with_excludes_is_hashed(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        target_with_excludes = self.make_target(":jvm-target", target_type=JvmTarget, excludes=[Exclude("org.some")])

        self.assertIsNotNone(strategy.compute_fingerprint(target_with_excludes))
    def test_target_target_is_none(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        target = self.make_target(':just-target')

        self.assertIsNone(strategy.compute_fingerprint(target))
Example #3
0
    def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        managed_jar_deps = self.make_target(
            ":managed",
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency("org.some", "name")],
        )
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_with_managed_deps = self.make_target(
            ":jar-lib-1",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        jar_lib_without_managed_deps = self.make_target(
            ":jar-lib-no-managed-dep",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
        )

        self.assertNotEqual(
            strategy.compute_fingerprint(jar_lib_with_managed_deps),
            strategy.compute_fingerprint(jar_lib_without_managed_deps),
        )
Example #4
0
    def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        managed_jar_deps = self.make_target(
            ":managed",
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency("org.some", "name")],
        )
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_1 = self.make_target(
            ":jar-lib-1",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        jar_lib_2 = self.make_target(
            ":jar-lib-2",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        self.assertEqual(
            strategy.compute_fingerprint(jar_lib_1), strategy.compute_fingerprint(jar_lib_2)
        )
Example #5
0
    def test_jvm_target_without_excludes_is_none(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(confs)

        target_without_excludes = self.make_target(":jvm-target", target_type=JvmTarget)

        self.assertIsNone(strategy.compute_fingerprint(target_without_excludes))
Example #6
0
    def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)

        managed_jar_deps = self.make_target(
            ':managed',
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency('org.some', 'name')])
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_with_managed_deps = self.make_target(
            ':jar-lib-1',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')],
            managed_dependencies=':managed')

        jar_lib_without_managed_deps = self.make_target(
            ':jar-lib-no-managed-dep',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')])

        self.assertNotEqual(
            strategy.compute_fingerprint(jar_lib_with_managed_deps),
            strategy.compute_fingerprint(jar_lib_without_managed_deps))
Example #7
0
    def test_target_target_is_none(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        target = self.make_target(":just-target")

        self.assertIsNone(strategy.compute_fingerprint(target))
Example #8
0
    def test_jar_library_with_one_jar_is_hashed(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        jar_library = self.make_target(":jar-library", target_type=JarLibrary, jars=[JarDependency("org.some", "name")])

        self.assertIsNotNone(strategy.compute_fingerprint(jar_library))
Example #9
0
    def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)

        managed_jar_deps = self.make_target(
            ':managed',
            target_type=ManagedJarDependencies,
            artifacts=[JarDependency('org.some', 'name')])
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_with_managed_deps = self.make_target(
            ':jar-lib-1',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')],
            managed_dependencies=':managed')

        jar_lib_without_managed_deps = self.make_target(
            ':jar-lib-no-managed-dep',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')])

        self.assertNotEqual(
            strategy.compute_fingerprint(jar_lib_with_managed_deps),
            strategy.compute_fingerprint(jar_lib_without_managed_deps))
Example #10
0
  def test_target_target_is_none(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target = self.make_target(':just-target')

    self.assertIsNone(strategy.compute_fingerprint(target))
Example #11
0
  def test_jvm_target_without_excludes_is_none(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target_without_excludes = self.make_target(':jvm-target', target_type=JvmTarget)

    self.assertIsNone(strategy.compute_fingerprint(target_without_excludes))
Example #12
0
  def test_jar_library_with_one_jar_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    jar_library = self.make_target(':jar-library', target_type=JarLibrary,
                                   jars=[JarDependency('org.some', 'name')])

    self.assertIsNotNone(strategy.compute_fingerprint(jar_library))
Example #13
0
  def test_jar_library_with_one_jar_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    jar_library = self.make_target(':jar-library', target_type=JarLibrary,
                                   jars=[JarDependency('org.some', 'name')])

    self.assertIsNotNone(strategy.compute_fingerprint(jar_library))
Example #14
0
  def test_jvm_target_with_excludes_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target_with_excludes = self.make_target(':jvm-target', target_type=JvmTarget,
                                               excludes=[Exclude('org.some')])

    self.assertIsNotNone(strategy.compute_fingerprint(target_with_excludes))
Example #15
0
  def test_jvm_target_with_excludes_is_hashed(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    target_with_excludes = self.make_target(':jvm-target', target_type=JvmTarget,
                                               excludes=[Exclude('org.some')])

    self.assertIsNotNone(strategy.compute_fingerprint(target_with_excludes))
Example #16
0
    def test_options_included_in_fingerprint(self):
        confs = ()
        jar_library = self.make_target(":jar-library", target_type=JarLibrary, jars=[JarDependency("org.some", "name")])

        self.set_options(a=True)
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)
        with_true_a = strategy.compute_fingerprint(jar_library)

        self.set_options(a=False)
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        with_false_a = strategy.compute_fingerprint(jar_library)

        self.assertNotEqual(with_true_a, with_false_a)
Example #17
0
  def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(self):
    confs = ()
    strategy = IvyResolveFingerprintStrategy(confs)

    managed_jar_deps = self.make_target(':managed', target_type=ManagedJarDependencies,
                               artifacts=[JarDependency('org.some', 'name')])
    self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

    jar_lib_1 = self.make_target(':jar-lib-1', target_type=JarLibrary,
                                   jars=[JarDependency('org.some', 'name')],
                                   managed_dependencies=':managed')


    jar_lib_2 = self.make_target(':jar-lib-2', target_type=JarLibrary,
                              jars=[JarDependency('org.some', 'name')],
                              managed_dependencies=':managed')

    self.assertEqual(strategy.compute_fingerprint(jar_lib_1),
                     strategy.compute_fingerprint(jar_lib_2))
Example #18
0
    def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(self):
        confs = ()
        strategy = IvyResolveFingerprintStrategy(self.create_task(self.context()), confs)

        managed_jar_deps = self.make_target(
            ":managed", target_type=ManagedJarDependencies, artifacts=[JarDependency("org.some", "name")]
        )
        self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())

        jar_lib_1 = self.make_target(
            ":jar-lib-1",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        jar_lib_2 = self.make_target(
            ":jar-lib-2",
            target_type=JarLibrary,
            jars=[JarDependency("org.some", "name")],
            managed_dependencies=":managed",
        )

        self.assertEqual(strategy.compute_fingerprint(jar_lib_1), strategy.compute_fingerprint(jar_lib_2))
Example #19
0
    def test_options_included_in_fingerprint(self):
        confs = ()
        jar_library = self.make_target(
            ':jar-library',
            target_type=JarLibrary,
            jars=[JarDependency('org.some', 'name')])

        self.set_options(a=True)
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)
        with_true_a = strategy.compute_fingerprint(jar_library)

        self.set_options(a=False)
        strategy = IvyResolveFingerprintStrategy(
            self.create_task(self.context()), confs)

        with_false_a = strategy.compute_fingerprint(jar_library)

        self.assertNotEqual(with_true_a, with_false_a)
Example #20
0
    def _ivy_resolve(self,
                     targets,
                     executor=None,
                     silent=False,
                     workunit_name=None,
                     confs=None,
                     extra_args=None,
                     invalidate_dependents=False,
                     pinned_artifacts=None):
        """Resolves external dependencies for the given targets."""
        # If there are no targets, we don't need to do a resolve.
        if not targets:
            return NO_RESOLVE_RUN_RESULT
        confs = confs or ('default', )
        fingerprint_strategy = IvyResolveFingerprintStrategy(confs)
        with self.invalidated(targets,
                              invalidate_dependents=invalidate_dependents,
                              silent=silent,
                              fingerprint_strategy=fingerprint_strategy
                              ) as invalidation_check:
            # In case all the targets were filtered out because they didn't participate in fingerprinting.
            if not invalidation_check.all_vts:
                return NO_RESOLVE_RUN_RESULT
            resolve_vts = VersionedTargetSet.from_versioned_targets(
                invalidation_check.all_vts)
            resolve_hash_name = resolve_vts.cache_key.hash
            global_ivy_workdir = os.path.join(
                self.context.options.for_global_scope().pants_workdir, 'ivy')
            fetch = self._create_ivy_fetch_step(
                confs, resolve_hash_name, pinned_artifacts,
                self.get_options().soft_excludes, self.ivy_cache_dir,
                global_ivy_workdir)

            resolve = self._create_ivy_resolve_step(
                confs, resolve_hash_name, pinned_artifacts,
                self.get_options().soft_excludes, self.ivy_cache_dir,
                global_ivy_workdir, self.global_excludes)
            result = self._perform_resolution(
                fetch,
                resolve,
                executor,
                extra_args,
                invalidation_check,
                resolve_vts,
                resolve_vts.targets,
                workunit_name,
            )

            # NOTE(mateo): Wiring up our own reports, the full ivy report is too heavy weight for our purposes.
            if result.resolved_artifact_paths and self.resolution_report_outdir and not self.get_options(
            ).disable_reports:
                # This is added to get a reasonable handle for managed_dependencies target sets.
                # If there is more than one VT it defaults to the VTS.id, which is a non-human-readable cache key.
                # If we wanted to be more performant than rigorous, we could bail after the first query.
                managed_dependencies = set(
                    j.target.managed_dependencies
                    for j in invalidation_check.all_vts
                    if isinstance(j.target, JarLibrary)
                    and j.target.managed_dependencies is not None)

                if managed_dependencies and len(managed_dependencies) > 1:
                    raise TaskError(
                        'Each partition should be mapped to a single managed_dependencies target: (was: {})\n Targets: {}'
                        .format(managed_dependencies, resolve_vts.targets))
                default_target_name = JarDependencyManagement.global_instance(
                )._default_target.name
                partition_name = list(
                    managed_dependencies
                )[0].name if managed_dependencies else default_target_name
                self.write_resolve_report(resolve.frozen_resolve_file,
                                          partition_name)
            return result