|
|
@@ -1,1357 +0,0 @@
|
|
|
-/**
|
|
|
- * Licensed to the Apache Software Foundation (ASF) under one
|
|
|
- * or more contributor license agreements. See the NOTICE file
|
|
|
- * distributed with this work for additional information
|
|
|
- * regarding copyright ownership. The ASF licenses this file
|
|
|
- * to you under the Apache License, Version 2.0 (the
|
|
|
- * "License"); you may not use this file except in compliance
|
|
|
- * with the License. You may obtain a copy of the License at
|
|
|
- *
|
|
|
- * http://www.apache.org/licenses/LICENSE-2.0
|
|
|
- *
|
|
|
- * Unless required by applicable law or agreed to in writing, software
|
|
|
- * distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
- * See the License for the specific language governing permissions and
|
|
|
- * limitations under the License.
|
|
|
- */
|
|
|
-package org.apache.hadoop.fs;
|
|
|
-
|
|
|
-import java.io.*;
|
|
|
-import java.net.URI;
|
|
|
-import java.util.EnumSet;
|
|
|
-import org.apache.hadoop.fs.FileContext;
|
|
|
-import org.apache.hadoop.fs.Options.CreateOpts;
|
|
|
-import org.apache.hadoop.fs.Options.Rename;
|
|
|
-import org.apache.hadoop.fs.permission.FsPermission;
|
|
|
-import org.apache.hadoop.fs.CreateFlag;
|
|
|
-import org.apache.hadoop.fs.Path;
|
|
|
-import org.apache.hadoop.fs.FSDataOutputStream;
|
|
|
-import static org.apache.hadoop.fs.FileContextTestHelper.*;
|
|
|
-
|
|
|
-import static org.junit.Assert.*;
|
|
|
-import static org.junit.Assume.assumeTrue;
|
|
|
-import org.junit.Test;
|
|
|
-import org.junit.Before;
|
|
|
-import org.junit.After;
|
|
|
-
|
|
|
-/**
|
|
|
- * Test symbolic links using FileContext.
|
|
|
- */
|
|
|
-public abstract class FileContextSymlinkBaseTest {
|
|
|
- static final long seed = 0xDEADBEEFL;
|
|
|
- static final int blockSize = 8192;
|
|
|
- static final int fileSize = 16384;
|
|
|
-
|
|
|
- protected final FileContextTestHelper fileContextTestHelper = new FileContextTestHelper();
|
|
|
- protected static FileContext fc;
|
|
|
-
|
|
|
- abstract protected String getScheme();
|
|
|
- abstract protected String testBaseDir1() throws IOException;
|
|
|
- abstract protected String testBaseDir2() throws IOException;
|
|
|
- abstract protected URI testURI();
|
|
|
-
|
|
|
- protected IOException unwrapException(IOException e) {
|
|
|
- return e;
|
|
|
- }
|
|
|
-
|
|
|
- protected static void createAndWriteFile(FileContext fc, Path p)
|
|
|
- throws IOException {
|
|
|
- createFile(fc, p, fileSize / blockSize,
|
|
|
- CreateOpts.createParent(),
|
|
|
- CreateOpts.repFac((short) 1),
|
|
|
- CreateOpts.blockSize(blockSize));
|
|
|
- }
|
|
|
-
|
|
|
- protected static void createAndWriteFile(Path p) throws IOException {
|
|
|
- createAndWriteFile(fc, p);
|
|
|
- }
|
|
|
-
|
|
|
- protected static void readFile(Path p) throws IOException {
|
|
|
- FileContextTestHelper.readFile(fc, p, fileSize);
|
|
|
- }
|
|
|
-
|
|
|
- protected static void readFile(FileContext fc, Path p) throws IOException {
|
|
|
- FileContextTestHelper.readFile(fc, p, fileSize);
|
|
|
- }
|
|
|
-
|
|
|
- protected static void appendToFile(Path p) throws IOException {
|
|
|
- FileContextTestHelper.appendToFile(fc, p, fileSize / blockSize,
|
|
|
- CreateOpts.blockSize(blockSize));
|
|
|
- }
|
|
|
-
|
|
|
- @Before
|
|
|
- public void setUp() throws Exception {
|
|
|
- fc.mkdir(new Path(testBaseDir1()), FileContext.DEFAULT_PERM, true);
|
|
|
- fc.mkdir(new Path(testBaseDir2()), FileContext.DEFAULT_PERM, true);
|
|
|
- }
|
|
|
-
|
|
|
- @After
|
|
|
- public void tearDown() throws Exception {
|
|
|
- fc.delete(new Path(testBaseDir1()), true);
|
|
|
- fc.delete(new Path(testBaseDir2()), true);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** The root is not a symlink */
|
|
|
- public void testStatRoot() throws IOException {
|
|
|
- assertFalse(fc.getFileLinkStatus(new Path("/")).isSymlink());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test setWorkingDirectory not resolves symlinks */
|
|
|
- public void testSetWDNotResolvesLinks() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path linkToDir = new Path(testBaseDir1()+"/link");
|
|
|
- fc.createSymlink(dir, linkToDir, false);
|
|
|
- fc.setWorkingDirectory(linkToDir);
|
|
|
- assertEquals(linkToDir.getName(), fc.getWorkingDirectory().getName());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create a dangling link */
|
|
|
- public void testCreateDanglingLink() throws IOException {
|
|
|
- Path file = new Path("/noSuchFile");
|
|
|
- Path link = new Path(testBaseDir1()+"/link");
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- try {
|
|
|
- fc.getFileStatus(link);
|
|
|
- fail("Got file status of non-existant file");
|
|
|
- } catch (FileNotFoundException f) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- fc.delete(link, false);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create a link to null and empty path */
|
|
|
- public void testCreateLinkToNullEmpty() throws IOException {
|
|
|
- Path link = new Path(testBaseDir1()+"/link");
|
|
|
- try {
|
|
|
- fc.createSymlink(null, link, false);
|
|
|
- fail("Can't create symlink to null");
|
|
|
- } catch (java.lang.NullPointerException e) {
|
|
|
- // Expected, create* with null yields NPEs
|
|
|
- }
|
|
|
- try {
|
|
|
- fc.createSymlink(new Path(""), link, false);
|
|
|
- fail("Can't create symlink to empty string");
|
|
|
- } catch (java.lang.IllegalArgumentException e) {
|
|
|
- // Expected, Path("") is invalid
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Create a link with createParent set */
|
|
|
- public void testCreateLinkCanCreateParent() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1()+"/file");
|
|
|
- Path link = new Path(testBaseDir2()+"/linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.delete(new Path(testBaseDir2()), true);
|
|
|
- try {
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- fail("Created link without first creating parent dir");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected. Need to create testBaseDir2() first.
|
|
|
- }
|
|
|
- assertFalse(exists(fc, new Path(testBaseDir2())));
|
|
|
- fc.createSymlink(file, link, true);
|
|
|
- readFile(link);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Try to create a directory given a path that refers to a symlink */
|
|
|
- public void testMkdirExistingLink() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1()+"/link");
|
|
|
- fc.createSymlink(new Path("/doesNotExist"), dir, false);
|
|
|
- try {
|
|
|
- fc.mkdir(dir, FileContext.DEFAULT_PERM, false);
|
|
|
- fail("Created a dir where a symlink exists");
|
|
|
- } catch (FileAlreadyExistsException e) {
|
|
|
- // Expected. The symlink already exists.
|
|
|
- } catch (IOException e) {
|
|
|
- // LocalFs just throws an IOException
|
|
|
- assertEquals("file", getScheme());
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Try to create a file with parent that is a dangling link */
|
|
|
- public void testCreateFileViaDanglingLinkParent() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1()+"/dangling");
|
|
|
- Path file = new Path(testBaseDir1()+"/dangling/file");
|
|
|
- fc.createSymlink(new Path("/doesNotExist"), dir, false);
|
|
|
- FSDataOutputStream out;
|
|
|
- try {
|
|
|
- out = fc.create(file, EnumSet.of(CreateFlag.CREATE),
|
|
|
- CreateOpts.repFac((short) 1),
|
|
|
- CreateOpts.blockSize(blockSize));
|
|
|
- out.close();
|
|
|
- fail("Created a link with dangling link parent");
|
|
|
- } catch (FileNotFoundException e) {
|
|
|
- // Expected. The parent is dangling.
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Delete a link */
|
|
|
- public void testDeleteLink() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1()+"/file");
|
|
|
- Path link = new Path(testBaseDir1()+"/linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- readFile(link);
|
|
|
- fc.delete(link, false);
|
|
|
- try {
|
|
|
- readFile(link);
|
|
|
- fail("Symlink should have been deleted");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- // If we deleted the link we can put it back
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Ensure open resolves symlinks */
|
|
|
- public void testOpenResolvesLinks() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1()+"/noSuchFile");
|
|
|
- Path link = new Path(testBaseDir1()+"/link");
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- try {
|
|
|
- fc.open(link);
|
|
|
- fail("link target does not exist");
|
|
|
- } catch (FileNotFoundException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- fc.delete(link, false);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Stat a link to a file */
|
|
|
- public void testStatLinkToFile() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1()+"/file");
|
|
|
- Path linkToFile = new Path(testBaseDir1()+"/linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, linkToFile, false);
|
|
|
- assertFalse(fc.getFileLinkStatus(linkToFile).isDirectory());
|
|
|
- assertTrue(isSymlink(fc, linkToFile));
|
|
|
- assertTrue(isFile(fc, linkToFile));
|
|
|
- assertFalse(isDir(fc, linkToFile));
|
|
|
- assertEquals(file.toUri().getPath(),
|
|
|
- fc.getLinkTarget(linkToFile).toString());
|
|
|
- // The local file system does not fully resolve the link
|
|
|
- // when obtaining the file status
|
|
|
- if (!"file".equals(getScheme())) {
|
|
|
- assertEquals(fc.getFileStatus(file), fc.getFileStatus(linkToFile));
|
|
|
- assertEquals(fc.makeQualified(file),
|
|
|
- fc.getFileStatus(linkToFile).getPath());
|
|
|
- assertEquals(fc.makeQualified(linkToFile),
|
|
|
- fc.getFileLinkStatus(linkToFile).getPath());
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Stat a relative link to a file */
|
|
|
- public void testStatRelLinkToFile() throws IOException {
|
|
|
- assumeTrue(!"file".equals(getScheme()));
|
|
|
- Path baseDir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path linkToFile = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(new Path("file"), linkToFile, false);
|
|
|
- assertEquals(fc.getFileStatus(file), fc.getFileStatus(linkToFile));
|
|
|
- assertEquals(fc.makeQualified(file),
|
|
|
- fc.getFileStatus(linkToFile).getPath());
|
|
|
- assertEquals(fc.makeQualified(linkToFile),
|
|
|
- fc.getFileLinkStatus(linkToFile).getPath());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Stat a link to a directory */
|
|
|
- public void testStatLinkToDir() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path linkToDir = new Path(testBaseDir1()+"/linkToDir");
|
|
|
- fc.createSymlink(dir, linkToDir, false);
|
|
|
-
|
|
|
- assertFalse(fc.getFileStatus(linkToDir).isSymlink());
|
|
|
- assertTrue(isDir(fc, linkToDir));
|
|
|
- assertFalse(fc.getFileLinkStatus(linkToDir).isDirectory());
|
|
|
- assertTrue(fc.getFileLinkStatus(linkToDir).isSymlink());
|
|
|
-
|
|
|
- assertFalse(isFile(fc, linkToDir));
|
|
|
- assertTrue(isDir(fc, linkToDir));
|
|
|
-
|
|
|
- assertEquals(dir.toUri().getPath(),
|
|
|
- fc.getLinkTarget(linkToDir).toString());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Stat a dangling link */
|
|
|
- public void testStatDanglingLink() throws IOException {
|
|
|
- Path file = new Path("/noSuchFile");
|
|
|
- Path link = new Path(testBaseDir1()+"/link");
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- assertFalse(fc.getFileLinkStatus(link).isDirectory());
|
|
|
- assertTrue(fc.getFileLinkStatus(link).isSymlink());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Stat a non-existant file */
|
|
|
- public void testStatNonExistantFiles() throws IOException {
|
|
|
- Path fileAbs = new Path("/doesNotExist");
|
|
|
- try {
|
|
|
- fc.getFileLinkStatus(fileAbs);
|
|
|
- fail("Got FileStatus for non-existant file");
|
|
|
- } catch (FileNotFoundException f) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- try {
|
|
|
- fc.getLinkTarget(fileAbs);
|
|
|
- fail("Got link target for non-existant file");
|
|
|
- } catch (FileNotFoundException f) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test stat'ing a regular file and directory */
|
|
|
- public void testStatNonLinks() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1()+"/file");
|
|
|
- createAndWriteFile(file);
|
|
|
- try {
|
|
|
- fc.getLinkTarget(dir);
|
|
|
- fail("Lstat'd a non-symlink");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected.
|
|
|
- }
|
|
|
- try {
|
|
|
- fc.getLinkTarget(file);
|
|
|
- fail("Lstat'd a non-symlink");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected.
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test links that link to each other */
|
|
|
- public void testRecursiveLinks() throws IOException {
|
|
|
- Path link1 = new Path(testBaseDir1()+"/link1");
|
|
|
- Path link2 = new Path(testBaseDir1()+"/link2");
|
|
|
- fc.createSymlink(link1, link2, false);
|
|
|
- fc.createSymlink(link2, link1, false);
|
|
|
- try {
|
|
|
- readFile(link1);
|
|
|
- fail("Read recursive link");
|
|
|
- } catch (FileNotFoundException f) {
|
|
|
- // LocalFs throws sub class of IOException, since File.exists
|
|
|
- // returns false for a link to link.
|
|
|
- } catch (IOException x) {
|
|
|
- assertEquals("Possible cyclic loop while following symbolic link "+
|
|
|
- link1.toString(), x.getMessage());
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /* Assert that the given link to a file behaves as expected. */
|
|
|
- private void checkLink(Path linkAbs, Path expectedTarget, Path targetQual)
|
|
|
- throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- // isFile/Directory
|
|
|
- assertTrue(isFile(fc, linkAbs));
|
|
|
- assertFalse(isDir(fc, linkAbs));
|
|
|
-
|
|
|
- // Check getFileStatus
|
|
|
- assertFalse(fc.getFileStatus(linkAbs).isSymlink());
|
|
|
- assertFalse(fc.getFileStatus(linkAbs).isDirectory());
|
|
|
- assertEquals(fileSize, fc.getFileStatus(linkAbs).getLen());
|
|
|
-
|
|
|
- // Check getFileLinkStatus
|
|
|
- assertTrue(isSymlink(fc, linkAbs));
|
|
|
- assertFalse(fc.getFileLinkStatus(linkAbs).isDirectory());
|
|
|
-
|
|
|
- // Check getSymlink always returns a qualified target, except
|
|
|
- // when partially qualified paths are used (see tests below).
|
|
|
- assertEquals(targetQual.toString(),
|
|
|
- fc.getFileLinkStatus(linkAbs).getSymlink().toString());
|
|
|
- assertEquals(targetQual, fc.getFileLinkStatus(linkAbs).getSymlink());
|
|
|
- // Check that the target is qualified using the file system of the
|
|
|
- // path used to access the link (if the link target was not specified
|
|
|
- // fully qualified, in that case we use the link target verbatim).
|
|
|
- if (!"file".equals(getScheme())) {
|
|
|
- FileContext localFc = FileContext.getLocalFSFileContext();
|
|
|
- Path linkQual = new Path(testURI().toString(), linkAbs);
|
|
|
- assertEquals(targetQual,
|
|
|
- localFc.getFileLinkStatus(linkQual).getSymlink());
|
|
|
- }
|
|
|
-
|
|
|
- // Check getLinkTarget
|
|
|
- assertEquals(expectedTarget, fc.getLinkTarget(linkAbs));
|
|
|
-
|
|
|
- // Now read using all path types..
|
|
|
- fc.setWorkingDirectory(dir);
|
|
|
- readFile(new Path("linkToFile"));
|
|
|
- readFile(linkAbs);
|
|
|
- // And fully qualified.. (NB: for local fs this is partially qualified)
|
|
|
- readFile(new Path(testURI().toString(), linkAbs));
|
|
|
- // And partially qualified..
|
|
|
- boolean failureExpected = "file".equals(getScheme()) ? false : true;
|
|
|
- try {
|
|
|
- readFile(new Path(getScheme()+"://"+testBaseDir1()+"/linkToFile"));
|
|
|
- assertFalse(failureExpected);
|
|
|
- } catch (Exception e) {
|
|
|
- assertTrue(failureExpected);
|
|
|
- }
|
|
|
-
|
|
|
- // Now read using a different file context (for HDFS at least)
|
|
|
- if (!"file".equals(getScheme())) {
|
|
|
- FileContext localFc = FileContext.getLocalFSFileContext();
|
|
|
- readFile(localFc, new Path(testURI().toString(), linkAbs));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test creating a symlink using relative paths */
|
|
|
- public void testCreateLinkUsingRelPaths() throws IOException {
|
|
|
- Path fileAbs = new Path(testBaseDir1(), "file");
|
|
|
- Path linkAbs = new Path(testBaseDir1(), "linkToFile");
|
|
|
- Path schemeAuth = new Path(testURI().toString());
|
|
|
- Path fileQual = new Path(schemeAuth, testBaseDir1()+"/file");
|
|
|
- createAndWriteFile(fileAbs);
|
|
|
-
|
|
|
- fc.setWorkingDirectory(new Path(testBaseDir1()));
|
|
|
- fc.createSymlink(new Path("file"), new Path("linkToFile"), false);
|
|
|
- checkLink(linkAbs, new Path("file"), fileQual);
|
|
|
-
|
|
|
- // Now rename the link's parent. Because the target was specified
|
|
|
- // with a relative path the link should still resolve.
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path dir2 = new Path(testBaseDir2());
|
|
|
- Path linkViaDir2 = new Path(testBaseDir2(), "linkToFile");
|
|
|
- Path fileViaDir2 = new Path(schemeAuth, testBaseDir2()+"/file");
|
|
|
- fc.rename(dir1, dir2, Rename.OVERWRITE);
|
|
|
- assertEquals(fileViaDir2, fc.getFileLinkStatus(linkViaDir2).getSymlink());
|
|
|
- readFile(linkViaDir2);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test creating a symlink using absolute paths */
|
|
|
- public void testCreateLinkUsingAbsPaths() throws IOException {
|
|
|
- Path fileAbs = new Path(testBaseDir1()+"/file");
|
|
|
- Path linkAbs = new Path(testBaseDir1()+"/linkToFile");
|
|
|
- Path schemeAuth = new Path(testURI().toString());
|
|
|
- Path fileQual = new Path(schemeAuth, testBaseDir1()+"/file");
|
|
|
- createAndWriteFile(fileAbs);
|
|
|
-
|
|
|
- fc.createSymlink(fileAbs, linkAbs, false);
|
|
|
- checkLink(linkAbs, fileAbs, fileQual);
|
|
|
-
|
|
|
- // Now rename the link's parent. The target doesn't change and
|
|
|
- // now no longer exists so accessing the link should fail.
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path dir2 = new Path(testBaseDir2());
|
|
|
- Path linkViaDir2 = new Path(testBaseDir2(), "linkToFile");
|
|
|
- fc.rename(dir1, dir2, Rename.OVERWRITE);
|
|
|
- assertEquals(fileQual, fc.getFileLinkStatus(linkViaDir2).getSymlink());
|
|
|
- try {
|
|
|
- readFile(linkViaDir2);
|
|
|
- fail("The target should not exist");
|
|
|
- } catch (FileNotFoundException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /**
|
|
|
- * Test creating a symlink using fully and partially qualified paths.
|
|
|
- * NB: For local fs this actually tests partially qualified paths,
|
|
|
- * as they don't support fully qualified paths.
|
|
|
- */
|
|
|
- public void testCreateLinkUsingFullyQualPaths() throws IOException {
|
|
|
- Path fileAbs = new Path(testBaseDir1(), "file");
|
|
|
- Path linkAbs = new Path(testBaseDir1(), "linkToFile");
|
|
|
- Path fileQual = new Path(testURI().toString(), fileAbs);
|
|
|
- Path linkQual = new Path(testURI().toString(), linkAbs);
|
|
|
- createAndWriteFile(fileAbs);
|
|
|
-
|
|
|
- fc.createSymlink(fileQual, linkQual, false);
|
|
|
- checkLink(linkAbs,
|
|
|
- "file".equals(getScheme()) ? fileAbs : fileQual,
|
|
|
- fileQual);
|
|
|
-
|
|
|
- // Now rename the link's parent. The target doesn't change and
|
|
|
- // now no longer exists so accessing the link should fail.
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path dir2 = new Path(testBaseDir2());
|
|
|
- Path linkViaDir2 = new Path(testBaseDir2(), "linkToFile");
|
|
|
- fc.rename(dir1, dir2, Rename.OVERWRITE);
|
|
|
- assertEquals(fileQual, fc.getFileLinkStatus(linkViaDir2).getSymlink());
|
|
|
- try {
|
|
|
- readFile(linkViaDir2);
|
|
|
- fail("The target should not exist");
|
|
|
- } catch (FileNotFoundException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /**
|
|
|
- * Test creating a symlink using partially qualified paths, ie a scheme
|
|
|
- * but no authority and vice versa. We just test link targets here since
|
|
|
- * creating using a partially qualified path is file system specific.
|
|
|
- */
|
|
|
- public void testCreateLinkUsingPartQualPath1() throws IOException {
|
|
|
- // Partially qualified paths are covered for local file systems
|
|
|
- // in the previous test.
|
|
|
- assumeTrue(!"file".equals(getScheme()));
|
|
|
- Path schemeAuth = new Path(testURI().toString());
|
|
|
- Path fileWoHost = new Path(getScheme()+"://"+testBaseDir1()+"/file");
|
|
|
- Path link = new Path(testBaseDir1()+"/linkToFile");
|
|
|
- Path linkQual = new Path(schemeAuth, testBaseDir1()+"/linkToFile");
|
|
|
- FileContext localFc = FileContext.getLocalFSFileContext();
|
|
|
-
|
|
|
- fc.createSymlink(fileWoHost, link, false);
|
|
|
- // Partially qualified path is stored
|
|
|
- assertEquals(fileWoHost, fc.getLinkTarget(linkQual));
|
|
|
- // NB: We do not add an authority
|
|
|
- assertEquals(fileWoHost.toString(),
|
|
|
- fc.getFileLinkStatus(link).getSymlink().toString());
|
|
|
- assertEquals(fileWoHost.toString(),
|
|
|
- fc.getFileLinkStatus(linkQual).getSymlink().toString());
|
|
|
- // Ditto even from another file system
|
|
|
- assertEquals(fileWoHost.toString(),
|
|
|
- localFc.getFileLinkStatus(linkQual).getSymlink().toString());
|
|
|
- // Same as if we accessed a partially qualified path directly
|
|
|
- try {
|
|
|
- readFile(link);
|
|
|
- fail("DFS requires URIs with schemes have an authority");
|
|
|
- } catch (java.lang.RuntimeException e) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Same as above but vice versa (authority but no scheme) */
|
|
|
- public void testCreateLinkUsingPartQualPath2() throws IOException {
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- Path fileWoScheme = new Path("//"+testURI().getAuthority()+
|
|
|
- testBaseDir1()+"/file");
|
|
|
- if ("file".equals(getScheme())) {
|
|
|
- return;
|
|
|
- }
|
|
|
- fc.createSymlink(fileWoScheme, link, false);
|
|
|
- assertEquals(fileWoScheme, fc.getLinkTarget(link));
|
|
|
- assertEquals(fileWoScheme.toString(),
|
|
|
- fc.getFileLinkStatus(link).getSymlink().toString());
|
|
|
- try {
|
|
|
- readFile(link);
|
|
|
- fail("Accessed a file with w/o scheme");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected
|
|
|
- assertEquals("No AbstractFileSystem for scheme: null", e.getMessage());
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Lstat and readlink on a normal file and directory */
|
|
|
- public void testLinkStatusAndTargetWithNonLink() throws IOException {
|
|
|
- Path schemeAuth = new Path(testURI().toString());
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path dirQual = new Path(schemeAuth, dir.toString());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path fileQual = new Path(schemeAuth, file.toString());
|
|
|
- createAndWriteFile(file);
|
|
|
- assertEquals(fc.getFileStatus(file), fc.getFileLinkStatus(file));
|
|
|
- assertEquals(fc.getFileStatus(dir), fc.getFileLinkStatus(dir));
|
|
|
- try {
|
|
|
- fc.getLinkTarget(file);
|
|
|
- fail("Get link target on non-link should throw an IOException");
|
|
|
- } catch (IOException x) {
|
|
|
- assertEquals("Path "+fileQual+" is not a symbolic link", x.getMessage());
|
|
|
- }
|
|
|
- try {
|
|
|
- fc.getLinkTarget(dir);
|
|
|
- fail("Get link target on non-link should throw an IOException");
|
|
|
- } catch (IOException x) {
|
|
|
- assertEquals("Path "+dirQual+" is not a symbolic link", x.getMessage());
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create symlink to a directory */
|
|
|
- public void testCreateLinkToDirectory() throws IOException {
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(dir1, linkToDir, false);
|
|
|
- assertFalse(isFile(fc, linkToDir));
|
|
|
- assertTrue(isDir(fc, linkToDir));
|
|
|
- assertTrue(fc.getFileStatus(linkToDir).isDirectory());
|
|
|
- assertTrue(fc.getFileLinkStatus(linkToDir).isSymlink());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create and remove a file through a symlink */
|
|
|
- public void testCreateFileViaSymlink() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path fileViaLink = new Path(linkToDir, "file");
|
|
|
- fc.createSymlink(dir, linkToDir, false);
|
|
|
- createAndWriteFile(fileViaLink);
|
|
|
- assertTrue(isFile(fc, fileViaLink));
|
|
|
- assertFalse(isDir(fc, fileViaLink));
|
|
|
- assertFalse(fc.getFileLinkStatus(fileViaLink).isSymlink());
|
|
|
- assertFalse(fc.getFileStatus(fileViaLink).isDirectory());
|
|
|
- readFile(fileViaLink);
|
|
|
- fc.delete(fileViaLink, true);
|
|
|
- assertFalse(exists(fc, fileViaLink));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test make and delete directory through a symlink */
|
|
|
- public void testCreateDirViaSymlink() throws IOException {
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path subDir = new Path(testBaseDir1(), "subDir");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path subDirViaLink = new Path(linkToDir, "subDir");
|
|
|
- fc.createSymlink(dir1, linkToDir, false);
|
|
|
- fc.mkdir(subDirViaLink, FileContext.DEFAULT_PERM, true);
|
|
|
- assertTrue(isDir(fc, subDirViaLink));
|
|
|
- fc.delete(subDirViaLink, false);
|
|
|
- assertFalse(exists(fc, subDirViaLink));
|
|
|
- assertFalse(exists(fc, subDir));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Create symlink through a symlink */
|
|
|
- public void testCreateLinkViaLink() throws IOException {
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path fileViaLink = new Path(linkToDir, "file");
|
|
|
- Path linkToFile = new Path(linkToDir, "linkToFile");
|
|
|
- /*
|
|
|
- * /b2/linkToDir -> /b1
|
|
|
- * /b2/linkToDir/linkToFile -> /b2/linkToDir/file
|
|
|
- */
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(dir1, linkToDir, false);
|
|
|
- fc.createSymlink(fileViaLink, linkToFile, false);
|
|
|
- assertTrue(isFile(fc, linkToFile));
|
|
|
- assertTrue(fc.getFileLinkStatus(linkToFile).isSymlink());
|
|
|
- readFile(linkToFile);
|
|
|
- assertEquals(fileSize, fc.getFileStatus(linkToFile).getLen());
|
|
|
- assertEquals(fileViaLink, fc.getLinkTarget(linkToFile));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create symlink to a directory */
|
|
|
- public void testListStatusUsingLink() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "link");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(new Path(testBaseDir1()), link, false);
|
|
|
- // The size of the result is file system dependent, Hdfs is 2 (file
|
|
|
- // and link) and LocalFs is 3 (file, link, file crc).
|
|
|
- FileStatus[] stats = fc.util().listStatus(link);
|
|
|
- assertTrue(stats.length == 2 || stats.length == 3);
|
|
|
- RemoteIterator<FileStatus> statsItor = fc.listStatus(link);
|
|
|
- int dirLen = 0;
|
|
|
- while(statsItor.hasNext()) {
|
|
|
- statsItor.next();
|
|
|
- dirLen++;
|
|
|
- }
|
|
|
- assertTrue(dirLen == 2 || dirLen == 3);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create symlink using the same path */
|
|
|
- public void testCreateLinkTwice() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- try {
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- fail("link already exists");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test access via a symlink to a symlink */
|
|
|
- public void testCreateLinkToLink() throws IOException {
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path linkToLink = new Path(testBaseDir2(), "linkToLink");
|
|
|
- Path fileViaLink = new Path(testBaseDir2(), "linkToLink/file");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(dir1, linkToDir, false);
|
|
|
- fc.createSymlink(linkToDir, linkToLink, false);
|
|
|
- assertTrue(isFile(fc, fileViaLink));
|
|
|
- assertFalse(isDir(fc, fileViaLink));
|
|
|
- assertFalse(fc.getFileLinkStatus(fileViaLink).isSymlink());
|
|
|
- assertFalse(fc.getFileStatus(fileViaLink).isDirectory());
|
|
|
- readFile(fileViaLink);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Can not create a file with path that refers to a symlink */
|
|
|
- public void testCreateFileDirExistingLink() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- try {
|
|
|
- createAndWriteFile(link);
|
|
|
- fail("link already exists");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- try {
|
|
|
- fc.mkdir(link, FsPermission.getDefault(), false);
|
|
|
- fail("link already exists");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test deleting and recreating a symlink */
|
|
|
- public void testUseLinkAferDeleteLink() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- fc.delete(link, false);
|
|
|
- try {
|
|
|
- readFile(link);
|
|
|
- fail("link was deleted");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- readFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- readFile(link);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create symlink to . */
|
|
|
- public void testCreateLinkToDot() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToDot");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.setWorkingDirectory(dir);
|
|
|
- try {
|
|
|
- fc.createSymlink(new Path("."), link, false);
|
|
|
- fail("Created symlink to dot");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected. Path(".") resolves to "" because URI normalizes
|
|
|
- // the dot away and AbstractFileSystem considers "" invalid.
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create symlink to .. */
|
|
|
- public void testCreateLinkToDotDot() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "test/file");
|
|
|
- Path dotDot = new Path(testBaseDir1(), "test/..");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path fileViaLink = new Path(linkToDir, "test/file");
|
|
|
- // Symlink to .. is not a problem since the .. is squashed early
|
|
|
- assertEquals(testBaseDir1(), dotDot.toString());
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(dotDot, linkToDir, false);
|
|
|
- readFile(fileViaLink);
|
|
|
- assertEquals(fileSize, fc.getFileStatus(fileViaLink).getLen());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create symlink to ../file */
|
|
|
- public void testCreateLinkToDotDotPrefix() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path dir = new Path(testBaseDir1(), "test");
|
|
|
- Path link = new Path(testBaseDir1(), "test/link");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.mkdir(dir, FsPermission.getDefault(), false);
|
|
|
- fc.setWorkingDirectory(dir);
|
|
|
- fc.createSymlink(new Path("../file"), link, false);
|
|
|
- readFile(link);
|
|
|
- assertEquals(new Path("../file"), fc.getLinkTarget(link));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename file using a path that contains a symlink. The rename should
|
|
|
- * work as if the path did not contain a symlink */
|
|
|
- public void testRenameFileViaSymlink() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path fileViaLink = new Path(linkToDir, "file");
|
|
|
- Path fileNewViaLink = new Path(linkToDir, "fileNew");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(dir, linkToDir, false);
|
|
|
- fc.rename(fileViaLink, fileNewViaLink);
|
|
|
- assertFalse(exists(fc, fileViaLink));
|
|
|
- assertFalse(exists(fc, file));
|
|
|
- assertTrue(exists(fc, fileNewViaLink));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a file through a symlink but this time only the
|
|
|
- * destination path has an intermediate symlink. The rename should work
|
|
|
- * as if the path did not contain a symlink */
|
|
|
- public void testRenameFileToDestViaSymlink() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path subDir = new Path(linkToDir, "subDir");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(dir, linkToDir, false);
|
|
|
- fc.mkdir(subDir, FileContext.DEFAULT_PERM, false);
|
|
|
- try {
|
|
|
- fc.rename(file, subDir);
|
|
|
- fail("Renamed file to a directory");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected. Both must be directories.
|
|
|
- assertTrue(unwrapException(e) instanceof IOException);
|
|
|
- }
|
|
|
- assertTrue(exists(fc, file));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Similar tests as the previous ones but rename a directory */
|
|
|
- public void testRenameDirViaSymlink() throws IOException {
|
|
|
- Path baseDir = new Path(testBaseDir1());
|
|
|
- Path dir = new Path(baseDir, "dir");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path dirViaLink = new Path(linkToDir, "dir");
|
|
|
- Path dirNewViaLink = new Path(linkToDir, "dirNew");
|
|
|
- fc.mkdir(dir, FileContext.DEFAULT_PERM, false);
|
|
|
- fc.createSymlink(baseDir, linkToDir, false);
|
|
|
- assertTrue(exists(fc, dirViaLink));
|
|
|
- fc.rename(dirViaLink, dirNewViaLink);
|
|
|
- assertFalse(exists(fc, dirViaLink));
|
|
|
- assertFalse(exists(fc, dir));
|
|
|
- assertTrue(exists(fc, dirNewViaLink));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Similar tests as the previous ones but rename a symlink */
|
|
|
- public void testRenameSymlinkViaSymlink() throws IOException {
|
|
|
- Path baseDir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "link");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path linkViaLink = new Path(linkToDir, "link");
|
|
|
- Path linkNewViaLink = new Path(linkToDir, "linkNew");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- fc.createSymlink(baseDir, linkToDir, false);
|
|
|
- fc.rename(linkViaLink, linkNewViaLink);
|
|
|
- assertFalse(exists(fc, linkViaLink));
|
|
|
- // Check that we didn't rename the link target
|
|
|
- assertTrue(exists(fc, file));
|
|
|
- assertTrue(fc.getFileLinkStatus(linkNewViaLink).isSymlink());
|
|
|
- readFile(linkNewViaLink);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a directory to a symlink to a directory */
|
|
|
- public void testRenameDirToSymlinkToDir() throws IOException {
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path subDir = new Path(testBaseDir2(), "subDir");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- fc.mkdir(subDir, FileContext.DEFAULT_PERM, false);
|
|
|
- fc.createSymlink(subDir, linkToDir, false);
|
|
|
- try {
|
|
|
- fc.rename(dir1, linkToDir, Rename.OVERWRITE);
|
|
|
- fail("Renamed directory to a symlink");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected. Both must be directories.
|
|
|
- assertTrue(unwrapException(e) instanceof IOException);
|
|
|
- }
|
|
|
- assertTrue(exists(fc, dir1));
|
|
|
- assertTrue(exists(fc, linkToDir));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a directory to a symlink to a file */
|
|
|
- public void testRenameDirToSymlinkToFile() throws IOException {
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir2(), "file");
|
|
|
- Path linkToFile = new Path(testBaseDir2(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, linkToFile, false);
|
|
|
- try {
|
|
|
- fc.rename(dir1, linkToFile, Rename.OVERWRITE);
|
|
|
- fail("Renamed directory to a symlink");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected. Both must be directories.
|
|
|
- assertTrue(unwrapException(e) instanceof IOException);
|
|
|
- }
|
|
|
- assertTrue(exists(fc, dir1));
|
|
|
- assertTrue(exists(fc, linkToFile));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a directory to a dangling symlink */
|
|
|
- public void testRenameDirToDanglingSymlink() throws IOException {
|
|
|
- Path dir = new Path(testBaseDir1());
|
|
|
- Path link = new Path(testBaseDir2(), "linkToFile");
|
|
|
- fc.createSymlink(new Path("/doesNotExist"), link, false);
|
|
|
- try {
|
|
|
- fc.rename(dir, link, Rename.OVERWRITE);
|
|
|
- fail("Renamed directory to a symlink");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected. Both must be directories.
|
|
|
- assertTrue(unwrapException(e) instanceof IOException);
|
|
|
- }
|
|
|
- assertTrue(exists(fc, dir));
|
|
|
- assertTrue(fc.getFileLinkStatus(link) != null);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a file to a symlink to a directory */
|
|
|
- public void testRenameFileToSymlinkToDir() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path subDir = new Path(testBaseDir1(), "subDir");
|
|
|
- Path link = new Path(testBaseDir1(), "link");
|
|
|
- fc.mkdir(subDir, FileContext.DEFAULT_PERM, false);
|
|
|
- fc.createSymlink(subDir, link, false);
|
|
|
- createAndWriteFile(file);
|
|
|
- try {
|
|
|
- fc.rename(file, link);
|
|
|
- fail("Renamed file to symlink w/o overwrite");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- fc.rename(file, link, Rename.OVERWRITE);
|
|
|
- assertFalse(exists(fc, file));
|
|
|
- assertTrue(exists(fc, link));
|
|
|
- assertTrue(isFile(fc, link));
|
|
|
- assertFalse(fc.getFileLinkStatus(link).isSymlink());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a file to a symlink to a file */
|
|
|
- public void testRenameFileToSymlinkToFile() throws IOException {
|
|
|
- Path file1 = new Path(testBaseDir1(), "file1");
|
|
|
- Path file2 = new Path(testBaseDir1(), "file2");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file1);
|
|
|
- createAndWriteFile(file2);
|
|
|
- fc.createSymlink(file2, link, false);
|
|
|
- try {
|
|
|
- fc.rename(file1, link);
|
|
|
- fail("Renamed file to symlink w/o overwrite");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- fc.rename(file1, link, Rename.OVERWRITE);
|
|
|
- assertFalse(exists(fc, file1));
|
|
|
- assertTrue(exists(fc, link));
|
|
|
- assertTrue(isFile(fc, link));
|
|
|
- assertFalse(fc.getFileLinkStatus(link).isSymlink());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a file to a dangling symlink */
|
|
|
- public void testRenameFileToDanglingSymlink() throws IOException {
|
|
|
- /* NB: Local file system doesn't handle dangling links correctly
|
|
|
- * since File.exists(danglinLink) returns false. */
|
|
|
- if ("file".equals(getScheme())) {
|
|
|
- return;
|
|
|
- }
|
|
|
- Path file1 = new Path(testBaseDir1(), "file1");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file1);
|
|
|
- fc.createSymlink(new Path("/doesNotExist"), link, false);
|
|
|
- try {
|
|
|
- fc.rename(file1, link);
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- fc.rename(file1, link, Rename.OVERWRITE);
|
|
|
- assertFalse(exists(fc, file1));
|
|
|
- assertTrue(exists(fc, link));
|
|
|
- assertTrue(isFile(fc, link));
|
|
|
- assertFalse(fc.getFileLinkStatus(link).isSymlink());
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Rename a symlink to a new non-existant name */
|
|
|
- public void testRenameSymlinkNonExistantDest() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link1 = new Path(testBaseDir1(), "linkToFile1");
|
|
|
- Path link2 = new Path(testBaseDir1(), "linkToFile2");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link1, false);
|
|
|
- fc.rename(link1, link2);
|
|
|
- assertTrue(fc.getFileLinkStatus(link2).isSymlink());
|
|
|
- readFile(link2);
|
|
|
- readFile(file);
|
|
|
- assertFalse(exists(fc, link1));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Rename a symlink to a file that exists */
|
|
|
- public void testRenameSymlinkToExistingFile() throws IOException {
|
|
|
- Path file1 = new Path(testBaseDir1(), "file");
|
|
|
- Path file2 = new Path(testBaseDir1(), "someFile");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file1);
|
|
|
- createAndWriteFile(file2);
|
|
|
- fc.createSymlink(file2, link, false);
|
|
|
- try {
|
|
|
- fc.rename(link, file1);
|
|
|
- fail("Renamed w/o passing overwrite");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- fc.rename(link, file1, Rename.OVERWRITE);
|
|
|
- assertFalse(exists(fc, link));
|
|
|
- assertTrue(fc.getFileLinkStatus(file1).isSymlink());
|
|
|
- assertEquals(file2, fc.getLinkTarget(file1));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Rename a symlink to a directory that exists */
|
|
|
- public void testRenameSymlinkToExistingDir() throws IOException {
|
|
|
- Path dir1 = new Path(testBaseDir1());
|
|
|
- Path dir2 = new Path(testBaseDir2());
|
|
|
- Path subDir = new Path(testBaseDir2(), "subDir");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToDir");
|
|
|
- fc.createSymlink(dir1, link, false);
|
|
|
- try {
|
|
|
- fc.rename(link, dir2);
|
|
|
- fail("Renamed link to a directory");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected. Both must be directories.
|
|
|
- assertTrue(unwrapException(e) instanceof IOException);
|
|
|
- }
|
|
|
- try {
|
|
|
- fc.rename(link, dir2, Rename.OVERWRITE);
|
|
|
- fail("Renamed link to a directory");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected. Both must be directories.
|
|
|
- assertTrue(unwrapException(e) instanceof IOException);
|
|
|
- }
|
|
|
- // Also fails when dir2 has a sub-directory
|
|
|
- fc.mkdir(subDir, FsPermission.getDefault(), false);
|
|
|
- try {
|
|
|
- fc.rename(link, dir2, Rename.OVERWRITE);
|
|
|
- fail("Renamed link to a directory");
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected. Both must be directories.
|
|
|
- assertTrue(unwrapException(e) instanceof IOException);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Rename a symlink to itself */
|
|
|
- public void testRenameSymlinkToItself() throws IOException {
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile1");
|
|
|
- fc.createSymlink(new Path("/doestNotExist"), link, false);
|
|
|
- try {
|
|
|
- fc.rename(link, link);
|
|
|
- } catch (IOException e) {
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- // Fails with overwrite as well
|
|
|
- try {
|
|
|
- fc.rename(link, link, Rename.OVERWRITE);
|
|
|
- } catch (IOException e) {
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Rename a symlink */
|
|
|
- public void testRenameSymlink() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link1 = new Path(testBaseDir1(), "linkToFile1");
|
|
|
- Path link2 = new Path(testBaseDir1(), "linkToFile2");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link1, false);
|
|
|
- fc.rename(link1, link2);
|
|
|
- assertTrue(fc.getFileLinkStatus(link2).isSymlink());
|
|
|
- assertFalse(fc.getFileStatus(link2).isDirectory());
|
|
|
- readFile(link2);
|
|
|
- readFile(file);
|
|
|
- try {
|
|
|
- createAndWriteFile(link2);
|
|
|
- fail("link was not renamed");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Rename a symlink to the file it links to */
|
|
|
- public void testRenameSymlinkToFileItLinksTo() throws IOException {
|
|
|
- /* NB: The rename is not atomic, so file is deleted before renaming
|
|
|
- * linkToFile. In this interval linkToFile is dangling and local file
|
|
|
- * system does not handle dangling links because File.exists returns
|
|
|
- * false for dangling links. */
|
|
|
- if ("file".equals(getScheme())) {
|
|
|
- return;
|
|
|
- }
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- try {
|
|
|
- fc.rename(link, file);
|
|
|
- fail("Renamed symlink to its target");
|
|
|
- } catch (IOException e) {
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- // Check the rename didn't happen
|
|
|
- assertTrue(isFile(fc, file));
|
|
|
- assertTrue(exists(fc, link));
|
|
|
- assertTrue(isSymlink(fc, link));
|
|
|
- assertEquals(file, fc.getLinkTarget(link));
|
|
|
- try {
|
|
|
- fc.rename(link, file, Rename.OVERWRITE);
|
|
|
- fail("Renamed symlink to its target");
|
|
|
- } catch (IOException e) {
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- // Check the rename didn't happen
|
|
|
- assertTrue(isFile(fc, file));
|
|
|
- assertTrue(exists(fc, link));
|
|
|
- assertTrue(isSymlink(fc, link));
|
|
|
- assertEquals(file, fc.getLinkTarget(link));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Rename a symlink to the directory it links to */
|
|
|
- public void testRenameSymlinkToDirItLinksTo() throws IOException {
|
|
|
- /* NB: The rename is not atomic, so dir is deleted before renaming
|
|
|
- * linkToFile. In this interval linkToFile is dangling and local file
|
|
|
- * system does not handle dangling links because File.exists returns
|
|
|
- * false for dangling links. */
|
|
|
- if ("file".equals(getScheme())) {
|
|
|
- return;
|
|
|
- }
|
|
|
- Path dir = new Path(testBaseDir1(), "dir");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToDir");
|
|
|
- fc.mkdir(dir, FileContext.DEFAULT_PERM, false);
|
|
|
- fc.createSymlink(dir, link, false);
|
|
|
- try {
|
|
|
- fc.rename(link, dir);
|
|
|
- fail("Renamed symlink to its target");
|
|
|
- } catch (IOException e) {
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- // Check the rename didn't happen
|
|
|
- assertTrue(isDir(fc, dir));
|
|
|
- assertTrue(exists(fc, link));
|
|
|
- assertTrue(isSymlink(fc, link));
|
|
|
- assertEquals(dir, fc.getLinkTarget(link));
|
|
|
- try {
|
|
|
- fc.rename(link, dir, Rename.OVERWRITE);
|
|
|
- fail("Renamed symlink to its target");
|
|
|
- } catch (IOException e) {
|
|
|
- assertTrue(unwrapException(e) instanceof FileAlreadyExistsException);
|
|
|
- }
|
|
|
- // Check the rename didn't happen
|
|
|
- assertTrue(isDir(fc, dir));
|
|
|
- assertTrue(exists(fc, link));
|
|
|
- assertTrue(isSymlink(fc, link));
|
|
|
- assertEquals(dir, fc.getLinkTarget(link));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename the symlink's target */
|
|
|
- public void testRenameLinkTarget() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path fileNew = new Path(testBaseDir1(), "fileNew");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- fc.rename(file, fileNew, Rename.OVERWRITE);
|
|
|
- try {
|
|
|
- readFile(link);
|
|
|
- fail("Link should be dangling");
|
|
|
- } catch (IOException x) {
|
|
|
- // Expected
|
|
|
- }
|
|
|
- fc.rename(fileNew, file, Rename.OVERWRITE);
|
|
|
- readFile(link);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test rename a file to path with destination that has symlink parent */
|
|
|
- public void testRenameFileWithDestParentSymlink() throws IOException {
|
|
|
- Path link = new Path(testBaseDir1(), "link");
|
|
|
- Path file1 = new Path(testBaseDir1(), "file1");
|
|
|
- Path file2 = new Path(testBaseDir1(), "file2");
|
|
|
- Path file3 = new Path(link, "file3");
|
|
|
- Path dir2 = new Path(testBaseDir2());
|
|
|
-
|
|
|
- // Renaming /dir1/file1 to non-existant file /dir1/link/file3 is OK
|
|
|
- // if link points to a directory...
|
|
|
- fc.createSymlink(dir2, link, false);
|
|
|
- createAndWriteFile(file1);
|
|
|
- fc.rename(file1, file3);
|
|
|
- assertFalse(exists(fc, file1));
|
|
|
- assertTrue(exists(fc, file3));
|
|
|
- fc.rename(file3, file1);
|
|
|
-
|
|
|
- // But fails if link is dangling...
|
|
|
- fc.delete(link, false);
|
|
|
- fc.createSymlink(file2, link, false);
|
|
|
- try {
|
|
|
- fc.rename(file1, file3);
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected
|
|
|
- assertTrue(unwrapException(e) instanceof FileNotFoundException);
|
|
|
- }
|
|
|
-
|
|
|
- // And if link points to a file...
|
|
|
- createAndWriteFile(file2);
|
|
|
- try {
|
|
|
- fc.rename(file1, file3);
|
|
|
- } catch (IOException e) {
|
|
|
- // Expected
|
|
|
- assertTrue(unwrapException(e) instanceof ParentNotDirectoryException);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /**
|
|
|
- * Create, write, read, append, rename, get the block locations,
|
|
|
- * checksums, and delete a file using a path with a symlink as an
|
|
|
- * intermediate path component where the link target was specified
|
|
|
- * using an absolute path. Rename is covered in more depth below.
|
|
|
- */
|
|
|
- public void testAccessFileViaInterSymlinkAbsTarget() throws IOException {
|
|
|
- Path baseDir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path fileNew = new Path(baseDir, "fileNew");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path fileViaLink = new Path(linkToDir, "file");
|
|
|
- Path fileNewViaLink = new Path(linkToDir, "fileNew");
|
|
|
- fc.createSymlink(baseDir, linkToDir, false);
|
|
|
- createAndWriteFile(fileViaLink);
|
|
|
- assertTrue(exists(fc, fileViaLink));
|
|
|
- assertTrue(isFile(fc, fileViaLink));
|
|
|
- assertFalse(isDir(fc, fileViaLink));
|
|
|
- assertFalse(fc.getFileLinkStatus(fileViaLink).isSymlink());
|
|
|
- assertFalse(isDir(fc, fileViaLink));
|
|
|
- assertEquals(fc.getFileStatus(file),
|
|
|
- fc.getFileLinkStatus(file));
|
|
|
- assertEquals(fc.getFileStatus(fileViaLink),
|
|
|
- fc.getFileLinkStatus(fileViaLink));
|
|
|
- readFile(fileViaLink);
|
|
|
- appendToFile(fileViaLink);
|
|
|
- fc.rename(fileViaLink, fileNewViaLink);
|
|
|
- assertFalse(exists(fc, fileViaLink));
|
|
|
- assertTrue(exists(fc, fileNewViaLink));
|
|
|
- readFile(fileNewViaLink);
|
|
|
- assertEquals(fc.getFileBlockLocations(fileNew, 0, 1).length,
|
|
|
- fc.getFileBlockLocations(fileNewViaLink, 0, 1).length);
|
|
|
- assertEquals(fc.getFileChecksum(fileNew),
|
|
|
- fc.getFileChecksum(fileNewViaLink));
|
|
|
- fc.delete(fileNewViaLink, true);
|
|
|
- assertFalse(exists(fc, fileNewViaLink));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /**
|
|
|
- * Operate on a file using a path with an intermediate symlink where
|
|
|
- * the link target was specified as a fully qualified path.
|
|
|
- */
|
|
|
- public void testAccessFileViaInterSymlinkQualTarget() throws IOException {
|
|
|
- Path baseDir = new Path(testBaseDir1());
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path fileNew = new Path(baseDir, "fileNew");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path fileViaLink = new Path(linkToDir, "file");
|
|
|
- Path fileNewViaLink = new Path(linkToDir, "fileNew");
|
|
|
- fc.createSymlink(fc.makeQualified(baseDir), linkToDir, false);
|
|
|
- createAndWriteFile(fileViaLink);
|
|
|
- assertEquals(fc.getFileStatus(file),
|
|
|
- fc.getFileLinkStatus(file));
|
|
|
- assertEquals(fc.getFileStatus(fileViaLink),
|
|
|
- fc.getFileLinkStatus(fileViaLink));
|
|
|
- readFile(fileViaLink);
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /**
|
|
|
- * Operate on a file using a path with an intermediate symlink where
|
|
|
- * the link target was specified as a relative path.
|
|
|
- */
|
|
|
- public void testAccessFileViaInterSymlinkRelTarget() throws IOException {
|
|
|
- assumeTrue(!"file".equals(getScheme()));
|
|
|
- Path baseDir = new Path(testBaseDir1());
|
|
|
- Path dir = new Path(testBaseDir1(), "dir");
|
|
|
- Path file = new Path(dir, "file");
|
|
|
- Path linkToDir = new Path(testBaseDir1(), "linkToDir");
|
|
|
- Path fileViaLink = new Path(linkToDir, "file");
|
|
|
-
|
|
|
- fc.mkdir(dir, FileContext.DEFAULT_PERM, false);
|
|
|
- fc.createSymlink(new Path("dir"), linkToDir, false);
|
|
|
- createAndWriteFile(fileViaLink);
|
|
|
- // Note that getFileStatus returns fully qualified paths even
|
|
|
- // when called on an absolute path.
|
|
|
- assertEquals(fc.makeQualified(file),
|
|
|
- fc.getFileStatus(file).getPath());
|
|
|
- // In each case getFileLinkStatus returns the same FileStatus
|
|
|
- // as getFileStatus since we're not calling it on a link and
|
|
|
- // FileStatus objects are compared by Path.
|
|
|
- assertEquals(fc.getFileStatus(file),
|
|
|
- fc.getFileLinkStatus(file));
|
|
|
- assertEquals(fc.getFileStatus(fileViaLink),
|
|
|
- fc.getFileLinkStatus(fileViaLink));
|
|
|
- assertEquals(fc.getFileStatus(fileViaLink),
|
|
|
- fc.getFileLinkStatus(file));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** Test create, list, and delete a directory through a symlink */
|
|
|
- public void testAccessDirViaSymlink() throws IOException {
|
|
|
- Path baseDir = new Path(testBaseDir1());
|
|
|
- Path dir = new Path(testBaseDir1(), "dir");
|
|
|
- Path linkToDir = new Path(testBaseDir2(), "linkToDir");
|
|
|
- Path dirViaLink = new Path(linkToDir, "dir");
|
|
|
- fc.createSymlink(baseDir, linkToDir, false);
|
|
|
- fc.mkdir(dirViaLink, FileContext.DEFAULT_PERM, true);
|
|
|
- assertTrue(fc.getFileStatus(dirViaLink).isDirectory());
|
|
|
- FileStatus[] stats = fc.util().listStatus(dirViaLink);
|
|
|
- assertEquals(0, stats.length);
|
|
|
- RemoteIterator<FileStatus> statsItor = fc.listStatus(dirViaLink);
|
|
|
- assertFalse(statsItor.hasNext());
|
|
|
- fc.delete(dirViaLink, false);
|
|
|
- assertFalse(exists(fc, dirViaLink));
|
|
|
- assertFalse(exists(fc, dir));
|
|
|
- }
|
|
|
-
|
|
|
- @Test
|
|
|
- /** setTimes affects the target not the link */
|
|
|
- public void testSetTimes() throws IOException {
|
|
|
- Path file = new Path(testBaseDir1(), "file");
|
|
|
- Path link = new Path(testBaseDir1(), "linkToFile");
|
|
|
- createAndWriteFile(file);
|
|
|
- fc.createSymlink(file, link, false);
|
|
|
- long at = fc.getFileLinkStatus(link).getAccessTime();
|
|
|
- fc.setTimes(link, 2L, 3L);
|
|
|
- // NB: local file systems don't implement setTimes
|
|
|
- if (!"file".equals(getScheme())) {
|
|
|
- assertEquals(at, fc.getFileLinkStatus(link).getAccessTime());
|
|
|
- assertEquals(3, fc.getFileStatus(file).getAccessTime());
|
|
|
- assertEquals(2, fc.getFileStatus(file).getModificationTime());
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
Colin McCabe