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))
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), )
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) )
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))
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))
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))
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))
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))
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))
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))
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)
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))
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))
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)
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