def parse_override(override): try: coordinate, rev = override.split('=', 1) try: # overrides imply semantic versioning rev = Semver.parse(rev) except ValueError as e: raise TaskError('Invalid version {}: {}'.format(rev, e)) return parse_jarcoordinate(coordinate), rev except ValueError: raise TaskError('Invalid override: {}'.format(override))
def parse_override(override): try: coordinate, rev = override.split("=", 1) try: # overrides imply semantic versioning rev = Semver.parse(rev) except ValueError as e: raise TaskError(f"Invalid version {rev}: {e!r}") return parse_jarcoordinate(coordinate), rev except ValueError: raise TaskError(f"Invalid override: {override}")
def get_entry(self, target): """Given an internal target, return a PushDb.Entry, which might contain defaults.""" db_get, _ = self._accessors_for_target(target) major = int(db_get('revision.major', '0')) minor = int(db_get('revision.minor', '0')) patch = int(db_get('revision.patch', '0')) snapshot = str(db_get('revision.snapshot', 'false')).lower() == 'true' named_version = db_get('revision.named_version', None) named_is_latest = str(db_get('revision.named_is_latest', 'false')).lower() == 'true' sha = db_get('revision.sha', None) fingerprint = db_get('revision.fingerprint', None) sem_ver = Semver(major, minor, patch, snapshot=snapshot) named_ver = Namedver(named_version) if named_version else None return self.Entry(sem_ver, named_ver, named_is_latest, sha, fingerprint)
def work_for_vts_rsc(vts, ctx): target = ctx.target (tgt, ) = vts.targets rsc_cc = compile_contexts[target].rsc_cc use_youtline = rsc_cc.workflow == self.JvmCompileWorkflowType.outline_and_zinc outliner = "scalac-outliner" if use_youtline else "rsc" if use_youtline and Semver.parse( self._scala_library_version) < Semver.parse("2.12.9"): raise RuntimeError( f"To use scalac's built-in outlining, scala version must be at least 2.12.9, but got {self._scala_library_version}" ) # If we didn't hit the cache in the cache job, run rsc. if not vts.valid: counter_val = str(counter()).rjust(counter.format_length(), " ") counter_str = f"[{counter_val}/{counter.size}] " action_str = "Outlining " if use_youtline else "Rsc-ing " self.context.log.info( counter_str, action_str, items_to_report_element(ctx.sources, f"{self.name()} source"), " in ", items_to_report_element( [t.address.reference() for t in vts.targets], "target"), " (", ctx.target.address.spec, ").", ) # This does the following # - Collect the rsc classpath elements, including zinc compiles of rsc incompatible targets # and rsc compiles of rsc compatible targets. # - Run Rsc on the current target with those as dependencies. dependencies_for_target = list( DependencyContext.global_instance( ).dependencies_respecting_strict_deps(target)) classpath_paths = [] classpath_digests = [] classpath_product = self.context.products.get_data( "rsc_mixed_compile_classpath") classpath_entries = classpath_product.get_classpath_entries_for_targets( dependencies_for_target) hermetic = self.execution_strategy == self.ExecutionStrategy.hermetic for _conf, classpath_entry in classpath_entries: classpath_paths.append( fast_relpath(classpath_entry.path, get_buildroot())) if hermetic and not classpath_entry.directory_digest: raise AssertionError( "ClasspathEntry {} didn't have a Digest, so won't be present for hermetic " "execution of {}".format(classpath_entry, outliner)) classpath_digests.append(classpath_entry.directory_digest) ctx.ensure_output_dirs_exist() with Timer() as timer: # Outline Scala sources into SemanticDB / scalac compatible header jars. # --------------------------------------------- rsc_jar_file_relative_path = fast_relpath( ctx.rsc_jar_file.path, get_buildroot()) sources_snapshot = ctx.target.sources_snapshot( scheduler=self.context._scheduler) distribution = self._get_jvm_distribution() def hermetic_digest_classpath(): jdk_libs_rel, jdk_libs_digest = self._jdk_libs_paths_and_digest( distribution) merged_sources_and_jdk_digest = self.context._scheduler.merge_directories( (jdk_libs_digest, sources_snapshot.digest) + tuple(classpath_digests)) classpath_rel_jdk = classpath_paths + jdk_libs_rel return (merged_sources_and_jdk_digest, classpath_rel_jdk) def nonhermetic_digest_classpath(): classpath_abs_jdk = classpath_paths + self._jdk_libs_abs( distribution) return ((EMPTY_DIGEST), classpath_abs_jdk) (input_digest, classpath_entry_paths) = match( self.execution_strategy, { self.ExecutionStrategy.hermetic: hermetic_digest_classpath, self.ExecutionStrategy.subprocess: nonhermetic_digest_classpath, self.ExecutionStrategy.nailgun: nonhermetic_digest_classpath, }, )() youtline_args = [] if use_youtline: youtline_args = [ "-Youtline", "-Ystop-after:pickler", "-Ypickle-write", rsc_jar_file_relative_path, ] target_sources = ctx.sources # TODO: m.jar digests aren't found, so hermetic will fail. if use_youtline and not hermetic and self.get_options( ).zinc_outline: self._zinc_outline(ctx, classpath_paths, target_sources, youtline_args) else: args = ([ "-cp", os.pathsep.join(classpath_entry_paths), "-d", rsc_jar_file_relative_path, ] + self.get_options().extra_rsc_args + youtline_args + target_sources) self.write_argsfile(ctx, args) self._runtool(distribution, input_digest, ctx, use_youtline) self._record_target_stats( tgt, len(classpath_entry_paths), len(target_sources), timer.elapsed, False, outliner, ) # Update the products with the latest classes. self.register_extra_products_from_contexts([ctx.target], compile_contexts)
def work_for_vts_rsc(vts, ctx): target = ctx.target tgt, = vts.targets rsc_cc = compile_contexts[target].rsc_cc use_youtline = rsc_cc.workflow == self.JvmCompileWorkflowType.outline_and_zinc outliner = 'scalac-outliner' if use_youtline else 'rsc' if use_youtline and Semver.parse( self._scala_library_version) < Semver.parse("2.12.9"): raise RuntimeError( f"To use scalac's built-in outlining, scala version must be at least 2.12.9, but got {self._scala_library_version}" ) # If we didn't hit the cache in the cache job, run rsc. if not vts.valid: counter_val = str(counter()).rjust(counter.format_length(), ' ') counter_str = '[{}/{}] '.format(counter_val, counter.size) action_str = 'Outlining ' if use_youtline else 'Rsc-ing ' self.context.log.info( counter_str, action_str, items_to_report_element(ctx.sources, '{} source'.format(self.name())), ' in ', items_to_report_element( [t.address.reference() for t in vts.targets], 'target'), ' (', ctx.target.address.spec, ').') # This does the following # - Collect the rsc classpath elements, including zinc compiles of rsc incompatible targets # and rsc compiles of rsc compatible targets. # - Run Rsc on the current target with those as dependencies. dependencies_for_target = list( DependencyContext.global_instance( ).dependencies_respecting_strict_deps(target)) classpath_paths = [] classpath_directory_digests = [] classpath_product = self.context.products.get_data( 'rsc_mixed_compile_classpath') classpath_entries = classpath_product.get_classpath_entries_for_targets( dependencies_for_target) for _conf, classpath_entry in classpath_entries: classpath_paths.append( fast_relpath(classpath_entry.path, get_buildroot())) if self.execution_strategy == self.ExecutionStrategy.hermetic and not classpath_entry.directory_digest: raise AssertionError( "ClasspathEntry {} didn't have a Digest, so won't be present for hermetic " "execution of {}".format(classpath_entry, outliner)) classpath_directory_digests.append( classpath_entry.directory_digest) ctx.ensure_output_dirs_exist() with Timer() as timer: # Outline Scala sources into SemanticDB / scalac compatible header jars. # --------------------------------------------- rsc_jar_file_relative_path = fast_relpath( ctx.rsc_jar_file.path, get_buildroot()) sources_snapshot = ctx.target.sources_snapshot( scheduler=self.context._scheduler) distribution = self._get_jvm_distribution() def hermetic_digest_classpath(): jdk_libs_rel, jdk_libs_digest = self._jdk_libs_paths_and_digest( distribution) merged_sources_and_jdk_digest = self.context._scheduler.merge_directories( (jdk_libs_digest, sources_snapshot.directory_digest) + tuple(classpath_directory_digests)) classpath_rel_jdk = classpath_paths + jdk_libs_rel return (merged_sources_and_jdk_digest, classpath_rel_jdk) def nonhermetic_digest_classpath(): classpath_abs_jdk = classpath_paths + self._jdk_libs_abs( distribution) return ((EMPTY_DIRECTORY_DIGEST), classpath_abs_jdk) (input_digest, classpath_entry_paths) = self.execution_strategy.match({ self.ExecutionStrategy.hermetic: hermetic_digest_classpath, self.ExecutionStrategy.subprocess: nonhermetic_digest_classpath, self.ExecutionStrategy.nailgun: nonhermetic_digest_classpath, })() youtline_args = [] if use_youtline: youtline_args = [ "-Youtline", "-Ystop-after:pickler", "-Ypickle-write", rsc_jar_file_relative_path, ] if not self.get_options().allow_public_inference: wartremover_args = [ f"-Xplugin:{self._wartremover_classpath[0]}", "-P:wartremover:traverser:org.wartremover.warts.PublicInference", "-Ycache-plugin-class-loader:last-modified", ] youtline_args = wartremover_args + youtline_args target_sources = ctx.sources args = [ '-cp', os.pathsep.join(classpath_entry_paths), '-d', rsc_jar_file_relative_path, ] + self.get_options( ).extra_rsc_args + youtline_args + target_sources self.write_argsfile(ctx, args) self._runtool(distribution, input_digest, ctx, use_youtline) self._record_target_stats(tgt, len(classpath_entry_paths), len(target_sources), timer.elapsed, False, outliner) # Update the products with the latest classes. self.register_extra_products_from_contexts([ctx.target], compile_contexts)