/// <exception cref="System.IO.IOException"/> private void ListSubtree(FileStatus rootStatus, SequenceFile.Writer writer) { Path rootFile = rootStatus.GetPath(); if (rootStatus.IsFile()) { nrFiles++; // For a regular file generate <fName,offset> pairs long blockSize = fs.GetDefaultBlockSize(rootFile); long fileLength = rootStatus.GetLen(); for (long offset = 0; offset < fileLength; offset += blockSize) { writer.Append(new Text(rootFile.ToString()), new LongWritable(offset)); } return; } FileStatus[] children = null; try { children = fs.ListStatus(rootFile); } catch (FileNotFoundException) { throw new IOException("Could not get listing for " + rootFile); } for (int i = 0; i < children.Length; i++) { ListSubtree(children[i], writer); } }
/// <exception cref="System.IO.IOException"/> public override void CheckFileLinkStatus(string path, FSTestWrapper.FileType expectedType ) { FileStatus s = fs.GetFileLinkStatus(new Path(path)); NUnit.Framework.Assert.IsNotNull(s); if (expectedType == FSTestWrapper.FileType.isDir) { Assert.True(s.IsDirectory()); } else { if (expectedType == FSTestWrapper.FileType.isFile) { Assert.True(s.IsFile()); } else { if (expectedType == FSTestWrapper.FileType.isSymlink) { Assert.True(s.IsSymlink()); } } } Assert.Equal(fs.MakeQualified(new Path(path)), s.GetPath()); }
/// <exception cref="System.IO.IOException"/> public static void CheckFileStatus(FileSystem aFs, string path, FileSystemTestHelper.FileType expectedType) { FileStatus s = aFs.GetFileStatus(new Path(path)); NUnit.Framework.Assert.IsNotNull(s); if (expectedType == FileSystemTestHelper.FileType.isDir) { Assert.True(s.IsDirectory()); } else { if (expectedType == FileSystemTestHelper.FileType.isFile) { Assert.True(s.IsFile()); } else { if (expectedType == FileSystemTestHelper.FileType.isSymlink) { Assert.True(s.IsSymlink()); } } } Assert.Equal(aFs.MakeQualified(new Path(path)), s.GetPath()); }
/// <summary>Validates the toString method for FileStatus.</summary> /// <param name="fileStatus">FileStatus to be validated</param> /// <exception cref="System.IO.IOException"/> private void ValidateToString(FileStatus fileStatus) { StringBuilder expected = new StringBuilder(); expected.Append("FileStatus{"); expected.Append("path=").Append(fileStatus.GetPath()).Append("; "); expected.Append("isDirectory=").Append(fileStatus.IsDirectory()).Append("; "); if (!fileStatus.IsDirectory()) { expected.Append("length=").Append(fileStatus.GetLen()).Append("; "); expected.Append("replication=").Append(fileStatus.GetReplication()).Append("; "); expected.Append("blocksize=").Append(fileStatus.GetBlockSize()).Append("; "); } expected.Append("modification_time=").Append(fileStatus.GetModificationTime()).Append ("; "); expected.Append("access_time=").Append(fileStatus.GetAccessTime()).Append("; "); expected.Append("owner=").Append(fileStatus.GetOwner()).Append("; "); expected.Append("group=").Append(fileStatus.GetGroup()).Append("; "); expected.Append("permission=").Append(fileStatus.GetPermission()).Append("; "); if (fileStatus.IsSymlink()) { expected.Append("isSymlink=").Append(true).Append("; "); expected.Append("symlink=").Append(fileStatus.GetSymlink()).Append("}"); } else { expected.Append("isSymlink=").Append(false).Append("}"); } Assert.Equal(expected.ToString(), fileStatus.ToString()); }
/// <exception cref="System.IO.IOException"/> public virtual void TestPathEscapes() { Path path = new Path(TestRootDir, "foo%bar"); FileSystemTestHelper.WriteFile(fileSys, path, 1); FileStatus status = fileSys.GetFileStatus(path); Assert.Equal(path.MakeQualified(fileSys), status.GetPath()); CleanupFile(fileSys, path); }
/// <summary>Constructor</summary> /// <param name="stat">a file status</param> /// <param name="locations">a file's block locations</param> /// <exception cref="System.IO.IOException"/> public LocatedFileStatus(FileStatus stat, BlockLocation[] locations) : this(stat.GetLen(), stat.IsDirectory(), stat.GetReplication(), stat.GetBlockSize (), stat.GetModificationTime(), stat.GetAccessTime(), stat.GetPermission(), stat .GetOwner(), stat.GetGroup(), null, stat.GetPath(), locations) { if (stat.IsSymlink()) { SetSymlink(stat.GetSymlink()); } }
// Expected /// <exception cref="System.IO.IOException"/> public virtual void TestDanglingLink() { Assume.AssumeTrue(!Path.Windows); Path fileAbs = new Path(TestBaseDir1() + "/file"); Path fileQual = new Path(TestURI().ToString(), fileAbs); Path link = new Path(TestBaseDir1() + "/linkToFile"); Path linkQual = new Path(TestURI().ToString(), link.ToString()); wrapper.CreateSymlink(fileAbs, link, false); // Deleting the link using FileContext currently fails because // resolve looks up LocalFs rather than RawLocalFs for the path // so we call ChecksumFs delete (which doesn't delete dangling // links) instead of delegating to delete in RawLocalFileSystem // which deletes via fullyDelete. testDeleteLink above works // because the link is not dangling. //assertTrue(fc.delete(link, false)); FileUtil.FullyDelete(new FilePath(link.ToUri().GetPath())); wrapper.CreateSymlink(fileAbs, link, false); try { wrapper.GetFileStatus(link); NUnit.Framework.Assert.Fail("Got FileStatus for dangling link"); } catch (FileNotFoundException) { } // Expected. File's exists method returns false for dangling links // We can stat a dangling link UserGroupInformation user = UserGroupInformation.GetCurrentUser(); FileStatus fsd = wrapper.GetFileLinkStatus(link); Assert.Equal(fileQual, fsd.GetSymlink()); Assert.True(fsd.IsSymlink()); NUnit.Framework.Assert.IsFalse(fsd.IsDirectory()); Assert.Equal(user.GetUserName(), fsd.GetOwner()); // Compare against user's primary group Assert.Equal(user.GetGroupNames()[0], fsd.GetGroup()); Assert.Equal(linkQual, fsd.GetPath()); // Accessing the link try { ReadFile(link); NUnit.Framework.Assert.Fail("Got FileStatus for dangling link"); } catch (FileNotFoundException) { } // Ditto. // Creating the file makes the link work CreateAndWriteFile(fileAbs); wrapper.GetFileStatus(link); }
/// <summary>Return a FileStatus representing the given path.</summary> /// <remarks> /// Return a FileStatus representing the given path. If the path refers /// to a symlink return a FileStatus representing the link rather than /// the object the link refers to. /// </remarks> /// <exception cref="System.IO.IOException"/> public override FileStatus GetFileLinkStatus(Path f) { FileStatus fi = GetFileLinkStatusInternal(f, false); // getFileLinkStatus is supposed to return a symlink with a // qualified path if (fi.IsSymlink()) { Path targetQual = FSLinkResolver.QualifySymlinkTarget(this.GetUri(), fi.GetPath() , fi.GetSymlink()); fi.SetSymlink(targetQual); } return(fi); }
/// <summary>Validate the accessors for FileStatus.</summary> /// <param name="fileStatus">FileStatus to checked</param> /// <param name="length">expected length</param> /// <param name="isdir">expected isDirectory</param> /// <param name="replication">expected replication</param> /// <param name="blocksize">expected blocksize</param> /// <param name="mtime">expected modification time</param> /// <param name="atime">expected access time</param> /// <param name="permission">expected permission</param> /// <param name="owner">expected owner</param> /// <param name="group">expected group</param> /// <param name="symlink">expected symlink</param> /// <param name="path">expected path</param> /// <exception cref="System.IO.IOException"/> private void ValidateAccessors(FileStatus fileStatus, long length, bool isdir, int replication, long blocksize, long mtime, long atime, FsPermission permission, string owner, string group, Path symlink, Path path) { Assert.Equal(length, fileStatus.GetLen()); Assert.Equal(isdir, fileStatus.IsDirectory()); Assert.Equal(replication, fileStatus.GetReplication()); Assert.Equal(blocksize, fileStatus.GetBlockSize()); Assert.Equal(mtime, fileStatus.GetModificationTime()); Assert.Equal(atime, fileStatus.GetAccessTime()); Assert.Equal(permission, fileStatus.GetPermission()); Assert.Equal(owner, fileStatus.GetOwner()); Assert.Equal(group, fileStatus.GetGroup()); if (symlink == null) { NUnit.Framework.Assert.IsFalse(fileStatus.IsSymlink()); } else { Assert.True(fileStatus.IsSymlink()); Assert.Equal(symlink, fileStatus.GetSymlink()); } Assert.Equal(path, fileStatus.GetPath()); }
public virtual void TestListStatus() { string hPrefix = "test/hadoop"; string[] dirs = new string[] { hPrefix + "/a", hPrefix + "/b", hPrefix + "/c", hPrefix + "/1", hPrefix + "/#@#@", hPrefix + "/&*#$#$@234" }; AList <Path> testDirs = new AList <Path>(); foreach (string d in dirs) { if (!IsTestableFileNameOnPlatform(d)) { continue; } testDirs.AddItem(QualifiedPath(d, fc2)); } NUnit.Framework.Assert.IsFalse(FileContextTestHelper.Exists(fc1, testDirs[0])); foreach (Path path in testDirs) { fc1.Mkdir(path, FsPermission.GetDefault(), true); } // test listStatus that returns an array of FileStatus FileStatus[] paths = fc1.Util().ListStatus(QualifiedPath("test", fc1)); Assert.Equal(1, paths.Length); Assert.Equal(QualifiedPath(hPrefix, fc1), paths[0].GetPath()); paths = fc1.Util().ListStatus(QualifiedPath(hPrefix, fc1)); Assert.Equal(testDirs.Count, paths.Length); for (int i = 0; i < testDirs.Count; i++) { bool found = false; for (int j = 0; j < paths.Length; j++) { if (QualifiedPath(testDirs[i].ToString(), fc1).Equals(paths[j].GetPath())) { found = true; } } Assert.True(testDirs[i] + " not found", found); } paths = fc1.Util().ListStatus(QualifiedPath(dirs[0], fc1)); Assert.Equal(0, paths.Length); // test listStatus that returns an iterator of FileStatus RemoteIterator <FileStatus> pathsItor = fc1.ListStatus(QualifiedPath("test", fc1)); Assert.Equal(QualifiedPath(hPrefix, fc1), pathsItor.Next().GetPath ()); NUnit.Framework.Assert.IsFalse(pathsItor.HasNext()); pathsItor = fc1.ListStatus(QualifiedPath(hPrefix, fc1)); int dirLen = 0; for (; pathsItor.HasNext(); dirLen++) { bool found = false; FileStatus stat = pathsItor.Next(); for (int j = 0; j < dirs.Length; j++) { if (QualifiedPath(dirs[j], fc1).Equals(stat.GetPath())) { found = true; break; } } Assert.True(stat.GetPath() + " not found", found); } Assert.Equal(testDirs.Count, dirLen); pathsItor = fc1.ListStatus(QualifiedPath(dirs[0], fc1)); NUnit.Framework.Assert.IsFalse(pathsItor.HasNext()); }