Examples with RootedPath com.google.devtools.build.lib.vfs.RootedPath used on opensource projects

Example 81 with RootedPath

use of com.google.devtools.build.lib.vfs.RootedPath in project bazel by bazelbuild.

the class FileFunctionTest method testAbsoluteSymlinkToExternal.

@Test
public void testAbsoluteSymlinkToExternal() throws Exception {
    String externalPath = outputBase.getRelative(Label.EXTERNAL_PACKAGE_NAME).getRelative("a/b").getPathString();
    symlink("a", externalPath);
    file("b");
    file(externalPath);
    Set<RootedPath> seenFiles = Sets.newHashSet();
    seenFiles.addAll(getFilesSeenAndAssertValueChangesIfContentsOfFileChanges("b", false, "a"));
    seenFiles.addAll(getFilesSeenAndAssertValueChangesIfContentsOfFileChanges(externalPath, true, "a"));
    Path root = fs.getRootDirectory();
    assertThat(seenFiles).containsExactly(rootedPath("WORKSPACE"), rootedPath("a"), rootedPath(""), RootedPath.toRootedPath(root, PathFragment.EMPTY_FRAGMENT), RootedPath.toRootedPath(root, new PathFragment("output_base")), RootedPath.toRootedPath(root, new PathFragment("output_base/external")), RootedPath.toRootedPath(root, new PathFragment("output_base/external/a")), RootedPath.toRootedPath(root, new PathFragment("output_base/external/a/b")));
}

Example 82 with RootedPath

use of com.google.devtools.build.lib.vfs.RootedPath in project bazel by bazelbuild.

the class FileSymlinkCycleUniquenessFunctionTest method testHashCodeAndEqualsContract.

@Test
public void testHashCodeAndEqualsContract() throws Exception {
    Path root = new InMemoryFileSystem().getRootDirectory().getRelative("root");
    RootedPath p1 = RootedPath.toRootedPath(root, new PathFragment("p1"));
    RootedPath p2 = RootedPath.toRootedPath(root, new PathFragment("p2"));
    RootedPath p3 = RootedPath.toRootedPath(root, new PathFragment("p3"));
    ImmutableList<RootedPath> cycleA1 = ImmutableList.of(p1);
    ImmutableList<RootedPath> cycleB1 = ImmutableList.of(p2);
    ImmutableList<RootedPath> cycleC1 = ImmutableList.of(p1, p2, p3);
    ImmutableList<RootedPath> cycleC2 = ImmutableList.of(p2, p3, p1);
    ImmutableList<RootedPath> cycleC3 = ImmutableList.of(p3, p1, p2);
    new EqualsTester().addEqualityGroup(FileSymlinkCycleUniquenessFunction.key(cycleA1)).addEqualityGroup(FileSymlinkCycleUniquenessFunction.key(cycleB1)).addEqualityGroup(FileSymlinkCycleUniquenessFunction.key(cycleC1), FileSymlinkCycleUniquenessFunction.key(cycleC2), FileSymlinkCycleUniquenessFunction.key(cycleC3)).testEquals();
}

Example 83 with RootedPath

use of com.google.devtools.build.lib.vfs.RootedPath in project bazel by bazelbuild.

the class FileFunctionTest method runTestInfiniteSymlinkExpansion.

private void runTestInfiniteSymlinkExpansion(boolean symlinkToAncestor, boolean absoluteSymlink) throws Exception {
    Path otherPath = path("other");
    RootedPath otherRootedPath = RootedPath.toRootedPath(pkgRoot, otherPath.relativeTo(pkgRoot));
    Path ancestorPath = path("a");
    RootedPath ancestorRootedPath = RootedPath.toRootedPath(pkgRoot, ancestorPath.relativeTo(pkgRoot));
    FileSystemUtils.ensureSymbolicLink(otherPath, ancestorPath);
    Path intermediatePath = path("inter");
    RootedPath intermediateRootedPath = RootedPath.toRootedPath(pkgRoot, intermediatePath.relativeTo(pkgRoot));
    Path descendantPath = path("a/b/c/d/e");
    RootedPath descendantRootedPath = RootedPath.toRootedPath(pkgRoot, descendantPath.relativeTo(pkgRoot));
    if (symlinkToAncestor) {
        FileSystemUtils.ensureSymbolicLink(descendantPath, intermediatePath);
        if (absoluteSymlink) {
            FileSystemUtils.ensureSymbolicLink(intermediatePath, ancestorPath);
        } else {
            FileSystemUtils.ensureSymbolicLink(intermediatePath, ancestorRootedPath.getRelativePath());
        }
    } else {
        FileSystemUtils.ensureSymbolicLink(ancestorPath, intermediatePath);
        if (absoluteSymlink) {
            FileSystemUtils.ensureSymbolicLink(intermediatePath, descendantPath);
        } else {
            FileSystemUtils.ensureSymbolicLink(intermediatePath, descendantRootedPath.getRelativePath());
        }
    }
    StoredEventHandler eventHandler = new StoredEventHandler();
    SequentialBuildDriver driver = makeDriver();
    SkyKey ancestorPathKey = FileValue.key(ancestorRootedPath);
    SkyKey descendantPathKey = FileValue.key(descendantRootedPath);
    SkyKey otherPathKey = FileValue.key(otherRootedPath);
    ImmutableList<SkyKey> keys;
    ImmutableList<SkyKey> errorKeys;
    ImmutableList<RootedPath> expectedChain;
    if (symlinkToAncestor) {
        keys = ImmutableList.of(descendantPathKey, otherPathKey);
        errorKeys = ImmutableList.of(descendantPathKey);
        expectedChain = ImmutableList.of(descendantRootedPath, intermediateRootedPath, ancestorRootedPath);
    } else {
        keys = ImmutableList.of(ancestorPathKey, otherPathKey);
        errorKeys = keys;
        expectedChain = ImmutableList.of(ancestorRootedPath, intermediateRootedPath, descendantRootedPath);
    }
    EvaluationResult<FileValue> result = driver.evaluate(keys, /*keepGoing=*/
    true, DEFAULT_THREAD_COUNT, eventHandler);
    assertTrue(result.hasError());
    for (SkyKey key : errorKeys) {
        ErrorInfo errorInfo = result.getError(key);
        // FileFunction detects infinite symlink expansion explicitly.
        assertThat(errorInfo.getCycleInfo()).isEmpty();
        FileSymlinkInfiniteExpansionException fsiee = (FileSymlinkInfiniteExpansionException) errorInfo.getException();
        assertThat(fsiee.getMessage()).contains("Infinite symlink expansion");
        assertThat(fsiee.getChain()).containsExactlyElementsIn(expectedChain).inOrder();
    }
    // Check that the unique symlink expansion error was reported exactly once.
    assertThat(eventHandler.getEvents()).hasSize(1);
    assertThat(Iterables.getOnlyElement(eventHandler.getEvents()).getMessage()).contains("infinite symlink expansion detected");
}

