Examples with FilesToRunProvider com.google.devtools.build.lib.analysis.FilesToRunProvider used on opensource projects

Example 11 with FilesToRunProvider

use of com.google.devtools.build.lib.analysis.FilesToRunProvider in project bazel by bazelbuild.

the class BazelPythonSemantics method postInitBinary.

@Override
public void postInitBinary(RuleContext ruleContext, RunfilesSupport runfilesSupport, PyCommon common) throws InterruptedException {
    if (ruleContext.getConfiguration().buildPythonZip()) {
        FilesToRunProvider zipper = ruleContext.getExecutablePrerequisite("$zipper", Mode.HOST);
        Artifact executable = common.getExecutable();
        if (!ruleContext.hasErrors()) {
            createPythonZipAction(ruleContext, executable, getPythonZipArtifact(ruleContext, executable), getPythonTemplateMainArtifact(ruleContext, executable), zipper, runfilesSupport);
        }
    }
}

Example 12 with FilesToRunProvider

use of com.google.devtools.build.lib.analysis.FilesToRunProvider in project bazel by bazelbuild.

the class SkylarkRuleContext method buildAttributesCollection.

private static SkylarkRuleAttributesCollection buildAttributesCollection(Collection<Attribute> attributes, RuleContext ruleContext, Function<Attribute, Object> attributeValueExtractor) {
    Builder<String, Object> attrBuilder = new Builder<>();
    Builder<String, Object> executableBuilder = new Builder<>();
    Builder<Artifact, FilesToRunProvider> executableRunfilesbuilder = new Builder<>();
    Builder<String, Object> fileBuilder = new Builder<>();
    Builder<String, Object> filesBuilder = new Builder<>();
    HashSet<Artifact> seenExecutables = new HashSet<>();
    for (Attribute a : attributes) {
        Type<?> type = a.getType();
        Object val = attributeValueExtractor.apply(a);
        // Skylark as a Map<String, Label>; this special case preserves that behavior temporarily.
        if (type.getLabelClass() != LabelClass.DEPENDENCY || type == BuildType.LABEL_DICT_UNARY) {
            attrBuilder.put(a.getPublicName(), val == null ? Runtime.NONE : // Attribute values should be type safe
            SkylarkType.convertToSkylark(val, null));
            continue;
        }
        String skyname = a.getPublicName();
        if (a.isExecutable()) {
            // In Skylark only label (not label list) type attributes can have the Executable flag.
            FilesToRunProvider provider = ruleContext.getExecutablePrerequisite(a.getName(), Mode.DONT_CHECK);
            if (provider != null && provider.getExecutable() != null) {
                Artifact executable = provider.getExecutable();
                executableBuilder.put(skyname, executable);
                if (!seenExecutables.contains(executable)) {
                    // todo(dslomov,laurentlb): In general, this is incorrect.
                    // We associate the first encountered FilesToRunProvider with
                    // the executable (this provider is later used to build the spawn).
                    // However ideally we should associate a provider with the attribute name,
                    // and pass the correct FilesToRunProvider to the spawn depending on
                    // what attribute is used to access the executable.
                    executableRunfilesbuilder.put(executable, provider);
                    seenExecutables.add(executable);
                }
            } else {
                executableBuilder.put(skyname, Runtime.NONE);
            }
        }
        if (a.isSingleArtifact()) {
            // In Skylark only label (not label list) type attributes can have the SingleArtifact flag.
            Artifact artifact = ruleContext.getPrerequisiteArtifact(a.getName(), Mode.DONT_CHECK);
            if (artifact != null) {
                fileBuilder.put(skyname, artifact);
            } else {
                fileBuilder.put(skyname, Runtime.NONE);
            }
        }
        filesBuilder.put(skyname, ruleContext.getPrerequisiteArtifacts(a.getName(), Mode.DONT_CHECK).list());
        if (type == BuildType.LABEL && !a.hasSplitConfigurationTransition()) {
            Object prereq = ruleContext.getPrerequisite(a.getName(), Mode.DONT_CHECK);
            if (prereq == null) {
                prereq = Runtime.NONE;
            }
            attrBuilder.put(skyname, prereq);
        } else if (type == BuildType.LABEL_LIST || (type == BuildType.LABEL && a.hasSplitConfigurationTransition())) {
            List<?> allPrereq = ruleContext.getPrerequisites(a.getName(), Mode.DONT_CHECK);
            attrBuilder.put(skyname, SkylarkList.createImmutable(allPrereq));
        } else if (type == BuildType.LABEL_KEYED_STRING_DICT) {
            ImmutableMap.Builder<TransitiveInfoCollection, String> builder = new ImmutableMap.Builder<>();
            Map<Label, String> original = BuildType.LABEL_KEYED_STRING_DICT.cast(val);
            List<? extends TransitiveInfoCollection> allPrereq = ruleContext.getPrerequisites(a.getName(), Mode.DONT_CHECK);
            for (TransitiveInfoCollection prereq : allPrereq) {
                builder.put(prereq, original.get(prereq.getLabel()));
            }
            attrBuilder.put(skyname, SkylarkType.convertToSkylark(builder.build(), null));
        } else if (type == BuildType.LABEL_DICT_UNARY) {
            Map<Label, TransitiveInfoCollection> prereqsByLabel = new LinkedHashMap<>();
            for (TransitiveInfoCollection target : ruleContext.getPrerequisites(a.getName(), Mode.DONT_CHECK)) {
                prereqsByLabel.put(target.getLabel(), target);
            }
            ImmutableMap.Builder<String, TransitiveInfoCollection> attrValue = new ImmutableMap.Builder<>();
            for (Map.Entry<String, Label> entry : ((Map<String, Label>) val).entrySet()) {
                attrValue.put(entry.getKey(), prereqsByLabel.get(entry.getValue()));
            }
            attrBuilder.put(skyname, attrValue.build());
        } else {
            throw new IllegalArgumentException("Can't transform attribute " + a.getName() + " of type " + type + " to a Skylark object");
        }
    }
    return new SkylarkRuleAttributesCollection(ruleContext.getRule().getRuleClass(), attrBuilder.build(), executableBuilder.build(), fileBuilder.build(), filesBuilder.build(), executableRunfilesbuilder.build());
}

