/**
* 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 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());
}
}
}