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