Example 13 with FilesToRunProvider

use of com.google.devtools.build.lib.analysis.FilesToRunProvider in project bazel by bazelbuild.

the class AndroidBinary method createInstallAction.

private static void createInstallAction(RuleContext ruleContext, boolean incremental, Artifact marker, Artifact argsArtifact, Artifact dexmanifest, Artifact resourceApk, Artifact apk, NativeLibs nativeLibs, Artifact stubDataFile) {
    FilesToRunProvider adb = AndroidSdkProvider.fromRuleContext(ruleContext).getAdb();
    SpawnAction.Builder builder = new SpawnAction.Builder().setExecutable(ruleContext.getExecutablePrerequisite("$incremental_install", Mode.HOST)).executeUnconditionally().setMnemonic("AndroidInstall").setProgressMessage("Installing " + ruleContext.getLabel() + (incremental ? " incrementally" : "")).setExecutionInfo(ImmutableMap.of("local", "")).addArgument("--output_marker").addOutputArgument(marker).addArgument("--dexmanifest").addInputArgument(dexmanifest).addArgument("--resource_apk").addInputArgument(resourceApk).addArgument("--stub_datafile").addInputArgument(stubDataFile).addArgument("--adb").addArgument(adb.getExecutable().getExecPathString()).addTool(adb).addArgument("--flagfile").addInputArgument(argsArtifact);
    if (!incremental) {
        builder.addArgument("--apk").addInputArgument(apk);
    }
    if (ruleContext.getFragment(AndroidConfiguration.class).useIncrementalNativeLibs()) {
        for (Map.Entry<String, Iterable<Artifact>> arch : nativeLibs.getMap().entrySet()) {
            for (Artifact lib : arch.getValue()) {
                builder.addArgument("--native_lib").addArgument(arch.getKey() + ":" + lib.getExecPathString()).addInput(lib);
            }
        }
    }
    ruleContext.registerAction(builder.build(ruleContext));
}

Example 14 with FilesToRunProvider

use of com.google.devtools.build.lib.analysis.FilesToRunProvider in project bazel by bazelbuild.

the class AndroidSdk method create.