Example 84 with RootedPath

use of com.google.devtools.build.lib.vfs.RootedPath in project bazel by bazelbuild.

the class FileFunctionTest method runTestSymlinkCycle.

private void runTestSymlinkCycle(boolean ancestorCycle, boolean startInCycle) throws Exception {
    symlink("a", "b");
    symlink("b", "c");
    symlink("c", "d");
    symlink("d", "e");
    symlink("e", "c");
    // We build multiple keys at once to make sure the cycle is reported exactly once.
    Map<RootedPath, ImmutableList<RootedPath>> startToCycleMap = ImmutableMap.<RootedPath, ImmutableList<RootedPath>>builder().put(rootedPath("a"), ImmutableList.of(rootedPath("c"), rootedPath("d"), rootedPath("e"))).put(rootedPath("b"), ImmutableList.of(rootedPath("c"), rootedPath("d"), rootedPath("e"))).put(rootedPath("d"), ImmutableList.<RootedPath>of(rootedPath("d"), rootedPath("e"), rootedPath("c"))).put(rootedPath("e"), ImmutableList.<RootedPath>of(rootedPath("e"), rootedPath("c"), rootedPath("d"))).put(rootedPath("a/some/descendant"), ImmutableList.of(rootedPath("c"), rootedPath("d"), rootedPath("e"))).put(rootedPath("b/some/descendant"), ImmutableList.of(rootedPath("c"), rootedPath("d"), rootedPath("e"))).put(rootedPath("d/some/descendant"), ImmutableList.<RootedPath>of(rootedPath("d"), rootedPath("e"), rootedPath("c"))).put(rootedPath("e/some/descendant"), ImmutableList.<RootedPath>of(rootedPath("e"), rootedPath("c"), rootedPath("d"))).build();
    Map<RootedPath, ImmutableList<RootedPath>> startToPathToCycleMap = ImmutableMap.<RootedPath, ImmutableList<RootedPath>>builder().put(rootedPath("a"), ImmutableList.of(rootedPath("a"), rootedPath("b"))).put(rootedPath("b"), ImmutableList.of(rootedPath("b"))).put(rootedPath("d"), ImmutableList.<RootedPath>of()).put(rootedPath("e"), ImmutableList.<RootedPath>of()).put(rootedPath("a/some/descendant"), ImmutableList.of(rootedPath("a"), rootedPath("b"))).put(rootedPath("b/some/descendant"), ImmutableList.of(rootedPath("b"))).put(rootedPath("d/some/descendant"), ImmutableList.<RootedPath>of()).put(rootedPath("e/some/descendant"), ImmutableList.<RootedPath>of()).build();
    ImmutableList<SkyKey> keys;
    if (ancestorCycle && startInCycle) {
        keys = ImmutableList.of(skyKey("d/some/descendant"), skyKey("e/some/descendant"));
    } else if (ancestorCycle && !startInCycle) {
        keys = ImmutableList.of(skyKey("a/some/descendant"), skyKey("b/some/descendant"));
    } else if (!ancestorCycle && startInCycle) {
        keys = ImmutableList.of(skyKey("d"), skyKey("e"));
    } else {
        keys = ImmutableList.of(skyKey("a"), skyKey("b"));
    }
    StoredEventHandler eventHandler = new StoredEventHandler();
    SequentialBuildDriver driver = makeDriver();
    EvaluationResult<FileValue> result = driver.evaluate(keys, /*keepGoing=*/
    true, DEFAULT_THREAD_COUNT, eventHandler);
    assertTrue(result.hasError());
    for (SkyKey key : keys) {
        ErrorInfo errorInfo = result.getError(key);
        // FileFunction detects symlink cycles explicitly.
        assertThat(errorInfo.getCycleInfo()).isEmpty();
        FileSymlinkCycleException fsce = (FileSymlinkCycleException) errorInfo.getException();
        RootedPath start = (RootedPath) key.argument();
        assertThat(fsce.getPathToCycle()).containsExactlyElementsIn(startToPathToCycleMap.get(start)).inOrder();
        assertThat(fsce.getCycle()).containsExactlyElementsIn(startToCycleMap.get(start)).inOrder();
    }
    // Check that the unique cycle was reported exactly once.
    assertThat(eventHandler.getEvents()).hasSize(1);
    assertThat(Iterables.getOnlyElement(eventHandler.getEvents()).getMessage()).contains("circular symlinks detected");
}