@Override
public ConfiguredTarget create(RuleContext ruleContext) throws InterruptedException, RuleErrorException {
    // If the user didn't specify --proguard_top, go with the proguard attribute in the android_sdk
    // rule. Otherwise, use what she told us to.
    FilesToRunProvider proguard = ruleContext.getFragment(JavaConfiguration.class).getProguardBinary() == null ? ruleContext.getExecutablePrerequisite("proguard", Mode.HOST) : ruleContext.getExecutablePrerequisite(":proguard", Mode.HOST);
    String buildToolsVersion = AggregatingAttributeMapper.of(ruleContext.getRule()).get("build_tools_version", Type.STRING);
    Revision parsedBuildToolsVersion = null;
    try {
        parsedBuildToolsVersion = Strings.isNullOrEmpty(buildToolsVersion) ? null : Revision.parseRevision(buildToolsVersion);
    } catch (NumberFormatException nfe) {
        ruleContext.attributeError("build_tools_version", "Invalid version: " + buildToolsVersion);
    }
    boolean aaptSupportsMainDexGeneration = parsedBuildToolsVersion == null || parsedBuildToolsVersion.compareTo(new Revision(24)) >= 0;
    FilesToRunProvider aidl = ruleContext.getExecutablePrerequisite("aidl", Mode.HOST);
    FilesToRunProvider aapt = ruleContext.getExecutablePrerequisite("aapt", Mode.HOST);
    FilesToRunProvider apkBuilder = ruleContext.getExecutablePrerequisite("apkbuilder", Mode.HOST);
    FilesToRunProvider apkSigner = ruleContext.getExecutablePrerequisite("apksigner", Mode.HOST);
    FilesToRunProvider adb = ruleContext.getExecutablePrerequisite("adb", Mode.HOST);
    FilesToRunProvider dx = ruleContext.getExecutablePrerequisite("dx", Mode.HOST);
    FilesToRunProvider mainDexListCreator = ruleContext.getExecutablePrerequisite("main_dex_list_creator", Mode.HOST);
    FilesToRunProvider zipalign = ruleContext.getExecutablePrerequisite("zipalign", Mode.HOST);
    FilesToRunProvider jack = ruleContext.getExecutablePrerequisite("jack", Mode.HOST);
    FilesToRunProvider jill = ruleContext.getExecutablePrerequisite("jill", Mode.HOST);
    FilesToRunProvider resourceExtractor = ruleContext.getExecutablePrerequisite("resource_extractor", Mode.HOST);
    Artifact frameworkAidl = ruleContext.getPrerequisiteArtifact("framework_aidl", Mode.HOST);
    TransitiveInfoCollection aidlLib = ruleContext.getPrerequisite("aidl_lib", Mode.TARGET);
    Artifact androidJar = ruleContext.getPrerequisiteArtifact("android_jar", Mode.HOST);
    Artifact shrinkedAndroidJar = ruleContext.getPrerequisiteArtifact("shrinked_android_jar", Mode.HOST);
    // Because all Jack actions using this android_sdk will need Jack versions of the Android and
    // Java classpaths, pre-translate the jars for Android and Java targets here. (They will only
    // be run if needed, as usual for Bazel.)
    NestedSet<Artifact> androidBaseClasspathForJack = convertClasspathJarsToJack(ruleContext, jack, jill, resourceExtractor, ImmutableList.of(androidJar));
    NestedSet<Artifact> javaBaseClasspathForJack = convertClasspathJarsToJack(ruleContext, jack, jill, resourceExtractor, JavaCompilationHelper.getBootClasspath(JavaToolchainProvider.fromRuleContext(ruleContext)));
    Artifact annotationsJar = ruleContext.getPrerequisiteArtifact("annotations_jar", Mode.HOST);
    Artifact mainDexClasses = ruleContext.getPrerequisiteArtifact("main_dex_classes", Mode.HOST);
    if (ruleContext.hasErrors()) {
        return null;
    }
    return new RuleConfiguredTargetBuilder(ruleContext).add(AndroidSdkProvider.class, AndroidSdkProvider.create(buildToolsVersion, aaptSupportsMainDexGeneration, frameworkAidl, aidlLib, androidJar, shrinkedAndroidJar, androidBaseClasspathForJack, javaBaseClasspathForJack, annotationsJar, mainDexClasses, adb, dx, mainDexListCreator, aidl, aapt, apkBuilder, apkSigner, proguard, zipalign, jack, jill, resourceExtractor)).add(RunfilesProvider.class, RunfilesProvider.EMPTY).setFilesToBuild(NestedSetBuilder.<Artifact>emptySet(Order.STABLE_ORDER)).build();
}

Example 15 with FilesToRunProvider

use of com.google.devtools.build.lib.analysis.FilesToRunProvider in project bazel by bazelbuild.

the class AndroidCommon method createJarJarActions.

private void createJarJarActions(JavaTargetAttributes.Builder attributes, NestedSetBuilder<Artifact> jarsProducedForRuntime, Iterable<ResourceContainer> resourceContainers, String originalPackage, Artifact binaryResourcesJar) {
    // the transitive closure of this binary.
    for (ResourceContainer otherContainer : resourceContainers) {
        if (otherContainer.getLabel().equals(ruleContext.getLabel())) {
            continue;
        }
        Artifact resourcesJar = createResourceJarArtifact(ruleContext, otherContainer, ".jar");
        // combined resource constants copy needs to come before library classes that may contain
        // their local resource constants
        attributes.addRuntimeClassPathEntry(resourcesJar);
        Artifact jarJarRuleFile = createResourceJarArtifact(ruleContext, otherContainer, ".jar_jarjar_rules.txt");
        String jarJarRule = String.format("rule %s.* %s.@1", originalPackage, otherContainer.getJavaPackage());
        ruleContext.registerAction(FileWriteAction.create(ruleContext, jarJarRuleFile, jarJarRule, false));
        FilesToRunProvider jarjar = ruleContext.getExecutablePrerequisite("$jarjar_bin", Mode.HOST);
        ruleContext.registerAction(new SpawnAction.Builder().setExecutable(jarjar).addArgument("process").addInputArgument(jarJarRuleFile).addInputArgument(binaryResourcesJar).addOutputArgument(resourcesJar).setProgressMessage("Repackaging jar").setMnemonic("AndroidRepackageJar").build(ruleContext));
        jarsProducedForRuntime.add(resourcesJar);
    }
}